@fitlab-ai/agent-infra 0.9.1 → 0.9.2

package/dist/lib/sandbox/recovery.js

@@ -1,6 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { containerNameCandidates, sandboxBranchLabel, sandboxLabel } from './constants.js';
+import { containerNameCandidates, sandboxBranchLabel, sandboxLabel, sandboxRuntimeCapabilityLabel } from './constants.js';
+import { isAgentClientId } from '../agent-clients/types.js';
+import { createSandboxCapabilityPlan } from './agent-client-reconciler.js';
 import { toEnginePath } from './engines/wsl2-paths.js';
 import { sandboxCoreBindMounts } from './mounts.js';
 import { runEngine, runOkEngine, runVerboseEngine } from './shell.js';
@@ -17,6 +19,19 @@ export function classifySandboxRecovery(snapshot) {
             message: 'Container identity does not match the requested sandbox branch.'
         });
     }
+    if (snapshot.runtimeCapabilityOk === false) {
+        findings.push({
+            repairKind: 'hard-failure',
+            message: 'Container runtime capability signature does not match the current sandbox plan.'
+        });
+    }
+    for (const mountPath of snapshot.unexpectedCapabilityMounts ?? []) {
+        findings.push({
+            repairKind: 'hard-failure',
+            message: `Disabled Agent Client capability remains mounted at ${mountPath}.`,
+            path: mountPath
+        });
+    }
     for (const mount of snapshot.mounts) {
         if (mount.actualType !== mount.expectedType
             || !mount.sourceMatches
@@ -74,25 +89,11 @@ export function classifySandboxRecovery(snapshot) {
             path: '/home/devuser/.bash_aliases'
         });
     }
-    if (snapshot.codex) {
-        if (!snapshot.codex.commandAvailable) {
-            findings.push({
-                repairKind: 'hard-failure',
-                message: 'Codex is not available on PATH inside the sandbox.'
-            });
-        }
-        if (!snapshot.codex.stateWritable) {
+    for (const check of snapshot.agentClientChecks) {
+        if (check.applicable && !check.healthy) {
             findings.push({
-                repairKind: 'permissions',
-                message: 'Codex state directory is not writable by devuser.',
-                path: '/home/devuser/.codex'
-            });
-        }
-        if (snapshot.codex.promptsSourceExists && !snapshot.codex.promptsValid) {
-            findings.push({
-                repairKind: 'builtin-link',
-                message: 'Codex prompts link does not point to the workspace commands directory.',
-                path: '/home/devuser/.codex/prompts'
+                ...check.finding,
+                ...(check.repair === undefined ? {} : { repair: check.repair })
             });
         }
     }
@@ -154,8 +155,7 @@ function hostSourceAccessible(hostPath, writable) {
     }
 }
 function expectedMounts(params) {
-    const { config, branch, actualMounts } = params;
-    const tools = resolveTools(config);
+    const { config, branch, tools, actualMounts } = params;
     const core = sandboxCoreBindMounts(config, branch).map((mount) => ({
         path: mount.containerPath,
         expectedType: 'bind',
@@ -174,7 +174,9 @@ function expectedMounts(params) {
             }];
     }));
     const persistentTools = tools
-        .filter((tool) => !tool.tmpfs && actualMounts.has(tool.containerMount))
+        .filter((tool) => !tool.tmpfs
+        && (config.agentClientSource === 'canonical'
+            || actualMounts.has(tool.containerMount)))
         .map((tool) => ({
         path: tool.containerMount,
         expectedType: 'bind',
@@ -245,7 +247,8 @@ export function collectSandboxRecoverySnapshot(params) {
             });
         }
     }
-    const tools = resolveTools(params.config);
+    const capabilityPlan = createSandboxCapabilityPlan(params.config);
+    const tools = [...capabilityPlan.tools];
     const seeds = declaredTmpfsSeedEntries(tools).map((seed) => {
         const mounted = mountsByDestination.get(seed.stagingPath)?.Type === 'bind';
         return {
@@ -266,11 +269,18 @@ export function collectSandboxRecoverySnapshot(params) {
     }));
     const labels = inspection.Config?.Labels ?? {};
     const branchLabel = labels[sandboxBranchLabel(params.config)];
-    const hasCodex = tools.some((tool) => tool.id === 'codex');
+    const selectedToolIds = new Set(tools.map((tool) => tool.id));
+    const enforceCanonicalPlan = params.config.agentClientSource === 'canonical';
+    const unexpectedCapabilityMounts = enforceCanonicalPlan
+        ? capabilityPlan.cleanupInventory
+            .filter((tool) => isAgentClientId(tool.id) && !selectedToolIds.has(tool.id))
+            .map((tool) => tool.containerMount)
+            .filter((mountPath) => mountsByDestination.has(mountPath))
+        : [];
     const mountSnapshots = expectedMounts({
         config: params.config,
         branch: params.branch,
-        engine: params.engine,
+        tools,
         actualMounts: mountsByDestination
     }).map((expected) => {
         const actual = mountsByDestination.get(expected.path);
@@ -304,18 +314,25 @@ export function collectSandboxRecoverySnapshot(params) {
         identityOk: typeof inspection.Id === 'string'
             && inspection.Id.length > 0
             && branchLabel === params.branch,
+        runtimeCapabilityOk: enforceCanonicalPlan
+            ? labels[sandboxRuntimeCapabilityLabel(params.config)] === capabilityPlan.runtimeSignature
+            : undefined,
+        unexpectedCapabilityMounts,
         mounts: mountSnapshots,
         tmpfs,
         seeds,
         aliasesReadable: probe(params.engine, params.container, 'test -r "$1"', ['/home/devuser/.bash_aliases'], runOkFn),
-        codex: hasCodex
-            ? {
-                commandAvailable: probe(params.engine, params.container, 'command -v codex', [], runOkFn),
-                stateWritable: probe(params.engine, params.container, 'probe="$1/.agent-infra-codex-state-$$"; trap \'rm -f -- "$probe"\' EXIT; : > "$probe"', ['/home/devuser/.codex'], runOkFn),
-                promptsSourceExists: probe(params.engine, params.container, 'test -d "$1"', ['/workspace/.codex/commands'], runOkFn),
-                promptsValid: probe(params.engine, params.container, 'test "$(readlink -- "$1")" = "$2"', ['/home/devuser/.codex/prompts', '/workspace/.codex/commands'], runOkFn)
-            }
-            : undefined
+        agentClientChecks: capabilityPlan.recoveryChecks.map(({ adapterId, check }) => {
+            const applicable = check.when === undefined || probe(params.engine, params.container, check.when.script, [...check.when.args], runOkFn, check.when.user);
+            return {
+                adapterId,
+                checkId: check.id,
+                applicable,
+                healthy: !applicable || probe(params.engine, params.container, check.probe.script, [...check.probe.args], runOkFn, check.probe.user),
+                finding: check.finding,
+                ...(check.repair === undefined ? {} : { repair: check.repair })
+            };
+        })
     };
 }
 export function prepareTmpfsMounts(params) {
@@ -394,10 +411,9 @@ function repairFindings(params) {
         deps: params.deps
     });
     const runVerboseFn = params.deps?.runVerbose ?? runVerboseEngine;
-    if (params.findings.some((finding) => finding.repairKind === 'builtin-link')) {
+    for (const repair of params.findings.flatMap((finding) => finding.repair === undefined ? [] : [finding.repair])) {
         runVerboseFn(params.engine, 'docker', [
-            'exec', '--user', 'devuser', params.container, 'ln', '-sfn',
-            '/workspace/.codex/commands', '/home/devuser/.codex/prompts'
+            'exec', '--user', repair.user, params.container, repair.command, ...repair.args
         ]);
     }
 }

package/dist/lib/sandbox/shell.js

@@ -114,7 +114,7 @@ export function runSafe(cmd, args, opts = {}) {
 export function commandForEngine(engine, cmd, args = []) {
     if (engine === 'wsl2') {
         const resolvedWrapper = resolveCommand('wsl.exe');
-        return { cmd: resolvedWrapper, args: ['--', cmd, ...args] };
+        return { cmd: resolvedWrapper, args: ['--exec', cmd, ...args] };
     }
     if (cmd === 'docker') {
         const context = getAdapter(engine).dockerContext;

package/dist/lib/sandbox/tool-types.js

@@ -0,0 +1,8 @@
+const SANDBOX_HOOK_PHASES = [
+    'prepare',
+    'before-container-create',
+    'after-container-start',
+    'before-enter'
+];
+export { SANDBOX_HOOK_PHASES };
+//# sourceMappingURL=tool-types.js.map

package/dist/lib/sandbox/tools.js

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { createSandboxCapabilityPlan } from './agent-client-reconciler.js';
 import { safeNameCandidates, sanitizeBranchName } from './constants.js';
 import { hostJoin } from './engines/wsl2-paths.js';
 export function tmpfsSeedStagingPath(toolId, index) {
@@ -20,108 +21,6 @@ export function declaredTmpfsSeedEntries(tools) {
     })));
 }
 const TOOL_ID_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
-function createBuiltinTools(home, project) {
-    return {
-        'claude-code': {
-            id: 'claude-code',
-            name: 'Claude Code',
-            install: { type: 'npm', cmd: '@anthropic-ai/claude-code@latest' },
-            sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'claude-code'),
-            containerMount: '/home/devuser/.claude',
-            versionCmd: 'claude --version',
-            setupHint: 'Authenticates via host credentials live-mounted at ~/.claude/.credentials.json',
-            // Claude Code stores user data (.claude.json — onboarding state, theme,
-            // workspace trust) at $HOME/.claude.json by default, which sits OUTSIDE
-            // the bind-mounted /home/devuser/.claude tree, so our preseeded
-            // .claude.json never gets read and the theme picker re-runs on every
-            // container start. Pinning CLAUDE_CONFIG_DIR to the tool mount relocates
-            // .claude.json into the same directory as .credentials.json/settings.json,
-            // letting ensureClaudeOnboarding actually take effect.
-            envVars: { CLAUDE_CONFIG_DIR: '/home/devuser/.claude' },
-            hostPreSeedDirs: [
-                { hostDir: hostJoin(home, '.claude', 'plugins'), sandboxSubdir: 'plugins' }
-            ],
-            pathRewriteFiles: [
-                'plugins/installed_plugins.json',
-                'plugins/known_marketplaces.json'
-            ],
-            hostLiveMounts: [
-                {
-                    hostPath: hostJoin(home, '.agent-infra', 'credentials', project, 'claude-code', '.credentials.json'),
-                    containerSubpath: '.credentials.json'
-                }
-            ]
-        },
-        codex: {
-            id: 'codex',
-            name: 'Codex',
-            install: { type: 'npm', cmd: '@openai/codex' },
-            sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'codex'),
-            containerMount: '/home/devuser/.codex',
-            versionCmd: 'codex --version',
-            setupHint: 'Run codex once inside the container and choose Device Code login if needed.',
-            // codex churns ~/.codex/logs_2.sqlite heavily (upstream openai/codex#24275);
-            // a bind-mount would write-amplify onto the host SSD via virtiofs. Mount the
-            // codex home as tmpfs so those logs stay in RAM and die with the container.
-            // Seeded config (config.toml, model-catalogs) is copied into the tmpfs at
-            // startup; runtime files like logs_2.sqlite stay in RAM.
-            tmpfs: { size: '512m', seed: ['config.toml', 'model-catalogs'] },
-            hostLiveMounts: [
-                { hostPath: hostJoin(home, '.codex', 'auth.json'), containerSubpath: 'auth.json' }
-            ],
-            postSetupCmds: [
-                'test -d /workspace/.codex/commands && ln -sfn /workspace/.codex/commands /home/devuser/.codex/prompts || true'
-            ]
-        },
-        opencode: {
-            id: 'opencode',
-            name: 'OpenCode',
-            install: { type: 'npm', cmd: 'opencode-ai' },
-            sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'opencode'),
-            containerMount: '/home/devuser/.local/share/opencode',
-            versionCmd: 'opencode version',
-            setupHint: 'Configure OpenCode credentials inside the container before first use.',
-            // OpenCode reads opencode.json from $XDG_CONFIG_HOME/opencode by default,
-            // outside this tool mount. Pin the config file path so the inherited
-            // sandbox opencode.json is the one the TUI actually reads.
-            envVars: { OPENCODE_CONFIG: '/home/devuser/.local/share/opencode/opencode.json' },
-            hostLiveMounts: [
-                {
-                    hostPath: hostJoin(home, '.local', 'share', 'opencode', 'auth.json'),
-                    containerSubpath: 'auth.json'
-                }
-            ]
-        },
-        'gemini-cli': {
-            id: 'gemini-cli',
-            name: 'Gemini CLI',
-            install: { type: 'npm', cmd: '@google/gemini-cli' },
-            sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'gemini-cli'),
-            containerMount: '/home/devuser/.gemini',
-            versionCmd: 'gemini --version',
-            setupHint: 'Run gemini inside the container to finish authentication.',
-            hostLiveMounts: [
-                { hostPath: hostJoin(home, '.gemini', 'oauth_creds.json'), containerSubpath: 'oauth_creds.json' }
-            ],
-            hostPreSeedFiles: [
-                { hostPath: hostJoin(home, '.gemini', 'settings.json'), sandboxName: 'settings.json' },
-                { hostPath: hostJoin(home, '.gemini', 'google_accounts.json'), sandboxName: 'google_accounts.json' }
-            ]
-        },
-        'agent-infra': {
-            id: 'agent-infra',
-            name: 'agent-infra CLI',
-            install: { type: 'npm', cmd: '@fitlab-ai/agent-infra@latest' },
-            sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'agent-infra'),
-            containerMount: '/home/devuser/.agent-infra-cli',
-            versionCmd: 'ai version --raw',
-            setupHint: 'Provides the ai and agent-infra CLI commands inside the sandbox.'
-        }
-    };
-}
-export function builtinToolIds() {
-    return Object.keys(createBuiltinTools('', ''));
-}
 function validateTool(tool) {
     if (!tool.id || !TOOL_ID_PATTERN.test(tool.id)) {
         throw new Error(`Invalid sandbox tool id: ${String(tool.id)}`);
@@ -308,30 +207,7 @@ export function parseCustomTools(value, options) {
     return value.map((entry, index) => parseCustomTool(entry, index, options));
 }
 export function resolveTools(config) {
-    const builtins = createBuiltinTools(config.home, config.project);
-    const customs = config.customTools ?? [];
-    const seen = new Set();
-    for (const tool of customs) {
-        if (builtins[tool.id]) {
-            throw new Error(`Custom sandbox tool id "${tool.id}" collides with a built-in tool`);
-        }
-        if (seen.has(tool.id)) {
-            throw new Error(`Duplicate sandbox tool id "${tool.id}" in customTools`);
-        }
-        seen.add(tool.id);
-    }
-    const merged = { ...builtins };
-    for (const tool of customs) {
-        merged[tool.id] = tool;
-    }
-    return config.tools.map((id) => {
-        const tool = merged[id];
-        if (!tool) {
-            throw new Error(`Unknown sandbox tool: ${id}`);
-        }
-        validateTool(tool);
-        return tool;
-    });
+    return [...createSandboxCapabilityPlan(config).tools];
 }
 export function toolConfigDir(tool, project, branch) {
     return hostJoin(tool.sandboxBase, project, sanitizeBranchName(branch));

package/dist/lib/task/artifact-lifecycle.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { resolveTaskRef } from './resolve-ref.js';
 import { locateActivityLog } from './activity-log.js';
 import { parseImplementationInputs, selectPendingImplementationInput } from './implementation-inputs.js';
+import { parseVerdict } from './review-artifacts.js';
 import { extractSection, findSectionHeading } from './sections.js';
 const artifactFamilyCatalog = [
     { family: 'analysis', sectionAliases: ['分析', 'Analysis'], heading: '分析', labels: ['需求分析报告', 'Requirements Analysis'] },
@@ -173,24 +174,6 @@ function resolveReviewedInput(taskDir, review, expectedFamily, diagnostics) {
         return null;
     }
 }
-function extractMarkdownSection(content, names) {
-    const lines = content.split(/\r?\n/);
-    const allowed = new Set(names);
-    const start = lines.findIndex((line) => {
-        const match = /^##\s+(.+?)\s*$/.exec(line.trim());
-        return Boolean(match?.[1] && allowed.has(match[1]));
-    });
-    if (start === -1)
-        return '';
-    let end = lines.length;
-    for (let index = start + 1; index < lines.length; index += 1) {
-        if (/^##\s+/.test(lines[index])) {
-            end = index;
-            break;
-        }
-    }
-    return lines.slice(start + 1, end).join('\n');
-}
 function assertWritableInventory(inventory) {
     if (inventory.status === 'failed')
         return inventory.error;
@@ -333,37 +316,6 @@ function resolveDecisionImplementationInput(inventory, review) {
         return { error: error instanceof Error ? error.message : String(error) };
     }
 }
-function normalizeVerdict(value) {
-    const normalized = value.trim().toLowerCase();
-    if (normalized === '通过' || normalized === 'approved')
-        return 'Approved';
-    if (normalized === '需要修改' || normalized === 'changes requested')
-        return 'Changes Requested';
-    if (normalized === '拒绝' || normalized === 'rejected')
-        return 'Rejected';
-    return null;
-}
-function parseVerdict(file) {
-    let content;
-    try {
-        content = fs.readFileSync(file, 'utf8');
-    }
-    catch (error) {
-        return { ok: false, message: String(error) };
-    }
-    const summary = extractMarkdownSection(content, ['审查摘要', 'Review Summary']);
-    const verdictMatch = /^[-*]?\s*\*\*(?:总体结论|Overall Verdict)\*\*[:：]\s*(.+?)\s*$/im.exec(summary);
-    const verdict = verdictMatch?.[1] ? normalizeVerdict(verdictMatch[1]) : null;
-    if (!verdict)
-        return { ok: false, message: `cannot parse verdict in ${path.basename(file)}` };
-    if (verdict !== 'Approved')
-        return { ok: true, verdict };
-    const findings = /^[-*]?\s*\*\*(?:发现（AI 可处理）|Findings \(AI-actionable\))\*\*[:：]\s*(.+?)\s*$/im.exec(summary)?.[1];
-    const counts = findings?.match(/(\d+)\s*(?:阻塞项|blockers?).*?(\d+)\s*(?:主要|majors?).*?(\d+)\s*(?:次要|minors?)/i);
-    if (!counts)
-        return { ok: false, message: `cannot parse findings count in ${path.basename(file)}` };
-    return { ok: true, verdict: counts.slice(1).some((value) => Number(value) > 0) ? 'Approved-with-issues' : 'Approved' };
-}
 function validateCompletedArtifact(taskDir, family, name, round) {
     if (path.basename(name) !== name)
         return { ok: false, error: { code: 'ARTIFACT_PATH_INVALID', message: 'artifact must be a top-level basename' } };

package/dist/lib/task/commands/decisions.js

@@ -9,8 +9,9 @@ import { extractSubSection } from '../sections.js';
 const USAGE = `Usage: ai task decisions [--task <ref> | -t <ref>] [--item <selector> | -i <selector>] [options]
        ai task decisions <ref> [selector] [options]
 
-Lists decision items recorded in a task's review disagreement
-ledger, or prints the full detail block for a single item. Read-only.
+Shows what still needs a maintainer's decision. Without a selector, it lists
+the choices. With a selector, it shows the explanation and how to respond.
+Read-only.
 
   Omit <ref>     Resolve the unique active task for the current branch.
   <ref>          Legacy positional task ref.
@@ -161,28 +162,29 @@ function findDecisionRecord(id, content) {
 function titleOf(row, taskDir) {
     const block = findDetailBlock(row, taskDir);
     if (block) {
-        return block
+        const title = block
             .split('\n')[0]
             .replace(/^###\s+/, '')
             .replace(/\s*\[needs-human-decision\]\s*$/, '')
             .trim();
+        return title.replace(new RegExp(`^${row.id}\\s*[:：]\\s*`, 'i'), '').trim();
     }
-    return row.evidence || '(无详情)';
+    return '(explanation unavailable)';
+}
+function trackingOf(row) {
+    return `stage=${row.stage} · severity=${row.severity} · status=${row.status} · evidence=${row.evidence}`;
 }
 function renderList(rows, format, taskDir) {
     if (rows.length === 0) {
-        process.stdout.write('无待裁决项。\n');
+        process.stdout.write('No pending decisions.\n');
         return;
     }
-    const headers = ['#', 'ID', 'STAGE', 'SEVERITY', 'STATUS', 'EVIDENCE', 'TITLE'];
+    const headers = ['#', 'CHOICE', 'WHAT NEEDS A DECISION', 'TRACKING'];
     const data = rows.map((r, i) => [
         String(i + 1),
         r.id,
-        r.stage,
-        r.severity,
-        r.status,
-        r.evidence,
-        titleOf(r, taskDir)
+        titleOf(r, taskDir),
+        trackingOf(r)
     ]);
     if (format === 'markdown') {
         const sep = headers.map(() => '---');
@@ -191,10 +193,28 @@ function renderList(rows, format, taskDir) {
             `| ${sep.join(' | ')} |`,
             ...data.map((row) => `| ${row.join(' | ')} |`)
         ];
-        process.stdout.write(`${md.join('\n')}\n`);
+        process.stdout.write(`${md.join('\n')}\n\nView one item: ai task decisions <task-ref> <ordinal|ledger-id>\n`);
         return;
     }
-    process.stdout.write(`${formatTable(headers, data).join('\n')}\n`);
+    process.stdout.write(`${formatTable(headers, data).join('\n')}\n\nView one item: ai task decisions <task-ref> <ordinal|ledger-id>\n`);
+}
+function renderTracking(row, format) {
+    if (format === 'markdown') {
+        return [
+            '**Tracking**',
+            `- stage: \`${row.stage}\``,
+            `- severity: \`${row.severity}\``,
+            `- status: \`${row.status}\``,
+            `- evidence: \`${row.evidence}\``
+        ];
+    }
+    return [
+        'Tracking:',
+        `stage: ${row.stage}`,
+        `severity: ${row.severity}`,
+        `status: ${row.status}`,
+        `evidence: ${row.evidence}`
+    ];
 }
 function renderDetail(rows, selector, format, taskDir, content) {
     const selected = selectDecisionItem(rows, selector);
@@ -204,25 +224,35 @@ function renderDetail(rows, selector, format, taskDir, content) {
     }
     const r = selected.row;
     const block = findDetailBlock(r, taskDir);
+    const title = titleOf(r, taskDir);
     const lines = [];
+    const decided = r.status === 'human-decided';
     if (format === 'markdown') {
-        lines.push(`**${r.id}** (${r.stage}/${r.severity}) · status=\`${r.status}\` · evidence: \`${r.evidence}\``, '');
+        lines.push(`## ${decided ? 'Decision already recorded' : 'Decision needed'}: ${title}`, '');
+        if (!decided) {
+            lines.push('**How to record your choice**', `\`ai decide <task-ref> ${r.id} <your choice and rationale>\``, '');
+        }
+        lines.push('**Original context**', '');
     }
     else {
-        lines.push(`${r.id} (${r.stage}/${r.severity}) status=${r.status}`, `evidence: ${r.evidence}`, '');
+        lines.push(`${decided ? 'Decision already recorded' : 'Decision needed'}: ${title}`, '');
+        if (!decided) {
+            lines.push('How to record your choice:', `ai decide <task-ref> ${r.id} <your choice and rationale>`, '');
+        }
+        lines.push('Original context:');
     }
     if (block) {
         lines.push(block);
     }
     else {
-        lines.push(`（详情块未找到：未在任务产物中定位到 \`### ${r.id}\` 锚点，可能为历史产物或尚未写入；evidence 指向 ${r.evidence}）`);
+        lines.push(`This older task does not include a full explanation for ${r.id}.`, 'Use the tracking reference below to find the original context.');
     }
-    if (r.status === 'human-decided') {
+    if (decided) {
         const record = findDecisionRecord(r.id, content);
-        if (record.length) {
-            lines.push('', '人工裁定：', ...record);
-        }
+        lines.push('', format === 'markdown' ? '**Recorded choice**' : 'Recorded choice:');
+        lines.push(...(record.length ? record : ['No separate ruling record was found.']));
     }
+    lines.push('', ...renderTracking(r, format));
     process.stdout.write(`${lines.join('\n')}\n`);
 }
 function decisions(args = []) {

package/dist/lib/task/delegation-receipts.js

@@ -0,0 +1,107 @@
+import { randomUUID } from 'node:crypto';
+const MANAGED_AGENTS = {
+    'agent-infra-lifecycle-executor': 'executor',
+    'agent-infra-lifecycle-reviewer': 'reviewer'
+};
+function managedDelegationRole(nativeAgent) {
+    return MANAGED_AGENTS[nativeAgent] ?? null;
+}
+function fail(code, message) {
+    return { ok: false, code, message };
+}
+function prepareDelegation(input, options = {}) {
+    return Object.freeze({
+        ...input,
+        id: (options.id ?? randomUUID)(),
+        actualModel: null,
+        modelFallbackReason: null,
+        parentId: null,
+        childId: null,
+        spawnMode: null,
+        agent: null,
+        status: 'prepared',
+        afterFingerprint: null,
+        changedPaths: Object.freeze([]),
+        createdAt: (options.now ?? (() => new Date().toISOString()))(),
+        activatedAt: null,
+        sealedAt: null,
+        consumedAt: null
+    });
+}
+function activateDelegation(receipt, event, options = {}) {
+    const managedRole = managedDelegationRole(event.nativeAgent);
+    if (!managedRole)
+        return fail('DELEGATION_IGNORED', `subagent '${event.nativeAgent}' is not lifecycle-managed`);
+    if (receipt.status !== 'prepared')
+        return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected prepared`);
+    if (managedRole !== receipt.role)
+        return fail('DELEGATION_ROLE_MISMATCH', `managed role ${managedRole} does not match ${receipt.role}`);
+    if (!event.parentId || (receipt.parentId !== null && event.parentId !== receipt.parentId) || !event.childId || event.childId === event.parentId) {
+        return fail('DELEGATION_IDENTITY_INVALID', 'native parent/child identity does not match the prepared delegation');
+    }
+    if (event.spawnMode !== 'fresh')
+        return fail('DELEGATION_FORK_FORBIDDEN', `spawn mode '${event.spawnMode}' is not fresh`);
+    const actualModel = event.actualModel ?? null;
+    if (actualModel && receipt.requestedModel && actualModel !== receipt.requestedModel && !event.modelFallbackReason) {
+        return fail('DELEGATION_MODEL_FALLBACK_UNRECORDED', 'actual model differs from requested model without a fallback reason');
+    }
+    return { ok: true, receipt: Object.freeze({
+            ...receipt,
+            status: 'activated',
+            parentId: event.parentId,
+            childId: event.childId,
+            spawnMode: event.spawnMode,
+            actualModel,
+            modelFallbackReason: event.modelFallbackReason ?? null,
+            activatedAt: (options.now ?? (() => new Date().toISOString()))()
+        }) };
+}
+function completeDelegationStage(receipt, event) {
+    if (receipt.status !== 'activated')
+        return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected activated`);
+    if (event.stage !== receipt.stage || event.round !== receipt.round || event.artifact !== receipt.artifact) {
+        return fail('DELEGATION_STAGE_MISMATCH', 'stage completion identity does not match the active delegation');
+    }
+    const acceptedAgents = receipt.client === 'claude-code' ? ['claude', 'claude-code'] : [receipt.client];
+    if (!acceptedAgents.includes(event.agent)) {
+        return fail('DELEGATION_AGENT_MISMATCH', `stage agent '${event.agent}' does not match client '${receipt.client}'`);
+    }
+    return { ok: true, receipt: Object.freeze({ ...receipt, status: 'stage-completed', agent: event.agent }) };
+}
+function sealDelegation(receipt, event, options = {}) {
+    if (receipt.status !== 'stage-completed')
+        return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected stage-completed`);
+    if (event.childId !== receipt.childId || event.exitCode !== 0)
+        return fail('DELEGATION_STOP_INVALID', 'native stop identity or exit status is invalid');
+    if (receipt.role === 'reviewer') {
+        const taskRoot = `.agents/workspace/active/${receipt.taskId}/`;
+        const allowed = new Set([
+            `${taskRoot}${receipt.artifact}`,
+            `${taskRoot}task.md`,
+            `${taskRoot}orchestration.json`
+        ]);
+        const disallowed = event.changedPaths.find((entry) => !allowed.has(entry));
+        if (disallowed)
+            return fail('DELEGATION_REVIEWER_WRITE_FORBIDDEN', `reviewer changed forbidden path '${disallowed}'`);
+    }
+    return { ok: true, receipt: Object.freeze({
+            ...receipt,
+            status: 'sealed',
+            afterFingerprint: event.afterFingerprint,
+            changedPaths: Object.freeze([...event.changedPaths]),
+            sealedAt: (options.now ?? (() => new Date().toISOString()))()
+        }) };
+}
+function consumeDelegation(receipt, options = {}) {
+    if (receipt.status === 'consumed')
+        return fail('DELEGATION_REPLAY', `delegation ${receipt.id} was already consumed`);
+    if (receipt.status !== 'sealed')
+        return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected sealed`);
+    return { ok: true, receipt: Object.freeze({
+            ...receipt,
+            status: 'consumed',
+            consumedAt: (options.now ?? (() => new Date().toISOString()))()
+        }) };
+}
+export { activateDelegation, completeDelegationStage, consumeDelegation, managedDelegationRole, prepareDelegation, sealDelegation };
+//# sourceMappingURL=delegation-receipts.js.map