Pascal’s RNG tool provides cryptographically secure random numbers for any purpose: dice rolls, coin flips, and random participant selection. Results are permanent chat messages visible to all characters, so the outcome becomes part of the conversation and part of the narrative.

Pending tool results appear as chips in the composer before sending, so you can see what will be rolled before the message goes out. The standard dice vocabulary covers the games people actually play: a coin flip is 1d2, an ordinary die is 1d6, a Yahtzee turn is 5d6, a D&D attack with advantage is 2d20, and spin the bottle picks one name from the participant list. Anything from d2 to d1000 is supported for the edge cases that tabletop players inevitably discover.

Modifiers are honored too. Write 3d6+2 or 2d10-1 and the bonus lands on the total rather than being quietly dropped; the rng tool carries a modifier parameter so a character can call for the modified roll directly. Dice parsing and rolling live in one shared module, so the composer, the prose auto-detector, and Pascal’s custom tables all count the pips the same way.

Dice rolls decide what happens. State records that it happened. The ledger is a persistent JSON store that runs four tiers deep—chat over project over group over general, merged shallowly with the narrowest layer winning—and it carries game mechanics, inventories, character stats, scores, and any structured data that should survive a message, a session, or a whole campaign. It is the older half of Pascal’s room, and everything the croupier does downstairs reads from it and, latterly, writes back into it.

A custom tool is a single JSON document—a Tools/*.tool.json file at the root of any document store—that teaches Pascal a chance mechanic of your own invention. Each one is a named action with parameters, a random roll, and an ordered table of outcomes mapping the roll to a message and a semantic state. Both the model, through a single run_custom tool, and you, through the wand in the composer’s gutter, can reach for it. Pascal deals honestly either way—though not from quite the same chair: a table you pull yourself is dealt against your own character’s fact sheet, of which more below.

An outcome is now simply the result. There is no croupier’s narration and no italic (rolled 14) suffix—what a roll says is the author’s to decide, spelled out with {{value}}, {{dice}}, and the other placeholders. The Salon’s message bar names the table by its display title, so a run reads as the event, not the machinery behind it.

The house keeps limits, as any house must. Sixty-four tools per scene; eight parameters and thirty-two outcomes per tool; a thousand characters per message, five hundred per description, eighty per title. An oracle’s prompt runs to four thousand characters and its error line to a thousand. Should a scene somehow exceed the roster limit, the surplus is dropped and said so out loud—never silently.

Every character vault gains an optional metadata.json: one flat object of arbitrary, user-authored keys with any JSON values you please— { "hasAnsibleAccess": true, "clearanceLevel": 3, "faction": "Ordo Aurum" }. Every other file in a vault answers to some field Aurora’s editor already knows about; the fact sheet answers to nothing at all, and Quilltap has not the faintest opinion about any of it. It hydrates onto the character and round-trips through export and import like everything else there.

Until now a roll settled a question and said so. Now it can also change the world it was asked about. A definition may carry side effects—up to sixteen conditional writes the house applies server-side the moment the outcome is settled and before Pascal announces it. The draw resolves, the effects land, and only then does the croupier speak, so the ledger and the announcement always agree.

A definition may carry one of two optional clauses: availableWhen, which offers the tool only to a character whose fact sheet passes every test, or withheldWhen, which quietly takes it from one who does. Each is written exactly as an outcome’s metadata clause—

{ "availableWhen": { "metadata": { "toolAbilities": { "contains": "programmable" } } } }

The gate is settled when the roster is assembled, before any roll— so a withheld tool is simply absent: not in the model’s description, not in the chat’s tool listing, not callable by name. A character who has not been given the ansible does not know the house owns one.

Only one of the two keys may appear in a file—a definition that both offers and withholds is a question its author has not yet finished asking—and the values compared against must be plain literals rather than $param or $state references, since the question is settled before there is a roll or a parameter for those to refer to.

Pulling a table yourself is no longer a matter of squinting into a narrow popover that vanished at the slightest click elsewhere. Where a scene has any custom tools at all, a wand appears in the composer’s left-hand gutter and opens a proper two-part dialog—one you may dismiss with Escape, with the backdrop, or with Cancel, and which does not close itself the moment your attention wanders. It remembers, too: close it and reopen it and you are back on the tool you last used, with the figures you last set still in their boxes, on the sound reasoning that the same roll is usually wanted twice and re-typing it is a tax on the second one.

Rolling this way posts exactly one thing: the outcome, precisely as it would have read had a character rolled it themselves. Pascal is a croupier and not a raconteur. Which means nothing records that it was you—should you nudge a parameter before rolling, that is between you and the wheel, and no character can read what you did to arrange the odds. They see what befell. This seems to us the correct division of information.

Custom tools began life as hand-authored JSON. They still can be—but they no longer have to be. Pascal’s Workbench, at /custom-tools, is a visual editor for the whole format, reachable as its own page, a workspace tab, a left-rail entry, and—from inside a scene—the composer’s custom-tools dialog: the wrench beside each listed tool, and New contrivance… at its foot. It is where a table goes from an idea to a saved, valid, provable document.

The bench keeps three further cards for the things a table needs supplied before it can be honestly tried. A fact sheet: pick a character and the bench reads their real metadata.json, hydrated fresh—the honest “what would happen if Imogen rolled this”—or hand-type a sheet for keys no character carries yet. Supply nothing and every metadata test declines, exactly as for an unattributed manual roll, and the bench says so rather than letting you wonder. A Mock state field beside it: type a JSON object to stand in for the cascade while you dry-run or audit a $state-using table, and leave it empty to watch every reference take its fallback—which is, after all, what a real run does when there is nothing to draw on. And, where the tool consults one, an oracle card that lets you script its answer, script a silence (the one path every such table must survive), or—for single rolls only—ask it live at the cost of one real cheap-model call. The audit never asks live: ten thousand hands must not mean ten thousand paid consults.

Nor is the Workbench’s inventory a private matter any longer. The Almanack now counts Pascal’s contrivances along with everything else in the house—including the definitions that failed to parse, which is the number you actually want, a recipe that silently refuses to load being precisely the one you will spend an evening looking for.

Not every improvement is a new mechanic. Some are simply the house remembering how you like your dice, naming a result the way you would, and letting an outcome wear its own colours.

Pascal’s tools have already been used in ways that show what they are for:

The narrow room lit by green lamps has grown crowded, but it still has space for more tables. Fair randomness, persistent structured state, author-defined tables, and a bench to build them—that is a great deal of the infrastructure games require. What sits on top of it is a matter of time and ambition.

Dice games with formal rule enforcement. Card games with shuffled decks and dealt hands. Mahjong with tile draws and discard logic. Full tabletop RPG support with character sheets, initiative tracking, and combat resolution. These are not announced features—they are the natural extensions of a system that already rolls dice fairly, runs custom tables honestly, tracks state across four tiers, and lets AI characters participate as players. The tables are filling. The croupier is still watching.

Pascal is quiet as usual. Watching. Waiting. He knows exactly how the odds will fall.