@fitlab-ai/agent-infra 0.11.6 → 0.11.7

package/dist/lib/git/primary-worktree.js

@@ -0,0 +1,58 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import { sameFilesystemEntry } from './worktree-identity.js';
+function gitText(repositoryRoot, args) {
+    return execFileSync('git', ['-C', repositoryRoot, ...args], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe']
+    }).replace(/\r?\n$/, '');
+}
+function isPrimaryWorktree(candidate, expectedCommonDirectory) {
+    try {
+        const root = fs.realpathSync.native(candidate);
+        if (!fs.statSync(root).isDirectory())
+            return false;
+        if (gitText(root, ['rev-parse', '--show-prefix']) !== '')
+            return false;
+        const commonDirectory = gitText(root, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+        const gitDirectory = gitText(root, ['rev-parse', '--absolute-git-dir']);
+        return sameFilesystemEntry(commonDirectory, expectedCommonDirectory) &&
+            sameFilesystemEntry(gitDirectory, expectedCommonDirectory);
+    }
+    catch {
+        return false;
+    }
+}
+function worktreePaths(repositoryRoot) {
+    const output = execFileSync('git', ['-C', repositoryRoot, 'worktree', 'list', '--porcelain', '-z'], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe']
+    });
+    return output
+        .split('\0\0')
+        .flatMap((record) => record.split('\0'))
+        .filter((field) => field.startsWith('worktree '))
+        .map((field) => field.slice('worktree '.length));
+}
+export function resolvePrimaryWorktreeRoot(repositoryRoot) {
+    try {
+        const root = fs.realpathSync.native(repositoryRoot);
+        if (!fs.statSync(root).isDirectory() || gitText(root, ['rev-parse', '--show-prefix']) !== '') {
+            throw new Error('repository root is not a worktree root');
+        }
+        const commonDirectory = gitText(root, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+        const gitDirectory = gitText(root, ['rev-parse', '--absolute-git-dir']);
+        if (sameFilesystemEntry(gitDirectory, commonDirectory))
+            return root;
+        const matches = worktreePaths(root).filter((candidate) => isPrimaryWorktree(candidate, commonDirectory));
+        if (matches.length !== 1) {
+            throw new Error(matches.length === 0 ? 'primary worktree metadata was not found' : 'primary worktree metadata is ambiguous');
+        }
+        return fs.realpathSync.native(matches[0]);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`server: unable to locate primary worktree: ${detail}`);
+    }
+}
+//# sourceMappingURL=primary-worktree.js.map

package/dist/lib/platform/pull-requests.js

@@ -974,9 +974,35 @@ async function createExternalPullRequest(taskRef, options, base) {
     }
     if (base.prIdentity) {
         const inspected = await inspectExternalPullRequest(base, base.prIdentity);
-        return inspected.status === 'failed' || inspected.status === 'blocked'
-            ? withCreation(inspected, PRECONDITION_NOT_CREATED)
-            : withCreation({ ...inspected, result: 'no_op' }, { kind: 'no-op', createdByCurrentOperation: false });
+        if (inspected.status === 'failed' || inspected.status === 'blocked') {
+            return withCreation(inspected, PRECONDITION_NOT_CREATED);
+        }
+        const deliveredHeadSha = typeof base.frontmatter.delivery_remote_head === 'string'
+            ? base.frontmatter.delivery_remote_head
+            : undefined;
+        const expectedHeadSha = verifiedHeadSha ?? deliveredHeadSha;
+        if (!expectedHeadSha)
+            return withCreation(result('failed', base.resolved.taskId, base.issueNumber, base.prNumber, {
+                platform: base.context.platform,
+                capabilities: base.context.capabilities,
+                resource: { kind: 'pull-request', number: base.prNumber, identity: base.prIdentity },
+                pullRequest: inspected.pullRequest,
+                error: { code: 'PR_HEAD_UNVERIFIED', message: 'Unable to verify the bound pull request head SHA', retryable: false }
+            }), PRECONDITION_NOT_CREATED);
+        const identity = validateWriterIdentity(base, inspected.pullRequest ?? null, {
+            expectedHead: options.head,
+            expectedHeadSha,
+            errorCode: 'PR_BIND_IDENTITY_MISMATCH'
+        });
+        if (!identity.ok)
+            return withCreation(result('failed', base.resolved.taskId, base.issueNumber, base.prNumber, {
+                platform: base.context.platform,
+                capabilities: base.context.capabilities,
+                resource: { kind: 'pull-request', number: base.prNumber, identity: base.prIdentity },
+                pullRequest: inspected.pullRequest,
+                error: identity.error
+            }), PRECONDITION_NOT_CREATED);
+        return withCreation({ ...inspected, result: 'no_op' }, { kind: 'no-op', createdByCurrentOperation: false });
     }
     if (options.dryRun)
         return withCreation(result('planned', base.resolved.taskId, base.issueNumber, null, {

package/dist/lib/sandbox/control/server.js

@@ -171,13 +171,17 @@ function taskCreateDomainEvidence(manifest, output) {
         ? output.task : null;
     const taskId = typeof task?.id === 'string' ? task.id : null;
     const shortId = typeof task?.shortId === 'string' ? task.shortId : null;
-    if (!taskId || !shortId)
+    const state = task?.state;
+    if (!taskId || !['active', 'blocked', 'completed', 'archive'].includes(String(state)))
+        return { consistent: false };
+    if (state === 'active' ? !shortId : output.status !== 'no-op' || shortId !== null)
         return { consistent: false };
     try {
         const resolved = resolveTaskRef(taskId, { repoRoot: manifest.repoRoot });
         const shortIds = loadShortIdByTaskId(manifest.repoRoot);
         return {
-            consistent: resolved.ok && resolved.taskId === taskId && resolved.state === 'active' && shortIds.get(taskId) === shortId,
+            consistent: resolved.ok && resolved.taskId === taskId && resolved.state === state
+                && (state === 'active' ? shortIds.get(taskId) === shortId : !shortIds.has(taskId)),
             taskId,
             shortId
         };

package/dist/lib/server/config.js

@@ -1,8 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { homedir } from 'node:os';
-import { createHash } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
+import { resolvePrimaryWorktreeRoot } from '../git/primary-worktree.js';
 const ENV_PREFIX = 'AGENT_INFRA_SERVER_';
 // Keys whose presence in the *committed* server.json is treated as a leaked
 // secret. Secrets belong in .agents/server.local.json or the environment.
@@ -16,17 +16,7 @@ export const DEFAULT_SERVER_CONFIG = {
 function isPlainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-// Daemon runtime state (log + PID) lives OUTSIDE the repo, under the user's home
-// directory, keyed by the .airc.json "project" AND a stable hash of the repo
-// root path:
-//   ~/.agent-infra/logs/<project>/<repo-hash>/server.log
-//   ~/.agent-infra/run/<project>/<repo-hash>/server.pid
-// The <project> segment groups a project's checkouts for readability; the
-// <repo-hash> segment guarantees that two checkouts/worktrees of the same
-// project (same "project" but different absolute path) get ISOLATED runtime
-// dirs, so they never read/control each other's daemon. Using os.homedir() +
-// path.join keeps this correct on Windows too (C:\Users\<name>\.agent-infra\...).
-// An explicit log.path in server.json/.local/env still overrides the log default.
+// Runtime state is shared by all worktrees through the primary checkout.
 function resolveProjectKey(repoRoot) {
     try {
         const airc = JSON.parse(fs.readFileSync(path.join(repoRoot, '.agents', '.airc.json'), 'utf8'));
@@ -39,12 +29,8 @@ function resolveProjectKey(repoRoot) {
     }
     return path.basename(repoRoot);
 }
-// Short, stable, filesystem-safe discriminator for a checkout's absolute path.
-function repoKey(repoRoot) {
-    return createHash('sha256').update(repoRoot).digest('hex').slice(0, 12);
-}
-function runtimePath(repoRoot, projectKey, kind, file) {
-    return path.join(homedir(), '.agent-infra', kind, projectKey, repoKey(repoRoot), file);
+function runtimePath(projectKey, kind, file) {
+    return path.join(homedir(), '.agent-infra', kind, projectKey, file);
 }
 function detectRepoRoot() {
     try {
@@ -147,7 +133,7 @@ export function validateServerConfig(committed) {
     return { ok: true };
 }
 export function loadServerConfig({ rootDir } = {}) {
-    const repoRoot = rootDir ?? detectRepoRoot();
+    const repoRoot = resolvePrimaryWorktreeRoot(rootDir ?? detectRepoRoot());
     const agentsDir = path.join(repoRoot, '.agents');
     const committed = readJsonIfPresent(path.join(agentsDir, 'server.json'));
     const validation = validateServerConfig(committed);
@@ -160,17 +146,11 @@ export function loadServerConfig({ rootDir } = {}) {
     merged = deepMerge(merged, envOverrides(process.env));
     const projectKey = resolveProjectKey(repoRoot);
     const log = isPlainObject(merged.log) ? merged.log : {};
-    // No explicit log.path → default under ~/.agent-infra/logs/<project>/.
-    // Explicit relative path resolves against the repo root; absolute is used as-is.
-    const explicitPath = typeof log.path === 'string' ? log.path : null;
-    const resolvedLogPath = explicitPath === null
-        ? runtimePath(repoRoot, projectKey, 'logs', 'server.log')
-        : (path.isAbsolute(explicitPath) ? explicitPath : path.join(repoRoot, explicitPath));
     return {
         repoRoot,
-        pidFile: runtimePath(repoRoot, projectKey, 'run', 'server.pid'),
+        pidFile: runtimePath(projectKey, 'run', 'server.pid'),
         log: {
-            path: resolvedLogPath,
+            path: runtimePath(projectKey, 'logs', 'server.log'),
             rotateAtBytes: typeof log.rotateAtBytes === 'number' ? log.rotateAtBytes : DEFAULT_ROTATE_BYTES
         },
         heartbeatMs: typeof merged.heartbeatMs === 'number' ? merged.heartbeatMs : DEFAULT_SERVER_CONFIG.heartbeatMs,

package/dist/lib/server/daemon.js

@@ -61,7 +61,7 @@ export function createMessageDispatcher(options) {
                 title: `ai ${plan.argv.join(' ')}`,
                 chunkChars: typeof options.config.stream?.chunkChars === 'number' ? options.config.stream.chunkChars : 4000,
                 throttleMs: typeof options.config.stream?.throttleMs === 'number' ? options.config.stream.throttleMs : 1500
-            }, (emit) => runAiImpl(plan.argv, { onChunk: emit }), (outbound) => replyOutbound(message, outbound));
+            }, (emit) => runAiImpl(plan.argv, { onChunk: emit, cwd: options.config.repoRoot }), (outbound) => replyOutbound(message, outbound));
         }
     };
 }
@@ -75,15 +75,16 @@ export function createMessageDispatcher(options) {
 //   - runDaemon() awaits a shutdown promise that only resolves once a
 //     SIGINT/SIGTERM handler has finished graceful cleanup. We never unref()
 //     the only keep-alive timer (that would let the process exit immediately).
-export async function runDaemon() {
+export async function runDaemon({ rootDir } = {}) {
     let config;
     try {
-        config = loadServerConfig();
+        config = loadServerConfig({ rootDir });
     }
     catch (error) {
         process.stderr.write(`${errorMessage(error)}\n`);
         process.exit(1);
     }
+    process.chdir(config.repoRoot);
     const logger = createLogger(config.log);
     logger.info(`daemon starting agent-infra ${VERSION} pid=${process.pid}`);
     const ownStartTime = getProcessStartTime(process.pid);

package/dist/lib/server/process-control.js

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import path from 'node:path';
 import { spawn, execFileSync } from 'node:child_process';
 import { loadServerConfig } from './config.js';
 import { runDaemon } from './daemon.js';
@@ -65,7 +66,7 @@ export async function start({ foreground = false } = {}) {
         removePidFileIfMatches(pidPath, existing.snapshot);
     }
     if (foreground) {
-        await runDaemon();
+        await runDaemon({ rootDir: config.repoRoot });
         return;
     }
     const cliEntry = process.argv[1];
@@ -75,8 +76,9 @@ export async function start({ foreground = false } = {}) {
     // Re-spawn ourselves detached. process.execArgv is forwarded so the dev path
     // (node --experimental-strip-types ./bin/cli.ts) and the built path
     // (node dist/bin/cli.js) both work.
-    const child = spawn(process.execPath, [...process.execArgv, cliEntry, 'server', '__daemon'], {
+    const child = spawn(process.execPath, [...process.execArgv, path.resolve(cliEntry), 'server', '__daemon'], {
         detached: true,
+        cwd: config.repoRoot,
         stdio: 'ignore'
     });
     child.unref();

package/dist/lib/server/runner.js

@@ -22,12 +22,13 @@ function resolveCommand(file) {
 function needsShell(file) {
     return process.platform === 'win32' && /\.(?:bat|cmd)$/i.test(file);
 }
-function spawnCapture(file, args, onChunk) {
+function spawnCapture(file, args, onChunk, cwd) {
     return new Promise((resolve, reject) => {
         const resolvedFile = resolveCommand(file);
         const child = spawn(resolvedFile, args, {
             stdio: ['ignore', 'pipe', 'pipe'],
-            shell: needsShell(resolvedFile)
+            shell: needsShell(resolvedFile),
+            ...(cwd === undefined ? {} : { cwd })
         });
         let stdout = '';
         let stderr = '';
@@ -70,6 +71,6 @@ function spawnCapture(file, args, onChunk) {
     });
 }
 export async function runAi(args, options = {}) {
-    return (options.spawn ?? spawnCapture)('ai', args, options.onChunk);
+    return (options.spawn ?? spawnCapture)('ai', args, options.onChunk, options.cwd);
 }
 //# sourceMappingURL=runner.js.map

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

@@ -7,6 +7,8 @@ import { parseImplementationInputs, selectPendingImplementationInput } from './i
 import { parseVerdict } from './review-artifacts.js';
 import { extractSection, findSectionHeading } from './sections.js';
 import { receiptForOutput, sha256File } from './artifact-receipts.js';
+import { hasArtifactCompletionFact, hasArtifactCompletionLog } from './completion-facts.js';
+import { inspectReviewIdentity } from './review-identity.js';
 import { isArtifactInvalidated, parseInvalidationDocument } from './invalidation.js';
 import { parseLifecyclePathDecision } from './lifecycle-path.js';
 import { parseReworkIntentDocument } from './rework-intent.js';
@@ -149,7 +151,16 @@ function inspectArtifactDirectory(taskDir, family, identity = {}) {
             diagnostics.push(diagnostic('ROUND_GAP', family, null, `${artifactName(family, round)} is missing`));
     }
     const latest = artifacts.at(-1) ?? null;
-    const reviewedInput = family.startsWith('review-') && latest
+    let hasReviewCodeReceipt = false;
+    if (family === 'review-code' && latest) {
+        try {
+            hasReviewCodeReceipt = Boolean(receiptForOutput(fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8'), latest.name));
+        }
+        catch {
+            hasReviewCodeReceipt = false;
+        }
+    }
+    const reviewedInput = family.startsWith('review-') && latest && (family !== 'review-code' || hasReviewCodeReceipt)
         ? resolveReviewedInput(taskDir, latest, family === 'review-analysis' ? 'analysis' : family === 'review-plan' ? 'plan' : 'code', diagnostics)
         : null;
     return {
@@ -248,14 +259,16 @@ function assertWritableInventory(inventory) {
     };
 }
 const REQUIRED_INPUT = {
-    'review-analysis': 'analysis', plan: 'analysis', 'review-plan': 'plan', 'review-code': 'code'
+    'review-analysis': 'analysis', plan: 'analysis', 'review-plan': 'plan'
 };
 const OPTIONAL_CONTEXT = {
-    analysis: { family: 'review-analysis' },
-    plan: { family: 'review-plan' },
-    'review-code': { family: 'review-plan' },
-    'manual-validation': { family: 'review-code' },
-    'validation-run': { family: 'review-code' }
+    analysis: ['review-analysis'],
+    plan: ['review-analysis', 'review-plan'],
+    'review-plan': ['review-analysis'],
+    code: ['review-plan'],
+    'review-code': ['code', 'plan', 'review-plan'],
+    'manual-validation': ['review-code'],
+    'validation-run': ['review-code']
 };
 function hasSelectionEvidence(content, family, options, context) {
     if (options.sourceFinding && options.sourceArtifact && options.sourceSha256)
@@ -265,6 +278,20 @@ function hasSelectionEvidence(content, family, options, context) {
     if (family.startsWith('review-')) {
         const reviewedFamily = family === 'review-analysis' ? 'analysis' : family === 'review-plan' ? 'plan' : 'code';
         const currentInput = context.inputs.find((input) => input.family === reviewedFamily);
+        if (family === 'review-code') {
+            if (!context.latest)
+                return false;
+            try {
+                const reportContent = fs.readFileSync(context.latest.path, 'utf8');
+                const identity = inspectReviewIdentity(context.taskDir, reportContent, options.repoRoot);
+                return identity.status !== 'matched'
+                    || !hasArtifactCompletionFact(content, context.latest.path, 'review-code.completed')
+                    || !hasArtifactCompletionLog(content, context.latest.name, 'review-code.completed');
+            }
+            catch {
+                return true;
+            }
+        }
         if (currentInput && context.reviewedInput?.name !== currentInput.name)
             return true;
     }
@@ -387,9 +414,10 @@ function resolveArtifactContext(taskRef, family, options = {}) {
     }
     const optional = OPTIONAL_CONTEXT[inventory.family];
     if (optional) {
-        const context = inspectTaskArtifacts(taskRef, optional.family, options);
-        if (context.status === 'ready' && context.latest) {
-            inputs.push(context.latest);
+        for (const family of optional) {
+            const context = inspectTaskArtifacts(taskRef, family, options);
+            if (context.status === 'ready' && context.latest)
+                inputs.push(context.latest);
         }
     }
     if (inventory.family === 'manual-validation' || inventory.family === 'validation-run') {
@@ -411,6 +439,10 @@ function resolveCodeContext(inventory, options) {
     const codeMax = latestCode?.round ?? 0;
     const reviewMax = reviewCode.latest?.round ?? 0;
     const inputs = [source.latest];
+    const sourceReviewFamily = inputFamily === 'analysis' ? 'review-analysis' : 'review-plan';
+    const sourceReview = inspectTaskArtifacts(taskRef, sourceReviewFamily, options);
+    if (sourceReview.status === 'ready' && sourceReview.latest && sourceReview.reviewedInput?.name === source.latest.name)
+        inputs.push(sourceReview.latest);
     if (latestCode) {
         try {
             const taskContent = fs.readFileSync(path.join(inventory.taskDir, 'task.md'), 'utf8');

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

@@ -5,17 +5,21 @@ import { extractSection, findSectionHeading, parseTable } from './sections.js';
 const RECEIPT_SECTION_ALIASES = ['产物生命周期收据', 'Artifact Lifecycle Receipts'];
 const RECEIPT_COLUMNS = ['event', 'output', 'input', 'input_sha256', 'completed_at'];
 const RECEIPT_EVENTS = new Set([
+    'analysis.completed',
+    'plan.completed',
     'review-analysis.completed',
     'review-plan.completed',
+    'code.completed',
     'review-code.completed',
-    'code.completed'
 ]);
 const SHA256_RE = /^[a-f0-9]{64}$/;
 const RECEIPT_SHAPES = {
+    'analysis.completed': { output: 'analysis', input: 'review-analysis' },
+    'plan.completed': { output: 'plan', input: 'analysis' },
     'review-analysis.completed': { output: 'review-analysis', input: 'analysis' },
     'review-plan.completed': { output: 'review-plan', input: 'plan' },
-    'review-code.completed': { output: 'review-code', input: 'code' },
-    'code.completed': { output: 'code', input: 'plan' }
+    'code.completed': { output: 'code', input: 'plan' },
+    'review-code.completed': { output: 'review-code', input: 'code' }
 };
 class ArtifactReceiptError extends Error {
     code = 'ARTIFACT_RECEIPT_INVALID';
@@ -37,8 +41,16 @@ function validateReceiptShape(event, output, input) {
         throw new ArtifactReceiptError(`receipt artifact identity is invalid: ${output} -> ${input}`);
     const shape = RECEIPT_SHAPES[event];
     const inputMatches = event === 'code.completed'
-        ? inputIdentity.family === 'analysis' || inputIdentity.family === 'plan'
-        : inputIdentity.family === shape.input;
+        ? inputIdentity.family === 'analysis' || inputIdentity.family === 'plan' || inputIdentity.family === 'review-analysis' || inputIdentity.family === 'review-plan' || inputIdentity.family === 'review-code'
+        : event === 'plan.completed'
+            ? inputIdentity.family === 'analysis' || inputIdentity.family === 'review-analysis' || inputIdentity.family === 'review-plan'
+            : event === 'analysis.completed'
+                ? inputIdentity.family === 'review-analysis'
+                : event === 'review-plan.completed'
+                    ? inputIdentity.family === 'plan' || inputIdentity.family === 'review-analysis'
+                    : event === 'review-code.completed'
+                        ? inputIdentity.family === 'code' || inputIdentity.family === 'plan' || inputIdentity.family === 'review-plan'
+                        : inputIdentity.family === shape.input;
     if (outputIdentity.family !== shape.output || !inputMatches) {
         throw new ArtifactReceiptError(`receipt event '${event}' does not match ${output} -> ${input}`);
     }
@@ -52,7 +64,9 @@ function parseArtifactReceipts(content) {
         table = parseTable(content, {
             sectionAliases: [...RECEIPT_SECTION_ALIASES],
             columns: [...RECEIPT_COLUMNS],
-            keyColumn: 'output'
+            // A completed artifact can have multiple lifecycle inputs. Pair
+            // uniqueness is checked below because the table parser supports one key.
+            keyColumn: null
         });
     }
     catch (error) {
@@ -84,29 +98,55 @@ function parseArtifactReceipts(content) {
             completedAt
         };
     });
+    const edges = new Set();
+    for (const row of rows) {
+        const edge = `${row.output}\0${row.input}`;
+        if (edges.has(edge))
+            throw new ArtifactReceiptError(`duplicate receipt edge '${row.output}' <- '${row.input}'`);
+        edges.add(edge);
+    }
     return { present: true, rows };
 }
+function receiptsForOutput(content, output) {
+    return parseArtifactReceipts(content).rows.filter((row) => row.output === output);
+}
 function receiptForOutput(content, output) {
-    const parsed = parseArtifactReceipts(content);
-    return parsed.rows.find((row) => row.output === output) ?? null;
+    return receiptsForOutput(content, output)[0] ?? null;
 }
 function upsertArtifactReceipt(content, receipt) {
-    if (!RECEIPT_EVENTS.has(receipt.event))
-        throw new ArtifactReceiptError(`unknown receipt event '${receipt.event}'`);
-    if (!receipt.output || !receipt.input)
-        throw new ArtifactReceiptError('receipt output and input are required');
-    validateReceiptShape(receipt.event, receipt.output, receipt.input);
-    if (!SHA256_RE.test(receipt.inputSha256))
-        throw new ArtifactReceiptError(`receipt digest for '${receipt.output}' is invalid`);
-    if (!receipt.completedAt || Number.isNaN(Date.parse(receipt.completedAt.replace(' ', 'T')))) {
-        throw new ArtifactReceiptError(`receipt completion time for '${receipt.output}' is invalid`);
+    return upsertArtifactReceipts(content, [receipt]);
+}
+function upsertArtifactReceipts(content, receiptsToAdd) {
+    if (receiptsToAdd.length === 0)
+        throw new ArtifactReceiptError('at least one receipt is required');
+    const additions = new Map();
+    for (const receipt of receiptsToAdd) {
+        if (!RECEIPT_EVENTS.has(receipt.event))
+            throw new ArtifactReceiptError(`unknown receipt event '${receipt.event}'`);
+        if (!receipt.output || !receipt.input)
+            throw new ArtifactReceiptError('receipt output and input are required');
+        validateReceiptShape(receipt.event, receipt.output, receipt.input);
+        if (!SHA256_RE.test(receipt.inputSha256))
+            throw new ArtifactReceiptError(`receipt digest for '${receipt.output}' is invalid`);
+        if (!receipt.completedAt || Number.isNaN(Date.parse(receipt.completedAt.replace(' ', 'T')))) {
+            throw new ArtifactReceiptError(`receipt completion time for '${receipt.output}' is invalid`);
+        }
+        const key = `${receipt.output}\0${receipt.input}`;
+        const duplicate = additions.get(key);
+        if (duplicate && JSON.stringify(duplicate) !== JSON.stringify(receipt))
+            throw new ArtifactReceiptError(`receipt for '${receipt.output}' from '${receipt.input}' has conflicting evidence`);
+        additions.set(key, receipt);
     }
     const existing = parseArtifactReceipts(content).rows;
-    const previous = existing.find((row) => row.output === receipt.output);
-    if (previous && JSON.stringify(previous) !== JSON.stringify(receipt)) {
-        throw new ArtifactReceiptError(`receipt for '${receipt.output}' already exists with different evidence`);
+    for (const receipt of additions.values()) {
+        const previous = existing.find((row) => row.output === receipt.output && row.input === receipt.input);
+        if (previous && JSON.stringify(previous) !== JSON.stringify(receipt))
+            throw new ArtifactReceiptError(`receipt for '${receipt.output}' from '${receipt.input}' already exists with different evidence`);
     }
-    const rows = previous ? existing : [...existing, receipt];
+    const rows = [...existing];
+    for (const receipt of additions.values())
+        if (!rows.some((row) => row.output === receipt.output && row.input === receipt.input))
+            rows.push(receipt);
     const heading = findSectionHeading(content, [...RECEIPT_SECTION_ALIASES]);
     const body = [
         `| ${RECEIPT_COLUMNS.join(' | ')} |`,
@@ -115,5 +155,5 @@ function upsertArtifactReceipt(content, receipt) {
     ].join('\n');
     return { aliases: [...RECEIPT_SECTION_ALIASES], heading, body };
 }
-export { ArtifactReceiptError, RECEIPT_SECTION_ALIASES, parseArtifactReceipts, receiptForOutput, sha256Bytes, sha256File, upsertArtifactReceipt };
+export { ArtifactReceiptError, RECEIPT_SECTION_ALIASES, parseArtifactReceipts, receiptForOutput, receiptsForOutput, sha256Bytes, sha256File, upsertArtifactReceipt, upsertArtifactReceipts };
 //# sourceMappingURL=artifact-receipts.js.map

package/dist/lib/task/capabilities.js

@@ -12,6 +12,8 @@ import { hasOpenLifecycleExecution } from './activity-log.js';
 import { parseQualificationAudit, parseTaskQualification } from './qualification-audit.js';
 import { parseLifecyclePathDecision, pathIncludes } from './lifecycle-path.js';
 import { parseImplementationInputs } from './implementation-inputs.js';
+import { hasArtifactCompletionFact, hasArtifactCompletionLog } from './completion-facts.js';
+import { inspectReviewIdentity } from './review-identity.js';
 const ARTIFACT_AUDIT_FAMILIES = new Set(['analysis', 'review-analysis', 'plan', 'review-plan', 'code', 'review-code']);
 const REASONS = new Set([
     'user-request', 'new-requirement', 'upstream-fact-doubt', 'review-finding', 'retry', 'validation-rerun'
@@ -139,13 +141,15 @@ function canStart(action, facts, trigger) {
         return allow('plan-review-approved');
     }
     if (action === 'review-code') {
-        return hasArtifact(facts, 'code') ? allow('code-artifact') : deny('CODE_ARTIFACT_REQUIRED');
+        return allow(hasArtifact(facts, 'code') ? 'optional-code-context' : 'review-current-git-diff');
     }
     if (action === 'manual-validation' || action === 'validation-run') {
         if (!hasArtifact(facts, 'review-code'))
             return deny('CODE_REVIEW_REQUIRED');
-        if (!reviewMatchesLatest(facts, 'code', 'review-code'))
+        if (hasArtifact(facts, 'code') && !reviewMatchesLatest(facts, 'code', 'review-code'))
             return deny('CODE_REVIEW_NOT_LATEST');
+        if (!facts.reviewCodeIdentityValid)
+            return deny('CODE_REVIEW_IDENTITY_INVALID');
         if (facts.reviews['review-code'] !== 'approved')
             return deny('CODE_REVIEW_NOT_APPROVED');
         if (facts.unresolvedLedger.code > 0)
@@ -309,7 +313,13 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
                     continue;
                 }
                 const audit = parseQualificationAudit(auditContent);
-                if (!audit.ok || !audit.audit.present || !audit.audit.snapshot) {
+                if (!audit.ok) {
+                    qualificationStaleArtifacts.push(name);
+                    continue;
+                }
+                if (!audit.audit.present)
+                    continue;
+                if (!audit.audit.snapshot) {
                     qualificationStaleArtifacts.push(name);
                     continue;
                 }
@@ -324,6 +334,7 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
         }
         const reviews = {};
         const reviewedInputs = {};
+        let reviewCodeIdentityValid = false;
         for (const family of ['review-analysis', 'review-plan', 'review-code']) {
             const latest = latestArtifact(artifacts[family] ?? []);
             if (!latest)
@@ -337,6 +348,12 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
                 && (artifacts[expectedFamily] ?? []).includes(input)
                 && artifactHashes[input] === receipt.inputSha256)
                 reviewedInputs[family] = input;
+            if (family === 'review-code') {
+                const identity = inspectReviewIdentity(taskDir, reviewContent);
+                reviewCodeIdentityValid = identity.status === 'matched'
+                    && hasArtifactCompletionFact(content, path.join(taskDir, latest), 'review-code.completed')
+                    && hasArtifactCompletionLog(content, latest, 'review-code.completed');
+            }
             const parsed = parseReviewSummary(reviewContent);
             if (!parsed.ok)
                 continue;
@@ -407,7 +424,8 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
             qualificationStaleArtifacts,
             pathState,
             reworkClassificationRequired,
-            resolvedHumanDecisions
+            resolvedHumanDecisions,
+            reviewCodeIdentityValid
         };
         facts.recommendedAction = recommendNext(facts).action;
         return { ok: true, facts };

package/dist/lib/task/completion-facts.js

@@ -0,0 +1,56 @@
+import fs from 'node:fs';
+import { canonicalSemanticDigest } from './artifact-operations.js';
+import { inspectActivityLog } from './activity-log.js';
+import { parseTypedTaskFrontmatter } from './frontmatter.js';
+import { parseArtifactName } from './artifact-name.js';
+import { sha256File } from './artifact-receipts.js';
+export function parseCompletionFacts(value) {
+    if (typeof value !== 'string')
+        return [];
+    try {
+        const parsed = JSON.parse(value);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter((fact) => Boolean(fact && typeof fact === 'object' && !Array.isArray(fact)
+            && typeof fact.event === 'string'
+            && typeof fact.output === 'string'
+            && /^[a-f0-9]{64}$/u.test(fact.outputSha256)
+            && /^[a-f0-9]{64}$/u.test(fact.semanticDigest)
+            && typeof fact.requestId === 'string'
+            && typeof fact.result === 'string'));
+    }
+    catch {
+        return [];
+    }
+}
+export function hasArtifactCompletionFact(taskContent, artifactPath, event) {
+    try {
+        const frontmatter = parseTypedTaskFrontmatter(taskContent);
+        const output = artifactPath.split(/[\\/]/u).at(-1) ?? '';
+        const content = fs.readFileSync(artifactPath, 'utf8');
+        const outputSha256 = sha256File(artifactPath);
+        const semanticDigest = canonicalSemanticDigest(content);
+        return parseCompletionFacts(frontmatter.completion_facts).some((fact) => fact.event === event && fact.output === output
+            && fact.outputSha256 === outputSha256 && fact.semanticDigest === semanticDigest
+            && fact.requestId.length > 0);
+    }
+    catch {
+        return false;
+    }
+}
+export function hasArtifactCompletionLog(taskContent, artifact, event) {
+    const identity = parseArtifactName(artifact);
+    if (!identity)
+        return false;
+    const action = event === 'review-code.completed' ? 'Review Code'
+        : event === 'review-plan.completed' ? 'Review Plan'
+            : event === 'review-analysis.completed' ? 'Review Analysis' : null;
+    if (!action)
+        return false;
+    const { section, invalidEntries } = inspectActivityLog(taskContent);
+    if (!section || invalidEntries.length > 0)
+        return false;
+    const expected = `${action} (Round ${identity.round})`;
+    return section.entries.some((entry) => entry.step === expected && entry.note.includes(`→ ${artifact}`));
+}
+//# sourceMappingURL=completion-facts.js.map