@fitlab-ai/agent-infra 0.11.6 → 0.11.8

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/activity-intent.js

@@ -11,6 +11,7 @@ const REVIEW_ACTION_RE = /^Review PR \(Round ([1-9]\d*)\)( \[started\])?$/;
 const VERDICTS = new Set(['approved', 'changes-requested', 'commented']);
 const OUTCOMES = new Set(['aborted', 'superseded']);
 const SUCCESS_STATUSES = new Set(['applied', 'no-op']);
+const LOCAL_COMPLETION_STATUSES = new Set(['applied', 'no-op', 'blocked', 'failed']);
 const ARTIFACT_STATUSES = new Set([
     'pending', 'applied', 'no-op', 'blocked', 'failed', 'aborted', 'superseded'
 ]);
@@ -102,7 +103,7 @@ function readSnapshot(taskRef, repoRoot) {
         }
         if (terminal.length === 1) {
             const note = terminal[0].note;
-            const terminalMatchesStatus = (note.startsWith('Verdict: ') && SUCCESS_STATUSES.has(parsed.status))
+            const terminalMatchesStatus = (note.startsWith('Verdict: ') && LOCAL_COMPLETION_STATUSES.has(parsed.status))
                 || (note.startsWith('Outcome: Aborted, ') && parsed.status === 'aborted')
                 || (note.startsWith('Outcome: Superseded, ') && parsed.status === 'superseded')
                 || (note.startsWith('receipt ') && SUCCESS_STATUSES.has(parsed.status));
@@ -233,8 +234,8 @@ function applyLocked(intent, normalizedAgent, options) {
         if (roundState.startedAgent === null) {
             return failed(intent, 'ACTIVITY_STATE_CONFLICT', `${base} has no matching started row`, state.taskId);
         }
-        if (intent.kind === 'pr-review-complete' && !SUCCESS_STATUSES.has(roundState.status)) {
-            return failed(intent, 'ACTIVITY_STATE_CONFLICT', `${intent.artifact} must be applied or no-op before completion`, state.taskId);
+        if (intent.kind === 'pr-review-complete' && !LOCAL_COMPLETION_STATUSES.has(roundState.status)) {
+            return failed(intent, 'ACTIVITY_STATE_CONFLICT', `${intent.artifact} must record a publication outcome before completion`, state.taskId);
         }
         if (intent.kind === 'pr-review-terminate' && roundState.status !== intent.outcome) {
             return failed(intent, 'ACTIVITY_STATE_CONFLICT', `${intent.artifact} status must match outcome ${intent.outcome}`, state.taskId);

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

package/dist/lib/task/create-service.js

@@ -3,6 +3,7 @@ import { createPlatformIssue, syncPlatformIssue } from '../platform/issues.js';
 import { VERSION } from '../version.js';
 import { applyWorkflowWarningIntent } from './workflow-warning-intents.js';
 import { createLocalTask } from './create.js';
+import { TaskExecutionLockError } from './task-execution-lock.js';
 import { verifyTaskEvent } from './verification.js';
 const DEFAULT_DEPENDENCIES = {
     createIssue: createPlatformIssue,
@@ -48,9 +49,10 @@ export function parseTaskCreateResult(value) {
     if (!['applied', 'no-op', 'degraded', 'failed', 'blocked'].includes(result.status)
         || typeof result.changed !== 'boolean'
         || !result.task || typeof result.task !== 'object' || Array.isArray(result.task)
-        || !exactKeys(result.task, ['id', 'shortId'])
+        || !exactKeys(result.task, ['id', 'shortId', 'state'])
         || !validTaskReference(result.task.id)
         || !validTaskReference(result.task.shortId)
+        || ![null, 'active', 'blocked', 'completed', 'archive'].includes(result.task.state)
         || !Array.isArray(result.operations)
         || !result.operations.every((operation) => {
             if (!operation || typeof operation !== 'object' || Array.isArray(operation))
@@ -93,7 +95,7 @@ export function taskCreateFailure(error, control) {
     return {
         status: error.retryable ? 'blocked' : 'failed',
         changed: false,
-        task: { id: null, shortId: null },
+        task: { id: null, shortId: null, state: null },
         issue: null,
         operations: [],
         warnings: [],
@@ -150,12 +152,16 @@ async function createTask(value, options) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        const code = /^([A-Z][A-Z0-9_]+)/.exec(message)?.[1] ?? 'TASK_CREATE_FAILED';
-        return taskCreateFailure({ code, message, retryable: code === 'TASK_CREATE_LOCK_TIMEOUT' });
+        const lockBusy = error instanceof TaskExecutionLockError && error.code === 'ORCHESTRATION_LOCK_BUSY';
+        const code = lockBusy ? error.code : /^([A-Z][A-Z0-9_]+)/.exec(message)?.[1] ?? 'TASK_CREATE_FAILED';
+        return taskCreateFailure({ code, message, retryable: lockBusy || code === 'TASK_CREATE_LOCK_TIMEOUT' });
     }
     const operations = [{
             name: 'task:local', status: local.status, reasonCode: null
         }];
+    if (local.status === 'no-op' && local.task.state !== 'active') {
+        return { status: 'no-op', changed: false, task: local.task, issue: null, operations, warnings: [], error: null };
+    }
     let issue = null;
     const created = await dependencies.createIssue(local.task.id, { cwd: options.repoRoot, agent: candidate.agent });
     operations.push(...platformOperations('platform-create', created.operations));
@@ -199,7 +205,7 @@ async function createTask(value, options) {
                 task: local.task, issue, operations, warnings: [], error: verified.error
             };
         return {
-            status: platformFailure.status === 'blocked' ? 'blocked' : 'degraded',
+            status: 'degraded',
             changed: local.changed,
             task: local.task,
             issue,