@kasenri/dsh-orbit 0.5.1

package/lib/decisions.js

@@ -0,0 +1,167 @@
+import { ORBIT_CAPABILITIES } from "./kernel.js";
+import {} from "./types.js";
+// ── DSH-native structured decision schemas ───────────────────────────────────
+//
+// The model submits its decision through the DSH structured-output protocol and
+// the provider validates it against one of these schemas. They are written in
+// the enforced JSON Schema subset (dsh-tools `assertObjectJsonSchema`), keep only
+// format-level rules (types, required fields, legal enums), and leave Orbit's
+// domain rules (plan size, correction depth, budget) to the checks below.
+const CAPABILITY_ENUM = [...ORBIT_CAPABILITIES];
+/** Plan steps are object-rooted; capabilities stay optional per step. */
+export const COMMANDER_PLAN_SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['summary', 'steps'],
+    properties: {
+        summary: { type: 'string', description: 'One-sentence plan summary.' },
+        steps: {
+            type: 'array',
+            description: '2-5 logical engineering steps.',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['goal'],
+                properties: {
+                    id: { type: 'string', description: 'Stable id such as P0.' },
+                    goal: { type: 'string' },
+                    capabilities: { type: 'array', items: { type: 'string', enum: CAPABILITY_ENUM } },
+                },
+            },
+        },
+    },
+};
+export const COMMANDER_STEP_EVALUATE_SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['decision'],
+    properties: {
+        decision: { type: 'string', enum: ['PASS_CURRENT_STEP', 'CORRECT_CURRENT_STEP', 'NEEDS_USER'] },
+        reason: { type: 'string' },
+        next_step_goal: { type: 'string' },
+        next_step_capabilities: { type: 'array', items: { type: 'string', enum: CAPABILITY_ENUM } },
+    },
+};
+export const COMMANDER_FINAL_EVALUATE_SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['decision'],
+    properties: {
+        decision: { type: 'string', enum: ['SUCCESS', 'APPEND', 'NEEDS_USER'] },
+        summary: { type: 'string' },
+        next_step_goal: { type: 'string' },
+        next_step_capabilities: { type: 'array', items: { type: 'string', enum: CAPABILITY_ENUM } },
+        next_steps: {
+            type: 'array',
+            items: {
+                oneOf: [
+                    { type: 'string' },
+                    {
+                        type: 'object',
+                        additionalProperties: false,
+                        required: ['goal'],
+                        properties: {
+                            goal: { type: 'string' },
+                            capabilities: { type: 'array', items: { type: 'string', enum: CAPABILITY_ENUM } },
+                        },
+                    },
+                ],
+            },
+        },
+    },
+};
+export const COMMANDER_STRATEGY_SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['decision'],
+    properties: {
+        decision: { type: 'string', enum: ['KEEP_APPROACH', 'REPLACE_CURRENT_STEP', 'NEEDS_USER'] },
+        reason: { type: 'string' },
+        replacement_goal: { type: 'string' },
+    },
+};
+export const WATCHDOG_RUNTIME_SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['decision'],
+    properties: {
+        decision: { type: 'string', enum: ['RESUME_CHILD', 'RESTART_STEP', 'NEEDS_USER', 'RUNTIME_BUG'] },
+        reason: { type: 'string' },
+    },
+};
+export const WATCHDOG_STRATEGY_SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['question'],
+    properties: {
+        question: { type: 'string', description: 'The single strategy question to put to the Commander.' },
+    },
+};
+export const WATCHDOG_GUARD_SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['decision'],
+    properties: {
+        decision: { type: 'string', enum: ['RETRY_DIFFERENTLY', 'NEEDS_USER'] },
+        instruction: { type: 'string' },
+    },
+};
+export const WATCHDOG_TIMEOUT_SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['decision'],
+    properties: {
+        decision: { type: 'string', enum: ['EXTEND', 'INTERRUPT', 'NEEDS_USER'] },
+        reason: { type: 'string' },
+    },
+};
+export const ORBIT_DECISION_SCHEMAS = {
+    COMMANDER_PLAN_SCHEMA,
+    COMMANDER_STEP_EVALUATE_SCHEMA,
+    COMMANDER_FINAL_EVALUATE_SCHEMA,
+    COMMANDER_STRATEGY_SCHEMA,
+    WATCHDOG_RUNTIME_SCHEMA,
+    WATCHDOG_STRATEGY_SCHEMA,
+    WATCHDOG_GUARD_SCHEMA,
+    WATCHDOG_TIMEOUT_SCHEMA,
+};
+const STEP_DECISIONS = ['PASS_CURRENT_STEP', 'CORRECT_CURRENT_STEP', 'NEEDS_USER'];
+const FINAL_DECISIONS = ['SUCCESS', 'APPEND', 'NEEDS_USER'];
+export function assertCommanderDecision(decision, mode) {
+    const allowed = mode === 'FINAL_EVALUATE' ? FINAL_DECISIONS : STEP_DECISIONS;
+    if (!allowed.includes(decision.decision)) {
+        throw new Error(`COMMANDER_EVALUATION_DECISION_INVALID_FOR_MODE: ${mode} cannot return ${decision.decision}`);
+    }
+    return decision;
+}
+export function assertStrategyDecision(decision) {
+    const allowed = ['KEEP_APPROACH', 'REPLACE_CURRENT_STEP', 'NEEDS_USER'];
+    if (!allowed.includes(decision.decision)) {
+        throw new Error(`COMMANDER_STRATEGY_DECISION_INVALID: ${decision.decision}`);
+    }
+    if (decision.decision === 'REPLACE_CURRENT_STEP' && !decision.replacement_goal?.trim()) {
+        throw new Error('COMMANDER_STRATEGY_OUTPUT_INVALID: replacement_goal is required');
+    }
+    return decision;
+}
+export function assertTimeoutDecision(decision) {
+    const allowed = ['EXTEND', 'INTERRUPT', 'NEEDS_USER'];
+    if (!allowed.includes(decision.decision)) {
+        throw new Error(`COMMANDER_TIMEOUT_WATCHDOG_DECISION_INVALID: ${decision.decision}`);
+    }
+    return decision;
+}
+export function assertWatchdogDecision(decision) {
+    const allowed = ['RESUME_CHILD', 'RESTART_STEP', 'NEEDS_USER', 'RUNTIME_BUG'];
+    if (!allowed.includes(decision.decision)) {
+        throw new Error(`SMART_WATCHDOG_RUNTIME_DECISION_INVALID: ${decision.decision}`);
+    }
+    return decision;
+}
+export function assertGuardWatchdogDecision(decision) {
+    const allowed = ['RETRY_DIFFERENTLY', 'NEEDS_USER'];
+    if (!allowed.includes(decision.decision)) {
+        throw new Error(`SMART_WATCHDOG_GUARD_DECISION_INVALID: ${decision.decision}`);
+    }
+    return decision;
+}

package/lib/dsh-host.js

@@ -0,0 +1,364 @@
+import { execFileSync } from 'node:child_process';
+import { collectTurnToolFacts } from "./evidence.js";
+import { redactText, truncateSafe } from "./sanitize.js";
+import { classifyTurnSettlement } from "./settlement.js";
+const EXECUTOR_TURN_START_TIMEOUT_MS = 5_000;
+function contentToText(blocks) {
+    if (!blocks)
+        return '';
+    return blocks
+        .map((block) => (block.type === 'text' ? block.text : `[${block.type}]`))
+        .join('\n');
+}
+/**
+ * Wire the Orbit supervisor to DeepSeek Harness native Agent/Subagent services.
+ *
+ * Roles keep the Pi-validated split:
+ * - Commander/Watchdog: one-shot children, cancelled through the launch signal
+ *   plus `run.dispose()` (the real one-shot cancellation seam).
+ * - Executor: continuable child so a runtime restart can interrupt it and a
+ *   resume can reuse the same child.
+ */
+export class DshOrbitHost {
+    ctx;
+    ownedChildren = new Set();
+    interruptedChildren = new Set();
+    childParents = new Map();
+    nowFn;
+    sleepFn;
+    constructor(ctx, options = {}) {
+        this.ctx = ctx;
+        this.nowFn = options.now ?? (() => Date.now());
+        this.sleepFn = options.sleep ?? defaultSleep;
+    }
+    now() {
+        return this.nowFn();
+    }
+    sleep(ms, signal) {
+        return this.sleepFn(ms, signal);
+    }
+    async startRole(request) {
+        const parent = this.parent();
+        const prompt = [{ type: 'text', text: request.prompt }];
+        const agentOptions = {
+            provider: request.route.provider,
+            model: request.route.model,
+            ...(request.route.reasoningEffort ? { reasoningEffort: request.route.reasoningEffort } : {}),
+            ...(request.route.maxTokens ? { maxTokens: request.route.maxTokens } : {}),
+        };
+        if (request.role === 'executor') {
+            return this.startExecutor(parent, request, prompt, agentOptions);
+        }
+        return this.startOneShot(parent, request, prompt, agentOptions);
+    }
+    parent() {
+        const initiator = this.ctx.agents.currentInitiator();
+        if (initiator)
+            return initiator;
+        return this.ctx.agents.requireInitiator();
+    }
+    async startOneShot(parent, request, prompt, agentOptions) {
+        const controller = new AbortController();
+        const onAbort = () => controller.abort();
+        request.signal?.addEventListener('abort', onAbort, { once: true });
+        const run = (await this.ctx.subagents.start('spawn', {
+            label: request.label,
+            prompt,
+            parent,
+            signal: controller.signal,
+            agentOptions,
+            ...(request.toolFilter ? { toolFilter: request.toolFilter } : {}),
+            ...(request.outputSchema ? { outputSchema: request.outputSchema } : {}),
+        }));
+        this.registerChild(run.id, parent);
+        const result = run.result
+            .then((value) => ({
+            childId: run.id,
+            output: contentToText(value.output),
+            interrupted: value.stopReason !== 'completed',
+            ...(value.stopReason !== 'completed' ? { reason: value.stopReason } : {}),
+            ...(value.diagnostic ? { testSummary: [value.diagnostic] } : {}),
+            ...(value.structured !== undefined ? { structured: value.structured } : {}),
+        }))
+            .catch((error) => ({
+            childId: run.id,
+            output: '',
+            interrupted: true,
+            reason: error instanceof Error ? error.message : String(error),
+        }));
+        return {
+            childId: run.id,
+            result,
+            cancel: async (reason) => {
+                this.interruptedChildren.add(run.id);
+                controller.abort(new Error(reason));
+                await run.dispose();
+                this.forgetChild(run.id);
+            },
+            dispose: async () => {
+                await run.dispose();
+                this.forgetChild(run.id);
+            },
+            runtimeSnapshot: () => this.snapshotAgent(run.localAgent),
+        };
+    }
+    async startExecutor(parent, request, prompt, agentOptions) {
+        if (request.resumeOf) {
+            const existingId = request.resumeOf;
+            const existing = this.ctx.agents.get(existingId);
+            if (existing) {
+                const agent = existing;
+                this.interruptedChildren.delete(existingId);
+                const done = this.waitForExecutorSettlement(agent, existingId);
+                await this.ctx.subagents.sendMessage(parent, existingId, prompt, {
+                    signal: new AbortController().signal,
+                });
+                return {
+                    childId: existingId,
+                    result: done,
+                    cancel: async (reason) => this.interruptExecutor(existingId, reason),
+                    dispose: async () => this.drainExecutor(parent, existingId),
+                    runtimeSnapshot: () => this.snapshotAgent(agent),
+                };
+            }
+        }
+        const controller = new AbortController();
+        request.signal?.addEventListener('abort', () => controller.abort(), { once: true });
+        const started = await this.ctx.subagents.startContinuable({
+            provider: 'spawn',
+            label: request.label,
+            request: {
+                prompt,
+                parent,
+                agentOptions,
+                ...(request.toolFilter ? { toolFilter: request.toolFilter } : {}),
+            },
+            signal: controller.signal,
+        });
+        const childId = String(started.childId);
+        this.registerChild(childId, parent);
+        const agent = this.ctx.agents.get(started.childId);
+        const result = agent
+            ? this.waitForExecutorSettlement(agent, childId)
+            : Promise.resolve({ childId, output: '', interrupted: true, reason: 'EXECUTOR_CHILD_MISSING' });
+        return {
+            childId,
+            result,
+            cancel: async (reason) => this.interruptExecutor(childId, reason),
+            dispose: async () => this.drainExecutor(parent, childId),
+            runtimeSnapshot: agent ? () => this.snapshotAgent(agent) : undefined,
+        };
+    }
+    registerChild(childId, parent) {
+        this.ownedChildren.add(childId);
+        this.childParents.set(childId, parent);
+    }
+    forgetChild(childId) {
+        this.ownedChildren.delete(childId);
+        this.interruptedChildren.delete(childId);
+        this.childParents.delete(childId);
+    }
+    async interruptExecutor(childId, reason) {
+        this.interruptedChildren.add(childId);
+        const parent = this.childParents.get(childId);
+        this.ctx.subagents.interrupt(childId, parent ? { kind: 'ancestor', agent: parent } : { kind: 'user', parentSessionId: childId });
+        void reason;
+    }
+    async drainExecutor(parent, childId) {
+        try {
+            await this.ctx.subagents.drainContinuableChildren(parent, [childId]);
+        }
+        catch {
+            // already released
+        }
+        this.forgetChild(childId);
+    }
+    async waitForExecutorSettlement(agent, childId) {
+        await this.waitForTurnOrIdle(agent);
+        const events = agent.session?.snapshotEvents?.() ?? agent.session?.ownEvents?.() ?? [];
+        const classified = classifyTurnSettlement(events);
+        const output = this.readFinalOutput(agent);
+        const telemetry = await this.snapshotAgent(agent);
+        // Evidence is read from the settled turn's own events; a resumed executor
+        // therefore reports only the turn that just finished, never an earlier one.
+        const toolEvidence = collectTurnToolFacts(events);
+        const evidence = {
+            settlement: classified.settlement,
+            ...(toolEvidence.length > 0 ? { toolEvidence } : {}),
+        };
+        if (this.interruptedChildren.has(childId)) {
+            return { childId, output, interrupted: true, reason: 'EXECUTOR_INTERRUPTED', telemetry, ...evidence };
+        }
+        switch (classified.settlement) {
+            case 'completed':
+                return { childId, output, interrupted: false, telemetry, ...evidence };
+            case 'aborted':
+                return {
+                    childId,
+                    output,
+                    interrupted: true,
+                    reason: `EXECUTOR_ABORTED${classified.cancelCause ? `:${classified.cancelCause}` : ''}`,
+                    telemetry,
+                    ...evidence,
+                };
+            case 'error':
+                return {
+                    childId,
+                    output,
+                    interrupted: true,
+                    reason: `EXECUTOR_ERROR: ${redactText(classified.errorMessage ?? 'unknown failure')}`,
+                    telemetry,
+                    ...evidence,
+                };
+            case 'blocked':
+                return { childId, output, interrupted: true, reason: 'EXECUTOR_BLOCKED', telemetry, ...evidence };
+            case 'max-tokens':
+                return { childId, output, interrupted: true, reason: 'EXECUTOR_MAX_TOKENS', telemetry, ...evidence };
+            default:
+                return { childId, output, interrupted: true, reason: 'EXECUTOR_NO_TURN', telemetry, ...evidence };
+        }
+    }
+    async waitForTurnOrIdle(agent) {
+        const deadline = this.nowFn() + EXECUTOR_TURN_START_TIMEOUT_MS;
+        while (this.nowFn() < deadline && !this.hasTurnStarted(agent)) {
+            await this.sleepFn(20);
+        }
+        await agent.whenIdle?.();
+    }
+    hasTurnStarted(agent) {
+        const events = agent.session?.snapshotEvents?.() ?? [];
+        return events.some((event) => event.type === 'turn/start');
+    }
+    readFinalOutput(agent) {
+        const events = agent.session?.snapshotEvents?.() ?? agent.session?.ownEvents?.() ?? [];
+        for (let index = events.length - 1; index >= 0; index -= 1) {
+            const event = events[index];
+            if (!event || event.type !== 'assistant/message')
+                continue;
+            const data = event.data;
+            const text = contentToText(data?.message?.content ?? data?.content);
+            if (text.trim())
+                return text;
+        }
+        return '';
+    }
+    /** Bounded telemetry for the exact agent behind a handle. */
+    async snapshotAgent(agent) {
+        if (!agent)
+            return { status: 'unknown' };
+        const events = agent.session?.snapshotEvents?.() ?? [];
+        const openCalls = new Map();
+        let turnCount = 0;
+        let toolCount = 0;
+        let lastAssistant = '';
+        for (const event of events) {
+            if (event.type === 'turn/end')
+                turnCount += 1;
+            if (event.type === 'tool/call') {
+                toolCount += 1;
+                const data = event.data;
+                if (data?.callId)
+                    openCalls.set(data.callId, data.name ?? 'unknown');
+            }
+            if (event.type === 'tool/result') {
+                const data = event.data;
+                if (data?.callId)
+                    openCalls.delete(data.callId);
+            }
+            if (event.type === 'assistant/message') {
+                const data = event.data;
+                const text = contentToText(data?.message?.content ?? data?.content);
+                if (text.trim())
+                    lastAssistant = text;
+            }
+        }
+        const currentTool = [...openCalls.values()].pop();
+        return {
+            status: agent.status ?? 'unknown',
+            activity_state: agent.status ?? 'unknown',
+            turn_count: turnCount,
+            tool_count: toolCount,
+            ...(currentTool ? { current_tool: currentTool } : {}),
+            ...(lastAssistant ? { recent_output: truncateSafe(lastAssistant, 1500) } : {}),
+        };
+    }
+    async interruptRole(handle, reason) {
+        if (handle.cancel) {
+            await handle.cancel(reason);
+            return;
+        }
+        if (handle.childId)
+            await this.interruptExecutor(handle.childId, reason);
+    }
+    async releaseRole(handle) {
+        if (handle.dispose) {
+            await handle.dispose();
+            return;
+        }
+        if (handle.childId) {
+            const parent = this.childParents.get(handle.childId);
+            if (parent)
+                await this.drainExecutor(parent, handle.childId);
+        }
+    }
+    hasTool(name) {
+        // Standard profiles mount their tool composition on the agent plane
+        // (agent presets), so the visible set must resolve against the initiating
+        // agent's scope. Without an initiator this falls back to the global view.
+        const agent = this.ctx.agents.currentInitiator();
+        return this.ctx.tools.get(name, agent) !== undefined;
+    }
+    /**
+     * Mutation ownership is about top-level autonomous drivers, not about every
+     * running agent. The calling parent, Orbit's own children, and ordinary
+     * conversational/read-only agents are never competitors. Goal is the one
+     * DSH-native driver with a readable active state; ralph/workflow are blocked
+     * at tool start by the Orbit mutation guard.
+     */
+    async otherMutationDrivers(cwd) {
+        void cwd;
+        const drivers = [];
+        const initiator = this.ctx.agents.currentInitiator();
+        // `ctx.reflect.get` is the official service lookup that does not require an
+        // inject declaration, so Orbit stays loadable in profiles without dsh-goal.
+        const reflect = this.ctx.reflect;
+        const goals = reflect?.get('goals');
+        if (goals && initiator) {
+            try {
+                const goal = goals.get(initiator);
+                if (goal?.phase === 'active')
+                    drivers.push('goal');
+            }
+            catch {
+                // goal service is present but not readable for this initiator
+            }
+        }
+        return drivers;
+    }
+    changedFiles(cwd) {
+        try {
+            const output = execFileSync('git', ['-C', cwd, 'status', '--porcelain'], {
+                encoding: 'utf8',
+                timeout: 5000,
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            return output
+                .split('\n')
+                .map((line) => line.slice(3).trim())
+                .filter((line) => line.length > 0 && !line.startsWith('.cx/'));
+        }
+        catch {
+            return [];
+        }
+    }
+}
+function defaultSleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(resolve, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(new Error('ORBIT_ABORTED'));
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}

package/lib/evidence.js

@@ -0,0 +1,149 @@
+/**
+ * Bounded execution evidence assembled from real DSH session events.
+ *
+ * Everything in a bundle comes from data Orbit already has when a child
+ * settles: current-turn `tool/call` + `tool/result` events, the durable turn
+ * settlement, the executor's final text, real workspace changes, and agent
+ * telemetry. Nothing is inferred, nothing is re-run, and no extra model call
+ * is made. Bundles are sanitized and bounded before they reach a prompt, and
+ * they are never persisted into `.cx/state.json` as a whole.
+ */
+import { redactText, redactValue } from "./sanitize.js";
+export const EVIDENCE_LIMITS = {
+    changedFiles: 50,
+    toolEvidence: 20,
+    testEvidence: 10,
+    entry: 400,
+    executorSummary: 2000,
+    total: 8000,
+};
+const TEST_COMMAND_PATTERN = /(?:\b(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?test\b|\bnode\s+--test\b|\bvitest\b|\bjest\b|\bpytest\b|\bcargo\s+test\b|\bgo\s+test\b|\bmake\s+test\b)/u;
+/** True when a real command string is recognizably a test invocation. */
+export function isTestCommand(command) {
+    return TEST_COMMAND_PATTERN.test(command);
+}
+/** Strictly bound and redact one string without exceeding `max` characters. */
+function bounded(value, max) {
+    const redacted = redactText(value);
+    if (redacted.length <= max)
+        return redacted;
+    const marker = '...[truncated]';
+    return `${redacted.slice(0, Math.max(0, max - marker.length))}${marker}`;
+}
+function eventTurn(event) {
+    const turn = event.data?.turn;
+    return typeof turn === 'number' ? turn : undefined;
+}
+/** The most recent turn boundary in the log (closed or open), if any. */
+function currentTurnOf(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event?.type !== 'turn/end' && event?.type !== 'turn/start')
+            continue;
+        const turn = eventTurn(event);
+        if (turn !== undefined)
+            return turn;
+    }
+    return undefined;
+}
+function commandOf(argumentsJson) {
+    if (!argumentsJson)
+        return undefined;
+    try {
+        const parsed = JSON.parse(argumentsJson);
+        return typeof parsed.command === 'string' && parsed.command.length > 0 ? parsed.command : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Extract tool facts for the most recent turn only, so a resumed executor
+ * never mixes a previous turn's activity into the current settlement.
+ */
+export function collectTurnToolFacts(events) {
+    const turn = currentTurnOf(events);
+    if (turn === undefined)
+        return [];
+    const results = new Map();
+    for (const event of events) {
+        if (event.type !== 'tool/result' || eventTurn(event) !== turn)
+            continue;
+        const data = event.data;
+        const block = data?.message?.content?.[0];
+        if (!data || !block?.toolCallId)
+            continue;
+        const isError = data.error !== undefined || block.isError === true;
+        const identity = data.error ? [data.error.name, data.error.code].filter(Boolean).join(':') : '';
+        results.set(block.toolCallId, {
+            status: isError ? 'error' : 'ok',
+            ...(identity ? { detail: identity } : {}),
+        });
+    }
+    const facts = [];
+    for (const event of events) {
+        if (event.type !== 'tool/call' || eventTurn(event) !== turn)
+            continue;
+        const data = event.data;
+        if (!data?.name)
+            continue;
+        const result = data.callId ? results.get(data.callId) : undefined;
+        const command = commandOf(data.arguments);
+        const detail = result?.detail ?? command;
+        facts.push({
+            name: data.name,
+            status: result?.status ?? 'unknown',
+            ...(command ? { command } : {}),
+            ...(detail ? { detail } : {}),
+        });
+    }
+    return facts;
+}
+function boundTelemetry(telemetry) {
+    const redacted = redactValue(telemetry);
+    const out = {};
+    for (const [key, value] of Object.entries(redacted)) {
+        out[key] = typeof value === 'string' ? bounded(value, EVIDENCE_LIMITS.entry) : value;
+    }
+    return out;
+}
+/** Build one bounded, sanitized bundle from already-available execution facts. */
+export function buildEvidenceBundle(input) {
+    const changedFiles = [];
+    for (const path of input.changedFiles ?? []) {
+        const entry = bounded(path.trim(), EVIDENCE_LIMITS.entry);
+        if (entry && !changedFiles.includes(entry))
+            changedFiles.push(entry);
+        if (changedFiles.length >= EVIDENCE_LIMITS.changedFiles)
+            break;
+    }
+    const tools = [];
+    for (const tool of (input.tools ?? []).slice(0, EVIDENCE_LIMITS.toolEvidence)) {
+        tools.push({
+            name: bounded(tool.name, EVIDENCE_LIMITS.entry),
+            status: tool.status,
+            ...(tool.detail ? { detail: bounded(tool.detail, EVIDENCE_LIMITS.entry) } : {}),
+        });
+    }
+    const tests = [];
+    for (const tool of input.tools ?? []) {
+        if (tool.command === undefined || !isTestCommand(tool.command))
+            continue;
+        tests.push({ command: bounded(tool.command, EVIDENCE_LIMITS.entry), status: tool.status });
+        if (tests.length >= EVIDENCE_LIMITS.testEvidence)
+            break;
+    }
+    const summary = input.executorOutput ? bounded(input.executorOutput, EVIDENCE_LIMITS.executorSummary) : '';
+    return {
+        ...(input.settlement ? { settlement: input.settlement } : {}),
+        ...(summary ? { executor_summary: summary } : {}),
+        changed_files: changedFiles,
+        tools,
+        tests,
+        ...(input.telemetry ? { telemetry: boundTelemetry(input.telemetry) } : {}),
+    };
+}
+/** Render a bundle for a prompt, hard-capped at the total evidence budget. */
+export function formatEvidenceBundle(bundle) {
+    return bounded(JSON.stringify(bundle), EVIDENCE_LIMITS.total);
+}