@dynamicagents/plugins 0.11.1 → 0.13.0

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

@@ -1,82 +0,0 @@
-import { type CookieJar, type FrameResponse, type GameInfo, type ScorecardSummary } from "./types.js";
-/**
- * Typed client for the ARC-AGI-3 REST API.
- *
- * Two Workers-specific concerns are handled explicitly, because `fetch` in a
- * Worker manages neither:
- *
- * - **Session affinity**: the API pins a game session to a load-balancer via
- *   `AWSALB*` cookies returned on RESET/ACTION responses; they MUST be echoed on
- *   every subsequent request. The jar is passed in and returned as plain data
- *   (not a stateful client), so it checkpoints into the workspace and survives
- *   isolate eviction between chunks.
- * - **Rate limiting**: 600 RPM → 429; we honor `Retry-After` with bounded
- *   exponential backoff. Exhausted retries and 5xx throw (transient — the
- *   Workflow step retries and the runner resumes from its checkpoint); a 401
- *   throws a tagged deterministic error (bad key — a terminal failure).
- * - **Cancellation**: a client built with a `signal` stops at it — the `fetch` and
- *   the backoff between retries alike. `Retry-After` is honoured up to
- *   {@link MAX_RETRY_AFTER_MS} and no further: the header is the server's to set,
- *   and an uncapped one parks a tool for as long as the server likes.
- */
-export interface ArcClient {
-    listGames(cookies: CookieJar): Promise<{
-        games: GameInfo[];
-        cookies: CookieJar;
-    }>;
-    openScorecard(cookies: CookieJar): Promise<{
-        cardId: string;
-        cookies: CookieJar;
-    }>;
-    /**
-     * The whole card, with one `environments` entry per game played on it.
-     * Readable while the card is still open, which is what lets a result be
-     * reported without anything closing a card.
-     */
-    getScorecard(cardId: string, cookies: CookieJar): Promise<{
-        summary: ScorecardSummary;
-        cookies: CookieJar;
-    }>;
-    reset(input: {
-        gameId: string;
-        cardId: string;
-        guid?: string;
-    }, cookies: CookieJar): Promise<{
-        frame: FrameResponse;
-        cookies: CookieJar;
-    }>;
-    act(input: {
-        action: number;
-        gameId: string;
-        guid: string;
-        x?: number;
-        y?: number;
-        note?: string;
-    }, cookies: CookieJar): Promise<{
-        frame: FrameResponse;
-        cookies: CookieJar;
-    }>;
-}
-/**
- * The longest a `Retry-After` is waited out. A minute covers the API's own
- * per-minute rate window; past that the header is either hostile or describing an
- * outage, and a retry loop is the wrong place to sit through either.
- */
-export declare const MAX_RETRY_AFTER_MS = 60000;
-/** Message prefix of the deterministic (non-retryable) auth error. */
-export declare const ARC_AUTH_ERROR = "arc-client: unauthorized";
-export interface ArcClientOptions {
-    fetchFn?: typeof fetch;
-    /** Injected for tests; defaults to a real timed sleep. */
-    sleep?: (ms: number) => Promise<void>;
-    /** Max attempts per request before a 429/5xx becomes a thrown transient fault. */
-    maxAttempts?: number;
-    /**
-     * Stops every request this client makes, and every wait between them. Taken at
-     * 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;
-}
-export declare function makeArcClient(apiKey: string, options?: ArcClientOptions): ArcClient;

package/dist/arc-agi/client.js

@@ -1,113 +0,0 @@
-import { withAbort } from "@dynamicagents/core";
-import { ARC_BASE_URL } from "./types.js";
-/**
- * The longest a `Retry-After` is waited out. A minute covers the API's own
- * per-minute rate window; past that the header is either hostile or describing an
- * outage, and a retry loop is the wrong place to sit through either.
- */
-export const MAX_RETRY_AFTER_MS = 60_000;
-/** Message prefix of the deterministic (non-retryable) auth error. */
-export const ARC_AUTH_ERROR = "arc-client: unauthorized";
-const realSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-/** Merge `set-cookie` headers from a response into the jar (name=value pairs). */
-function mergeCookies(jar, res) {
-    const next = { ...jar };
-    for (const raw of res.headers.getSetCookie()) {
-        const pair = raw.split(";", 1)[0];
-        const eq = pair.indexOf("=");
-        if (eq <= 0)
-            continue;
-        next[pair.slice(0, eq).trim()] = pair.slice(eq + 1).trim();
-    }
-    return next;
-}
-/** Serialize the jar to a `Cookie` request header, or undefined when empty. */
-function cookieHeader(jar) {
-    const parts = Object.entries(jar).map(([k, v]) => `${k}=${v}`);
-    return parts.length === 0 ? undefined : parts.join("; ");
-}
-export function makeArcClient(apiKey, options = {}) {
-    const doFetch = options.fetchFn ?? fetch;
-    const sleep = options.sleep ?? realSleep;
-    const maxAttempts = options.maxAttempts ?? 4;
-    const signal = options.signal;
-    async function request(path, init, cookies) {
-        const headers = {
-            "X-API-Key": apiKey,
-            accept: "application/json"
-        };
-        if (init.body !== undefined)
-            headers["content-type"] = "application/json";
-        const cookie = cookieHeader(cookies);
-        if (cookie)
-            headers["cookie"] = cookie;
-        let attempt = 0;
-        for (;;) {
-            attempt++;
-            const res = await doFetch(`${ARC_BASE_URL}${path}`, {
-                method: init.method,
-                headers,
-                body: init.body === undefined ? undefined : JSON.stringify(init.body),
-                ...(signal ? { signal } : {})
-            });
-            if (res.ok) {
-                const nextCookies = mergeCookies(cookies, res);
-                const data = (await res.json());
-                return { data, cookies: nextCookies };
-            }
-            if (res.status === 401 || res.status === 403) {
-                throw new Error(`${ARC_AUTH_ERROR} (HTTP ${res.status})`);
-            }
-            // 429 / 5xx: retry with backoff, honoring Retry-After when present.
-            const retryable = res.status === 429 || res.status >= 500;
-            if (!retryable || attempt >= maxAttempts) {
-                throw new Error(`arc-client: ${init.method} ${path} failed (HTTP ${res.status})`);
-            }
-            const retryAfter = Number(res.headers.get("retry-after"));
-            const backoffMs = Number.isFinite(retryAfter) && retryAfter > 0
-                ? Math.min(retryAfter * 1000, MAX_RETRY_AFTER_MS)
-                : Math.min(1000 * 2 ** (attempt - 1), 8000);
-            // The wait between attempts is the longest thing this loop does, so it is
-            // the part a cancel most needs to reach.
-            await withAbort(signal, sleep(backoffMs));
-        }
-    }
-    return {
-        async listGames(cookies) {
-            const { data, cookies: next } = await request("/api/games", { method: "GET" }, cookies);
-            return { games: data, cookies: next };
-        },
-        async openScorecard(cookies) {
-            const { data, cookies: next } = await request("/api/scorecard/open", { method: "POST", body: {} }, cookies);
-            return { cardId: data.card_id, cookies: next };
-        },
-        async getScorecard(cardId, cookies) {
-            const { data, cookies: next } = await request(`/api/scorecard/${encodeURIComponent(cardId)}`, { method: "GET" }, cookies);
-            return { summary: data, cookies: next };
-        },
-        async reset(input, cookies) {
-            const body = {
-                game_id: input.gameId,
-                card_id: input.cardId
-            };
-            if (input.guid !== undefined)
-                body.guid = input.guid;
-            const { data, cookies: next } = await request("/api/cmd/RESET", { method: "POST", body }, cookies);
-            return { frame: data, cookies: next };
-        },
-        async act(input, cookies) {
-            const body = {
-                game_id: input.gameId,
-                guid: input.guid
-            };
-            if (input.action === 6) {
-                body.x = input.x;
-                body.y = input.y;
-            }
-            if (input.note !== undefined)
-                body.reasoning = { text: input.note };
-            const { data, cookies: next } = await request(`/api/cmd/ACTION${input.action}`, { method: "POST", body }, cookies);
-            return { frame: data, cookies: next };
-        }
-    };
-}

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

@@ -1,25 +0,0 @@
-import { type ToolSet } from "ai";
-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.
- *
- * 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.
- */
-export interface ArcGamesDeps {
-    client: ArcClient;
-}
-/** One line per game: id, title, and how it is played. */
-export declare function renderGames(games: {
-    game_id: string;
-    title?: string;
-    tags?: string[];
-}[]): string;
-export declare function buildArcGamesTools(deps: ArcGamesDeps): ToolSet;

package/dist/arc-agi/game-tools.js

@@ -1,26 +0,0 @@
-import { tool } from "ai";
-import { z } from "zod";
-/** One line per game: id, title, and how it is played. */
-export function renderGames(games) {
-    if (games.length === 0)
-        return "(the API listed no games)";
-    return games
-        .map((g) => {
-        const title = g.title ? ` (${g.title})` : "";
-        const tags = g.tags?.length ? ` [${g.tags.join(", ")}]` : "";
-        return `- ${g.game_id}${title}${tags}`;
-    })
-        .join("\n");
-}
-export function buildArcGamesTools(deps) {
-    return {
-        arc_list_games: tool({
-            description: "List the ARC-AGI-3 games available to play, with their exact game ids and tags describing how each is played. Use this to find the full game id before delegating a play.",
-            inputSchema: z.object({}),
-            execute: async () => {
-                const { games } = await deps.client.listGames({});
-                return renderGames(games);
-            }
-        })
-    };
-}

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

@@ -1,42 +0,0 @@
-import type { AgentPlugin } from "@dynamicagents/core";
-import { ARC_GAME_TYPE } from "./recipe.js";
-import { type ScorecardStore } from "./scorecard.js";
-import { ARC_GAME_FAMILY } from "./tools.js";
-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.
- *
- * 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
- * guid, or a game.
- */
-/** Everything this plugin needs from its host. */
-export interface ArcAgiConfig {
-    /** `ARC_API_KEY` — a secret the host must set. */
-    apiKey: string;
-    /**
-     * The Durable Object's storage, for the `arc_scorecards` ledger.
-     *
-     * `DurableObjectStorage` rather than the `SqlStorage` that `ensureTables`
-     * receives, because the query side builds a drizzle handle over it. The host
-     * has it as `this.ctx.storage`.
-     */
-    storage: DurableObjectStorage;
-    /**
-     * Test override: an in-memory {@link ScorecardStore}. Supplying this skips the
-     * table entirely, which is what lets the policy specs run with no SQLite.
-     */
-    store?: ScorecardStore;
-}
-export declare function arcAgi(config: ArcAgiConfig): AgentPlugin<ArcRuntime>;
-export { ARC_GAME_FAMILY, ARC_GAME_TYPE };
-export type { ArcRuntime, ScorecardStore };
-export { arcScorecardStore, makeScorecardStore } from "./store.js";
-export { ARC_GAME_RECIPE, ARC_GAME_SPEC } from "./recipe.js";

package/dist/arc-agi/index.js

@@ -1,175 +0,0 @@
-import { definePlugin } from "@dynamicagents/core";
-import { makeArcClient } from "./client.js";
-import { buildArcGamesTools } from "./game-tools.js";
-import { ARC_GAME_SPEC, ARC_GAME_TYPE } from "./recipe.js";
-import { gameScoreReport, resolvePlayOn, resolveScorecard } from "./scorecard.js";
-import { arcScorecardStore, makeScorecardStore } from "./store.js";
-import { ARC_GAME_FAMILY, buildArcGameTools } from "./tools.js";
-export function arcAgi(config) {
-    const { apiKey, storage } = config;
-    // Built once per DO instance, like the plugin itself. `makeScorecardStore`
-    // only constructs a drizzle handle — it issues no query until something asks —
-    // so this is safe before `AgentDB` has run the store's DDL.
-    let store = config.store;
-    const deps = () => ({
-        store: (store ??= makeScorecardStore(storage)),
-        client: makeArcClient(apiKey)
-    });
-    /**
-     * 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.
-     *
-     * 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
-     * gate — so without this, two branches starting together each find no live
-     * card and each open one. It matters more for a play: RESET is also a `fetch`,
-     * so two Subtasks for one game would each find no recorded guid and each open
-     * a play. The store settles that race anyway (first guid written wins), but
-     * only after a wasted run is already recorded on the card, so collapsing is
-     * what keeps the card's history honest rather than merely cheap.
-     */
-    let leasingCard;
-    const leasingPlays = new Map();
-    /**
-     * The card each execution *first* resolved onto, so a later chunk's lease can
-     * be recognised as a different one. See {@link ArcAgiConfig} and the note on
-     * `enrichResult`.
-     *
-     * In memory, and that is the honest limit: an isolate evicted between the
-     * final chunk and the result loses the entry and simply cannot tell. That is
-     * no worse than not tracking at all, and the common case — the parent
-     * resolving the last chunk and then handling its result — keeps it warm.
-     */
-    const firstCard = new Map();
-    const executionKey = (taskId, subtaskId) => `${taskId}:${subtaskId}`;
-    const leaseScorecard = () => (leasingCard ??= resolveScorecard(deps()).finally(() => {
-        leasingCard = undefined;
-    }));
-    const leasePlay = (gameId) => {
-        const inFlight = leasingPlays.get(gameId);
-        if (inFlight)
-            return inFlight;
-        // Keyed per game: different games legitimately open different plays on the
-        // same card — but they must all be on *the same card*, so the play resolves
-        // onto the collapsed lease rather than looking one up for itself. Calling
-        // `resolvePlay` here instead would re-enter `resolveScorecard` per game and
-        // undo the collapse entirely: two games starting together would each find
-        // an empty ledger and each open a card.
-        const pending = leaseScorecard()
-            .then((card) => resolvePlayOn(deps(), card, gameId))
-            .finally(() => {
-            leasingPlays.delete(gameId);
-        });
-        leasingPlays.set(gameId, pending);
-        return pending;
-    };
-    return definePlugin({
-        key: "arc-agi",
-        subtaskType: ARC_GAME_SPEC,
-        toolFamilies: {
-            [ARC_GAME_FAMILY]: (ctx) => buildArcGameTools(apiKey, ctx)
-        },
-        /**
-         * The **game catalogue only**. Playing is a subagent's job, and the card it
-         * plays on is leased below and never reaches a model — so the only thing the
-         * main agent needs from ARC is the exact id to delegate a play with.
-         */
-        mainAgentTools: () => buildArcGamesTools({ client: makeArcClient(apiKey) }),
-        // No `capability` here: it is on the subtask type, with the delegation
-        // guidance it has to agree with. See `ARC_GAME_SPEC`.
-        /**
-         * Resolve the session state an execution needs and no model can supply: the
-         * card, and the play on it.
-         *
-         * Neither is a decision. Which card is live is a fact about the clock, and a
-         * guid is mintable only by RESET — a call a subagent must never make, since a
-         * second RESET is a second run on the card that discards whatever the first
-         * reached. Both are settled here and handed down.
-         *
-         * Called once per **chunk**, not once per run, and the repetition is
-         * load-bearing twice over: each call restarts the card's reuse clock (which
-         * keeps a long play's card alive), and each call re-resolves the same guid
-         * from the store rather than opening anything.
-         */
-        async resolveRuntime(ctx) {
-            const gameId = ctx.params.game_id;
-            // A Subtask whose params never validated still reaches here. Resolve the
-            // card alone and let the recipe's own validation report the missing game,
-            // rather than RESETting on it and turning a clean failure into an API error.
-            const resolved = gameId
-                ? await leasePlay(gameId)
-                : await leaseScorecard();
-            // Remember the first card only. A later chunk that lands on a different
-            // one has rolled over, and the play it names is not the play running.
-            const key = executionKey(ctx.taskId, ctx.subtaskId);
-            if (!firstCard.has(key))
-                firstCard.set(key, resolved.cardId);
-            return resolved;
-        },
-        /**
-         * Append what only the parent can know to a completed execution's report:
-         * the score.
-         *
-         * Nothing closes a scorecard any more, so the score is *read* from the card
-         * once the play that earned it is done — which only this side can do, since
-         * it alone knows the leased card and holds the jar pinned to it. The score
-         * lands as an extra text part, and result parts are joined on delivery, so it
-         * reaches the user and any dependent Subtask with no other change.
-         *
-         * Never fails the execution: a play that succeeded is not retroactively
-         * broken by a rate-limited score read, so `gameScoreReport` swallows its own
-         * errors and a null leaves the report as the child wrote it. Safe to repeat
-         * on a Workflow step replay — the read is a GET.
-         */
-        async enrichResult(ctx, result) {
-            const gameId = ctx.request.params.game_id;
-            const cardId = ctx.runtime.cardId;
-            const key = executionKey(ctx.request.taskId, ctx.request.subtaskId);
-            const opened = firstCard.get(key);
-            firstCard.delete(key);
-            if (result.status !== "completed" || !cardId || !gameId)
-                return result;
-            // A rollover means this runtime names a card the play never ran on, so
-            // its score belongs to something else. The tool family keeps playing the
-            // session it already has when the lease diverges — deliberately, because
-            // joining the new play would throw away every level the real one reached
-            // — so the report is right and only the score would be wrong.
-            //
-            // Nothing here can recover the real one: the parent cannot read the
-            // child's workspace, which is the only place the play it actually ran is
-            // recorded. And a rollover means over 14 minutes passed between two
-            // chunks, so the old card is idle-closed and unreachable anyway. What is
-            // fixable is the lie — an empty RESET on the fresh card renders as a
-            // perfectly plausible "score 0, 0 levels", which reads as a play that
-            // achieved nothing rather than as a score that could not be read. Omit it
-            // instead; the main agent is told to report an absent score as
-            // unavailable.
-            if (opened !== undefined && opened !== cardId) {
-                console.warn("[arc-agi] scorecard rolled over mid-execution", {
-                    gameId,
-                    played: opened,
-                    leased: cardId
-                });
-                return result;
-            }
-            const score = await gameScoreReport(deps(), cardId, gameId);
-            if (!score)
-                return result;
-            return {
-                ...result,
-                resultParts: [...result.resultParts, { kind: "text", text: score }]
-            };
-        },
-        // No `onAbort`. There is deliberately nothing to release: the ARC API
-        // auto-closes an idle card, so an abandoned play needs no cleanup at all.
-        // Declaring an empty hook would imply otherwise.
-        store: arcScorecardStore,
-        requires: { secrets: ["ARC_API_KEY"] }
-    });
-}
-export { ARC_GAME_FAMILY, ARC_GAME_TYPE };
-export { arcScorecardStore, makeScorecardStore } from "./store.js";
-export { ARC_GAME_RECIPE, ARC_GAME_SPEC } from "./recipe.js";

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

@@ -1,27 +0,0 @@
-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: what the agent can do, and what to do with a result that
- * comes back. Deliberately names no scorecard tool and no `card_id` — the card is
- * leased by the recipe per chunk and is not this model's to manage, so naming one
- * would only invite a call to a tool that does not exist.
- */
-export declare const ARC_CAPABILITY: string;
-/**
- * The delegation guidance: how to build the `delegate` payload for a play. What
- * the capability block already says is not repeated here, and neither is the
- * params schema — the `delegate` tool description renders that from the type.
- */
-export declare function arcDelegationGuidance(names: DelegationNames): string;

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

@@ -1,65 +0,0 @@
-/**
- * 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: what the agent can do, and what to do with a result that
- * comes back. Deliberately names no scorecard tool and no `card_id` — the card is
- * leased by the recipe per chunk and is not this model's to manage, so naming one
- * would only invite a call to a tool that does not exist.
- */
-export const ARC_CAPABILITY = [
-    "You can run ARC-AGI-3 games, played for you by subagents:",
-    "- `arc_list_games` shows the available games with their exact ids and tags describing how each is played.",
-    "- To have a game played, delegate a subtask of type `arc-game` with param `game_id` (an exact id from `arc_list_games`). That is the whole contract — there is no scorecard for you to open, choose, or close.",
-    "- To have several games played, delegate one `arc-game` subtask per game; they run concurrently.",
-    "- Each play's report ends with that game's score, read from the scorecard once the play finishes. Report that score rather than inventing one — and if a report carries no score line, say the score was unavailable.",
-    "- A play's report also carries what it learned: the mechanics it confirmed, what it never got to test, and where the level's pieces are. That is the only record of it — the subagent keeps nothing between plays. Record what generalizes (mechanics, geography, what failed and why) so the next play starts from it, and keep it separate from what is merely suspected. Spent scorecard ids and other one-off residue are not worth keeping."
-].join("\n");
-/**
- * The delegation guidance: how to build the `delegate` payload for a play. What
- * the capability block already says is not repeated here, and neither is the
- * params schema — the `delegate` tool description renders that from the type.
- */
-export function arcDelegationGuidance(names) {
-    return `## Playing an ARC-AGI-3 game
-
-When the user asks for a game to be played (e.g. "play game ls20"), you can
-delegate in parallel subtasks of "type": "arc-game" per game they named.
-
-Each of those subtasks carries "params": { "game_id": "<id>" }, an exact id from
-\`arc_list_games\`. The param is what starts the play, and the "prompt" is never a
-substitute for it. Restate the request in the "prompt" as well (e.g. "Play the
-ARC-AGI-3 game ls20."), so the subagent knows what it was asked for.
-
-If the request does not name a game, or names it loosely — call \`arc_list_games\`
-first and delegate the id associated with "ls20". Never invent an id or pass through
-the user's wording as one. If nothing in the list matches well enough to choose,
-ask the user which game they mean with \`${names.finalReplyTool}\` rather than guessing.
-
-### What to put in the prompt
-
-Give it the goal, and give it what earlier plays actually established — labeled as
-what it is. Write "an earlier play observed …" for something a play reported seeing,
-and "we suspect …" for a hypothesis, so it can tell what to verify from what to use.
-A route or a map you pass down is a guess about a level nobody has finished; stated
-as fact, it gets followed off a cliff.
-
-Do **not** state mechanics of the tools or the budget: how many actions it has, how
-many moves fit in one call, how many turns it may spend. It is told all of that
-directly, it is told correctly, and a number you supply that disagrees will be
-believed over the truth — a play once stopped early because its prompt said it had
-"20 actions total" when 20 was its turn budget.
-
-These subtasks take several minutes — acknowledge in your "reply" that you have started playing
-and will report back, without promising a time.`;
-}

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

@@ -1,51 +0,0 @@
-import type { ResolvedRecipe, SubtaskTypeSpec } from "@dynamicagents/core";
-/** Semantic Subtask type the decomposer emits for a "play this game" request. */
-export declare const ARC_GAME_TYPE = "arc-game";
-/**
- * Recipe for playing an ARC-AGI-3 game. Names no model, so it runs on whatever
- * pair its host agent is configured with; what distinguishes it is its tool
- * family, its soul, its context discipline, and
- * 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.
- *
- * - `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.
- * - `reportMetrics` appends the turns/model-calls/wall-clock footer the user
- *   asked to see.
- *
- * Tool family: `arc-game` alone (act/inspect against the ARC REST API, session
- * 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.
- */
-export declare const ARC_GAME_RECIPE: ResolvedRecipe;
-/**
- * The arc-game type. Its one param is an id the model quotes back from a tool
- * result it already saw, so the contract is checkable before anything runs: a
- * play with no game cannot succeed, and refusing it here costs no model call.
- *
- * There is deliberately no `card_id`. Which scorecard a play runs on is not a
- * choice — the API auto-closes an idle card, so the live card is whichever one
- * was used recently — and the parent leases it per chunk (see
- * {@link file://./scorecard.ts}), handing it to the execution as runtime state.
- */
-export declare const ARC_GAME_SPEC: SubtaskTypeSpec;