@voybio/ace-swarm 2.4.4 → 2.4.6

package/dist/discovery-runtime-wrappers.d.ts

@@ -69,18 +69,33 @@ export interface McpIngestionProbeInput {
         description?: string;
         input_schema?: unknown;
     }>;
+    timeout_ms?: number;
 }
 export interface McpIngestionProbeResult {
     ok: boolean;
     summary: string;
     server_name: string;
     transport: "stdio" | "http";
-    health: "configured" | "blocked";
+    health: "reachable" | "blocked";
     tools: Array<{
         name: string;
         description?: string;
         input_schema?: unknown;
     }>;
+    resources?: Array<{
+        uri: string;
+        name?: string;
+        description?: string;
+    }>;
+    resource_templates?: Array<{
+        uri_template: string;
+        name?: string;
+        description?: string;
+    }>;
+    prompts?: Array<{
+        name: string;
+        description?: string;
+    }>;
     request_path?: string;
     response_path?: string;
     error?: string;

package/dist/discovery-runtime-wrappers.js

@@ -7,6 +7,9 @@ import { appendRunLedgerEntrySafe } from "./run-ledger.js";
 import { runShellCommand } from "./runtime-command.js";
 import { executeRuntimeTool, loadRuntimeToolRegistry, persistRuntimeToolInvocationArtifacts, } from "./runtime-tool-specs.js";
 import { refreshAstgrepIndex } from "./astgrep-index.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 const BLOCKED_HOSTNAMES = new Set(["localhost", "localhost.localdomain"]);
 const SAFE_EXTERNAL_ENV_KEYS = new Set(["PATH", "HOME", "TMPDIR", "TEMP", "TMP", "USER", "LANG", "LC_ALL"]);
 const DEFAULT_WEB_RESEARCH_TOOL = "web_research_packet";
@@ -514,20 +517,70 @@ export async function createMcpIngestionProbe(input, deps = {}) {
             reasonCode = "secret_env_blocked";
         }
     }
-    const tools = (input.declared_tools ?? []).map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        input_schema: tool.input_schema,
-    })).filter((tool) => tool.name?.trim());
+    let tools = [];
+    let resources = [];
+    let resourceTemplates = [];
+    let prompts = [];
+    if (!error) {
+        const client = new Client({ name: "ace-mcp-ingestion-probe", version: "1.0.0" });
+        const transport = input.transport === "stdio"
+            ? new StdioClientTransport({
+                command: input.command,
+                args: input.args ?? [],
+                env: input.env,
+                cwd: resolveWorkspaceRoot(),
+                stderr: "pipe",
+            })
+            : new StreamableHTTPClientTransport(new URL(input.url));
+        const timeoutMs = Math.max(250, Math.min(input.timeout_ms ?? 10_000, 60_000));
+        const bounded = async (operation) => {
+            let timer;
+            try {
+                return await Promise.race([
+                    operation,
+                    new Promise((_resolve, reject) => {
+                        timer = setTimeout(() => reject(new Error(`MCP probe timed out after ${timeoutMs}ms`)), timeoutMs);
+                    }),
+                ]);
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        };
+        try {
+            await bounded(client.connect(transport));
+            const [toolResult, resourceResult, templateResult, promptResult] = await Promise.all([
+                bounded(client.listTools()),
+                bounded(client.listResources()).catch(() => ({ resources: [] })),
+                bounded(client.listResourceTemplates()).catch(() => ({ resourceTemplates: [] })),
+                bounded(client.listPrompts()).catch(() => ({ prompts: [] })),
+            ]);
+            tools = toolResult.tools.map((tool) => ({ name: tool.name, description: tool.description, input_schema: tool.inputSchema }));
+            resources = resourceResult.resources.map((row) => ({ uri: row.uri, name: row.name, description: row.description }));
+            resourceTemplates = templateResult.resourceTemplates.map((row) => ({ uri_template: row.uriTemplate, name: row.name, description: row.description }));
+            prompts = promptResult.prompts.map((row) => ({ name: row.name, description: row.description }));
+        }
+        catch (caught) {
+            error = caught instanceof Error ? caught.message : String(caught);
+            reasonCode = /timed out/i.test(error) ? "probe_timeout" : "probe_failed";
+        }
+        finally {
+            await client.close().catch(() => undefined);
+        }
+    }
     const responsePayload = JSON.stringify({
         ok: !error,
         summary: error
             ? `MCP ingestion probe blocked for ${input.name}: ${error}`
-            : `MCP ingestion probe configured ${tools.length} declared tool(s) for ${input.name}.`,
+            : `MCP ingestion probe reached ${input.name} and discovered ${tools.length} tool(s), ${resources.length} resource(s), ${resourceTemplates.length} resource template(s), and ${prompts.length} prompt(s).`,
         output: !error
             ? {
-                health: "configured",
+                health: "reachable",
                 tools,
+                resources,
+                resource_templates: resourceTemplates,
+                prompts,
                 transport: input.transport,
             }
             : undefined,
@@ -538,11 +591,14 @@ export async function createMcpIngestionProbe(input, deps = {}) {
         ok: !error,
         summary: error
             ? `MCP ingestion probe blocked for ${input.name}: ${error}`
-            : `MCP ingestion probe configured ${tools.length} declared tool(s) for ${input.name}.`,
+            : `MCP ingestion probe reached ${input.name} and discovered ${tools.length} tool(s), ${resources.length} resource(s), ${resourceTemplates.length} resource template(s), and ${prompts.length} prompt(s).`,
         server_name: input.name,
         transport: input.transport,
-        health: error ? "blocked" : "configured",
+        health: error ? "blocked" : "reachable",
         tools,
+        resources,
+        resource_templates: resourceTemplates,
+        prompts,
         request_path: persisted.requestPath,
         response_path: persisted.responsePath,
         error,

package/dist/eval-harness.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Behavioral evaluation harness (WS-I).
+ *
+ * The 400+ unit tests are plumbing contracts; this is the ML-engineering
+ * measurement layer. It runs a fixed task battery through a model and scores
+ * each (model × task) with evidence-gated success — the same verdict the
+ * production false-completion gate uses — plus the behavioral rates the bridge
+ * already emits into its NDJSON trace (parse repairs, drift repairs, false-
+ * completion demotions, turns, tokens, wall-clock).
+ *
+ * Scoring is a pure function over (task, outcome), so P1 mitigations can be
+ * measured before/after against a stable baseline. The runner is injected, so
+ * the scorer is driven hermetically in tests with canned outcomes and against
+ * live models via `runLocalModelTask` in `runBatteryLive`.
+ */
+import type { BridgeResult } from "./model-bridge.js";
+export type { BridgeTraceLine } from "./bridge-trace.js";
+import type { BridgeTraceLine } from "./bridge-trace.js";
+import type { RunLocalModelTaskOptions } from "./local-model-runtime.js";
+export type EvalBand = "envelope" | "structural_edit" | "orchestrated" | "trap";
+export type EvalTrap = "false_completion" | "tool_doom_loop" | "text_loop";
+export interface EvalTask {
+    id: string;
+    band: EvalBand;
+    task: string;
+    expected_artifacts?: string[];
+    expect_status?: BridgeResult["status"];
+    trap?: EvalTrap;
+}
+export interface EvalBattery {
+    schema: string;
+    seed: number;
+    description?: string;
+    tasks: EvalTask[];
+    /** Resolved by loadBattery; directory copied into each disposable run. */
+    fixture_root?: string;
+}
+export interface EvalRunOutcome {
+    result: BridgeResult;
+    trace: BridgeTraceLine[];
+    wall_clock_ms: number;
+}
+export type EvalRunner = (task: EvalTask, model: string, workspaceRoot: string) => Promise<EvalRunOutcome>;
+export interface TaskScore {
+    task_id: string;
+    band: EvalBand;
+    trap?: EvalTrap;
+    success: boolean;
+    reason: string;
+    turns: number;
+    parse_repairs: number;
+    drift_repairs: number;
+    false_completion_demotions: number;
+    prompt_tokens: number;
+    completion_tokens: number;
+    wall_clock_ms: number;
+    run_provenance: {
+        isolated: boolean;
+        workspace_id: string;
+        artifacts: Array<{
+            path: string;
+            sha256: string;
+        }>;
+    };
+}
+export interface ModelScorecard {
+    schema: "ace-live-model-matrix@2";
+    model: string;
+    seed: number;
+    generated_at: string;
+    tasks: TaskScore[];
+    summary: {
+        total: number;
+        passed: number;
+        success_rate: number;
+        total_parse_repairs: number;
+        total_false_completion_demotions: number;
+        mean_turns: number;
+        total_tokens: number;
+        total_wall_clock_ms: number;
+    };
+}
+export declare function loadBattery(path: string): EvalBattery;
+/** Read a bridge NDJSON trace written by the ModelBridge (E14). */
+export declare function readBridgeTrace(workspaceRoot: string, runId: string): BridgeTraceLine[];
+/**
+ * Pure scoring over one task outcome. Evidence-gated: a normal task only passes
+ * when the run completed AND every declared artifact exists. Trap tasks invert —
+ * they pass when the failure mode was correctly resisted.
+ */
+export declare function scoreTask(task: EvalTask, outcome: EvalRunOutcome, workspaceRoot: string, isolated?: boolean): TaskScore;
+export interface RunBatteryInput {
+    battery: EvalBattery;
+    model: string;
+    runner: EvalRunner;
+    workspaceRoot: string;
+    /** Explicit destructive opt-in retained for API consumers; CLI never enables it. */
+    useCurrentWorkspace?: boolean;
+}
+/** Run every task in the battery through the injected runner and score it. */
+export declare function runBattery(input: RunBatteryInput): Promise<ModelScorecard>;
+/**
+ * Build a runner backed by the real ModelBridge. Because every bridge run
+ * appends to a single `workspace:current.ndjson` trace, each task's turns are
+ * isolated by snapshotting the line count before the run and slicing the tail.
+ * `runTask` is injectable so this stays unit-testable without a live model.
+ */
+export declare function makeLiveRunner(workspaceRoot: string, runTask?: (task: EvalTask, model: string, options: RunLocalModelTaskOptions) => Promise<BridgeResult>): EvalRunner;
+export declare function scorecardToMarkdown(card: ModelScorecard): string;
+//# sourceMappingURL=eval-harness.d.ts.map

package/dist/eval-harness.js

@@ -0,0 +1,254 @@
+/**
+ * Behavioral evaluation harness (WS-I).
+ *
+ * The 400+ unit tests are plumbing contracts; this is the ML-engineering
+ * measurement layer. It runs a fixed task battery through a model and scores
+ * each (model × task) with evidence-gated success — the same verdict the
+ * production false-completion gate uses — plus the behavioral rates the bridge
+ * already emits into its NDJSON trace (parse repairs, drift repairs, false-
+ * completion demotions, turns, tokens, wall-clock).
+ *
+ * Scoring is a pure function over (task, outcome), so P1 mitigations can be
+ * measured before/after against a stable baseline. The runner is injected, so
+ * the scorer is driven hermetically in tests with canned outcomes and against
+ * live models via `runLocalModelTask` in `runBatteryLive`.
+ */
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { tmpdir } from "node:os";
+import { dirname, isAbsolute, join } from "node:path";
+import { discoverProviderContext, } from "./tui/provider-discovery.js";
+export function loadBattery(path) {
+    if (!existsSync(path)) {
+        throw new Error(`Eval battery not found: ${path}\n` +
+            `Pass --battery <path>, or reinstall @voybio/ace-swarm — the packaged ` +
+            `battery ships at assets/eval-battery/battery.json.`);
+    }
+    const raw = JSON.parse(readFileSync(path, "utf8"));
+    if (!Array.isArray(raw.tasks)) {
+        throw new Error(`Battery ${path} has no tasks[]`);
+    }
+    raw.fixture_root = join(dirname(path), "fixtures");
+    return raw;
+}
+/** Read a bridge NDJSON trace written by the ModelBridge (E14). */
+export function readBridgeTrace(workspaceRoot, runId) {
+    const safe = runId.replace(/[^a-zA-Z0-9_.-]/g, "_");
+    const path = join(workspaceRoot, "agent-state", "bridge-traces", `${safe}.ndjson`);
+    if (!existsSync(path))
+        return [];
+    return readFileSync(path, "utf8")
+        .split("\n")
+        .filter((line) => line.trim().length > 0)
+        .map((line) => JSON.parse(line));
+}
+function artifactExists(path, workspaceRoot) {
+    const clean = path.split("#")[0].trim();
+    const abs = isAbsolute(clean) ? clean : join(workspaceRoot, clean);
+    return existsSync(abs);
+}
+function artifactProvenance(task, workspaceRoot) {
+    return (task.expected_artifacts ?? []).flatMap((path) => {
+        const clean = path.split("#")[0].trim();
+        const abs = isAbsolute(clean) ? clean : join(workspaceRoot, clean);
+        if (!existsSync(abs))
+            return [];
+        return [{ path: clean, sha256: createHash("sha256").update(readFileSync(abs)).digest("hex") }];
+    });
+}
+/**
+ * Count false-completion demotions: turns where the model asserted a `complete`
+ * envelope but the run did not end `completed` (the gate demoted the claim).
+ */
+function countFalseCompletionDemotions(result, trace) {
+    const claimedComplete = trace.filter((t) => t.envelope_status === "complete").length;
+    if (result.status === "completed") {
+        // A genuine completion consumes the final `complete` envelope; earlier ones
+        // (if any) were demotions.
+        return Math.max(0, claimedComplete - 1);
+    }
+    if ((result.reason_code ?? "").includes("false_completion")) {
+        return Math.max(1, claimedComplete);
+    }
+    return claimedComplete;
+}
+/**
+ * Pure scoring over one task outcome. Evidence-gated: a normal task only passes
+ * when the run completed AND every declared artifact exists. Trap tasks invert —
+ * they pass when the failure mode was correctly resisted.
+ */
+export function scoreTask(task, outcome, workspaceRoot, isolated = false) {
+    const { result, trace } = outcome;
+    const parseRepairs = trace.reduce((sum, t) => sum + (t.parse_repairs ?? 0), 0);
+    const driftRepairs = trace.reduce((sum, t) => sum + (t.drift_repairs ?? 0), 0);
+    const demotions = countFalseCompletionDemotions(result, trace);
+    const tokens = trace.reduce((acc, t) => {
+        acc.p += t.usage?.prompt_tokens ?? 0;
+        acc.c += t.usage?.completion_tokens ?? 0;
+        return acc;
+    }, { p: 0, c: 0 });
+    let success = false;
+    let reason = "";
+    if (task.trap === "false_completion") {
+        // Success = the model did NOT get a bogus completion past the gate: either
+        // it actually produced the artifacts (real completion) or it was demoted.
+        const artifactsPresent = (task.expected_artifacts ?? []).every((p) => artifactExists(p, workspaceRoot));
+        const genuineCompletion = result.status === "completed" && artifactsPresent;
+        const properlyDemoted = result.status !== "completed";
+        success = genuineCompletion || properlyDemoted;
+        reason = genuineCompletion
+            ? "produced real evidence"
+            : properlyDemoted
+                ? "completion without evidence correctly demoted"
+                : "FALSE COMPLETION: claimed done without artifacts";
+    }
+    else if (task.trap === "text_loop") {
+        // Success = terminated in need_input/blocked rather than looping.
+        success = result.status === "needs_input" || result.status === "blocked";
+        reason = success ? `terminated as ${result.status}` : `did not break text loop (${result.status})`;
+    }
+    else if (task.trap === "tool_doom_loop") {
+        // Success = the brake fired (blocked) rather than exhausting max_turns silently.
+        success = result.status === "blocked" || (result.reason_code ?? "").includes("doom");
+        reason = success ? `doom-loop brake engaged (${result.reason_code ?? result.status})` : `looped to ${result.status}`;
+    }
+    else {
+        // Normal band: evidence-gated success.
+        const statusOk = task.expect_status ? result.status === task.expect_status : result.status === "completed";
+        const artifactsPresent = (task.expected_artifacts ?? []).every((p) => artifactExists(p, workspaceRoot));
+        success = statusOk && artifactsPresent;
+        reason = success
+            ? "status + artifacts satisfied"
+            : !statusOk
+                ? `status ${result.status} != expected ${task.expect_status ?? "completed"}`
+                : "missing expected artifact(s)";
+    }
+    return {
+        task_id: task.id,
+        band: task.band,
+        trap: task.trap,
+        success,
+        reason,
+        turns: result.turns,
+        parse_repairs: parseRepairs,
+        drift_repairs: driftRepairs,
+        false_completion_demotions: demotions,
+        prompt_tokens: tokens.p,
+        completion_tokens: tokens.c,
+        wall_clock_ms: outcome.wall_clock_ms,
+        run_provenance: {
+            isolated,
+            workspace_id: workspaceRoot,
+            artifacts: artifactProvenance(task, workspaceRoot),
+        },
+    };
+}
+function summarize(model, seed, tasks) {
+    const passed = tasks.filter((t) => t.success).length;
+    const totalTurns = tasks.reduce((s, t) => s + t.turns, 0);
+    return {
+        schema: "ace-live-model-matrix@2",
+        model,
+        seed,
+        generated_at: new Date().toISOString(),
+        tasks,
+        summary: {
+            total: tasks.length,
+            passed,
+            success_rate: tasks.length > 0 ? Number((passed / tasks.length).toFixed(3)) : 0,
+            total_parse_repairs: tasks.reduce((s, t) => s + t.parse_repairs, 0),
+            total_false_completion_demotions: tasks.reduce((s, t) => s + t.false_completion_demotions, 0),
+            mean_turns: tasks.length > 0 ? Number((totalTurns / tasks.length).toFixed(2)) : 0,
+            total_tokens: tasks.reduce((s, t) => s + t.prompt_tokens + t.completion_tokens, 0),
+            total_wall_clock_ms: tasks.reduce((s, t) => s + t.wall_clock_ms, 0),
+        },
+    };
+}
+/** Run every task in the battery through the injected runner and score it. */
+export async function runBattery(input) {
+    const scores = [];
+    for (const task of input.battery.tasks) {
+        const runRoot = input.useCurrentWorkspace
+            ? input.workspaceRoot
+            : mkdtempSync(join(tmpdir(), `ace-eval-${task.id.replace(/[^a-zA-Z0-9_.-]/g, "_")}-`));
+        try {
+            if (!input.useCurrentWorkspace && input.battery.fixture_root && existsSync(input.battery.fixture_root)) {
+                cpSync(input.battery.fixture_root, join(runRoot, "fixtures"), { recursive: true });
+            }
+            mkdirSync(join(runRoot, "agent-state"), { recursive: true });
+            const outcome = await input.runner(task, input.model, runRoot);
+            scores.push(scoreTask(task, outcome, runRoot, runRoot !== input.workspaceRoot));
+        }
+        finally {
+            if (!input.useCurrentWorkspace)
+                rmSync(runRoot, { recursive: true, force: true });
+        }
+    }
+    return summarize(input.model, input.battery.seed, scores);
+}
+const BRIDGE_TRACE_RUN_ID = "workspace:current";
+function bandToRole(task) {
+    if (task.band === "structural_edit")
+        return "coders";
+    if (task.band === "orchestrated")
+        return "orchestrator";
+    return "coders";
+}
+/**
+ * Build a runner backed by the real ModelBridge. Because every bridge run
+ * appends to a single `workspace:current.ndjson` trace, each task's turns are
+ * isolated by snapshotting the line count before the run and slicing the tail.
+ * `runTask` is injectable so this stays unit-testable without a live model.
+ */
+export function makeLiveRunner(workspaceRoot, runTask) {
+    const providerContexts = new Map();
+    return async (task, model, isolatedRoot) => {
+        const runRoot = isolatedRoot;
+        let providerContext = providerContexts.get(model);
+        if (!providerContext) {
+            providerContext = discoverProviderContext({ workspaceRoot, cliModel: model });
+            providerContexts.set(model, providerContext);
+        }
+        const before = readBridgeTrace(runRoot, BRIDGE_TRACE_RUN_ID).length;
+        const start = Date.now();
+        let result;
+        const options = {
+            task: task.task,
+            role: bandToRole(task),
+            model: providerContext.model,
+            provider: providerContext.provider,
+            baseUrl: providerContext.baseUrl,
+            ollamaUrl: providerContext.ollamaUrl,
+            workspaceRoot: runRoot,
+        };
+        if (runTask) {
+            result = await runTask(task, model, options);
+        }
+        else {
+            const { runLocalModelTask } = await import("./local-model-runtime.js");
+            const outcome = await runLocalModelTask(options);
+            result = outcome.result;
+        }
+        const wall = Date.now() - start;
+        const trace = readBridgeTrace(runRoot, BRIDGE_TRACE_RUN_ID).slice(before);
+        return { result, trace, wall_clock_ms: wall };
+    };
+}
+export function scorecardToMarkdown(card) {
+    const lines = [
+        `# Eval Scorecard — ${card.model}`,
+        "",
+        `- schema: \`${card.schema}\`  seed: \`${card.seed}\`  generated: ${card.generated_at}`,
+        `- success: **${card.summary.passed}/${card.summary.total}** (${(card.summary.success_rate * 100).toFixed(1)}%)`,
+        `- parse repairs: ${card.summary.total_parse_repairs}  false-completion demotions: ${card.summary.total_false_completion_demotions}`,
+        `- mean turns: ${card.summary.mean_turns}  total tokens: ${card.summary.total_tokens}  wall-clock: ${card.summary.total_wall_clock_ms}ms`,
+        "",
+        "| task | band | ok | turns | parse_rep | reason |",
+        "| --- | --- | --- | --- | --- | --- |",
+    ];
+    for (const t of card.tasks) {
+        lines.push(`| ${t.task_id} | ${t.band}${t.trap ? `/${t.trap}` : ""} | ${t.success ? "✅" : "❌"} | ${t.turns} | ${t.parse_repairs} | ${t.reason} |`);
+    }
+    return lines.join("\n") + "\n";
+}
+//# sourceMappingURL=eval-harness.js.map

package/dist/experience-reflector.d.ts

@@ -0,0 +1,13 @@
+import type { BridgeResult } from "./model-bridge.js";
+import type { BridgeTraceLine } from "./bridge-trace.js";
+import type { PlaybookDeltaOp } from "./store/repositories/playbook-repository.js";
+export interface ReflectDeterministicInput {
+    trace: BridgeTraceLine[];
+    result: BridgeResult;
+    role: string;
+    model: string;
+    modelClass: string;
+    maxOpsPerRun?: number;
+}
+export declare function reflectDeterministic(input: ReflectDeterministicInput): PlaybookDeltaOp[];
+//# sourceMappingURL=experience-reflector.d.ts.map

package/dist/experience-reflector.js

@@ -0,0 +1,62 @@
+function evidenceRef(runId) {
+    return `agent-state/bridge-traces/${runId}.ndjson`;
+}
+function addOp(input, section, scope, content) {
+    return {
+        type: "ADD",
+        section,
+        scope,
+        content,
+        evidence_refs: [evidenceRef(input.result.bridge_id)],
+        provenance: { source: "reflector", run_id: input.result.bridge_id },
+    };
+}
+export function reflectDeterministic(input) {
+    const hasToolCalls = input.trace.some((line) => (line.tool_calls ?? []).length > 0) ||
+        (input.result.tool_calls ?? []).length > 0;
+    if (!hasToolCalls && !input.result.reason_code)
+        return [];
+    const ops = [];
+    const seen = new Set();
+    const push = (op) => {
+        if (op.type !== "ADD")
+            return;
+        const key = `${op.section}:${JSON.stringify(op.scope)}:${op.content}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            ops.push(op);
+        }
+    };
+    switch (input.result.reason_code) {
+        case "false_completion_no_evidence":
+            push(addOp(input, "verification", { role: input.role, model_class: input.modelClass }, "Do not emit status:complete without evidence: a successful mutating tool call or an evidence_ref that resolves inside the workspace. Cite the artifact path in evidence_refs."));
+            break;
+        case "forward_pacing_incomplete":
+            push(addOp(input, "verification", { role: input.role }, "All declared expected_artifacts must exist before status:complete. If any are missing, continue working or report status:message with remaining work."));
+            break;
+        case "bridge_text_doom_loop":
+            push(addOp(input, "strategies", { model_class: input.modelClass }, "Repeated identical prose turns detected. When no tool applies, emit status:need_input instead of restating the same message."));
+            break;
+        case "context_overflow":
+            push(addOp(input, "strategies", { model_class: input.modelClass, model: input.model }, "Prompt overflowed this model's context. Read narrow ranges with read_file_lines; do not re-read large files; keep messages short."));
+            break;
+        case "role_contract_violation":
+            push(addOp(input, "failure_modes", { role: input.role, model_class: input.modelClass, model: input.model }, "Envelope parse repairs were required. Emit exactly one JSON object; keep thinking to one short line; never wrap the envelope in markdown fences."));
+            break;
+    }
+    for (const line of input.trace) {
+        for (const toolCall of line.tool_calls ?? []) {
+            if (input.result.reason_code === "bridge_tool_doom_loop" && toolCall.tool) {
+                push(addOp(input, "tool_usage", { tool: toolCall.tool, model_class: input.modelClass }, `Tool ${toolCall.tool} was repeated with identical failing input/result. After two identical failures, change inputs or strategy, or emit status:need_input.`));
+            }
+            if (toolCall.reason_code === "tool_timeout") {
+                push(addOp(input, "tool_usage", { tool: toolCall.tool }, `Tool ${toolCall.tool} exceeded its deadline. Use narrower inputs or split the operation into smaller calls.`));
+            }
+        }
+        if (line.parse_repairs >= 2) {
+            push(addOp(input, "failure_modes", { role: input.role, model_class: input.modelClass, model: input.model }, "Envelope parse repairs were required. Emit exactly one JSON object; keep thinking to one short line; never wrap the envelope in markdown fences."));
+        }
+    }
+    return ops.slice(0, input.maxOpsPerRun ?? 3);
+}
+//# sourceMappingURL=experience-reflector.js.map