@fitlab-ai/agent-infra 0.11.8 → 0.11.10

package/dist/lib/task/capabilities.js

@@ -1,7 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { parseArtifactName } from './artifact-name.js';
-import { invalidationBlocks, isArtifactInvalidated, parseInvalidationDocument } from './invalidation.js';
 import { parseArtifactReceipts, receiptForOutput } from './artifact-receipts.js';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
@@ -14,6 +13,8 @@ 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';
+import { inspectArtifactDirectory } from './artifact-lifecycle.js';
+import { executionInputsMatchLatest as executionReceiptsMatchLatest } from './execution-inputs.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'
@@ -52,8 +53,6 @@ function canStart(action, facts, trigger) {
     }
     if (facts.taskState !== 'active')
         return deny('TASK_NOT_ACTIVE', `state=${facts.taskState}`);
-    if (invalidationBlocks(facts.invalidation))
-        return deny('INVALIDATION_INCOMPLETE');
     if (facts.executionBusy)
         return deny('EXECUTION_BUSY');
     const pendingIntent = (facts.reworkIntents ?? []).find((intent) => intent.status === 'pending');
@@ -102,7 +101,9 @@ function canStart(action, facts, trigger) {
         return allow('analysis-review-approved');
     }
     if (action === 'review-plan') {
-        return hasArtifact(facts, 'plan') ? allow('plan-artifact') : deny('PLAN_ARTIFACT_REQUIRED');
+        if (!hasArtifact(facts, 'plan'))
+            return deny('PLAN_ARTIFACT_REQUIRED');
+        return executionInputsMatchLatest(facts, 'plan') ? allow('plan-artifact') : deny('PLAN_INPUT_STALE');
     }
     if (action === 'code') {
         if (trigger.implementationInput) {
@@ -141,11 +142,15 @@ function canStart(action, facts, trigger) {
         return allow('plan-review-approved');
     }
     if (action === 'review-code') {
+        if (hasArtifact(facts, 'code') && !executionInputsMatchLatest(facts, 'code'))
+            return deny('CODE_INPUT_STALE');
         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 (!executionInputsMatchLatest(facts, 'code'))
+            return deny('CODE_INPUT_STALE');
         if (hasArtifact(facts, 'code') && !reviewMatchesLatest(facts, 'code', 'review-code'))
             return deny('CODE_REVIEW_NOT_LATEST');
         if (!facts.reviewCodeIdentityValid)
@@ -159,13 +164,22 @@ function canStart(action, facts, trigger) {
     return deny('CAPABILITY_ACTION_UNKNOWN');
 }
 function latestArtifact(names) {
-    return names.map(parseArtifactName).filter((identity) => identity !== null)
-        .sort((left, right) => right.round - left.round || left.name.localeCompare(right.name))[0]?.name ?? null;
+    return names.at(-1) ?? null;
 }
 function reviewMatchesLatest(facts, source, review) {
     const latestSource = latestArtifact(facts.artifacts[source] ?? []);
     return Boolean(latestSource && facts.reviewedInputs?.[review] === latestSource);
 }
+function executionInputsMatchLatest(facts, stage) {
+    if (!facts.pathState || facts.pathState.status !== 'valid' || facts.executionInputs === undefined)
+        return true;
+    return executionReceiptsMatchLatest(stage, facts.pathState, {
+        analysis: latestArtifact(facts.artifacts.analysis ?? []) ?? undefined,
+        'review-analysis': latestArtifact(facts.artifacts['review-analysis'] ?? []) ?? undefined,
+        plan: latestArtifact(facts.artifacts.plan ?? []) ?? undefined,
+        'review-plan': latestArtifact(facts.artifacts['review-plan'] ?? []) ?? undefined
+    }, facts.executionInputs[stage] ?? []);
+}
 function qualificationCandidateSnapshotMatches(audit, qualification) {
     const current = new Map(qualification.candidates.map((candidate) => [candidate.candidateId, candidate]));
     return audit.candidateQualifications.length === current.size && audit.candidateQualifications.every((row) => {
@@ -201,6 +215,8 @@ function recommendNext(facts) {
             }
             if (stage === 'plan' && !hasArtifact(facts, stage))
                 return { action: stage, reasonCode: 'PLAN_ARTIFACT_MISSING', evidence: ['plan artifact is absent'] };
+            if (stage === 'plan' && !executionInputsMatchLatest(facts, stage))
+                return { action: stage, reasonCode: 'PLAN_INPUT_STALE', evidence: ['latest plan does not record the current selected analysis inputs'] };
             if (stage === 'review-plan' && (!reviewMatchesLatest(facts, 'plan', stage) || facts.reviews[stage] !== 'approved')) {
                 if (facts.reviews[stage] === 'changes-requested' && facts.resolvedHumanDecisions?.plan === 'review') {
                     return { action: stage, reasonCode: 'HUMAN_DECISION_REVIEW_REQUIRED', evidence: ['plan decision was resolved'] };
@@ -211,6 +227,8 @@ function recommendNext(facts) {
             }
             if (stage === 'code' && !hasArtifact(facts, stage))
                 return { action: stage, reasonCode: 'CODE_ARTIFACT_MISSING', evidence: ['code artifact is absent'] };
+            if (stage === 'code' && !executionInputsMatchLatest(facts, stage))
+                return { action: stage, reasonCode: 'CODE_INPUT_STALE', evidence: ['latest code does not record the current selected execution inputs'] };
             if (stage === 'review-code' && (!reviewMatchesLatest(facts, 'code', stage) || facts.reviews[stage] !== 'approved')) {
                 if (facts.reviews[stage] === 'changes-requested' && facts.resolvedHumanDecisions?.code) {
                     return facts.resolvedHumanDecisions.code === 'implementation'
@@ -234,6 +252,8 @@ function recommendNext(facts) {
     }
     if (!hasArtifact(facts, 'plan'))
         return { action: 'plan', reasonCode: 'PLAN_ARTIFACT_MISSING', evidence: ['plan artifact is absent'] };
+    if (!executionInputsMatchLatest(facts, 'plan'))
+        return { action: 'plan', reasonCode: 'PLAN_INPUT_STALE', evidence: ['latest plan does not record the current selected analysis inputs'] };
     if (!hasArtifact(facts, 'review-plan') || !reviewMatchesLatest(facts, 'plan', 'review-plan')) {
         return { action: 'review-plan', reasonCode: 'PLAN_REVIEW_MISSING', evidence: ['plan review does not bind the latest plan artifact'] };
     }
@@ -242,6 +262,8 @@ function recommendNext(facts) {
     }
     if (!hasArtifact(facts, 'code'))
         return { action: 'code', reasonCode: 'CODE_ARTIFACT_MISSING', evidence: ['code artifact is absent'] };
+    if (!executionInputsMatchLatest(facts, 'code'))
+        return { action: 'code', reasonCode: 'CODE_INPUT_STALE', evidence: ['latest code does not record the current selected execution inputs'] };
     if (!hasArtifact(facts, 'review-code') || !reviewMatchesLatest(facts, 'code', 'review-code')) {
         return { action: 'review-code', reasonCode: 'CODE_REVIEW_MISSING', evidence: ['code review does not bind the latest code artifact'] };
     }
@@ -253,9 +275,6 @@ function recommendNext(facts) {
 function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBusy = false) {
     try {
         const metadata = parseTypedTaskFrontmatter(content);
-        const invalidation = parseInvalidationDocument(content);
-        if (!invalidation.ok)
-            return { ok: false, code: 'TASK_CAPABILITY_FACTS_INVALID', message: invalidation.message };
         const rework = parseReworkIntentDocument(content);
         if (!rework.ok)
             return { ok: false, code: 'TASK_CAPABILITY_FACTS_INVALID', message: rework.message };
@@ -276,22 +295,38 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
             const family = parseArtifactName(name)?.family;
             return artifactFamilies.find((candidate) => candidate === family) ?? null;
         };
-        const activeFiles = files.filter((name) => {
-            const family = familyFor(name);
-            return !family || !isArtifactInvalidated(invalidation.document, family, name);
-        });
         const allArtifactHashes = {};
         for (const name of files)
             allArtifactHashes[name] = sha256File(path.join(taskDir, name));
         const artifactHashes = {};
-        for (const name of activeFiles)
+        for (const name of files)
             artifactHashes[name] = allArtifactHashes[name];
+        const completedByFamily = new Map();
+        for (const family of artifactFamilies) {
+            const inventory = inspectArtifactDirectory(taskDir, family);
+            if (inventory.status !== 'ready')
+                continue;
+            completedByFamily.set(family, inventory.completed.map((artifact) => artifact.name));
+        }
+        const completedFiles = new Set([...completedByFamily.values()].flat());
+        const activeFiles = [
+            ...files.filter((name) => !familyFor(name)),
+            ...artifactFamilies.flatMap((family) => completedByFamily.get(family) ?? [])
+        ];
         const artifacts = Object.fromEntries(artifactFamilies.map((family) => [
             family, activeFiles.filter((name) => familyFor(name) === family)
         ]));
-        const staleArtifacts = Object.fromEntries(artifactFamilies.map((family) => [
-            family, files.filter((name) => familyFor(name) === family && isArtifactInvalidated(invalidation.document, family, name))
-        ]));
+        const receipts = parseArtifactReceipts(content).rows;
+        const executionInputs = {};
+        for (const family of ['plan', 'code']) {
+            const output = latestArtifact(artifacts[family] ?? []);
+            if (!output)
+                continue;
+            executionInputs[family] = receipts.filter((receipt) => receipt.output === output
+                && receipt.event === `${family}.completed`
+                && completedFiles.has(receipt.input)
+                && artifactHashes[receipt.input] === receipt.inputSha256).map((receipt) => receipt.input);
+        }
         const qualification = parseTaskQualification(content);
         if (!qualification.ok)
             return { ok: false, code: 'TASK_CAPABILITY_FACTS_INVALID', message: qualification.message };
@@ -362,9 +397,8 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
                 reviews[family] = verdict.verdict === 'Approved' ? 'approved' : verdict.verdict === 'Changes Requested' ? 'changes-requested' : 'rejected';
         }
         const reworkClassificationRequired = [];
-        const receipts = parseArtifactReceipts(content).rows;
         for (const [reviewFamily, stage] of [['review-analysis', 'analysis'], ['review-plan', 'plan'], ['review-code', 'code']]) {
-            const cycles = receipts.filter((receipt) => receipt.event === `${reviewFamily}.completed` && files.includes(receipt.output)
+            const cycles = receipts.filter((receipt) => receipt.event === `${reviewFamily}.completed` && completedFiles.has(receipt.output)
                 && allArtifactHashes[receipt.input] === receipt.inputSha256).map((receipt) => {
                 const parsed = parseReviewSummary(fs.readFileSync(path.join(taskDir, receipt.output), 'utf8'));
                 const verdict = parsed.ok ? resolveCanonicalVerdict(parsed.summary) : null;
@@ -415,8 +449,8 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
         }
         const facts = {
             taskState, currentStep: String(metadata.current_step ?? ''), artifacts, reviews,
-            staleArtifacts, reviewedInputs, artifactHashes,
-            invalidation: invalidation.document, reworkIntents: rework.intents,
+            reviewedInputs, executionInputs, artifactHashes,
+            reworkIntents: rework.intents,
             unresolvedLedger,
             executionBusy: executionBusy || hasOpenLifecycleExecution(content),
             recommendedAction: null,

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

@@ -11,8 +11,6 @@ import { getOpenWorkflowWarnings, formatWorkflowWarningSummary } from '../workfl
 import { parseActivityLog, pairEntries, startedBackedRows } from '../activity-log.js';
 import { readRun } from '../orchestration.js';
 import { statusCard } from '../../server/display.js';
-import { invalidationBlocks, parseInvalidationDocument } from '../invalidation.js';
-import { parseReworkIntentDocument } from '../rework-intent.js';
 import { buildLifecycleFacts, recommendNext } from '../capabilities.js';
 const USAGE = `Usage: ai task status [--task <ref> | -t <ref>]
 
@@ -320,11 +318,6 @@ function renderStatus(model) {
     else {
         lines.push(...renderPairs(model.artifacts.groups.map((group) => [group.stage, group.files.join(', ')])));
     }
-    lines.push('', 'Invalidation', ...renderPairs([
-        ['status', model.invalidation?.status ?? 'unknown'],
-        ['processed', `${model.invalidation?.processed ?? 0}/${model.invalidation?.total ?? 0}`],
-        ['pending_intents', String(model.invalidation?.pendingIntents ?? 0)]
-    ]));
     lines.push('', 'Recommendation', ...renderPairs([
         ['path', model.lifecyclePath ?? DASH],
         ['action', model.recommendation ?? DASH],
@@ -374,10 +367,6 @@ function renderStatus(model) {
     return lines;
 }
 function modelTone(model) {
-    if (model.invalidation?.status === 'invalid')
-        return 'danger';
-    if (model.invalidation?.status === 'pending' || model.invalidation?.status === 'in-progress')
-        return 'warning';
     if (model.orchestration.status === 'paused')
         return 'warning';
     if (model.orchestration.status === 'running')
@@ -399,21 +388,6 @@ function buildFromResolved(input) {
     const run = input.run ?? makeRunner(input.repoRoot);
     const artifacts = enumerateArtifacts(input.taskDir);
     const workflow = collectWorkflow(content, input.now);
-    const invalidation = parseInvalidationDocument(content);
-    const rework = parseReworkIntentDocument(content);
-    const pendingIntents = rework.ok ? rework.intents.filter((intent) => intent.status === 'pending').length : 0;
-    const invalidationInfo = !invalidation.ok
-        ? { status: 'invalid', processed: 0, total: 0, pendingIntents }
-        : {
-            status: invalidation.present
-                ? invalidationBlocks(invalidation.document)
-                    ? invalidation.document.operations.some((operation) => operation.status === 'in-progress') ? 'in-progress' : 'pending'
-                    : 'completed'
-                : 'none',
-            processed: invalidation.document.operations.reduce((sum, operation) => sum + operation.processed, 0),
-            total: invalidation.document.operations.reduce((sum, operation) => sum + operation.total, 0),
-            pendingIntents
-        };
     const facts = buildLifecycleFacts(input.taskDir, content, fm.status ?? 'active');
     const next = facts.ok ? recommendNext(facts.facts) : null;
     const recommendation = next?.action ?? DASH;
@@ -427,7 +401,6 @@ function buildFromResolved(input) {
         workflow,
         runtime: collectRuntime(input.taskDir, workflow, run),
         orchestration: collectOrchestration(input.taskDir),
-        invalidation: invalidationInfo,
         recommendation,
         recommendationReason: next?.reasonCode ?? 'TASK_CAPABILITY_FACTS_INVALID',
         lifecyclePath: facts.ok && facts.facts.pathState?.status === 'valid' ? facts.facts.pathState.decision.path : facts.ok ? facts.facts.pathState?.status ?? DASH : DASH,

package/dist/lib/task/commit-identity.js

@@ -6,19 +6,34 @@ function gitText(repoRoot, args) {
         stdio: ['ignore', 'pipe', 'pipe']
     }).trim();
 }
+function gitOutput(repoRoot, args) {
+    return execFileSync('git', [...args], {
+        cwd: repoRoot,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe']
+    });
+}
+function commitPaths(repoRoot, head, pathspec) {
+    const args = ['diff-tree', '--no-commit-id', '--name-only', '-r', '-z', head];
+    if (pathspec && pathspec.length > 0)
+        args.push('--', ...pathspec);
+    return gitOutput(repoRoot, args).split('\0').filter(Boolean).sort();
+}
+function canonicalMessage(message) {
+    return message.replace(/\r\n/g, '\n').replace(/\n+$/, '');
+}
 function checkpointCommitMatches(repoRoot, intent, head) {
     try {
         const parent = gitText(repoRoot, ['rev-parse', `${head}^`]);
         const tree = gitText(repoRoot, ['rev-parse', `${head}^{tree}`]);
-        const message = gitText(repoRoot, ['show', '-s', '--format=%s', head]);
-        const changed = gitText(repoRoot, ['diff-tree', '--no-commit-id', '--name-only', '-r', head])
-            .split('\n')
-            .filter(Boolean)
-            .sort();
+        const message = canonicalMessage(gitOutput(repoRoot, ['show', '-s', '--format=%B', head]));
+        const changed = commitPaths(repoRoot, head);
+        const selected = commitPaths(repoRoot, head, intent.paths);
         return parent === intent.expectedHead
             && tree === intent.expectedTree
-            && message === intent.message
-            && JSON.stringify(changed) === JSON.stringify([...intent.paths].sort());
+            && message === canonicalMessage(intent.message)
+            && changed.length > 0
+            && JSON.stringify(changed) === JSON.stringify(selected);
     }
     catch {
         return false;

package/dist/lib/task/commit-intent.js

@@ -1,11 +1,18 @@
-import { createHash } from 'node:crypto';
+import { createHash, randomBytes } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
-function intentRoot(repoRoot) {
-    return path.join(repoRoot, '.agents', 'workspace', '.task-commit-intents');
+const MAX_INTENT_SIZE = 1024 * 1024;
+const TASK_ID_PATTERN = /^TASK-\d{8}-\d{6}$/;
+function intentPath(taskDir) {
+    return path.join(taskDir, '.checkpoint-intent.json');
 }
-function intentPath(repoRoot, taskId) {
-    return path.join(intentRoot(repoRoot), `${taskId}.json`);
+function assertTaskDirectory(taskDir, taskId) {
+    if (!TASK_ID_PATTERN.test(taskId) || path.basename(path.resolve(taskDir)) !== taskId) {
+        throw new Error('COMMIT_INTENT_INVALID: task directory does not match task ID');
+    }
+    const stat = fs.statSync(taskDir);
+    if (!stat.isDirectory())
+        throw new Error('COMMIT_INTENT_INVALID: task directory is not a directory');
 }
 function checkpointIntentDigest(identity) {
     return createHash('sha256').update(JSON.stringify({
@@ -23,8 +30,13 @@ function isIntent(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         return false;
     const intent = value;
+    const validState = ['prepared', 'committed', 'synced'].includes(String(intent.state));
+    const validHead = intent.committedHead === null
+        ? intent.state === 'prepared'
+        : typeof intent.committedHead === 'string' && /^[a-f0-9]{40,64}$/.test(intent.committedHead)
+            && intent.state !== 'prepared';
     return intent.version === 1
-        && typeof intent.taskId === 'string' && intent.taskId.length > 0
+        && typeof intent.taskId === 'string' && TASK_ID_PATTERN.test(intent.taskId)
         && typeof intent.branch === 'string' && intent.branch.length > 0
         && intent.mode === 'local'
         && typeof intent.expectedHead === 'string' && /^[a-f0-9]{40,64}$/.test(intent.expectedHead)
@@ -33,28 +45,57 @@ function isIntent(value) {
         && typeof intent.message === 'string' && intent.message.length > 0
         && Number.isSafeInteger(intent.round) && Number(intent.round) > 0
         && typeof intent.digest === 'string' && /^[a-f0-9]{64}$/.test(intent.digest)
-        && ['prepared', 'committed', 'synced'].includes(String(intent.state))
-        && (intent.committedHead === null || (typeof intent.committedHead === 'string' && /^[a-f0-9]{40,64}$/.test(intent.committedHead)))
+        && validState && validHead
         && typeof intent.createdAt === 'string' && intent.createdAt.length > 0
         && typeof intent.updatedAt === 'string' && intent.updatedAt.length > 0
         && intent.digest === checkpointIntentDigest(intent);
 }
-function readCheckpointIntent(repoRoot, taskId) {
-    const target = intentPath(repoRoot, taskId);
-    if (!fs.existsSync(target))
-        return null;
-    const value = JSON.parse(fs.readFileSync(target, 'utf8'));
-    if (!isIntent(value))
-        throw new Error('COMMIT_INTENT_INVALID: checkpoint intent schema is invalid');
-    return value;
+function invalidIntent() {
+    throw new Error('COMMIT_INTENT_INVALID: checkpoint intent schema is invalid');
+}
+function readCheckpointIntent(taskDir, taskId) {
+    assertTaskDirectory(taskDir, taskId);
+    const target = intentPath(taskDir);
+    let before;
+    try {
+        before = fs.lstatSync(target);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+    if (!before.isFile() || before.isSymbolicLink() || before.size > MAX_INTENT_SIZE)
+        return invalidIntent();
+    let descriptor;
+    try {
+        const noFollow = typeof fs.constants.O_NOFOLLOW === 'number' ? fs.constants.O_NOFOLLOW : 0;
+        descriptor = fs.openSync(target, fs.constants.O_RDONLY | noFollow);
+        const opened = fs.fstatSync(descriptor);
+        if (!opened.isFile() || opened.dev !== before.dev || opened.ino !== before.ino
+            || opened.size !== before.size || opened.size > MAX_INTENT_SIZE)
+            return invalidIntent();
+        const value = JSON.parse(fs.readFileSync(descriptor, 'utf8'));
+        if (!isIntent(value) || value.taskId !== taskId)
+            return invalidIntent();
+        return value;
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith('COMMIT_INTENT_INVALID:'))
+            throw error;
+        return invalidIntent();
+    }
+    finally {
+        if (descriptor !== undefined)
+            fs.closeSync(descriptor);
+    }
 }
-function writeCheckpointIntent(repoRoot, value) {
+function writeCheckpointIntent(taskDir, value) {
+    assertTaskDirectory(taskDir, value.taskId);
     if (!isIntent(value))
-        throw new Error('COMMIT_INTENT_INVALID: checkpoint intent schema is invalid');
-    const directory = intentRoot(repoRoot);
-    fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
-    const target = intentPath(repoRoot, value.taskId);
-    const temporary = `${target}.${process.pid}.${Date.now()}.tmp`;
+        return invalidIntent();
+    const target = intentPath(taskDir);
+    const temporary = `${target}.${process.pid}.${randomBytes(8).toString('hex')}.tmp`;
     fs.writeFileSync(temporary, `${JSON.stringify(value)}\n`, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
     try {
         fs.renameSync(temporary, target);
@@ -75,10 +116,10 @@ function updateCheckpointIntent(value, patch) {
         throw new Error('COMMIT_INTENT_INVALID: committed intent requires a committed head');
     return next;
 }
-function removeCheckpointIntent(repoRoot, taskId) {
-    const target = intentPath(repoRoot, taskId);
+function removeCheckpointIntent(taskDir, taskId) {
+    assertTaskDirectory(taskDir, taskId);
     try {
-        fs.unlinkSync(target);
+        fs.unlinkSync(intentPath(taskDir));
     }
     catch (error) {
         if (error.code !== 'ENOENT')
@@ -96,5 +137,5 @@ function sameCheckpointIntent(left, right) {
         && left.round === right.round
         && JSON.stringify(left.paths) === JSON.stringify(right.paths);
 }
-export { checkpointIntentDigest, intentPath, intentRoot, isIntent, readCheckpointIntent, removeCheckpointIntent, sameCheckpointIntent, updateCheckpointIntent, writeCheckpointIntent };
+export { checkpointIntentDigest, intentPath, isIntent, readCheckpointIntent, removeCheckpointIntent, sameCheckpointIntent, updateCheckpointIntent, writeCheckpointIntent };
 //# sourceMappingURL=commit-intent.js.map

package/dist/lib/task/commit-operation.js

@@ -206,7 +206,7 @@ function executeUnlocked(input, task, mode) {
         ? (() => {
             const identity = checkpointIdentity(input, task, delivery);
             try {
-                pendingIntent = readCheckpointIntent(task.repoRoot, task.taskId);
+                pendingIntent = readCheckpointIntent(task.taskDir, task.taskId);
             }
             catch (error) {
                 return {
@@ -215,6 +215,11 @@ function executeUnlocked(input, task, mode) {
                 };
             }
             if (pendingIntent && !sameCheckpointIntent(pendingIntent, identity)) {
+                if (pendingIntent.state !== 'prepared')
+                    return {
+                        status: 'failed', changed: false, snapshot: inspected.snapshot, operations: [],
+                        error: { code: 'COMMIT_INTENT_INVALID', message: 'A committed checkpoint intent must be recovered with its original request' }
+                    };
                 const timestamp = checkpointTimestamp();
                 pendingIntent = {
                     version: 1, ...identity,
@@ -222,7 +227,7 @@ function executeUnlocked(input, task, mode) {
                     state: 'prepared', committedHead: null, createdAt: timestamp, updatedAt: timestamp
                 };
                 try {
-                    writeCheckpointIntent(task.repoRoot, pendingIntent);
+                    writeCheckpointIntent(task.taskDir, pendingIntent);
                 }
                 catch (error) {
                     return {
@@ -231,6 +236,12 @@ function executeUnlocked(input, task, mode) {
                     };
                 }
             }
+            if (pendingIntent && pendingIntent.state !== 'prepared'
+                && !checkpointCommitMatches(task.repoRoot, pendingIntent, pendingIntent.committedHead))
+                return {
+                    status: 'failed', changed: false, snapshot: inspected.snapshot, operations: [],
+                    error: { code: 'COMMIT_INTENT_INVALID', message: 'Committed checkpoint intent does not match its Git commit' }
+                };
             if (!pendingIntent) {
                 const timestamp = checkpointTimestamp();
                 pendingIntent = {
@@ -238,7 +249,7 @@ function executeUnlocked(input, task, mode) {
                     committedHead: null, createdAt: timestamp, updatedAt: timestamp
                 };
                 try {
-                    writeCheckpointIntent(task.repoRoot, pendingIntent);
+                    writeCheckpointIntent(task.taskDir, pendingIntent);
                 }
                 catch (error) {
                     return {
@@ -264,7 +275,7 @@ function executeUnlocked(input, task, mode) {
                 pendingIntent = updateCheckpointIntent(pendingIntent, {
                     state: 'committed', committedHead: checkpointCommittedHead, updatedAt: checkpointTimestamp()
                 });
-                writeCheckpointIntent(task.repoRoot, pendingIntent);
+                writeCheckpointIntent(task.taskDir, pendingIntent);
                 return {
                     status: 'no-op', changed: false, snapshot: inspected.snapshot,
                     operations: [{ name: 'commit', status: 'no-op' }], error: null
@@ -284,10 +295,10 @@ function executeUnlocked(input, task, mode) {
                 pendingIntent = updateCheckpointIntent(pendingIntent, {
                     state: 'committed', committedHead: checkpointCommittedHead, updatedAt: checkpointTimestamp()
                 });
-                writeCheckpointIntent(task.repoRoot, pendingIntent);
+                writeCheckpointIntent(task.taskDir, pendingIntent);
             }
             else if (created.status === 'no-op') {
-                removeCheckpointIntent(task.repoRoot, task.taskId);
+                removeCheckpointIntent(task.taskDir, task.taskId);
                 pendingIntent = null;
             }
             return created;
@@ -377,8 +388,8 @@ function executeUnlocked(input, task, mode) {
             const synced = updateCheckpointIntent(pendingIntent, {
                 state: 'synced', committedHead: checkpointCommittedHead, updatedAt: checkpointTimestamp()
             });
-            writeCheckpointIntent(task.repoRoot, synced);
-            removeCheckpointIntent(task.repoRoot, task.taskId);
+            writeCheckpointIntent(task.taskDir, synced);
+            removeCheckpointIntent(task.taskDir, task.taskId);
         }
     }
     return {

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

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import { canonicalSemanticDigest } from './artifact-operations.js';
-import { inspectActivityLog } from './activity-log.js';
+import { inspectActivityLog, pairEntries } from './activity-log.js';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { parseArtifactName } from './artifact-name.js';
 import { sha256File } from './artifact-receipts.js';
@@ -39,18 +39,40 @@ export function hasArtifactCompletionFact(taskContent, artifactPath, event) {
     }
 }
 export function hasArtifactCompletionLog(taskContent, artifact, event) {
+    return artifactCompletionOrder(taskContent, artifact, event) !== null;
+}
+/** Returns the stable Activity Log position of a paired completion row. */
+export function artifactCompletionOrder(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;
+        return null;
+    const family = event === 'analysis.completed' || event === 'analyze.completed' ? 'analysis'
+        : event === 'review-analysis.completed' ? 'review-analysis'
+            : event === 'plan.completed' ? 'plan'
+                : event === 'review-plan.completed' ? 'review-plan'
+                    : event === 'code.completed' ? 'code'
+                        : event === 'review-code.completed' ? 'review-code' : null;
+    if (!family || family !== identity.family)
+        return null;
+    const action = family === 'analysis' ? 'Analyze Task'
+        : family === 'review-analysis' ? 'Review Analysis'
+            : family === 'plan' ? 'Plan Task'
+                : family === 'review-plan' ? 'Review Plan'
+                    : family === 'code' ? 'Code Task' : 'Review Code';
     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}`));
+        return null;
+    const ordered = section.entries.map((entry, sourceOrder) => ({ entry, sourceOrder }))
+        .sort((left, right) => Date.parse(left.entry.time.replace(' ', 'T')) - Date.parse(right.entry.time.replace(' ', 'T')) || left.sourceOrder - right.sourceOrder);
+    const entries = ordered.map(({ entry }) => entry);
+    const roundPattern = new RegExp(`^${action} \\(Round ${identity.round}(?:, [^)]+)?\\)$`);
+    const row = pairEntries(entries).find((candidate) => candidate.started !== ''
+        && candidate.done !== '' && roundPattern.test(candidate.step)
+        && candidate.note.includes(`→ ${artifact}`));
+    if (!row)
+        return null;
+    const doneIndex = ordered.findIndex(({ entry }) => entry.time === row.done
+        && entry.step === row.step && entry.note === row.note);
+    return doneIndex < 0 ? null : doneIndex;
 }
 //# sourceMappingURL=completion-facts.js.map

package/dist/lib/task/control-authority.js

@@ -4,7 +4,7 @@ import { normalizeAgentToken } from '../agent-clients/tokens.js';
 import { isAgentClientId } from '../agent-clients/types.js';
 import { getAgentClientAdapter } from '../agent-clients/registry.js';
 import { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, awaitOrchestrationDelegationActivation, beginOrResumeOrchestration, dispatchOrchestrationDelegation, OrchestrationStateError, pauseOrchestration, prepareOrchestrationDelegation, recoverPreparedOrchestrationDelegation, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, statusOrchestration } from './orchestration.js';
-import { applyTaskFinalization, commitPreparedTaskFinalization } from './finalization.js';
+import { applyTaskFinalization } from './finalization.js';
 import { applyTaskLifecycle, taskLifecycleFailure } from './lifecycle.js';
 import { resolveTaskRef, TASK_ID_RE } from './resolve-ref.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
@@ -434,12 +434,10 @@ export function dispatchTaskControlOperation(context, operation) {
     }
     if (operation.family === 'task-finalization') {
         operationTaskId(context, operation.request.taskRef);
-        const finalize = context.source === 'sandbox-executor' ? commitPreparedTaskFinalization : applyTaskFinalization;
-        return finalize(operation.request, {
+        return applyTaskFinalization(operation.request, {
             repoRoot: context.repoRoot,
             ...(context.source === 'sandbox-executor' ? {
                 controlBinding: { generation: context.generation, requestId: context.requestId },
-                handoffDirectory: context.handoffDirectory,
                 manifestPath: context.manifestPath
             } : {}),
             preflight: (request, options) => verifyTaskEvent({ ...request, event: 'complete-task.hard-preflight' }, options)

package/dist/lib/task/current-contract.js

@@ -1,7 +1,6 @@
 import { isValidAgentInfraVersion } from '../version.js';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, validateLedgerRows } from './ledger.js';
-import { parseInvalidationDocument } from './invalidation.js';
 function validateCurrentTaskContract(content) {
     let metadata;
     try {
@@ -30,10 +29,7 @@ function validateCurrentTaskContract(content) {
     const invalid = validateLedgerRows(ledger.rows);
     if (invalid)
         return { ok: false, code: 'TASK_CURRENT_CONTRACT_INVALID', message: `${invalid.code}: ${invalid.message}` };
-    const invalidation = parseInvalidationDocument(content);
-    if (!invalidation.ok)
-        return { ok: false, code: 'TASK_CURRENT_CONTRACT_INVALID', message: `${invalidation.code}: ${invalidation.message}` };
-    return { ok: true, metadata, ledger, invalidation: invalidation.document };
+    return { ok: true, metadata, ledger };
 }
 export { validateCurrentTaskContract };
 //# sourceMappingURL=current-contract.js.map