xcoder-jarvis-agent 0.0.0-stage → 1.4.0

package/dist/jarvis/prompt/skills.js

@@ -0,0 +1,257 @@
+// xcoder:version 1 | xcoder:task task-f1b5f6 | xcoder:updated 2026-11-05T02:46:14.714Z | xcoder:subtask code-st-53c7b5
+import fsp from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { maybeSeedSkillsHome } from "xcoder-dna";
+import { byteLength, normalizeUntrusted, sha256 } from "../util/text.js";
+export const DEFAULT_MAX_PACKS = 8;
+export const DEFAULT_MAX_PACK_BYTES = 32_768;
+export const DEFAULT_MAX_TOTAL_BYTES = 131_072;
+/** Strip one or more matching quote pairs from a scalar. */
+function unquote(value) {
+    const v = value.trim();
+    if (v.length >= 2) {
+        const first = v[0];
+        const last = v[v.length - 1];
+        if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+            return v.slice(1, -1);
+        }
+    }
+    return v;
+}
+/** Parse `[a, b, "c d"]` into ['a','b','c d']. Unknown shapes yield []. */
+function parseInlineArray(value) {
+    const v = value.trim();
+    if (!v.startsWith("[") || !v.endsWith("]"))
+        return [];
+    const inner = v.slice(1, -1).trim();
+    if (inner.length === 0)
+        return [];
+    const out = [];
+    let current = "";
+    let quote = null;
+    for (const ch of inner) {
+        if (quote) {
+            if (ch === quote)
+                quote = null;
+            else
+                current += ch;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            continue;
+        }
+        if (ch === ",") {
+            const item = current.trim();
+            if (item)
+                out.push(item);
+            current = "";
+            continue;
+        }
+        current += ch;
+    }
+    const last = current.trim();
+    if (last)
+        out.push(last);
+    return out;
+}
+/**
+ * Parse the leading `---` frontmatter block.
+ * Returns undefined when there is no block or no closing fence.
+ */
+export function parseFrontmatter(raw) {
+    const lines = raw.replace(/^\uFEFF/, "").split(/\r?\n/);
+    if (lines.length === 0 || lines[0].trim() !== "---")
+        return undefined;
+    let end = -1;
+    for (let i = 1; i < lines.length; i += 1) {
+        if (lines[i].trim() === "---") {
+            end = i;
+            break;
+        }
+    }
+    if (end === -1)
+        return undefined;
+    const meta = { triggers: [], requiresTools: [], composesWith: [] };
+    const header = lines.slice(1, end);
+    for (let i = 0; i < header.length; i += 1) {
+        const line = header[i];
+        if (line.trim().length === 0 || line.trimStart().startsWith("#"))
+            continue;
+        // Only top-level `key: value` entries; indented continuation belongs to
+        // the folded-scalar branch below.
+        const m = /^([A-Za-z_][A-Za-z0-9_-]*)\s*:\s*(.*)$/.exec(line);
+        if (!m)
+            continue;
+        const key = m[1].toLowerCase();
+        const rest = m[2];
+        if ([">", ">-", "|", "|-"].includes(rest.trim())) {
+            const collected = [];
+            let j = i + 1;
+            while (j < header.length && /^\s+\S/.test(header[j])) {
+                collected.push(header[j].trim());
+                j += 1;
+            }
+            i = j - 1;
+            const folded = collected.join(rest.trim().startsWith("|") ? "\n" : " ").trim();
+            if (key === "description")
+                meta.description = folded;
+            else if (key === "role")
+                meta.role = folded;
+            else if (key === "name")
+                meta.name = folded;
+            continue;
+        }
+        const value = rest.trim();
+        if (key === "name")
+            meta.name = unquote(value);
+        else if (key === "role")
+            meta.role = unquote(value);
+        else if (key === "description")
+            meta.description = unquote(value);
+        else if (key === "version")
+            meta.version = unquote(value);
+        else if (key === "triggers")
+            meta.triggers = parseInlineArray(value);
+        else if (key === "requires_tools")
+            meta.requiresTools = parseInlineArray(value);
+        else if (key === "composes_with")
+            meta.composesWith = parseInlineArray(value);
+        // Unknown keys are dropped rather than carried into the prompt.
+    }
+    return { meta, body: lines.slice(end + 1).join("\n") };
+}
+async function readPack(file, dirName, maxPackBytes) {
+    let raw;
+    try {
+        const buf = await fsp.readFile(file);
+        if (buf.byteLength > maxPackBytes) {
+            return {
+                ok: false,
+                skipped: { name: dirName, reason: `pack exceeds ${maxPackBytes} bytes` },
+            };
+        }
+        raw = buf.toString("utf8");
+    }
+    catch {
+        return { ok: false, skipped: { name: dirName, reason: "pack could not be read" } };
+    }
+    const parsed = parseFrontmatter(raw);
+    if (!parsed) {
+        return { ok: false, skipped: { name: dirName, reason: "no frontmatter block" } };
+    }
+    const name = parsed.meta.name ?? dirName;
+    if (!/^[a-z0-9][a-z0-9._-]{0,63}$/i.test(name)) {
+        return { ok: false, skipped: { name: dirName, reason: "invalid pack name" } };
+    }
+    return {
+        ok: true,
+        pack: {
+            name,
+            role: parsed.meta.role,
+            description: parsed.meta.description,
+            triggers: parsed.meta.triggers,
+            version: parsed.meta.version,
+            requiresTools: parsed.meta.requiresTools,
+            composesWith: parsed.meta.composesWith,
+            body: normalizeUntrusted(parsed.body, maxPackBytes),
+            path: file,
+            sha256: sha256(raw),
+            bytes: byteLength(raw),
+        },
+    };
+}
+async function listPacks(root) {
+    let entries;
+    try {
+        entries = await fsp.readdir(root, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
+    const out = [];
+    for (const d of dirs) {
+        const file = path.join(root, d, "SKILL.md");
+        try {
+            const st = await fsp.stat(file);
+            if (st.isFile())
+                out.push(d);
+        }
+        catch {
+            /* not a pack directory */
+        }
+    }
+    return out;
+}
+/** `~/.xcoder/skills` — mirrors dna's helper without importing past the barrel. */
+function userSkillsDir(home) {
+    return path.join(home, ".xcoder", "skills");
+}
+function bundledSkillsDir(workspaceRoot) {
+    return path.join(workspaceRoot, "packages", "xcoder-dna", "skills");
+}
+/**
+ * Candidate roots in priority order. The first root that yields at least one
+ * parseable pack wins, so a user copy shadows the bundled packs wholesale
+ * instead of silently merging two versions of the same skill.
+ */
+async function candidateRoots(o) {
+    if (o.skillsRoot)
+        return [o.skillsRoot];
+    const env = o.env ?? process.env;
+    const home = env["HOME"] || env["USERPROFILE"] || os.homedir();
+    const out = [];
+    const override = env["XCODER_SKILLS_DIR"];
+    if (override && override.trim().length > 0)
+        out.push(path.resolve(override.trim()));
+    out.push(path.join(o.workspaceRoot, ".xcoder", "skills"));
+    // Seeding is best-effort and never throws; awaiting it means a fresh clone
+    // still finds packs on the very first run.
+    try {
+        await maybeSeedSkillsHome({ homeDir: home });
+    }
+    catch {
+        /* discovery must not fail because seeding did */
+    }
+    out.push(userSkillsDir(home));
+    out.push(bundledSkillsDir(o.workspaceRoot));
+    return out;
+}
+export async function discoverSkills(o) {
+    const maxPacks = o.maxPacks ?? DEFAULT_MAX_PACKS;
+    const maxPackBytes = o.maxPackBytes ?? DEFAULT_MAX_PACK_BYTES;
+    const maxTotalBytes = o.maxTotalBytes ?? DEFAULT_MAX_TOTAL_BYTES;
+    const allow = o.allow && o.allow.length > 0 ? new Set(o.allow.map((s) => s.toLowerCase())) : undefined;
+    for (const root of await candidateRoots(o)) {
+        const dirs = await listPacks(root);
+        if (dirs.length === 0)
+            continue;
+        const packs = [];
+        const skipped = [];
+        let total = 0;
+        for (const dir of dirs) {
+            if (packs.length >= maxPacks) {
+                skipped.push({ name: dir, reason: `pack cap reached (${maxPacks})` });
+                continue;
+            }
+            const result = await readPack(path.join(root, dir, "SKILL.md"), dir, maxPackBytes);
+            if (!result.ok) {
+                skipped.push(result.skipped);
+                continue;
+            }
+            if (total + result.pack.bytes > maxTotalBytes) {
+                skipped.push({ name: result.pack.name, reason: `total byte cap reached (${maxTotalBytes})` });
+                continue;
+            }
+            total += result.pack.bytes;
+            packs.push(result.pack);
+        }
+        const filtered = allow ? packs.filter((p) => allow.has(p.name.toLowerCase())) : packs;
+        if (filtered.length === 0)
+            continue;
+        return { packs: filtered, skipped, root };
+    }
+    return { packs: [], skipped: [], root: undefined };
+}

package/dist/jarvis/react-loop.d.ts

@@ -0,0 +1,51 @@
+import type { LlmMessage } from "xcoder-dna";
+import { type RunBudget } from "./budget.js";
+import type { AssembledPrompt } from "./prompt/assemble.js";
+import type { JarvisOutcome } from "./telemetry/provenance.js";
+import type { ToolContext, ToolObservation, ToolRegistry } from "./tools/registry.js";
+/**
+ * The ReAct loop, owned in-package (design §2.4, tradeoff T1).
+ *
+ * The shared `GenesisReActOrchestrator` in xcoder-dna could not be reused: its
+ * tool registry is internal and non-injectable, which would mean shipping an
+ * agent whose tool surface we do not control. Six invariants hold here, each
+ * covered by a test:
+ *  1. iterations never exceed `maxIterations` (clamped to 8 by the caller);
+ *  2. every reply is parsed before any side effect occurs;
+ *  3. a tool not in the registry allowlist is refused in code and fed back as
+ *     an error observation — it is never dispatched;
+ *  4. `isKilled()` is checked before each LLM call and each dispatch;
+ *  5. budget exhaustion yields `budget_exceeded` with no partial answer;
+ *  6. the kill-switch AbortSignal is passed to the tool context.
+ */
+export declare const MAX_ITERATIONS: 8;
+export interface LlmCompleter {
+    complete(systemPrompt: string, transcript: LlmMessage[]): Promise<{
+        text: string;
+        usage: {
+            inputTokens: number;
+            outputTokens: number;
+        };
+    }>;
+}
+export interface ReactLoopInput {
+    task: string;
+    systemPrompt: AssembledPrompt;
+    client: LlmCompleter;
+    registry: ToolRegistry;
+    toolContext: ToolContext;
+    maxIterations: number;
+    budget: RunBudget;
+    isKilled: () => boolean;
+    /** Called after each successful dispatch, for provenance. */
+    onToolUsed?: (name: string, observation: ToolObservation) => void;
+}
+export interface ReactLoopOutput {
+    outcome: JarvisOutcome;
+    answer?: string;
+    iterations: number;
+    transcript: ReadonlyArray<LlmMessage>;
+    error?: string;
+    killReason?: "env" | "stop-file";
+}
+export declare function runReactLoop(i: ReactLoopInput): Promise<ReactLoopOutput>;

package/dist/jarvis/react-loop.js

@@ -0,0 +1,160 @@
+import { BudgetExceeded } from "./budget.js";
+import { parseDecision, ReactParseError } from "./decision.js";
+import { wrapObservation } from "./prompt/assemble.js";
+/**
+ * The ReAct loop, owned in-package (design §2.4, tradeoff T1).
+ *
+ * The shared `GenesisReActOrchestrator` in xcoder-dna could not be reused: its
+ * tool registry is internal and non-injectable, which would mean shipping an
+ * agent whose tool surface we do not control. Six invariants hold here, each
+ * covered by a test:
+ *  1. iterations never exceed `maxIterations` (clamped to 8 by the caller);
+ *  2. every reply is parsed before any side effect occurs;
+ *  3. a tool not in the registry allowlist is refused in code and fed back as
+ *     an error observation — it is never dispatched;
+ *  4. `isKilled()` is checked before each LLM call and each dispatch;
+ *  5. budget exhaustion yields `budget_exceeded` with no partial answer;
+ *  6. the kill-switch AbortSignal is passed to the tool context.
+ */
+export const MAX_ITERATIONS = 8;
+const CORRECTIVE_NUDGE = "Your previous reply could not be used: it was not a single JSON object " +
+    "matching the required shape. Reply again with exactly one JSON object and " +
+    "no other text. Do not explain, and do not repeat the rejected text.";
+function transcriptWith(transcript, role, content) {
+    return [...transcript, { role, content }];
+}
+/**
+ * Execute one parsed action. The allowlist is enforced by `registry.get()`,
+ * which returns undefined for anything not registered AND allowed — so an
+ * off-list name cannot reach `execute()` at all.
+ */
+async function dispatch(input, decision) {
+    const descriptor = input.registry.get(decision.tool);
+    if (!descriptor) {
+        return {
+            dispatched: false,
+            observation: {
+                ok: false,
+                summary: `refused: tool '${decision.tool}' is not in this run's allowlist (${input.registry
+                    .allowlist()
+                    .join(", ")})`,
+                bytes: 0,
+                truncated: false,
+            },
+        };
+    }
+    const parsedArgs = descriptor.argsSchema.safeParse(decision.args);
+    if (!parsedArgs.success) {
+        const issue = parsedArgs.error.issues[0];
+        return {
+            dispatched: false,
+            observation: {
+                ok: false,
+                summary: `refused: arguments for '${decision.tool}' did not match its schema (${issue?.path.join(".") || "(root)"}: ${issue?.message ?? "invalid"})`,
+                bytes: 0,
+                truncated: false,
+            },
+        };
+    }
+    try {
+        const observation = await descriptor.execute(parsedArgs.data, input.toolContext);
+        return { dispatched: true, observation };
+    }
+    catch {
+        return {
+            dispatched: true,
+            observation: {
+                ok: false,
+                summary: `tool '${decision.tool}' failed while executing`,
+                bytes: 0,
+                truncated: false,
+            },
+        };
+    }
+}
+export async function runReactLoop(i) {
+    const maxIterations = Math.min(MAX_ITERATIONS, Math.max(1, i.maxIterations));
+    let transcript = [{ role: "user", content: i.task }];
+    let iterations = 0;
+    let consecutiveParseFailures = 0;
+    while (iterations < maxIterations) {
+        // (4) kill switch, before the LLM call.
+        if (i.isKilled()) {
+            return { outcome: "aborted", iterations, transcript, error: "kill switch tripped" };
+        }
+        // (5) budget, before spending anything.
+        try {
+            i.budget.check();
+        }
+        catch (err) {
+            if (err instanceof BudgetExceeded) {
+                return { outcome: "budget_exceeded", iterations, transcript, error: err.message };
+            }
+            throw err;
+        }
+        let reply;
+        try {
+            reply = await i.client.complete(i.systemPrompt.system, transcript);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message.slice(0, 300) : "model call failed";
+            return { outcome: "error", iterations, transcript, error: message };
+        }
+        iterations += 1;
+        try {
+            i.budget.chargeUsage(reply.usage);
+            i.budget.countIteration();
+        }
+        catch (err) {
+            if (err instanceof BudgetExceeded) {
+                return { outcome: "budget_exceeded", iterations, transcript, error: err.message };
+            }
+            throw err;
+        }
+        // (2) parse BEFORE any side effect.
+        let decision;
+        try {
+            decision = parseDecision(reply.text);
+            consecutiveParseFailures = 0;
+        }
+        catch (err) {
+            consecutiveParseFailures += 1;
+            const detail = err instanceof ReactParseError ? err.message : "unparseable reply";
+            if (consecutiveParseFailures >= 2) {
+                return {
+                    outcome: "error",
+                    iterations,
+                    transcript,
+                    error: `model reply could not be parsed twice (${detail})`,
+                };
+            }
+            // Observed as data, never as trusted instruction.
+            transcript = transcriptWith(transcriptWith(transcript, "assistant", "[reply rejected: not a valid decision object]"), "user", CORRECTIVE_NUDGE);
+            continue;
+        }
+        transcript = transcriptWith(transcript, "assistant", reply.text);
+        if (decision.kind === "final") {
+            return {
+                outcome: "answered",
+                answer: decision.answer,
+                iterations,
+                transcript,
+            };
+        }
+        // (4) kill switch again, before dispatching a tool.
+        if (i.isKilled()) {
+            return { outcome: "aborted", iterations, transcript, error: "kill switch tripped" };
+        }
+        // (3) allowlist + args schema, enforced in code.
+        const { observation, dispatched } = await dispatch(i, decision);
+        if (dispatched)
+            i.onToolUsed?.(decision.tool, observation);
+        transcript = transcriptWith(transcript, "user", wrapObservation(decision.tool, observation.summary));
+    }
+    return {
+        outcome: "iteration_limit",
+        iterations,
+        transcript,
+        error: `reached the ${maxIterations}-iteration limit without a final answer`,
+    };
+}

package/dist/jarvis/telemetry/provenance.d.ts

@@ -0,0 +1,54 @@
+export type JarvisOutcome = "answered" | "iteration_limit" | "budget_exceeded" | "aborted" | "error";
+export interface ProvenanceRecord {
+    v: 1;
+    runId: string;
+    ts: string;
+    agent: string;
+    version: string;
+    workspaceId: string;
+    userId: string;
+    session: string;
+    policyVersion: string;
+    policySha256: string;
+    skills: Array<{
+        name: string;
+        sha256: string;
+    }>;
+    skippedSkills: Array<{
+        name: string;
+        reason: string;
+    }>;
+    toolAllowlist: readonly string[];
+    toolsUsed: Array<{
+        name: string;
+        ok: boolean;
+        bytes: number;
+    }>;
+    iterations: number;
+    outcome: JarvisOutcome;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    memoryWrites: number;
+    redactions: number;
+    error?: string;
+}
+export declare const RETENTION_DAYS = 90;
+/**
+ * Audit record for one run (CORE-08, PRM-10, AI-12).
+ *
+ * The schema itself is the privacy control: it has no field that can hold
+ * prompt text, model replies, file contents, tokens or keys. What is recorded
+ * is identifiers, hashes and counts — enough to reconstruct which prompt and
+ * which policy produced which outcome, without retaining user data.
+ *
+ * The error string is the one free-text field; it is redacted and capped
+ * before it is written.
+ */
+export declare function writeProvenance(dir: string, r: ProvenanceRecord): Promise<string>;
+/**
+ * Delete run logs older than the retention window. Best-effort and never
+ * throws: pruning is housekeeping, and a failed prune must not fail a run.
+ */
+export declare function pruneProvenance(dir: string, now?: Date): Promise<number>;

package/dist/jarvis/telemetry/provenance.js

@@ -0,0 +1,56 @@
+// xcoder:version 1 | xcoder:task task-f1b5f6 | xcoder:updated 2026-11-05T02:47:00.711Z | xcoder:subtask code-st-53c7b5
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { redact, writeFilePrivate } from "../util/text.js";
+export const RETENTION_DAYS = 90;
+/**
+ * Audit record for one run (CORE-08, PRM-10, AI-12).
+ *
+ * The schema itself is the privacy control: it has no field that can hold
+ * prompt text, model replies, file contents, tokens or keys. What is recorded
+ * is identifiers, hashes and counts — enough to reconstruct which prompt and
+ * which policy produced which outcome, without retaining user data.
+ *
+ * The error string is the one free-text field; it is redacted and capped
+ * before it is written.
+ */
+export async function writeProvenance(dir, r) {
+    const record = {
+        ...r,
+        error: r.error === undefined ? undefined : redact(r.error).text.slice(0, 500),
+    };
+    const file = path.join(dir, `${r.runId}.jsonl`);
+    await writeFilePrivate(file, JSON.stringify(record) + "\n");
+    return file;
+}
+/**
+ * Delete run logs older than the retention window. Best-effort and never
+ * throws: pruning is housekeeping, and a failed prune must not fail a run.
+ */
+export async function pruneProvenance(dir, now = new Date()) {
+    const cutoff = now.getTime() - RETENTION_DAYS * 24 * 60 * 60 * 1000;
+    let removed = 0;
+    let entries;
+    try {
+        entries = await fsp.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return 0;
+    }
+    for (const e of entries) {
+        if (!e.isFile() || !e.name.endsWith(".jsonl"))
+            continue;
+        const full = path.join(dir, e.name);
+        try {
+            const st = await fsp.stat(full);
+            if (st.mtimeMs < cutoff) {
+                await fsp.unlink(full);
+                removed += 1;
+            }
+        }
+        catch {
+            /* skip unreadable entries */
+        }
+    }
+    return removed;
+}

package/dist/jarvis/test-helpers.d.ts

@@ -0,0 +1,14 @@
+import { MemoryStore } from "./memory/store.js";
+import { assembleSystemPrompt, type AssembledPrompt } from "./prompt/assemble.js";
+import { type ToolDescriptor, type ToolObservation } from "./tools/registry.js";
+import type { LlmCompleter, ReactLoopInput } from "./react-loop.js";
+/** Shared fixtures for the jarvis test suite. Not part of the public barrel. */
+export declare const TEST_WORKSPACE: string;
+export declare function promptFor(overrides?: Partial<Parameters<typeof assembleSystemPrompt>[0]>): AssembledPrompt;
+export declare function makeMemory(rootDir?: string): MemoryStore;
+export declare function stubClient(reply: () => string): LlmCompleter;
+/** A tool with a real zod args schema, so schema validation is genuinely exercised. */
+export declare function fakeTool(name: string, execute: () => Promise<ToolObservation>): ToolDescriptor<Record<string, unknown>>;
+export declare function baseInput(overrides?: Partial<ReactLoopInput>): ReactLoopInput;
+export declare function finalReply(answer: string): string;
+export declare function actionReply(tool: string, args?: Record<string, unknown>): string;

package/dist/jarvis/test-helpers.js

@@ -0,0 +1,69 @@
+// xcoder:version 1 | xcoder:task task-f1b5f6 | xcoder:updated 2026-11-05T02:48:23.033Z | xcoder:subtask code-st-53c7b5
+import { z } from "zod";
+import { RunBudget } from "./budget.js";
+import { MemoryStore } from "./memory/store.js";
+import { assembleSystemPrompt } from "./prompt/assemble.js";
+import { ALLOWED_TOOLS, createToolRegistry } from "./tools/registry.js";
+import { alwaysDeny } from "./util/confirm.js";
+/** Shared fixtures for the jarvis test suite. Not part of the public barrel. */
+export const TEST_WORKSPACE = process.cwd();
+export function promptFor(overrides = {}) {
+    return assembleSystemPrompt({
+        agentName: "jarvis-agent",
+        directive: "test task",
+        skills: [],
+        window: [],
+        toolAllowlist: [...ALLOWED_TOOLS],
+        toolManifest: "- read_file: read",
+        now: new Date("2026-01-01T00:00:00Z"),
+        ...overrides,
+    });
+}
+export function makeMemory(rootDir = "/tmp/jarvis-test") {
+    return new MemoryStore({ rootDir, scope: { workspaceId: "ws-test", userId: "u-test" } });
+}
+export function stubClient(reply) {
+    return {
+        complete: async () => ({ text: reply(), usage: { inputTokens: 10, outputTokens: 5 } }),
+    };
+}
+/** A tool with a real zod args schema, so schema validation is genuinely exercised. */
+export function fakeTool(name, execute) {
+    return {
+        name,
+        description: `fake ${name}`,
+        risk: "read",
+        argsSchema: z.object({}).passthrough().transform((v) => v),
+        execute: () => execute(),
+    };
+}
+export function baseInput(overrides = {}) {
+    return {
+        task: "do something",
+        systemPrompt: promptFor(),
+        client: stubClient(() => JSON.stringify({ kind: "final", thought: "t", answer: "done" })),
+        registry: createToolRegistry({ tools: [] }),
+        toolContext: {
+            workspaceRoot: TEST_WORKSPACE,
+            memory: makeMemory(),
+            session: "s1",
+            confirm: alwaysDeny,
+            limits: { maxReadBytes: 1024, maxResults: 10 },
+        },
+        maxIterations: 8,
+        budget: new RunBudget({
+            maxIterations: 8,
+            maxInputTokens: 1_000_000,
+            maxOutputTokens: 1_000_000,
+            maxWallMs: 60_000,
+        }),
+        isKilled: () => false,
+        ...overrides,
+    };
+}
+export function finalReply(answer) {
+    return JSON.stringify({ kind: "final", thought: "t", answer });
+}
+export function actionReply(tool, args = {}) {
+    return JSON.stringify({ kind: "action", thought: "t", tool, args });
+}