@fitlab-ai/agent-infra 0.11.9 → 0.11.11

package/dist/lib/sandbox/environment.js

@@ -0,0 +1,150 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { readSandboxControlIdentitySentinel } from './control/identity-sentinel.js';
+export const SANDBOX_CONTROL_STATUS_MOUNT = '/run/agent-infra/control-status';
+const TASK_MARKER_KEYS = [
+    'AGENT_INFRA_SANDBOX',
+    'AGENT_INFRA_TASK_ID',
+    'AGENT_INFRA_CONTROL_TOKEN',
+    'AGENT_INFRA_CONTROL_GENERATION',
+    'AGENT_INFRA_CONTROL_DIR',
+    'AGENT_INFRA_CONTROL_STATUS_DIR',
+    'AGENT_INFRA_RUNTIME_DIR'
+];
+const TASK_CONTROL_MARKER_KEYS = [
+    'AGENT_INFRA_CONTROL_TOKEN',
+    'AGENT_INFRA_CONTROL_GENERATION',
+    'AGENT_INFRA_CONTROL_DIR',
+    'AGENT_INFRA_CONTROL_STATUS_DIR'
+];
+const TASK_CONTROL_CONFIG_KEYS = [
+    ...TASK_CONTROL_MARKER_KEYS,
+    'AGENT_INFRA_CONTROL_ROOT_ID'
+];
+function nativeDirectoryProbe(candidate) {
+    if (process.platform === 'linux') {
+        try {
+            // Linux sandboxes use this fixed mount as a host/sandbox trust anchor.
+            // Do not let a preload replace the ordinary node:fs probe and select host routing.
+            const binding = process.binding('fs');
+            if (!Function.prototype.toString.call(binding.internalModuleStat).includes('[native code]'))
+                return 'unknown';
+            const result = binding.internalModuleStat(candidate);
+            if (result === 1)
+                return 'present';
+            if (result === -2)
+                return 'absent';
+            return 'unknown';
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+    try {
+        const stat = fs.lstatSync(candidate);
+        return stat.isDirectory() && !stat.isSymbolicLink() ? 'present' : 'unknown';
+    }
+    catch (error) {
+        if (error && typeof error === 'object' && 'code' in error
+            && (error.code === 'ENOENT' || error.code === 'ENOTDIR'))
+            return 'absent';
+        return 'unknown';
+    }
+}
+export function sandboxTaskMarkerState(env) {
+    const present = (key) => Boolean(env[key]);
+    const sandbox = env.AGENT_INFRA_SANDBOX === '1';
+    const taskId = present('AGENT_INFRA_TASK_ID');
+    const controls = TASK_CONTROL_MARKER_KEYS.every(present);
+    const runtime = present('AGENT_INFRA_RUNTIME_DIR');
+    const any = TASK_MARKER_KEYS.some(present);
+    if (!any)
+        return 'none';
+    if (!sandbox || !controls)
+        return 'incomplete';
+    if (taskId && runtime)
+        return 'task-bound';
+    if (!taskId && !runtime)
+        return 'branch-only';
+    return 'incomplete';
+}
+export function hasTaskBoundMarker(env = process.env) {
+    return sandboxTaskMarkerState(env) === 'task-bound';
+}
+export function hasSandboxControlMarker(env = process.env) {
+    return TASK_CONTROL_MARKER_KEYS.some((key) => Boolean(env[key]));
+}
+export function resolveSandboxControlTransport(env = process.env, options = {}) {
+    const markerState = sandboxTaskMarkerState(env);
+    const hasAnyMarker = markerState !== 'none'
+        || Boolean(env.AGENT_INFRA_CONTROL_CONTROLLER_BINDING)
+        || Boolean(env.AGENT_INFRA_EXECUTOR_MANIFEST);
+    const fixedStatusDir = options.statusMountPath ?? SANDBOX_CONTROL_STATUS_MOUNT;
+    const fixedStatusProbe = path.isAbsolute(fixedStatusDir)
+        ? nativeDirectoryProbe(fixedStatusDir) : 'absent';
+    if (fixedStatusProbe === 'unknown') {
+        return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_IDENTITY_UNAVAILABLE' };
+    }
+    const fixedStatusMounted = fixedStatusProbe === 'present';
+    if (!hasAnyMarker) {
+        return fixedStatusMounted
+            ? { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_CONFIGURATION_INCOMPLETE' }
+            : { kind: 'direct-host', reasonCode: null };
+    }
+    if (markerState === 'incomplete') {
+        return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_CONFIGURATION_INCOMPLETE' };
+    }
+    const hasCompleteConfig = TASK_CONTROL_CONFIG_KEYS.every((key) => Boolean(env[key]));
+    if (!hasCompleteConfig) {
+        return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_CONFIGURATION_INCOMPLETE' };
+    }
+    const configuredStatusDir = env.AGENT_INFRA_CONTROL_STATUS_DIR;
+    const configuredStatusProbe = configuredStatusDir && path.isAbsolute(configuredStatusDir)
+        ? nativeDirectoryProbe(configuredStatusDir) : 'absent';
+    if (configuredStatusProbe === 'unknown') {
+        return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_IDENTITY_UNAVAILABLE' };
+    }
+    const statusDir = configuredStatusDir && path.isAbsolute(configuredStatusDir)
+        ? configuredStatusProbe === 'present' ? configuredStatusDir : null
+        : fixedStatusMounted ? fixedStatusDir : null;
+    const statusMounted = statusDir !== null;
+    if (env.AGENT_INFRA_EXECUTOR_MANIFEST || env.AGENT_INFRA_CONTROL_CONTROLLER_BINDING) {
+        return { kind: 'fail-closed', reasonCode: 'TASK_CONTROL_TRANSPORT_INVALID' };
+    }
+    const taskBound = Boolean(env.AGENT_INFRA_TASK_ID);
+    const runtime = Boolean(env.AGENT_INFRA_RUNTIME_DIR);
+    if (statusMounted) {
+        let sentinel;
+        try {
+            sentinel = readSandboxControlIdentitySentinel(statusDir);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : '';
+            return { kind: 'fail-closed', reasonCode: message.endsWith('MISSING')
+                    ? 'SANDBOX_CONTROL_IDENTITY_MISSING'
+                    : 'SANDBOX_CONTROL_IDENTITY_MALFORMED' };
+        }
+        if (sentinel.generation !== env.AGENT_INFRA_CONTROL_GENERATION) {
+            return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_IDENTITY_GENERATION_MISMATCH' };
+        }
+        if (sentinel.controlRootId !== env.AGENT_INFRA_CONTROL_ROOT_ID) {
+            return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_IDENTITY_ROOT_ID_MISMATCH' };
+        }
+        if (sentinel.mode === 'task-bound'
+            && (sentinel.taskId !== env.AGENT_INFRA_TASK_ID || !runtime)) {
+            return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_IDENTITY_TOPOLOGY_MISMATCH' };
+        }
+        if (sentinel.mode === 'branch-only' && (taskBound || runtime)) {
+            return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_IDENTITY_TOPOLOGY_MISMATCH' };
+        }
+        return { kind: options.localWorkflow ? 'sandbox-local' : 'broker-client', reasonCode: null };
+    }
+    return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_IDENTITY_MISSING' };
+}
+export function isSandbox(env = process.env, options = {}) {
+    const decision = resolveSandboxControlTransport(env, options);
+    if (decision.kind === 'fail-closed')
+        throw new Error(decision.reasonCode ?? 'TASK_CONTROL_TRANSPORT_INVALID');
+    return decision.kind !== 'direct-host';
+}
+//# sourceMappingURL=environment.js.map

package/dist/lib/sandbox/recovery.js

@@ -567,6 +567,13 @@ function expectedMounts(params) {
         hostPaths: toolConfigDirCandidates(tool, config.project, branch),
         expectedRW: true
     }));
+    const hostState = tools.flatMap((tool) => (tool.hostStateMounts ?? []).map(({ hostSubdir, containerSubpath }) => ({
+        path: path.posix.join(tool.containerMount, containerSubpath),
+        expectedType: 'bind',
+        hostPaths: toolConfigDirCandidates(tool, config.project, branch)
+            .map((candidate) => path.join(candidate, hostSubdir)),
+        expectedRW: true
+    })));
     const staging = tools.flatMap((tool) => (tool.tmpfs?.seed ?? []).flatMap((seedEntry, index) => {
         const stagingPath = `/run/agent-infra/tmpfs-seeds/${tool.id}/${index}`;
         if (!actualMounts.has(stagingPath))
@@ -583,6 +590,7 @@ function expectedMounts(params) {
         ...core,
         ...persistentTools,
         ...live,
+        ...hostState,
         ...staging,
         ...tools
             .filter((tool) => tool.tmpfs)

package/dist/lib/sandbox/removal.js

@@ -19,7 +19,6 @@ import { getProcessStartTime } from '../server/process-state.js';
 import { releaseStaleShortIdRegistry } from '../task/short-id.js';
 import { withRepositoryMutationLock } from '../task/task-execution-lock.js';
 import { fetchSandboxRows } from './commands/list-running.js';
-import { formatIntermediateCleanupReport, cleanupIntermediateUnderRemovalCoordinator, protectIntermediateCleanupReport, mergeIntermediateCleanupReports, scanIntermediateCleanup } from '../task/intermediate-cleanup.js';
 import { createSandboxControlBindingEvidence } from './task-cleanup.js';
 import { createCleanPermit, createDiscardPermit, formatWorktreeSnapshot, inspectRecoveredWorktree, inspectWorktrees, verifyWorktreePermit } from './worktree-safety.js';
 function projectToolDirs(config, tools) {

package/dist/lib/sandbox/workspace-identity.js

@@ -79,20 +79,6 @@ export function resolveSandboxTarget(requestedRef, repoRoot) {
     }
     return { requestedRef, branch: requestedRef, workspace: { mode: 'branch-only' } };
 }
-export function resolveSandboxReentryContext(params) {
-    if (params.target.workspace.mode !== 'branch-only'
-        || params.containerWorkspace.mode !== 'task-bound') {
-        return { workspace: params.target.workspace, reentry: 'standard' };
-    }
-    const task = resolveTaskWorkspace(params.containerWorkspace.taskId, params.repoRoot);
-    if (task.state !== 'completed' || task.branch !== params.target.branch) {
-        return { workspace: params.target.workspace, reentry: 'standard' };
-    }
-    return {
-        workspace: { mode: 'task-bound', taskId: task.taskId },
-        reentry: 'completed'
-    };
-}
 export function resolveSandboxCleanupTarget(requestedRef, repoRoot, options = {}) {
     if (isRemovedHashShortIdInput(requestedRef)) {
         throw new Error(`Invalid task short id '${requestedRef}': task short ids must use bare digits`);

package/dist/lib/sandbox/workspace-view.js

@@ -1,6 +1,7 @@
 import { createHash, randomBytes } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
+import { resolveTaskWorkspace } from './task-resolver.js';
 import { createSandboxControlIdentitySentinel, writeSandboxControlIdentitySentinel } from './control/identity-sentinel.js';
 export const SANDBOX_WORKSPACE_VIEW_STATES = Object.freeze([
     'active',
@@ -73,15 +74,38 @@ function assertSafeMountTargetPath(target, worktreeRoot, canonicalWorktreeRoot)
 export function assertSandboxTaskSource(repoRoot, taskId) {
     if (!/^TASK-\d{8}-\d{6}$/.test(taskId))
         throw new Error('SANDBOX_TASK_SOURCE_INVALID');
-    const activeRoot = fs.realpathSync.native(path.join(repoRoot, '.agents', 'workspace', 'active'));
-    const source = path.join(activeRoot, taskId);
+    const activeSource = path.join(repoRoot, '.agents', 'workspace', 'active', taskId);
+    try {
+        const stat = fs.lstatSync(activeSource);
+        if (!stat.isDirectory() || stat.isSymbolicLink()) {
+            throw new Error(`SANDBOX_TASK_SOURCE_INVALID: ${activeSource} must be a real directory`);
+        }
+        const canonical = fs.realpathSync.native(activeSource);
+        const activeRoot = fs.realpathSync.native(path.dirname(activeSource));
+        const workspaceRoot = fs.realpathSync.native(path.join(repoRoot, '.agents', 'workspace'));
+        const relative = path.relative(workspaceRoot, canonical);
+        if (path.dirname(canonical) !== activeRoot || relative.startsWith('..') || path.isAbsolute(relative)) {
+            throw new Error(`SANDBOX_TASK_SOURCE_INVALID: ${activeSource} escapes the task workspace`);
+        }
+        return canonical;
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    const task = resolveTaskWorkspace(taskId, repoRoot);
+    const source = task.state === 'archive'
+        ? path.dirname(path.dirname(task.taskMd))
+        : path.dirname(task.taskMd);
     const stat = fs.lstatSync(source);
     if (!stat.isDirectory() || stat.isSymbolicLink()) {
         throw new Error(`SANDBOX_TASK_SOURCE_INVALID: ${source} must be a real directory`);
     }
     const canonical = fs.realpathSync.native(source);
-    if (path.dirname(canonical) !== activeRoot) {
-        throw new Error(`SANDBOX_TASK_SOURCE_INVALID: ${source} escapes the active workspace`);
+    const workspaceRoot = fs.realpathSync.native(path.join(repoRoot, '.agents', 'workspace'));
+    const relative = path.relative(workspaceRoot, canonical);
+    if (path.basename(canonical) !== taskId || relative.startsWith('..') || path.isAbsolute(relative)) {
+        throw new Error(`SANDBOX_TASK_SOURCE_INVALID: ${source} escapes the task workspace`);
     }
     return canonical;
 }
@@ -114,10 +138,13 @@ export function materializeSandboxWorkspaceView(params) {
         fs.mkdirSync(hostPath, { recursive: true, mode: 0o700 });
     }
     const active = path.join(root, 'active');
+    const shortId = params.identity.mode === 'task-bound' && 'shortId' in params.identity
+        ? params.identity.shortId
+        : null;
     const registry = {
         version: 1,
-        ids: params.identity.mode === 'task-bound'
-            ? { [params.identity.shortId]: params.identity.taskId }
+        ids: shortId !== null && params.identity.mode === 'task-bound'
+            ? { [shortId]: params.identity.taskId }
             : {}
     };
     fs.writeFileSync(path.join(active, '.short-ids.json'), `${JSON.stringify(registry)}\n`, {

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

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import path from 'node:path';
 import { resolveArtifactContext, hasOpenArtifactRound } from './artifact-lifecycle.js';
 import { parseArtifactName } from './artifact-name.js';
 import { resolveTaskRef } from './resolve-ref.js';
@@ -13,7 +14,7 @@ export function parseArtifactCommand(args) {
     }
     const fields = {};
     const allowed = {
-        inspect: ['--family', '--source-finding', '--source-artifact', '--source-sha256'],
+        inspect: ['--family', '--reason-code', '--source-finding', '--source-artifact', '--source-sha256'],
         init: ['--family', '--artifact', '--locale'],
         'preflight': ['--family', '--artifact'],
         'finalize-local': ['--family', '--artifact']
@@ -36,9 +37,13 @@ export function parseArtifactCommand(args) {
     const locale = fields['--locale'];
     if (locale !== undefined && locale !== 'zh-CN' && locale !== 'en')
         throw new Error("option '--locale' must be 'zh-CN' or 'en'");
+    const reasonCode = fields['--reason-code'];
+    if (reasonCode !== undefined && !['user-request', 'new-requirement', 'upstream-fact-doubt', 'review-finding', 'manual-review-supplement', 'retry', 'validation-rerun'].includes(reasonCode)) {
+        throw new Error("option '--reason-code' is invalid");
+    }
     return {
         taskRef, operation: operation, family: fields['--family'] ?? '',
-        artifact: fields['--artifact'] ?? '', locale,
+        artifact: fields['--artifact'] ?? '', locale, reasonCode: reasonCode,
         sourceFinding: fields['--source-finding'], sourceArtifact: fields['--source-artifact'],
         sourceSha256: fields['--source-sha256']
     };
@@ -50,6 +55,7 @@ export function executeArtifactCommand(command, options = {}) {
     if (operation === 'inspect') {
         const result = resolveArtifactContext(taskRef, family, {
             repoRoot: options.repoRoot,
+            reasonCode: command.reasonCode,
             sourceFinding: command.sourceFinding,
             sourceArtifact: command.sourceArtifact,
             sourceSha256: command.sourceSha256
@@ -74,7 +80,16 @@ export function executeArtifactCommand(command, options = {}) {
     const input = { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskDir, family: schema.family, artifact };
     if (operation === 'init') {
         const context = resolveArtifactContext(taskRef, family, { repoRoot: resolved.repoRoot });
-        if (context.status !== 'ready' || (context.next?.name !== artifact && !hasOpenArtifactRound(fs.readFileSync(resolved.taskMdPath, 'utf8'), family, parsed.round))) {
+        const existingCandidate = path.join(taskDir, artifact);
+        let matchingInitializedSkeleton = false;
+        try {
+            const existing = fs.readFileSync(existingCandidate, 'utf8');
+            matchingInitializedSkeleton = existing.includes(`<!-- artifact-context:${resolved.taskId}:${family}:${parsed.round} -->`);
+        }
+        catch { /* an absent candidate is created only for the selected identity */ }
+        if ((context.status !== 'ready' && !matchingInitializedSkeleton) || (context.next?.name !== artifact
+            && !hasOpenArtifactRound(fs.readFileSync(resolved.taskMdPath, 'utf8'), family, parsed.round)
+            && !matchingInitializedSkeleton)) {
             return fail('ARTIFACT_INIT_CONTEXT_INVALID', context.error?.message ?? `artifact '${artifact}' is not the next ${family} artifact`);
         }
         return { ...initializeArtifactSkeleton({ ...input, ...(locale ? { locale } : {}) }), ...identity };

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

@@ -4,15 +4,16 @@ import { ARTIFACT_FAMILY_CATALOG, artifactName, parseArtifactName } from './arti
 import { resolveTaskRef } from './resolve-ref.js';
 import { locateActivityLog, pairEntries, startedBackedRows } from './activity-log.js';
 import { parseImplementationInputs, selectPendingImplementationInput } from './implementation-inputs.js';
+import { parseTypedTaskFrontmatter } from './frontmatter.js';
 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 { receiptForOutput, receiptsForOutput, sha256File } from './artifact-receipts.js';
+import { artifactCompletionOrder, hasArtifactCompletionFact, hasArtifactCompletionLog, parseCompletionFacts } 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';
 import { selectArtifactDisposition } from './artifact-selection.js';
+import { executionInputsMatchLatest } from './execution-inputs.js';
 const artifactFamilyCatalog = ARTIFACT_FAMILY_CATALOG;
 const ARTIFACT_STEPS = {
     analysis: 'Analyze Task', 'review-analysis': 'Review Analysis',
@@ -21,28 +22,46 @@ const ARTIFACT_STEPS = {
 };
 /** Init, repair and finalization share the same authoritative round identity. */
 export function hasOpenArtifactRound(content, family, round) {
+    return openArtifactRounds(content, family).includes(round);
+}
+function openArtifactRounds(content, family) {
     const activity = locateActivityLog(content);
     const step = ARTIFACT_STEPS[family];
     if (!activity || !step)
-        return false;
+        return [];
     const qualifier = family === 'code'
         ? '(?:, (?:fix for review-code(?:-r(?:[2-9]|[1-9]\\d+))?\\.md|decision II-[1-9]\\d*))?'
         : '';
-    const expected = new RegExp(`^${step} \\(Round ${round}${qualifier}\\)$`);
-    return startedBackedRows(pairEntries(activity.entries)).filter((row) => expected.test(row.step) && !row.done).length === 1;
+    const expected = new RegExp(`^${step} \\(Round ([1-9]\\d*)${qualifier}\\)$`);
+    return [...new Set(startedBackedRows(pairEntries(activity.entries))
+            .filter((row) => expected.test(row.step) && !row.done)
+            .map((row) => Number(expected.exec(row.step)?.[1])))].sort((left, right) => left - right);
 }
 function hasCompletedArtifactRound(content, family, round, name) {
-    const activity = locateActivityLog(content);
-    const step = ARTIFACT_STEPS[family];
-    if (!activity || !step)
-        return false;
-    const expected = new RegExp(`^${escapeRegExp(step)} \\(Round ${round}(?:, [^)]+)?\\)$`);
-    return startedBackedRows(pairEntries(activity.entries)).some((row) => expected.test(row.step) && Boolean(row.done) && row.note.includes(`→ ${name}`));
+    const event = completionEvent(family);
+    return Boolean(event && parseArtifactName(name)?.round === round
+        && artifactCompletionOrder(content, name, event) !== null
+        && hasArtifactCompletionFact(content, name, event));
+}
+function completionEvent(family) {
+    if (family === 'analysis')
+        return 'analyze.completed';
+    if (family === 'review-analysis')
+        return 'review-analysis.completed';
+    if (family === 'plan')
+        return 'plan.completed';
+    if (family === 'review-plan')
+        return 'review-plan.completed';
+    if (family === 'code')
+        return 'code.completed';
+    if (family === 'review-code')
+        return 'review-code.completed';
+    return null;
 }
 const BLOCKING_DIAGNOSTICS = new Set([
     'NONCANONICAL_NAME', 'ROUND_OUT_OF_RANGE', 'MISSING_BASE', 'ROUND_GAP',
     'DUPLICATE_LOGICAL_ROUND', 'NON_REGULAR_FILE', 'SYMBOLIC_LINK',
-    'FILESYSTEM_RACE', 'CATALOG_CONFLICT'
+    'FILESYSTEM_RACE', 'CATALOG_CONFLICT', 'MULTIPLE_OPEN_ROUNDS'
 ]);
 function familySpec(family) {
     return artifactFamilyCatalog.find((item) => item.family === family) ?? null;
@@ -53,7 +72,7 @@ function escapeRegExp(value) {
 function failure(requestRef, family, error, extra = {}) {
     return {
         status: 'failed', changed: false, requestRef, taskId: null, taskDir: null,
-        taskState: null, family, artifacts: [], latest: null, next: null,
+        taskState: null, family, artifacts: [], completed: [], latest: null, next: null, openRounds: [],
         reviewedInput: null, diagnostics: [], error, ...extra
     };
 }
@@ -82,19 +101,12 @@ function inspectArtifactDirectory(taskDir, family, identity = {}) {
             taskId: identity.taskId ?? null, taskDir, taskState: identity.taskState ?? null
         });
     }
-    let invalidation = { operations: [], targets: [] };
+    let taskContent;
     try {
-        const taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
-        const parsed = parseInvalidationDocument(taskContent);
-        if (!parsed.ok) {
-            return failure(requestRef, family, { code: 'ARTIFACT_INVALIDATION_INVALID', message: parsed.message }, {
-                taskId: identity.taskId ?? null, taskDir, taskState: identity.taskState ?? null
-            });
-        }
-        invalidation = parsed.document;
+        taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
     }
     catch (error) {
-        return failure(requestRef, family, { code: 'ARTIFACT_INVALIDATION_INVALID', message: String(error) }, {
+        return failure(requestRef, family, { code: 'ARTIFACT_DIRECTORY_READ_FAILED', message: String(error) }, {
             taskId: identity.taskId ?? null, taskDir, taskState: identity.taskState ?? null
         });
     }
@@ -133,8 +145,7 @@ function inspectArtifactDirectory(taskDir, family, identity = {}) {
             }
             const identity = { ...parsed, path: abs, size: stat.size, mtimeMs: stat.mtimeMs };
             knownArtifacts.push(identity);
-            if (!isArtifactInvalidated(invalidation, family, entry.name))
-                artifacts.push(identity);
+            artifacts.push(identity);
         }
         catch (error) {
             diagnostics.push(diagnostic('FILESYSTEM_RACE', family, entry.name, String(error)));
@@ -142,19 +153,32 @@ function inspectArtifactDirectory(taskDir, family, identity = {}) {
     }
     artifacts.sort((left, right) => left.round - right.round);
     knownArtifacts.sort((left, right) => left.round - right.round);
+    const openRounds = openArtifactRounds(taskContent, family);
     const knownRounds = new Set(knownArtifacts.map((item) => item.round));
-    if (knownArtifacts.length > 0 && !knownRounds.has(1))
+    for (const round of openRounds)
+        knownRounds.add(round);
+    const max = Math.max(...knownRounds, 0);
+    if (max > 0 && !knownRounds.has(1))
         diagnostics.push(diagnostic('MISSING_BASE', family, null, `${family}.md is missing`));
-    const max = knownArtifacts.at(-1)?.round ?? 0;
     for (let round = 1; round <= max; round += 1) {
         if (!knownRounds.has(round))
             diagnostics.push(diagnostic('ROUND_GAP', family, null, `${artifactName(family, round)} is missing`));
     }
-    const latest = artifacts.at(-1) ?? null;
+    const event = completionEvent(family);
+    const completed = event
+        ? artifacts.flatMap((artifact) => {
+            const order = artifactCompletionOrder(taskContent, artifact.name, event);
+            return order !== null && hasArtifactCompletionFact(taskContent, artifact.path, event)
+                ? [{ artifact, order }] : [];
+        }).sort((left, right) => left.order - right.order).map(({ artifact }) => artifact)
+        : [];
+    if (openRounds.length > 1)
+        diagnostics.push(diagnostic('MULTIPLE_OPEN_ROUNDS', family, null, `multiple incomplete ${family} rounds are open: ${openRounds.join(', ')}`));
+    const latest = completed.at(-1) ?? null;
     let hasReviewCodeReceipt = false;
     if (family === 'review-code' && latest) {
         try {
-            hasReviewCodeReceipt = Boolean(receiptForOutput(fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8'), latest.name));
+            hasReviewCodeReceipt = Boolean(receiptForOutput(taskContent, latest.name));
         }
         catch {
             hasReviewCodeReceipt = false;
@@ -165,9 +189,9 @@ function inspectArtifactDirectory(taskDir, family, identity = {}) {
         : null;
     return {
         status: 'ready', changed: false, requestRef, taskId: identity.taskId ?? null,
-        taskDir, taskState: identity.taskState ?? null, family, artifacts, latest,
+        taskDir, taskState: identity.taskState ?? null, family, artifacts, completed, latest,
         next: { round: max + 1, name: artifactName(family, max + 1) },
-        reviewedInput, diagnostics, error: null
+        openRounds, reviewedInput, diagnostics, error: null
     };
 }
 function resolveReviewedInput(taskDir, review, expectedFamily, diagnostics) {
@@ -184,11 +208,6 @@ function resolveReviewedInput(taskDir, review, expectedFamily, diagnostics) {
         const stat = fs.lstatSync(abs);
         if (!stat.isFile() || stat.isSymbolicLink())
             throw new Error('referenced input is not a regular file');
-        const invalidation = parseInvalidationDocument(taskContent);
-        if (!invalidation.ok)
-            throw new Error(invalidation.message);
-        if (isArtifactInvalidated(invalidation.document, expectedFamily, input.name))
-            throw new Error(`${input.name} is invalidated`);
         const actualSha256 = sha256File(abs);
         if (actualSha256 !== receipt.inputSha256) {
             throw new Error(`${input.name} content digest does not match receipt`);
@@ -270,11 +289,28 @@ const OPTIONAL_CONTEXT = {
     'manual-validation': ['review-code'],
     'validation-run': ['review-code']
 };
-function hasSelectionEvidence(content, family, options, context) {
+function hasSelectionEvidence(content, family, options, context, pathState) {
     if (options.sourceFinding && options.sourceArtifact && options.sourceSha256)
         return true;
-    if (options.reasonCode === 'new-requirement' || options.reasonCode === 'upstream-fact-doubt')
+    if (options.reasonCode === 'new-requirement' || options.reasonCode === 'upstream-fact-doubt'
+        || family === 'review-code' && options.reasonCode === 'manual-review-supplement')
         return true;
+    if ((family === 'plan' || family === 'code') && context.latest) {
+        const latestInputs = Object.fromEntries(context.inputs.map((input) => [input.family, input.name]));
+        const capturedInputs = receiptsForOutput(content, context.latest.name)
+            .filter((receipt) => receipt.event === `${family}.completed`)
+            .filter((receipt) => {
+            try {
+                return sha256File(path.join(context.taskDir, receipt.input)) === receipt.inputSha256;
+            }
+            catch {
+                return false;
+            }
+        })
+            .map((receipt) => receipt.input);
+        if (!executionInputsMatchLatest(family, pathState, latestInputs, capturedInputs))
+            return true;
+    }
     if (family.startsWith('review-')) {
         const reviewedFamily = family === 'review-analysis' ? 'analysis' : family === 'review-plan' ? 'plan' : 'code';
         const currentInput = context.inputs.find((input) => input.family === reviewedFamily);
@@ -337,16 +373,20 @@ function attachArtifactSelection(context, pathState, options) {
     catch (error) {
         return fail('ARTIFACT_SELECTION_INDETERMINATE', error instanceof Error ? error.message : String(error));
     }
-    const openLatest = context.latest ? hasOpenArtifactRound(taskContent, family, context.latest.round) : false;
-    const openNext = hasOpenArtifactRound(taskContent, family, context.next.round);
-    const open = openLatest || openNext;
-    const selectedIdentity = openLatest ? context.latest : context.next;
+    const openRounds = openArtifactRounds(taskContent, family);
+    if (openRounds.length > 1)
+        return fail('ARTIFACT_TOPOLOGY_CONFLICT', `multiple incomplete ${family} rounds are open: ${openRounds.join(', ')}`);
+    const openRound = openRounds[0] ?? null;
+    const selectedIdentity = openRound === null ? context.next : {
+        family, round: openRound, name: artifactName(family, openRound),
+        path: path.join(context.taskDir, artifactName(family, openRound)), size: 0, mtimeMs: 0
+    };
     try {
-        const hasChangeEvidence = hasSelectionEvidence(taskContent, family, options, context);
+        const hasChangeEvidence = hasSelectionEvidence(taskContent, family, options, context, pathState);
         const selection = selectArtifactDisposition({
             next: { family, round: selectedIdentity.round, name: selectedIdentity.name },
             latest: context.latest,
-            open,
+            open: openRound !== null,
             hasChangeEvidence
         });
         return {
@@ -377,7 +417,8 @@ function resolveArtifactContext(taskRef, family, options = {}) {
             return selected;
         if (selected.selection.disposition === 'reuse')
             return selected;
-        if (selected.codeMode?.mode === 'error') {
+        if (selected.codeMode?.mode === 'error'
+            && selected.codeMode.message.includes('is not captured by the latest code input receipt')) {
             return {
                 ...selected,
                 status: 'ready',
@@ -435,32 +476,42 @@ function resolveCodeContext(inventory, options) {
     if (source.status === 'failed' || !source.latest)
         return contextFailure(inventory, 'ARTIFACT_INPUT_MISSING', `latest ${inputFamily} artifact is required`);
     const reviewCode = inspectTaskArtifacts(taskRef, 'review-code', options);
+    try {
+        const taskContent = fs.readFileSync(path.join(inventory.taskDir, 'task.md'), 'utf8');
+        const hasPendingImplementation = parseImplementationInputs(taskContent).rows.some((input) => input.needsImplementation && input.status === 'pending');
+        if (hasPendingImplementation && !reviewCode.latest) {
+            const candidate = reviewCode.artifacts.at(-1)?.name ?? 'review-code.md';
+            return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', `cannot find completed Activity Log identity for ${candidate}`);
+        }
+    }
+    catch (error) {
+        return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', error instanceof Error ? error.message : String(error));
+    }
     const latestCode = inventory.latest;
-    const codeMax = latestCode?.round ?? 0;
+    const codeMax = inventory.next?.round ? inventory.next.round - 1 : 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) {
+    if (inventory.openRounds.length > 0) {
         try {
             const taskContent = fs.readFileSync(path.join(inventory.taskDir, 'task.md'), 'utf8');
-            if (hasOpenArtifactRound(taskContent, 'code', latestCode.round)) {
-                const review = reviewCode.latest;
-                const openInputs = review ? [...inputs, review] : inputs;
-                const openVerdict = review ? parseVerdict(review.path) : null;
-                const openRow = locateActivityLog(taskContent)
-                    ? startedBackedRows(pairEntries(locateActivityLog(taskContent).entries))
-                        .find((row) => row.step.startsWith(`Code Task (Round ${latestCode.round}`) && !row.done)
-                    : null;
-                const decisionInput = /, decision (II-[1-9]\d*)\)$/u.exec(openRow?.step ?? '')?.[1] ?? null;
-                const fixInput = /, fix for (review-code(?:-r\d+)?\.md)\)$/u.exec(openRow?.step ?? '')?.[1] ?? null;
-                const mode = decisionInput ? 'decision'
-                    : fixInput || (openVerdict?.ok && openVerdict.verdict === 'Changes Requested') ? 'fix'
-                        : 'init';
-                return withCodeMode(inventory, openInputs, 'ready', mode, codeMax, reviewMax, openVerdict?.ok ? openVerdict.verdict : null, fixInput ?? review?.name ?? null, `Resuming open code round ${latestCode.round}.`, decisionInput);
-            }
+            const openRound = inventory.openRounds[0];
+            const review = reviewCode.latest;
+            const openInputs = review ? [...inputs, review] : inputs;
+            const openVerdict = review ? parseVerdict(review.path) : null;
+            const openRow = locateActivityLog(taskContent)
+                ? startedBackedRows(pairEntries(locateActivityLog(taskContent).entries))
+                    .find((row) => row.step.startsWith(`Code Task (Round ${openRound}`) && !row.done)
+                : null;
+            const decisionInput = /, decision (II-[1-9]\d*)\)$/u.exec(openRow?.step ?? '')?.[1] ?? null;
+            const fixInput = /, fix for (review-code(?:-r\d+)?\.md)\)$/u.exec(openRow?.step ?? '')?.[1] ?? null;
+            const mode = decisionInput ? 'decision'
+                : fixInput || (openVerdict?.ok && openVerdict.verdict === 'Changes Requested') ? 'fix'
+                    : 'init';
+            return withCodeMode(inventory, openInputs, 'ready', mode, codeMax, reviewMax, openVerdict?.ok ? openVerdict.verdict : null, fixInput ?? review?.name ?? null, `Resuming open code round ${openRound}.`, decisionInput);
         }
         catch (error) {
             return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', error instanceof Error ? error.message : String(error));
@@ -599,6 +650,13 @@ export function validateArtifactPublication(taskDir, family, name) {
             if (hasCompletedArtifactRound(task, family, existing.round, name)) {
                 return { code: 'ARTIFACT_IDENTITY_INVALID', message: `completed artifact '${name}' is immutable` };
             }
+            const event = completionEvent(family);
+            const frontmatter = parseTypedTaskFrontmatter(task);
+            const completionFactExists = event !== null && parseCompletionFacts(frontmatter.completion_facts)
+                .some((fact) => fact.event === event && fact.output === name);
+            if (event && completionFactExists && artifactCompletionOrder(task, name, event) !== null) {
+                return { code: 'ARTIFACT_IDENTITY_INVALID', message: `completion evidence for '${name}' does not match its current content` };
+            }
         }
         catch (error) {
             return { code: 'ARTIFACT_SELECTION_INDETERMINATE', message: error instanceof Error ? error.message : String(error) };