@dynamicagents/plugins 0.11.0 → 0.12.0

package/README.md

@@ -80,17 +80,17 @@ needing per-caller state takes it the same way.
 
 ## The plugins
 
-| Subpath                            | What it adds                                                                                 | Needs                                        |
-| ---------------------------------- | -------------------------------------------------------------------------------------------- | -------------------------------------------- |
-| [`/arc-agi`](src/arc-agi/)         | Play ARC-AGI-3 games — a delegable subtask type, a catalogue tool, a scorecard ledger        | `ARC_API_KEY`                                |
-| [`/browser`](src/browser/)         | Read web pages via Browser Rendering Quick Actions                                           | `BROWSER` (paid plan)                        |
-| [`/claude-code`](src/claude-code/) | Delegate a coding task to a Claude Code session in the workspace container                   | one or more `claude setup-token` credentials |
-| [`/computer`](src/computer/)       | A Linux container whose filesystem outlives it: shell, package manager, unrestricted network | `@cloudflare/computer` (paid)                |
-| [`/recall`](src/recall/)           | Episodic memory over Vectorize — search history that compaction folded away                  | `VECTORIZE` (1024-dim/cosine)                |
-| [`/repo`](src/repo/)               | Clone, commit, push a branch, open a pull request — over any container                       | `GITHUB_TOKEN`                               |
-| [`/scratch`](src/scratch/)         | A throwaway git repository with no remote, for work that needs a container but no checkout   | —                                            |
-| [`/triage`](src/triage/)           | A pre-turn gate: is this message even for me?                                                | —                                            |
-| [`/workspace`](src/workspace/)     | A durable file store for long subagent runs, plus tools over it                              | `@cloudflare/shell`                          |
+| Subpath                            | What it adds                                                                                                        | Needs                                              |
+| ---------------------------------- | ------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------- |
+| [`/arc-agi`](src/arc-agi/)         | Play ARC-AGI-3 games — a delegable subtask type, a catalogue tool, a scorecard ledger                               | `ARC_API_KEY`                                      |
+| [`/browser`](src/browser/)         | Read web pages via Browser Rendering Quick Actions                                                                  | `BROWSER` (paid plan)                              |
+| [`/claude-code`](src/claude-code/) | Delegate a coding task to a Claude Code session in the workspace container                                          | one or more `claude setup-token` credentials       |
+| [`/computer`](src/computer/)       | A Linux container whose filesystem outlives it — shell, package manager, network, and the Durable Object it runs in | `@cloudflare/computer`, `@platformatic/vfs` (paid) |
+| [`/recall`](src/recall/)           | Episodic memory over Vectorize — search history that compaction folded away                                         | `VECTORIZE` (1024-dim/cosine)                      |
+| [`/repo`](src/repo/)               | Clone, commit, push a branch, open a pull request — over any container                                              | `GITHUB_TOKEN`                                     |
+| [`/scratch`](src/scratch/)         | A throwaway git repository with no remote, for work that needs a container but no checkout                          | —                                                  |
+| [`/triage`](src/triage/)           | A pre-turn gate: is this message even for me?                                                                       | —                                                  |
+| [`/workspace`](src/workspace/)     | A durable file store for long subagent runs, plus tools over it                                                     | `@cloudflare/shell`                                |
 
 Each directory has its own README with the config shape and a paste-ready `wrangler.jsonc`
 snippet — a plugin cannot add its own binding, which is why it declares what it needs.
@@ -130,8 +130,7 @@ Specs run inside real workerd via `@cloudflare/vitest-plugin`, with the harness
 
 ```bash
 npm test          # the whole suite, no credentials and no network
-npm run check     # prettier + eslint + tsc + build
-npm run verify:exports
+npm run check     # prettier + eslint + tsc + build, then verify:exports over it
 ```
 
 ### Working against an unpublished core

package/dist/arc-agi/analysis.d.ts

@@ -84,11 +84,6 @@ export interface Component extends Box {
     color: number;
     size: number;
 }
-export interface ComponentSummary {
-    color: number;
-    components: number;
-    largest: number;
-}
 /**
  * Every 4-connected same-color region, with its bounding box, largest first.
  * Skips {@link BACKGROUND_COLOR}.
@@ -99,19 +94,12 @@ export interface ComponentSummary {
  * visit every cell regardless, so tracking min/max row/col is free.
  */
 export declare function locateComponents(grid: number[][]): Component[];
-/**
- * Summarize components per color: how many, and the largest. Derived from
- * {@link locateComponents} so only one flood fill ever runs.
- */
-export declare function connectedComponents(grid: number[][]): ComponentSummary[];
 /**
  * How much of its bounding box a region actually occupies, 0–1.
  *
- * Boxes are well formed by construction wherever this is used: every caller
- * passes either a {@link Component} from {@link locateComponents} or a
- * {@link unionBox} of those, and a flood fill cannot produce `bottom < top`. So
- * `area` is always at least 1, and the zero-area branch below is unreachable —
- * kept only so a malformed box degrades to 0 instead of dividing by zero.
+ * Every caller passes a {@link Component} from {@link locateComponents} or a
+ * {@link unionBox} of those, and a flood fill cannot produce `bottom < top`, so
+ * `area` is at least 1 and there is nothing to guard against dividing by.
  *
  * The result is deliberately **not** clamped into 0–1. An out-of-range value here
  * could only mean a caller broke that invariant, and the way to learn that is a
@@ -154,12 +142,12 @@ export declare function renderSpans(bands: SpanBand[]): string;
  *
  * A bounding box describes a region only when the region roughly fills it. That
  * holds for the movable pieces and fails for exactly the two things a route
- * depends on: on a real `ls20` board the model was told `off-black: rows 0-63,
- * cols 0-63 (2129 cells)` for the whole maze and `neutral: rows 5-54, cols 9-58
- * (1354 cells)` for the whole floor, both a shade over half-filled. The first says
- * nothing; the second is worse, asserting a 50×50 open arena of which 46% is wall.
- * Blind to both, the play read its route off the boxes and walked into walls, then
- * spent a dozen turns rebuilding the maze through 11×11 `region` peepholes.
+ * depends on: on a real `ls20` board the maze boxes as `off-black: rows 0-63,
+ * cols 0-63 (2129 cells)` and the floor as `neutral: rows 5-54, cols 9-58 (1354
+ * cells)`, both a shade over half-filled. The first says nothing; the second is
+ * worse, asserting a 50×50 open arena of which 46% is wall — and a play reading
+ * its route off those boxes walks into walls, then spends a dozen turns
+ * rebuilding the maze through 11×11 `region` peepholes.
  *
  * So a region that sprawls is rendered as {@link colorSpans} instead — every row
  * band and the columns it occupies, which is the same fact at a resolution that
@@ -257,9 +245,8 @@ export declare function describeShift(dRow: number, dCol: number): string;
  * *blocked or refused*: it leads a step only when everything else the delta holds
  * is a {@link ShapeChange} of kind `resized`, which is a counter or a bar doing
  * its own bookkeeping. A step that repainted a block, or made one appear, changed
- * the board — no object travelled, and saying so as `nothing moved` told a logged
- * `ft09` play that twenty clicks which each toggled a 36-cell block had been
- * refused.
+ * the board — no object travelled, and reporting that as `nothing moved` tells a
+ * click game that twenty clicks which each toggled a 36-cell block were refused.
  *
  * Null means *this view has nothing to say* — either no shape can be paired
  * across the frames, or so many changed that they are a repaint
@@ -326,11 +313,10 @@ export declare function renderGrid(grid: number[][]): string;
  * `firstCol + i`. Padding off-grid columns with spaces instead would shift that
  * mapping by up to `radius` near the left edge.
  *
- * The header used to be the only thing to count from, on the reasoning that a
- * window this narrow does not need a ruler. Logs disagree: asked to place a cell
- * in an 11-wide window, the model counted the characters by hand and got them
- * wrong — "cols 34-38, 5 chars wait that's 10... hmm" — then reasoned on the wrong
- * columns. So the window is ruled too, at {@link REGION_RULER_STEP} rather than
- * {@link renderGrid}'s tens, which a window this size can miss entirely.
+ * **The window is ruled, not just headed.** A model asked to place a cell in an
+ * 11-wide window counts the characters by hand and gets them wrong, then reasons
+ * on the columns it miscounted — so narrow is exactly where the ruler is needed.
+ * It steps at {@link REGION_RULER_STEP} rather than {@link renderGrid}'s tens,
+ * which a window this size can miss entirely.
  */
 export declare function renderRegion(grid: number[][], centerRow: number, centerCol: number, radius?: number): string;

package/dist/arc-agi/analysis.js

@@ -204,42 +204,19 @@ export function locateComponents(grid) {
     }
     return found.sort((x, y) => y.size - x.size);
 }
-/**
- * Summarize components per color: how many, and the largest. Derived from
- * {@link locateComponents} so only one flood fill ever runs.
- */
-export function connectedComponents(grid) {
-    const perColor = new Map();
-    for (const comp of locateComponents(grid)) {
-        const entry = perColor.get(comp.color) ?? { components: 0, largest: 0 };
-        entry.components++;
-        entry.largest = Math.max(entry.largest, comp.size);
-        perColor.set(comp.color, entry);
-    }
-    return [...perColor.entries()]
-        .map(([color, v]) => ({
-        color,
-        components: v.components,
-        largest: v.largest
-    }))
-        .sort((x, y) => y.components - x.components);
-}
 /**
  * How much of its bounding box a region actually occupies, 0–1.
  *
- * Boxes are well formed by construction wherever this is used: every caller
- * passes either a {@link Component} from {@link locateComponents} or a
- * {@link unionBox} of those, and a flood fill cannot produce `bottom < top`. So
- * `area` is always at least 1, and the zero-area branch below is unreachable —
- * kept only so a malformed box degrades to 0 instead of dividing by zero.
+ * Every caller passes a {@link Component} from {@link locateComponents} or a
+ * {@link unionBox} of those, and a flood fill cannot produce `bottom < top`, so
+ * `area` is at least 1 and there is nothing to guard against dividing by.
  *
  * The result is deliberately **not** clamped into 0–1. An out-of-range value here
  * could only mean a caller broke that invariant, and the way to learn that is a
  * region classified absurdly, not a number quietly corrected into looking sane.
  */
 export function fillRatio(box, size) {
-    const area = (box.bottom - box.top + 1) * (box.right - box.left + 1);
-    return area === 0 ? 0 : size / area;
+    return size / ((box.bottom - box.top + 1) * (box.right - box.left + 1));
 }
 /**
  * The rectangle enclosing several boxes. Takes a **non-empty** list — the reduce
@@ -349,12 +326,12 @@ const SPRAWL_COLORS = 3;
  *
  * A bounding box describes a region only when the region roughly fills it. That
  * holds for the movable pieces and fails for exactly the two things a route
- * depends on: on a real `ls20` board the model was told `off-black: rows 0-63,
- * cols 0-63 (2129 cells)` for the whole maze and `neutral: rows 5-54, cols 9-58
- * (1354 cells)` for the whole floor, both a shade over half-filled. The first says
- * nothing; the second is worse, asserting a 50×50 open arena of which 46% is wall.
- * Blind to both, the play read its route off the boxes and walked into walls, then
- * spent a dozen turns rebuilding the maze through 11×11 `region` peepholes.
+ * depends on: on a real `ls20` board the maze boxes as `off-black: rows 0-63,
+ * cols 0-63 (2129 cells)` and the floor as `neutral: rows 5-54, cols 9-58 (1354
+ * cells)`, both a shade over half-filled. The first says nothing; the second is
+ * worse, asserting a 50×50 open arena of which 46% is wall — and a play reading
+ * its route off those boxes walks into walls, then spends a dozen turns
+ * rebuilding the maze through 11×11 `region` peepholes.
  *
  * So a region that sprawls is rendered as {@link colorSpans} instead — every row
  * band and the columns it occupies, which is the same fact at a resolution that
@@ -532,11 +509,9 @@ export function matchShapes(before, after) {
  *
  * A click game is the case this exists for. Nothing on such a board ever travels,
  * so both earlier passes — which pair within a color — leave every changed block
- * as a `gone` and an `appeared` at the same coordinates, and a whole play reads as
- * things vanishing and other things materializing where they stood. The logged
- * `ft09` play was told `blue 6×6 at rows 36-41, cols 36-41 is gone; red 6×6
- * appeared at rows 36-41, cols 36-41` twenty times and had to work out for itself,
- * across several turns, that a click toggles a block's color.
+ * as a `gone` and an `appeared` at the same coordinates: `blue 6×6 at rows 36-41,
+ * cols 36-41 is gone; red 6×6 appeared at rows 36-41, cols 36-41`, twenty times
+ * over, with the model left to work out for itself that a click toggles a colour.
  *
  * Box and size together are strong evidence and not proof — two different shapes
  * can share a bounding box and a cell count without sharing a cell — but the
@@ -595,9 +570,8 @@ function describeDestination(change) {
  * *blocked or refused*: it leads a step only when everything else the delta holds
  * is a {@link ShapeChange} of kind `resized`, which is a counter or a bar doing
  * its own bookkeeping. A step that repainted a block, or made one appear, changed
- * the board — no object travelled, and saying so as `nothing moved` told a logged
- * `ft09` play that twenty clicks which each toggled a 36-cell block had been
- * refused.
+ * the board — no object travelled, and reporting that as `nothing moved` tells a
+ * click game that twenty clicks which each toggled a 36-cell block were refused.
  *
  * Null means *this view has nothing to say* — either no shape can be paired
  * across the frames, or so many changed that they are a repaint
@@ -790,12 +764,11 @@ export function renderGrid(grid) {
  * `firstCol + i`. Padding off-grid columns with spaces instead would shift that
  * mapping by up to `radius` near the left edge.
  *
- * The header used to be the only thing to count from, on the reasoning that a
- * window this narrow does not need a ruler. Logs disagree: asked to place a cell
- * in an 11-wide window, the model counted the characters by hand and got them
- * wrong — "cols 34-38, 5 chars wait that's 10... hmm" — then reasoned on the wrong
- * columns. So the window is ruled too, at {@link REGION_RULER_STEP} rather than
- * {@link renderGrid}'s tens, which a window this size can miss entirely.
+ * **The window is ruled, not just headed.** A model asked to place a cell in an
+ * 11-wide window counts the characters by hand and gets them wrong, then reasons
+ * on the columns it miscounted — so narrow is exactly where the ruler is needed.
+ * It steps at {@link REGION_RULER_STEP} rather than {@link renderGrid}'s tens,
+ * which a window this size can miss entirely.
  */
 export function renderRegion(grid, centerRow, centerCol, radius = 5) {
     if (grid.length === 0)

package/dist/arc-agi/client.d.ts

@@ -73,8 +73,9 @@ export interface ArcClientOptions {
     maxAttempts?: number;
     /**
      * Stops every request this client makes, and every wait between them. Taken at
-     * construction, because a client built for one tool surface stops on that
-     * surface's signal — core's `ToolFamilyContext.signal` for a subagent's.
+     * construction, so a client lives no longer than the signal it stops on: a tool
+     * builds one per call, from that call's signal — see
+     * {@link file://./tools.ts buildArcGameTools}.
      */
     signal?: AbortSignal;
 }

package/dist/arc-agi/game-tools.d.ts

@@ -3,12 +3,11 @@ import type { ArcClient } from "./client.js";
 /**
  * The **main agent's** ARC tool: the game catalogue, and nothing else.
  *
- * It used to also own the scorecard lifecycle — open a card, name it in each
- * play's params, close it for the score. That modelled a lifecycle the API
- * already manages (it auto-closes an idle card), and made every play depend on
- * the model getting the bookkeeping right. The card is now leased by the recipe
- * (see {@link file://./scorecard.ts}) and never named here, so the only thing the
- * main agent still needs from ARC is the exact game id to delegate a play with.
+ * **No scorecard lifecycle here.** The API retires an idle card itself, so a
+ * card opened, named and closed by the model is a lifecycle modelled twice with
+ * every play depending on the model's bookkeeping. The card is leased by the
+ * recipe (see {@link file://./scorecard.ts}) and never named here, so the only
+ * thing the main agent needs from ARC is the exact game id to delegate with.
  *
  * Handlers are exported separately from the `tool()` wiring so they unit-test
  * without an LLM, and the client is closed over so it is never model input.

package/dist/arc-agi/index.d.ts

@@ -6,15 +6,13 @@ import type { ArcRuntime } from "./types.js";
 /**
  * `@dynamicagents/plugins/arc-agi` — play ARC-AGI-3 games.
  *
- * The stress test for the whole plugin contract, and the reason three of its
- * hooks exist. In the predecessor these were four leaks in the agent's Durable
- * Object — `resolveRuntime`, `arcScorecardDeps`, `leaseScorecard`/`leasePlay`,
- * and `enrichResult` — each a piece of ARC-specific policy living in code that
- * had no other reason to know what a scorecard was. Inverted, they are this
- * file.
+ * The stress test for the whole plugin contract, and the reason `resolveRuntime`,
+ * the lease hooks and `enrichResult` exist on it: every one of them is a piece of
+ * ARC-specific policy that would otherwise sit in an agent's Durable Object,
+ * which has no other reason to know what a scorecard is.
  *
- * What the split makes visible: the *only* thing the agent still knows is that
- * it installed a plugin. Nothing in a loop, a workflow, or a DO names a card, a
+ * The line that keeps it honest: the *only* thing the agent knows is that it
+ * installed a plugin. Nothing in a loop, a workflow, or a DO names a card, a
  * guid, or a game.
  */
 /** Everything this plugin needs from its host. */

package/dist/arc-agi/index.js

@@ -18,9 +18,9 @@ export function arcAgi(config) {
     /**
      * In-flight leases, collapsed so concurrent branches share one call.
      *
-     * These were DO instance fields in the predecessor, and the plugin is built
-     * per DO instance, so this closure is the same scope — but it is now the scope
-     * of the thing that *cares*, rather than of the agent that merely hosted it.
+     * The plugin is built once per DO instance, so this closure is per-instance
+     * scope — held by the thing that cares about a card rather than by the agent
+     * that merely hosts it.
      *
      * Load-bearing, not an optimization. All of a round's ready Subtasks execute
      * concurrently, and opening a card is a `fetch`, which opens the DO's input

package/dist/arc-agi/main-agent.d.ts

@@ -3,14 +3,11 @@ import type { DelegationNames } from "@dynamicagents/core";
  * Everything the **main agent** is told about ARC-AGI-3 — the counterpart to
  * {@link file://./soul.ts}, which is what the *subagent* playing a game is told.
  *
- * Both blocks used to be hand-written inside `agent/` (`prompt.ts`'s
- * `ARC_CAPABILITY` and a `## Playing an ARC-AGI-3 game` section of
- * `turn.ts`'s round contract). The main agent's system prompt is soul +
- * round contract concatenated, so it read ARC advice twice per round from two
- * files with no reason to agree — and they had stopped agreeing: one said to
- * delegate a subtask per game, the other said to delegate exactly one subtask and
- * nothing else. They are one file now, and the guidance below follows the
- * capability block.
+ * **The capability block and the delegation guidance stay in this one file.** A
+ * main agent's system prompt is soul plus round contract concatenated, so split
+ * across two files they are two statements of the same advice with no reason to
+ * agree — and the way they disagree is one telling the model to delegate a
+ * subtask per game while the other allows exactly one.
  */
 /**
  * The capability block: what the agent can do, and what to do with a result that

package/dist/arc-agi/main-agent.js

@@ -2,14 +2,11 @@
  * Everything the **main agent** is told about ARC-AGI-3 — the counterpart to
  * {@link file://./soul.ts}, which is what the *subagent* playing a game is told.
  *
- * Both blocks used to be hand-written inside `agent/` (`prompt.ts`'s
- * `ARC_CAPABILITY` and a `## Playing an ARC-AGI-3 game` section of
- * `turn.ts`'s round contract). The main agent's system prompt is soul +
- * round contract concatenated, so it read ARC advice twice per round from two
- * files with no reason to agree — and they had stopped agreeing: one said to
- * delegate a subtask per game, the other said to delegate exactly one subtask and
- * nothing else. They are one file now, and the guidance below follows the
- * capability block.
+ * **The capability block and the delegation guidance stay in this one file.** A
+ * main agent's system prompt is soul plus round contract concatenated, so split
+ * across two files they are two statements of the same advice with no reason to
+ * agree — and the way they disagree is one telling the model to delegate a
+ * subtask per game while the other allows exactly one.
  */
 /**
  * The capability block: what the agent can do, and what to do with a result that

package/dist/arc-agi/recipe.d.ts

@@ -8,19 +8,18 @@ export declare const ARC_GAME_TYPE = "arc-game";
  * a turn budget twice the baseline — a play is a long sequence of cheap decisions,
  * and 20 turns bought roughly ten game actions once inspection was paid for.
  *
- * It used to be "the long recipe", budgeted at 1,000 turns on the reasoning that
- * 25 turns per chunk made 40 durable chunks. That arithmetic assumed a turn under
- * ten seconds. A turn here is a reasoning model plus an ARC HTTP round trip, so
- * real runs took 70-100 chunks, blew the per-branch cap, and were *failed* after
- * hours of unattended play rather than being asked to report. The budget is now
- * time and turns, both enforced directly, and a play ends through the graceful
- * summary — a terminal report with the metrics footer.
+ * **Budget the turns, never the chunks.** A turn here is a reasoning model plus
+ * an ARC HTTP round trip, nothing like the sub-ten-second turn a chunk count is
+ * implicitly sized against: 1,000 turns sliced 25 to a chunk is 40 chunks on
+ * paper and 70-100 in a real run, which blows the per-branch cap and *fails* a
+ * play after hours rather than asking it to report. Time and turns are both
+ * enforced directly, and a play ends through the graceful summary — a terminal
+ * report with the metrics footer.
  *
- * - `historyWindow` bounds context, and it is now the model's *only* memory: the
- *   workspace tools are gone (see below), so a plan that scrolls out of it is
- *   gone. Note it counts *assistant messages* — one per tool call, not one per
- *   game action — so a play spends it several times faster than the number
- *   suggests.
+ * - `historyWindow` bounds context, and it is the model's *only* memory: with no
+ *   workspace tools (see below) a plan that scrolls out of it is gone. Note it
+ *   counts *assistant messages* — one per tool call, not one per game action —
+ *   so a play spends it several times faster than the number suggests.
  * - `reportMetrics` appends the turns/model-calls/wall-clock footer the user
  *   asked to see.
  *
@@ -28,14 +27,12 @@ export declare const ARC_GAME_TYPE = "arc-game";
  * state kept in the workspace), code-validated by
  * `validateRecipe`/`buildRecipeTools`.
  *
- * It used to also carry `workspace`, on the theory that a small history window
- * needs a file store behind it. Two logged plays say otherwise: `ws_read` was
- * never called once, and the three `ws_write` calls between them were a
- * scratchpad for arithmetic — a use that costs a turn per note and now belongs in
- * `arc_act`'s `note` field, which costs none and stays in the model's own history.
- * The session file is unaffected: the family reaches the workspace through its
- * {@link file://../../agent/tools.ts ToolFamilyContext}, not through the tools the
- * model can see.
+ * **No `workspace` family, despite the small history window.** Across two logged
+ * plays `ws_read` was never called and the three `ws_write` calls were a
+ * scratchpad for arithmetic — a note costing a turn apiece, which `arc_act`'s
+ * `note` field carries for free and keeps in the model's own history. The
+ * session file is unaffected: the family reaches the workspace through the
+ * `ToolFamilyContext` core hands it, not through tools the model can see.
  */
 export declare const ARC_GAME_RECIPE: ResolvedRecipe;
 /**

package/dist/arc-agi/recipe.js

@@ -10,19 +10,18 @@ export const ARC_GAME_TYPE = "arc-game";
  * a turn budget twice the baseline — a play is a long sequence of cheap decisions,
  * and 20 turns bought roughly ten game actions once inspection was paid for.
  *
- * It used to be "the long recipe", budgeted at 1,000 turns on the reasoning that
- * 25 turns per chunk made 40 durable chunks. That arithmetic assumed a turn under
- * ten seconds. A turn here is a reasoning model plus an ARC HTTP round trip, so
- * real runs took 70-100 chunks, blew the per-branch cap, and were *failed* after
- * hours of unattended play rather than being asked to report. The budget is now
- * time and turns, both enforced directly, and a play ends through the graceful
- * summary — a terminal report with the metrics footer.
+ * **Budget the turns, never the chunks.** A turn here is a reasoning model plus
+ * an ARC HTTP round trip, nothing like the sub-ten-second turn a chunk count is
+ * implicitly sized against: 1,000 turns sliced 25 to a chunk is 40 chunks on
+ * paper and 70-100 in a real run, which blows the per-branch cap and *fails* a
+ * play after hours rather than asking it to report. Time and turns are both
+ * enforced directly, and a play ends through the graceful summary — a terminal
+ * report with the metrics footer.
  *
- * - `historyWindow` bounds context, and it is now the model's *only* memory: the
- *   workspace tools are gone (see below), so a plan that scrolls out of it is
- *   gone. Note it counts *assistant messages* — one per tool call, not one per
- *   game action — so a play spends it several times faster than the number
- *   suggests.
+ * - `historyWindow` bounds context, and it is the model's *only* memory: with no
+ *   workspace tools (see below) a plan that scrolls out of it is gone. Note it
+ *   counts *assistant messages* — one per tool call, not one per game action —
+ *   so a play spends it several times faster than the number suggests.
  * - `reportMetrics` appends the turns/model-calls/wall-clock footer the user
  *   asked to see.
  *
@@ -30,14 +29,12 @@ export const ARC_GAME_TYPE = "arc-game";
  * state kept in the workspace), code-validated by
  * `validateRecipe`/`buildRecipeTools`.
  *
- * It used to also carry `workspace`, on the theory that a small history window
- * needs a file store behind it. Two logged plays say otherwise: `ws_read` was
- * never called once, and the three `ws_write` calls between them were a
- * scratchpad for arithmetic — a use that costs a turn per note and now belongs in
- * `arc_act`'s `note` field, which costs none and stays in the model's own history.
- * The session file is unaffected: the family reaches the workspace through its
- * {@link file://../../agent/tools.ts ToolFamilyContext}, not through the tools the
- * model can see.
+ * **No `workspace` family, despite the small history window.** Across two logged
+ * plays `ws_read` was never called and the three `ws_write` calls were a
+ * scratchpad for arithmetic — a note costing a turn apiece, which `arc_act`'s
+ * `note` field carries for free and keeps in the model's own history. The
+ * session file is unaffected: the family reaches the workspace through the
+ * `ToolFamilyContext` core hands it, not through tools the model can see.
  */
 export const ARC_GAME_RECIPE = {
     key: ARC_GAME_TYPE,

package/dist/arc-agi/soul.d.ts

@@ -7,34 +7,23 @@
  * Subtask param and the card is resolved runtime state, so the tools close over
  * both and the model never names, chooses, or copies either id.
  *
- * Three sections here are written against specific, logged failures rather than
- * against a theory of good play, and each says so where it sits:
+ * Sections written against logged failures rather than a theory of good play,
+ * and the constraints they carry:
  *
- * - **Memory** used to be workspace discipline ("write your notes to a file").
- *   Two plays never read a note back, so the notes are gone and what replaces
- *   them is `arc_act`'s `note` field, which costs no turn.
- * - **Finishing** used to ask for the rules "in prose", and got a final report
- *   whose central claim its own last tool result contradicted. It now asks for
- *   provenance: observed, inferred, or untested.
- * - **Inherited knowledge** is new. A play handed a route from an earlier play
- *   executed it faithfully while the board disagreed, because nothing told it
- *   that what it was given was a guess about a level nobody had finished.
- * - **Reading a step's result** used to teach one phrase, `nothing moved`, as the
- *   whole vocabulary of a step that achieved nothing. That is a movement game's
- *   vocabulary: a click game moves nothing ever, and the play that found this out
- *   was told its every click had been "refused or blocked" while each was toggling
- *   a 36-cell block. The registers are now named separately here and rendered
- *   separately in {@link file://./analysis.ts}.
- * - **Where the views stand** was rewritten against measurements. It used to sell
- *   `shapes` as cheap and `grid` as the expensive last resort; three logged plays
- *   answered by calling `region` twelve times and `grid` not once, mapping a maze
- *   through 11×11 peepholes because the one line `shapes` gave them for the wall
- *   was its full-board bounding box. `shapes` now carries the terrain itself, and
- *   the full grid of a real board is 35 collapsed lines — so the ordering here is
+ * - **Reading a step's result** names each register separately — refused,
+ *   nothing moved, changed but did not travel — because `nothing moved` is a
+ *   movement game's vocabulary and a click game moves nothing ever. The wording
+ *   here is paired with the rendering in {@link file://./analysis.ts}: teach a
+ *   register the prompt does not name, or name one the renderer never emits, and
+ *   the model reads every click as refused.
+ * - **Where the views stand** is ordered by measurement, not by cost intuition:
  *   `shapes` for the map, `grid` for exact cells, `region` for fine detail only.
- *   The batching section gained the step that follows from it: a route is checked
- *   against those bands before it is sent. That check lives here rather than in
- *   the tool because it is a judgement about the game's rules — what blocks what —
- *   and a tool that made it would be guessing on the model's behalf.
+ *   The full grid of a real board is 35 collapsed lines, so `grid` is not the
+ *   expensive last resort it reads as; rank it as one and the model maps a
+ *   maze through `region` peepholes rather than reading the board whole.
+ * - **Batching** requires a route to be walked against those bands before it is
+ *   sent. That check is here rather than in the tool because it is a judgement
+ *   about the game's rules — what blocks what — and a tool making it would be
+ *   guessing on the model's behalf.
  */
 export declare const ARC_GAME_SOUL: string;

package/dist/arc-agi/soul.js

@@ -7,35 +7,24 @@
  * Subtask param and the card is resolved runtime state, so the tools close over
  * both and the model never names, chooses, or copies either id.
  *
- * Three sections here are written against specific, logged failures rather than
- * against a theory of good play, and each says so where it sits:
+ * Sections written against logged failures rather than a theory of good play,
+ * and the constraints they carry:
  *
- * - **Memory** used to be workspace discipline ("write your notes to a file").
- *   Two plays never read a note back, so the notes are gone and what replaces
- *   them is `arc_act`'s `note` field, which costs no turn.
- * - **Finishing** used to ask for the rules "in prose", and got a final report
- *   whose central claim its own last tool result contradicted. It now asks for
- *   provenance: observed, inferred, or untested.
- * - **Inherited knowledge** is new. A play handed a route from an earlier play
- *   executed it faithfully while the board disagreed, because nothing told it
- *   that what it was given was a guess about a level nobody had finished.
- * - **Reading a step's result** used to teach one phrase, `nothing moved`, as the
- *   whole vocabulary of a step that achieved nothing. That is a movement game's
- *   vocabulary: a click game moves nothing ever, and the play that found this out
- *   was told its every click had been "refused or blocked" while each was toggling
- *   a 36-cell block. The registers are now named separately here and rendered
- *   separately in {@link file://./analysis.ts}.
- * - **Where the views stand** was rewritten against measurements. It used to sell
- *   `shapes` as cheap and `grid` as the expensive last resort; three logged plays
- *   answered by calling `region` twelve times and `grid` not once, mapping a maze
- *   through 11×11 peepholes because the one line `shapes` gave them for the wall
- *   was its full-board bounding box. `shapes` now carries the terrain itself, and
- *   the full grid of a real board is 35 collapsed lines — so the ordering here is
+ * - **Reading a step's result** names each register separately — refused,
+ *   nothing moved, changed but did not travel — because `nothing moved` is a
+ *   movement game's vocabulary and a click game moves nothing ever. The wording
+ *   here is paired with the rendering in {@link file://./analysis.ts}: teach a
+ *   register the prompt does not name, or name one the renderer never emits, and
+ *   the model reads every click as refused.
+ * - **Where the views stand** is ordered by measurement, not by cost intuition:
  *   `shapes` for the map, `grid` for exact cells, `region` for fine detail only.
- *   The batching section gained the step that follows from it: a route is checked
- *   against those bands before it is sent. That check lives here rather than in
- *   the tool because it is a judgement about the game's rules — what blocks what —
- *   and a tool that made it would be guessing on the model's behalf.
+ *   The full grid of a real board is 35 collapsed lines, so `grid` is not the
+ *   expensive last resort it reads as; rank it as one and the model maps a
+ *   maze through `region` peepholes rather than reading the board whole.
+ * - **Batching** requires a route to be walked against those bands before it is
+ *   sent. That check is here rather than in the tool because it is a judgement
+ *   about the game's rules — what blocks what — and a tool making it would be
+ *   guessing on the model's behalf.
  */
 export const ARC_GAME_SOUL = [
     "You are playing an ARC-AGI-3 game: a visual-reasoning puzzle on a 64×64 grid of colored cells. You discover the game's hidden rules by acting and observing, and progress through levels toward a win.",

package/dist/arc-agi/store.d.ts

@@ -14,11 +14,10 @@ import type { ScorecardStore } from "./scorecard.js";
  *
  * A plugin must never run drizzle's durable-sqlite **migrator**: it keeps one
  * flat integer journal and one global `__drizzle_migrations` table, which two
- * independently-versioned packages cannot share — the two predecessor agents,
- * both consuming the same `notify_tasks` module, had already forked that journal
- * at index 1. And `drizzle-kit generate` diffs against a snapshot in a single
- * output directory, so a plugin shipping from its own repo cannot produce a
- * correct diff at all.
+ * independently-versioned packages cannot share: two agents consuming the same
+ * module fork that journal at the first index they disagree on. And
+ * `drizzle-kit generate` diffs against a snapshot in a single output directory,
+ * so a plugin shipping from its own repo cannot produce a correct diff at all.
  *
  * None of that touches the **query builder**, which is a typed wrapper over the
  * same `DurableObjectStorage` holding no journal and no connection state. So the