@cerebriline/core 4.100.274 → 4.100.277

package/dist/extensions/tools/helpers.d.ts

@@ -9,9 +9,23 @@ export declare function getEditorSizeError(input: EditFileInput): string | null;
  */
 export declare class TimeoutError extends Error {
     readonly timeoutMs: number;
-    constructor(message: string, timeoutMs: number);
+    /**
+     * What the work printed before it was stopped, when there is any. A
+     * timeout dropped it: the test runner's FAIL line printed before it hung
+     * was exactly what the model needed (automaticum audit 2026-11-08,
+     * readers 8).
+     */
+    readonly output?: string;
+    constructor(message: string, timeoutMs: number, output?: string);
 }
 export declare function withTimeout<T>(promise: Promise<T>, ms: number, message: string): Promise<T>;
+/**
+ * What a writing tool's timeout means: the call was abandoned, not stopped,
+ * so the files may hold some or all of its changes. "Failed" read as
+ * "nothing happened", and the model ran the same edit again over a file
+ * that already had it (automaticum audit 2026-11-08, outside scope).
+ */
+export declare function abandonedWriteMessage(tool: string, timeoutMs: number): string;
 export declare function formatReadFileQuery(request: ReadFileRequest): string;
 export declare function getReadFileRangeError(request: ReadFileRequest): string | null;
 /**

package/dist/extensions/tools/jev.d.ts

@@ -196,7 +196,7 @@ export declare function listJevModels(endpoint: Pick<JevEndpoint, "apiKey" | "ba
 export declare function jevConfidence(answer: JevAnswer): number;
 /** Cut a state part to its ceiling, keeping the head and the tail. */
 export declare function boundJevText(text: string, max?: number): string;
-export declare const JEV_TOOL_DESCRIPTION = "Get a calibrated confidence score from Jev, an external scoring model, before acting on something you are not sure of. Jev reads the context you give it and answers typed questions with probabilities; it writes no text and cannot explain itself.\n\nUse it when you are unsure:\n- whether you understood the user's request \u2014 ask whether the request is ambiguous, or which of your readings it means;\n- whether a fact your answer rests on is supported by what you have read \u2014 put the source text in the context and ask whether it states the claim;\n- which approach, option or file to choose;\n- how complex the task is, before deciding to escalate or delegate it.\n\nArguments:\n- `context` \u2014 the situation, in plain text: what the user asked, what you found, what you are deciding. Only what the questions need; unrelated text makes the answers worse.\n- `questions` \u2014 1 to 10, all asked in one call. Each has an `id`, a `kind` and a `question`:\n  - `yes_no` \u2014 a yes/no question. Returns the probability of yes.\n  - `choice` \u2014 pick one of `options` (2 to 50). Include a \"none of these\" option when that is possible: a choice always picks something.\n  - `score` \u2014 rate on `levels` (2 to 10, lowest first).\n  Set `high_stakes: true` on a question whose wrong answer is costly; it must clear a higher bar.\n\nEach answer comes back as confident or unsure against the user's confidence floor. Act on a confident answer. On an unsure one, verify it yourself or ask the user \u2014 do not treat it as settled. Jev is weak at arithmetic, counting and multi-step reasoning, so check those in code, and ask one property per question rather than one broad question.";
+export declare const JEV_TOOL_DESCRIPTION: string;
 export declare const JEV_TOOL_INPUT_SCHEMA: {
     readonly type: "object";
     readonly properties: {

package/dist/extensions/tools/list-files.d.ts

@@ -38,7 +38,7 @@ import { type AgentTool } from "@cerebriline/shared";
  * and it reaches for `ls` for exactly the same reason.
  */
 export declare const LIST_FILES_TOOL_NAME = "list_files";
-export declare const LIST_FILES_TOOL_DESCRIPTION = "List the files in the workspace. Use this to find out what exists \u2014 do not run `ls`, `dir`, `find` or `Get-ChildItem` through `run_commands` to look around, because this is scoped to the workspace and those are not.\n\nTwo ways to ask:\n- `path` \u2014 list what is directly inside one directory. Omit it to list the workspace root.\n- `pattern` \u2014 a glob searched across the whole workspace, e.g. `**/*.html`, `src/**/*.ts`, `**/config.*`. Use this when you know part of a name but not where it lives.\n\nResults are limited to the workspace folders the user opened, and directories the user's settings exclude from search \u2014 `node_modules`, `.git`, build output \u2014 are left out. A path outside the workspace is refused rather than listed.\n\nThis tells you which files exist, not what is in them. To find files by their contents use `search_codebase`, which reports the line each match is on and is the right way to locate the part of a file worth reading.";
+export declare const LIST_FILES_TOOL_DESCRIPTION = "List the files in the workspace. Use this to find out what exists \u2014 do not run `ls`, `dir`, `find` or `Get-ChildItem` through `run_commands` to look around, because this is scoped to the workspace and those are not.\n\nTwo ways to ask:\n- `path` \u2014 list what is directly inside one directory. Omit it to list the workspace root.\n- `pattern` \u2014 a glob searched across the whole workspace, e.g. `**/*.html`, `src/**/*.ts`, `**/config.*`. Use this when you know part of a name but not where it lives.\n\nResults are limited to the workspace folders the user opened. A `pattern` search does not enter the directories the user's settings exclude from search \u2014 `node_modules`, `.git` and the like \u2014 unless the pattern names one (`node_modules/**/package.json`); a `path` listing shows them, marked. A link to a directory is listed as one and searched through. A path outside the workspace is refused rather than listed.\n\nThis tells you which files exist, not what is in them. To find files by their contents use `search_codebase`, which reports the line each match is on and is the right way to locate the part of a file worth reading.";
 export declare const LIST_FILES_TOOL_INPUT_SCHEMA: {
     readonly type: "object";
     readonly properties: {
@@ -59,9 +59,18 @@ export declare const LIST_FILES_TOOL_INPUT_SCHEMA: {
 };
 export interface DirectoryEntry {
     name: string;
+    /** What it is, through a symbolic link: a link to a directory is one. */
     kind: "file" | "directory";
     /** Bytes, when the host could say cheaply. */
     size?: number;
+    /**
+     * A symbolic link, and where it points. Listed as a 60-byte file, a link
+     * to a directory hid everything behind it (automaticum audit 2026-11-08,
+     * readers 28).
+     */
+    link?: string;
+    /** A directory a pattern search does not enter unless it names it. */
+    excluded?: true;
 }
 /**
  * The workspace operations this tool needs.
@@ -104,6 +113,13 @@ export declare function normalizeMaxResults(value: unknown): number;
 export declare function renderDirectory(displayPath: string, entries: DirectoryEntry[], limit: number): string;
 /** Render a glob search, as paths relative to the root they were found under. */
 export declare function renderMatches(pattern: string, absolutePaths: string[], roots: string[], limit: number, readPaths?: string[]): string;
+/**
+ * A glob as the workspace-relative pattern it means: `./src/*.ts` is
+ * `src/*.ts`, which is what a model writing `./` intends (readers 11).
+ */
+export declare function normalizeGlob(pattern: string): string;
+/** Excluded directory names a pattern spells out, which it then searches. */
+export declare function namedExcludedDirectories(pattern: string): Set<string>;
 /**
  * Translate a glob into a regular expression over slash-separated paths.
  *

package/dist/extensions/tools/media-endpoint.d.ts

@@ -171,6 +171,22 @@ export declare class MediaRequestTimeoutError extends Error {
     readonly timeoutMs: number;
     constructor(timeoutMs: number);
 }
+/**
+ * What a media call's failure was, in words: the limit, a cancel, the file
+ * it could not save, or the endpoint it could not reach.
+ *
+ * Every failure was "could not reach the endpoint", a disk that would not
+ * take the file included, and a cancel was "stopped (the limit is N s)"
+ * (automaticum audit 2026-11-08, rest M10).
+ */
+export declare function describeMediaFailure(error: unknown, options: {
+    /** "The transcription", "Image generation". */
+    what: string;
+    /** "speech-to-text", "image". */
+    endpoint: string;
+    timeoutMs: number;
+    signal?: AbortSignal;
+}): string;
 /**
  * One media request, waited out while the engine is busy.
  *

package/dist/extensions/tools/model-tool-routing.d.ts

@@ -15,6 +15,12 @@ export interface ToolRoutingRule {
      * When omitted/empty, the rule is not constrained by model ID.
      */
     modelIdIncludes?: string[];
+    /**
+     * A case-insensitive regular expression the model ID must match, for a
+     * rule a substring cannot state. Both this and `modelIdIncludes` must
+     * match when both are given.
+     */
+    modelIdPattern?: string;
     /**
      * Case-insensitive substrings that must match the provider ID.
      * When omitted/empty, the rule is not constrained by provider ID.

package/dist/extensions/tools/schemas.d.ts

@@ -27,7 +27,7 @@ export declare const ReadFileRequestSchema: z.ZodObject<{
     path: z.ZodString;
     start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
     end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-    line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean>>>;
+    line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
 }, z.core.$strip>;
 /**
  * Schema for read_files tool input
@@ -37,7 +37,7 @@ export declare const ReadFilesInputSchema: z.ZodObject<{
         path: z.ZodString;
         start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-        line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean>>>;
+        line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
@@ -48,13 +48,13 @@ export declare const ReadFilesInputUnionSchema: z.ZodUnion<readonly [z.ZodObject
         path: z.ZodString;
         start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-        line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean>>>;
+        line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
     path: z.ZodString;
     start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
     end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-    line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean>>>;
+    line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
 }, z.core.$strip>, z.ZodPipe<z.ZodObject<{
     start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
     end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
@@ -83,7 +83,7 @@ export declare const ReadFilesInputUnionSchema: z.ZodUnion<readonly [z.ZodObject
     path: z.ZodString;
     start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
     end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-    line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean>>>;
+    line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
 }, z.core.$strip>, z.ZodPipe<z.ZodObject<{
     start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
     end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
@@ -113,7 +113,7 @@ export declare const ReadFilesInputUnionSchema: z.ZodUnion<readonly [z.ZodObject
         path: z.ZodString;
         start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-        line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean>>>;
+        line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
     }, z.core.$strip>, z.ZodPipe<z.ZodObject<{
         start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
@@ -144,7 +144,7 @@ export declare const ReadFilesInputUnionSchema: z.ZodUnion<readonly [z.ZodObject
         path: z.ZodString;
         start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-        line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean>>>;
+        line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
     }, z.core.$strip>, z.ZodPipe<z.ZodObject<{
         start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
@@ -181,7 +181,7 @@ export declare const ReadFilesInputUnionSchema: z.ZodUnion<readonly [z.ZodObject
         path: z.ZodString;
         start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-        line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean>>>;
+        line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
     }, z.core.$strip>, z.ZodPipe<z.ZodObject<{
         start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
@@ -212,7 +212,7 @@ export declare const ReadFilesInputUnionSchema: z.ZodUnion<readonly [z.ZodObject
         path: z.ZodString;
         start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-        line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean>>>;
+        line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
     }, z.core.$strip>, z.ZodPipe<z.ZodObject<{
         start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
@@ -649,7 +649,7 @@ export declare const EditFileInputSchema: z.ZodObject<{
     end_column: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
     insert_column: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
     occurrence: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-    replace_all: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean>>>;
+    replace_all: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
 }, z.core.$strip>;
 /**
  * The editor's arguments as the model is shown them and writes them.
@@ -671,7 +671,7 @@ export declare const EditorToolInputSchema: z.ZodObject<{
     end_column: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
     insert_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
     insert_column: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-    replace_all: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean>>>;
+    replace_all: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
     file_path: z.ZodString;
 }, z.core.$strip>;
 export type EditorToolInput = z.infer<typeof EditorToolInputSchema>;
@@ -820,7 +820,7 @@ export declare const GrepInputUnionSchema: z.ZodPreprocess<z.ZodObject<{
     context: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
     max_count: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
     paths: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>]>>;
-}, z.core.$strip>>;
+}, z.core.$strip>, unknown>;
 export declare const SedInputUnionSchema: z.ZodObject<{
     script: z.ZodString;
     in_place: z.ZodOptional<z.ZodBoolean>;

package/dist/extensions/tools/task-progress.d.ts

@@ -191,6 +191,8 @@ export declare class TaskProgressTracker {
     private untrackedEdits;
     /** A reminder waiting for the turn's tool calls to finish. */
     private pending;
+    /** The calls that queued the untracked-edit nudge {@link pending} holds. */
+    private readonly pendingFrom;
     private readonly reminderInterval;
     private readonly writeInterval;
     private readonly onUpdate;

package/dist/extensions/tools/team/agent-check.d.ts

@@ -73,11 +73,24 @@ export declare const AGENT_CHECK_MAX_IDENTICAL_FAILS = 3;
  * after which the agent is let finish and the check counts as not run.
  */
 export declare const AGENT_CHECK_MAX_UNRESOLVED = 2;
-/** Whether a failed run says the shell never found the program. */
+/**
+ * Whether a failed run says the shell never found the check's program.
+ *
+ * That is a statement about where the check runs, not about the agent's work.
+ * In swarm wlafh five of six fixers were sent back to work by it, spent 11 to
+ * 18 iterations on the environment, and three changed the host to get past it
+ * (the user's PATH, a hard link in `~/.local/bin`, a re-created program).
+ *
+ * Only the check's own program: exit 127 from a typo inside the agent's
+ * test script was blamed on the environment and recorded as not run,
+ * which hid the failure (automaticum audit 2026-11-08, rest C3).
+ */
 export declare function checkCommandUnresolved(verdict: {
     exitCode: number | null;
     output: string;
-}): boolean;
+}, 
+/** The check's command line; without it any program not found counts. */
+command?: string): boolean;
 /** The reason a check is not run when the agent has no sandboxed shell. */
 export declare const AGENT_CHECK_NO_SANDBOX = "no command sandbox";
 /**

package/dist/extensions/tools/team/agent-controls.d.ts

@@ -52,4 +52,4 @@ export declare function maxIterationsOf(input: unknown): number | undefined;
  */
 export declare const AGENT_SANDBOX_ROLE_NOTE = "How agents work: each runs in its own sandboxed copy of the workspace, so any number may read and edit the same files at once -- there is no concurrency problem to avoid, and no reason to forbid edits. Your files stay unchanged: each agent's edits come back to you as revisions. You are the synthesizer, and nothing merges on its own: read each report, inspect its revisions (`read_files` with `revision`), apply what is right (`restore_file`), reconcile agents that disagree, and verify the result yourself. ";
 /** What a spawn tool's description says about the two controls. */
-export declare const AGENT_CONTROLS_NOTE = "Agents run without an iteration cap; you are told every 60 iterations of a long-running one, so you can check on it with `agents_status`. A configured agent whose file sets a cap stops at it and waits for you with its work kept: `resume_agent(agent_ids?)` continues it, or `stop_agents` takes its work as it is. An agent the loop guard stops for sending the same call again waits for you the same way, reported as looping with the call it repeated: resume it with `instructions` saying what to do instead, or restart it. Per agent, or for the whole call (an agent's own wins): `check: {command, expect, must?}` is its oracle, and it is deterministic: when it says it is done, `command` runs in its own sandboxed copy of the workspace and must exit 0 with output matching the regex `expect` (`must: \"not_match\"`: not matching); on a fail it is shown the output and keeps working. It judges only that agent's own copy -- not the merged result, which is yours to check -- and a call-level check applies to every agent of the call: give it per agent to those whose edits it measures, never to review or analysis agents, which cannot pass it. It is told its check up front. Its report gives `iterations`/`maxIterations`, `stopReason` (`iteration_cap` or `loop_guard`) when either ended it, and `oracle` {status, exitCode, output}. ";
+export declare const AGENT_CONTROLS_NOTE = "Agents run without an iteration cap; you are told every 60 iterations of a long-running one, so you can check on it with `agents_status`. A configured agent whose file sets a cap stops at it and waits for you with its work kept: `resume_agent(agent_ids?)` continues it, or `stop_agents` takes its work as it is. An agent the loop guard stops for sending the same call again waits for you the same way, reported as looping with the call it repeated: resume it with `instructions` saying what to do instead, or restart it. Per agent, or for the whole call (an agent's own wins): `check: {command, expect, must?}` is its oracle, and it is deterministic: when it says it is done, `command` runs in its own sandboxed copy of the workspace and must exit 0 with output matching the regex `expect` (`must: \"not_match\"`: not matching); on a fail it is shown the output and keeps working. It judges only that agent's own copy -- not the merged result, which is yours to check -- and a call-level check applies to every agent of the call: give it per agent to those whose edits it measures, never to review or analysis agents, which cannot pass it. It is told its check up front. Its report gives `iterations`/`maxIterations`, `stopReason` when something other than the agent ended it (`iteration_cap`: its cap; `loop_guard`: it repeated a call; `supervisor`: it was struggling; `wrap_up`: it was stopped gracefully and its last turn was a report), and `oracle` {status, exitCode, output}. ";

package/dist/extensions/tools/team/batch-report.d.ts

@@ -79,9 +79,17 @@ export interface SpawnBatchIndexEntry {
 }
 export interface SpawnBatchSummary {
     total: number;
+    /** Ran to the end; how many of those failed their check is `checkFailed`. */
     completed: number;
     errored: number;
     cancelled: number;
+    /**
+     * Agents whose check failed, whatever their status: a completed agent
+     * with a failed check has not done its task (rest M3).
+     */
+    checkFailed: number;
+    /** Agents whose check could not run; their work is unverified. */
+    checkNotRun: number;
     /** Stopped at the iteration cap and waiting on you; see `agents`. */
     awaitingLead: number;
     /** Per configured type, or per name with its `-<n>` copy suffix dropped. */

package/dist/extensions/tools/team/lead-agent-tools.d.ts

@@ -71,8 +71,8 @@ export declare const RESTART_AGENT_DESCRIPTION = "Start an agent over from its o
 export declare const RESUME_AGENT_DESCRIPTION = "Continue agents that are waiting for you (awaiting_lead): stopped at their iteration cap, by the loop guard for repeating the same call, or by the struggle supervisor for grinding on after being told to commit a SUMMARY. Each carries on from where it stopped, with its transcript and its changes. One call takes several: `agent_ids`, or leave it out for every agent waiting on you. `extra_iterations` defaults to the cap each was spawned with (60 -> 120 -> 180). `instructions` are added as they resume -- for a looping agent, say what to do instead of the call it repeated; for a struggling one, what to settle for. To take the work as it is instead, stop_agents; to start over, restart_agent.";
 export declare const RETRY_FAILED_DESCRIPTION = "Run a round's failed and cancelled agents again, each from the task it was originally given (and any revised instructions from a restart), with the same check, sampler and cap. `agent_ids` limits it to some of them. The round reports again when they finish. Infrastructure trouble never fails an agent -- it is retried on its own -- so what this reruns failed on its task: consider restart_agent with instructions for one that will fail the same way again.";
 export declare const MESSAGE_AGENTS_DESCRIPTION = "Leave a message for running agents. Each reads it at its next turn, between tool calls, and carries on with it in mind. Use it to pass on a change of plan, a constraint, or an answer.";
-export declare const STOP_AGENTS_DESCRIPTION = "Stop agents. A last resort: its task ends unfinished, and is lost unless you run it again. Slowness and a full server are not reasons to stop one: the harness paces agents and retries refusals, the PolyKV server frees KV cells on its own, and while an agent compacts its throughput drops to zero for minutes -- that is progress, not a hang (agents_status shows each agent's phase). To free KV cells, compact_agents; to move an agent off a slow node, requeue_agent; to change its course, message_agents. The rest of its round carries on. By default the stop is graceful: the agent finishes the step it is in, then gets one turn with no tools to report what it changed, found and verified, and where it stopped -- its report reaches you as its result, marked as partial work, and its file changes are kept. That takes as long as its step plus one reply, minutes on a slow node or a looping model. `immediate: true` ends it at once, with its file changes and no report -- also the way to end one already stopping gracefully. An agent waiting on you (at its cap, looping, struggling) is ended where it stopped, after the same report turn unless `immediate`.";
-export declare const COMPACT_AGENTS_DESCRIPTION = "Compact running agents' context, giving their KV cells back without stopping them -- what to do instead of stop_agents when a PolyKV node is short of cells. Each compacts before its next model request: a summary call during which its throughput is zero, often for minutes, and after which it carries on with a summary in place of its detailed history. Rarely needed: agents compact on their own when their node's KV pressure reaches its threshold (0.85 unless configured), and the server frees cells itself. Use it only on agents holding a large share of a node's cells while the node's pressure is near its threshold -- agents_status shows both. An agent already compacting, or waiting on you, is left as it is.";
+export declare const STOP_AGENTS_DESCRIPTION = "Stop agents. A last resort: its task ends unfinished, and is lost unless you run it again. Slowness and a full server are not reasons to stop one: the harness paces agents and retries refusals, the PolyKV server frees KV cells on its own, and while an agent compacts its throughput drops to zero for minutes -- that is progress, not a hang, until agents_status says it has run too long (it shows each agent's phase). To free KV cells, compact_agents; to move an agent off a slow node, requeue_agent; to change its course, message_agents. The rest of its round carries on. By default the stop is graceful: the agent finishes the step it is in, then gets one turn with no tools to report what it changed, found and verified, and where it stopped -- its report reaches you as its result, marked as partial work, and its file changes are kept. That takes as long as its step plus one reply, minutes on a slow node or a looping model. `immediate: true` ends it at once, with its file changes and no report -- also the way to end one already stopping gracefully. An agent waiting on you (at its cap, looping, struggling) is ended where it stopped, after the same report turn unless `immediate`.";
+export declare const COMPACT_AGENTS_DESCRIPTION = "Compact running agents' context, giving their KV cells back without stopping them -- what to do instead of stop_agents when a PolyKV node is short of cells. Each compacts before its next model request: a summary call during which its throughput is zero, often for minutes, and after which it carries on with a summary in place of its detailed history. Rarely needed: an agent compacts on its own when its own KV pressure on the node reaches the threshold (0.85 unless configured; the node's pressure where the server reports none per agent) or when its context window fills, and the server frees cells itself. Use it only on agents holding a large share of a node's cells while the node's pressure is near its threshold -- agents_status shows both. An agent already compacting, or waiting on you, is left as it is.";
 export interface LeadAgentToolsOptions {
     sessionId: string;
     /** What each tool did, in words: the side turn reports it to the lead. */

package/dist/extensions/tools/transform-image.d.ts

@@ -94,6 +94,17 @@ export interface TransformSpec {
     /** Painted under the image, over the whole result. */
     background?: string;
 }
+/**
+ * `planTransform`'s text, for the page to run.
+ *
+ * Bound to the name in the page (`var planTransform = (...)`) rather than
+ * pasted as a declaration: a minified build renames the function -- the
+ * published 4.100.276 bundle has it as `function BK(...)` -- and a page that
+ * then calls `planTransform(...)` throws "planTransform is not defined",
+ * draws nothing, and every `transform_image` call reports a valid image as
+ * unreadable. As an expression its own name no longer matters.
+ */
+export declare function planTransformSource(): string;
 /** The page that draws one image at its new size. */
 export declare function buildTransformDocument(sourceUrl: string, spec: TransformSpec): string;
 /** One image, drawn at a new size by the host's browser. */