@fitlab-ai/agent-infra 0.11.9 → 0.11.10

package/dist/lib/task/platform-operation-journal.js

@@ -4,7 +4,6 @@ import { createHash, randomUUID } from 'node:crypto';
 import { isResourceIdentity } from '../platform/resource-identity.js';
 import { resolveTaskRef } from './resolve-ref.js';
 const JOURNAL_FILE = '.platform-operations.json';
-const MAX_ATTEMPTS = 3;
 function operationId(input) {
     return createHash('sha256')
         .update(`${input.kind}\0${input.target}\0${input.expectedDigest}`)
@@ -36,8 +35,7 @@ function parseJournal(file, taskId) {
             || !/^[a-f0-9]{64}$/u.test(item.expectedDigest)
             || !['deferred', 'required'].includes(item.dependency)
             || !['queued', 'pending', 'unknown', 'succeeded', 'failed'].includes(item.state)
-            || !Number.isSafeInteger(item.attempts) || item.attempts < 0 || item.attempts > MAX_ATTEMPTS
-            || item.maxAttempts !== MAX_ATTEMPTS
+            || !Number.isSafeInteger(item.attempts) || item.attempts < 0
             || !(item.lastCode === null || typeof item.lastCode === 'string')
             || (item.kind === 'issue-metadata'
                 ? !item.issueMetadata || typeof item.issueMetadata.requirements !== 'boolean'
@@ -120,7 +118,13 @@ function recordPlatformOperation(input) {
     const { taskId, file } = resolveJournal(input.taskRef, input.cwd);
     const journal = parseJournal(file, taskId);
     const id = operationId(input);
-    const previous = journal.operations.find((item) => item.id === id);
+    const targetIndex = journal.operations.findIndex((item) => item.id === id);
+    const replacementIndex = input.replaceOperationId
+        ? journal.operations.findIndex((item) => item.id === input.replaceOperationId)
+        : -1;
+    const target = targetIndex >= 0 ? journal.operations[targetIndex] : undefined;
+    const replacement = replacementIndex >= 0 ? journal.operations[replacementIndex] : undefined;
+    const previousAttempts = Math.max(target?.attempts ?? 0, replacement?.attempts ?? 0);
     const next = {
         id,
         kind: input.kind,
@@ -128,8 +132,7 @@ function recordPlatformOperation(input) {
         expectedDigest: input.expectedDigest,
         dependency: input.dependency,
         state: input.state,
-        attempts: Math.min(MAX_ATTEMPTS, (previous?.attempts ?? 0) + (input.state === 'pending' ? 1 : 0)),
-        maxAttempts: MAX_ATTEMPTS,
+        attempts: previousAttempts + (input.state === 'pending' ? 1 : 0),
         lastCode: input.lastCode ?? null,
         ...(input.issueMetadata ? { issueMetadata: input.issueMetadata } : {}),
         ...(input.issueCreate ? { issueCreate: input.issueCreate } : {}),
@@ -138,9 +141,13 @@ function recordPlatformOperation(input) {
         ...(input.pullRequestReview ? { pullRequestReview: input.pullRequestReview } : {}),
         updatedAt: new Date().toISOString()
     };
-    const operations = previous
-        ? journal.operations.map((item) => item.id === id ? next : item)
-        : [...journal.operations, next];
+    const operations = replacementIndex >= 0
+        ? journal.operations.flatMap((item, index) => index === replacementIndex
+            ? [next]
+            : index === targetIndex ? [] : [item])
+        : targetIndex >= 0
+            ? journal.operations.map((item, index) => index === targetIndex ? next : item)
+            : [...journal.operations, next];
     writeJournal(file, { version: 1, taskId, operations });
     return next;
 }
@@ -148,5 +155,5 @@ function readPlatformOperationJournal(taskRef, cwd) {
     const { taskId, file } = resolveJournal(taskRef, cwd);
     return parseJournal(file, taskId);
 }
-export { JOURNAL_FILE as PLATFORM_OPERATION_JOURNAL_FILE, MAX_ATTEMPTS as PLATFORM_OPERATION_MAX_ATTEMPTS, operationId, recordPlatformOperation, readPlatformOperationJournal };
+export { JOURNAL_FILE as PLATFORM_OPERATION_JOURNAL_FILE, operationId, recordPlatformOperation, readPlatformOperationJournal };
 //# sourceMappingURL=platform-operation-journal.js.map

package/dist/lib/task/platform-operation-recovery.js

@@ -18,6 +18,8 @@ import { canonicalizeSummaryBody } from '../platform/comment-safety.js';
 import { platformResult } from '../platform/types.js';
 import { resolveTaskRef } from './resolve-ref.js';
 import { readPlatformOperationJournal, recordPlatformOperation } from './platform-operation-journal.js';
+import { providerErrorRetryable } from '../platform/provider-validation.js';
+const DEFAULT_RECOVERY_ATTEMPTS = 3;
 function labelsMatchOwnedPrefix(actual, expected, prefix) {
     return actual.filter((label) => label.startsWith(prefix)).sort().join('\0')
         === expected.filter((label) => label.startsWith(prefix)).sort().join('\0');
@@ -26,7 +28,7 @@ function fieldsMatchExpected(actual, expected) {
     return Object.entries(expected).every(([name, value]) => actual[name] === value);
 }
 function result(status, recovered, pending, error = null) {
-    return { status, changed: recovered.length > 0, recovered, pending, error };
+    return { status, changed: recovered.length > 0, recovered, pending, error: error ? { code: error.code, message: error.message } : null };
 }
 function summaryPayload(taskDir, taskId) {
     const file = path.join(taskDir, '.delivery-summary.json');
@@ -198,7 +200,7 @@ async function replayPullRequestSummary(taskId, operation, agent, cwd, client) {
         ? await resolved.value.provider.comments.list({ context: providerOperationContext(resolved.value), parent: identity })
         : unsupportedProviderOperation(resolved.value.provider, 'comments.list');
     if (!listed.ok)
-        return platformResult(listed.error.retryable ? 'blocked' : 'failed', { error: providerError(listed.error, 'PLATFORM_PROVIDER_OPERATION_FAILED') });
+        return platformResult(providerErrorRetryable(listed.error.code) ? 'blocked' : 'failed', { error: providerError(listed.error, 'PLATFORM_PROVIDER_OPERATION_FAILED') });
     const marker = `<!-- sync-pr:${taskId}:summary -->`;
     const summaries = listed.value.filter((comment) => normalizeCommentContent(comment.body).split('\n', 1)[0] === marker);
     if (summaries.length > 1)
@@ -293,7 +295,7 @@ async function replayPullRequest(taskId, operation, agent, cwd) {
     }
     return recoverCreatedPullRequest(taskId, { agent, cwd, base: intent.baseRef || '', head: intent.headRef || '', skipQueue: true });
 }
-async function recoverPlatformOperations(taskRef, selection, options) {
+async function recoverPlatformOperationsOnce(taskRef, selection, options) {
     const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
     if (!resolved.ok)
         return result('failed', [], [], { code: resolved.code, message: resolved.message, retryable: false });
@@ -307,34 +309,23 @@ async function recoverPlatformOperations(taskRef, selection, options) {
     }
     const candidates = journal.operations.filter((operation) => operation.id !== options.excludeId
         && (operation.state === 'queued' || operation.state === 'pending' || operation.state === 'unknown'
-            || (operation.state === 'failed' && operation.lastCode !== 'PLATFORM_OPERATION_SUPERSEDED')))
-        .filter((operation) => selection === 'all' || operation.dependency === selection)
-        .sort((left, right) => left.updatedAt.localeCompare(right.updatedAt));
+            || (operation.state === 'failed' && operation.lastCode !== 'PLATFORM_OPERATION_SUPERSEDED')));
     if (!candidates.length)
         return result('no-op', [], []);
+    const head = candidates[0];
+    if (selection !== 'all' && head.dependency !== selection) {
+        return result('blocked', [], candidates.map((operation) => operation.id), {
+            code: 'PLATFORM_OPERATION_RECOVERY_PENDING',
+            message: 'The first unresolved platform operation belongs to another recovery selection',
+            retryable: true
+        });
+    }
     const limit = options.limit === undefined ? candidates.length : Math.max(1, options.limit);
     const recovered = [];
     const pending = [];
     const selected = candidates.slice(0, limit);
     for (const [index, operation] of selected.entries()) {
-        if (operation.state === 'failed') {
-            pending.push(operation.id);
-            return result('blocked', recovered, pending, {
-                code: operation.lastCode || 'PLATFORM_OPERATION_FAILED',
-                message: 'A previous platform operation failed permanently; later writes remain queued',
-                retryable: false
-            });
-        }
-        if (operation.attempts >= operation.maxAttempts) {
-            pending.push(operation.id, ...selected.slice(index + 1).map((next) => next.id));
-            pending.push(...candidates.slice(limit).map((next) => next.id));
-            return result('blocked', recovered, pending, {
-                code: operation.lastCode || 'PLATFORM_OPERATION_RETRY_LIMIT_REACHED',
-                message: 'A previous platform operation exhausted its recovery attempts; later writes remain queued',
-                retryable: false
-            });
-        }
-        if (operation.kind !== 'issue-create') {
+        {
             try {
                 recordPlatformOperation({
                     taskRef: resolved.taskId, cwd: resolved.repoRoot, kind: operation.kind,
@@ -368,8 +359,8 @@ async function recoverPlatformOperations(taskRef, selection, options) {
             if (current.id !== operation.id) {
                 try {
                     recordPlatformOperation({ taskRef: resolved.taskId, cwd: resolved.repoRoot, kind: operation.kind, target: operation.target,
-                        expectedDigest: operation.expectedDigest, issueMetadata: operation.issueMetadata, dependency: operation.dependency,
-                        state: 'failed', lastCode: 'PLATFORM_OPERATION_SUPERSEDED' });
+                        expectedDigest: current.expectedDigest, issueMetadata: current.issueMetadata, dependency: operation.dependency,
+                        state: 'queued', replaceOperationId: operation.id });
                     targetOperation = { ...operation, expectedDigest: current.expectedDigest, issueMetadata: current.issueMetadata, id: current.id };
                 }
                 catch (error) {
@@ -396,7 +387,7 @@ async function recoverPlatformOperations(taskRef, selection, options) {
             if (current.id !== operation.id) {
                 try {
                     recordPlatformOperation({ taskRef: resolved.taskId, cwd: resolved.repoRoot, kind: operation.kind, target: operation.target,
-                        expectedDigest: operation.expectedDigest, dependency: operation.dependency, state: 'failed', lastCode: 'PLATFORM_OPERATION_SUPERSEDED' });
+                        expectedDigest: current.expectedDigest, dependency: operation.dependency, state: 'queued', replaceOperationId: operation.id });
                     targetOperation = { ...operation, expectedDigest: current.expectedDigest, id: current.id };
                 }
                 catch (error) {
@@ -437,7 +428,7 @@ async function recoverPlatformOperations(taskRef, selection, options) {
                 ...(operation.pullRequestSummary ? { pullRequestSummary: operation.pullRequestSummary } : {}),
                 ...(operation.pullRequestReview ? { pullRequestReview: operation.pullRequestReview } : {}),
                 dependency: operation.dependency,
-                state: succeeded ? 'succeeded' : remote.status === 'failed' && remote.error?.retryable === false ? 'failed' : 'unknown',
+                state: succeeded ? 'succeeded' : 'unknown',
                 lastCode: remote.error?.code ?? null
             });
         }
@@ -455,5 +446,81 @@ async function recoverPlatformOperations(taskRef, selection, options) {
     pending.push(...remaining);
     return result(pending.length ? 'blocked' : recovered.length ? 'applied' : 'no-op', recovered, pending, pending.length ? { code: 'PLATFORM_OPERATION_RECOVERY_PENDING', message: 'Platform operations remain pending after the recovery budget', retryable: true } : null);
 }
+async function recoverPlatformOperations(taskRef, selection, options) {
+    const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
+    if (!resolved.ok)
+        return result('failed', [], [], { code: resolved.code, message: resolved.message, retryable: false });
+    let initial;
+    try {
+        initial = readPlatformOperationJournal(resolved.taskId, resolved.repoRoot);
+    }
+    catch (error) {
+        const value = error;
+        return result('failed', [], [], { code: value.code || 'PLATFORM_OPERATION_JOURNAL_INVALID', message: value.message || String(error), retryable: false });
+    }
+    const eligible = (operation) => operation.id !== options.excludeId
+        && (operation.state === 'queued' || operation.state === 'pending' || operation.state === 'unknown'
+            || (operation.state === 'failed' && operation.lastCode !== 'PLATFORM_OPERATION_SUPERSEDED'));
+    const first = initial.operations.filter(eligible);
+    if (!first.length)
+        return result('no-op', [], []);
+    const operationLimit = options.limit === undefined ? first.length : Math.max(1, options.limit);
+    const attemptLimit = options.attempts ?? DEFAULT_RECOVERY_ATTEMPTS;
+    if (!Number.isSafeInteger(attemptLimit) || attemptLimit <= 0) {
+        return result('failed', [], [], { code: 'PLATFORM_OPERATION_RECOVERY_PAYLOAD_INVALID', message: 'Recovery attempts must be a positive safe integer', retryable: false });
+    }
+    const recovered = [];
+    for (let operationIndex = 0; operationIndex < operationLimit; operationIndex += 1) {
+        let latest;
+        try {
+            latest = readPlatformOperationJournal(resolved.taskId, resolved.repoRoot);
+        }
+        catch (error) {
+            const value = error;
+            return result('failed', recovered, [], { code: value.code || 'PLATFORM_OPERATION_JOURNAL_INVALID', message: value.message || String(error), retryable: false });
+        }
+        const head = latest.operations.find(eligible);
+        if (!head)
+            break;
+        if (selection !== 'all' && head.dependency !== selection) {
+            const pending = latest.operations.filter(eligible).map((operation) => operation.id);
+            return result('blocked', recovered, pending, {
+                code: 'PLATFORM_OPERATION_RECOVERY_PENDING',
+                message: 'The first unresolved platform operation belongs to another recovery selection',
+                retryable: true
+            });
+        }
+        let last = null;
+        for (let attempt = 0; attempt < attemptLimit; attempt += 1) {
+            last = await recoverPlatformOperationsOnce(taskRef, selection, { ...options, limit: 1 });
+            recovered.push(...last.recovered.filter((id) => !recovered.includes(id)));
+            if (last.recovered.length > 0 || last.status === 'applied' || last.status === 'no-op')
+                break;
+        }
+        if (!last || (last.recovered.length === 0 && last.status !== 'applied' && last.status !== 'no-op')) {
+            let current;
+            try {
+                current = readPlatformOperationJournal(resolved.taskId, resolved.repoRoot);
+            }
+            catch {
+                return result('blocked', recovered, [head.id], last?.error ?? null);
+            }
+            const pending = current.operations.filter(eligible).map((operation) => operation.id);
+            return result(last?.status === 'failed' ? 'failed' : 'blocked', recovered, pending, last?.error ?? {
+                code: 'PLATFORM_OPERATION_RECOVERY_PENDING',
+                message: 'The first queued platform operation remains unresolved after this recovery run',
+                retryable: true
+            });
+        }
+    }
+    let remaining;
+    try {
+        remaining = readPlatformOperationJournal(resolved.taskId, resolved.repoRoot).operations.filter(eligible).map((operation) => operation.id);
+    }
+    catch {
+        remaining = [];
+    }
+    return result(remaining.length ? 'blocked' : recovered.length ? 'applied' : 'no-op', recovered, remaining, remaining.length ? { code: 'PLATFORM_OPERATION_RECOVERY_PENDING', message: 'Platform operations remain queued after this recovery run', retryable: true } : null);
+}
 export { fieldsMatchExpected, labelsMatchOwnedPrefix, recoverPlatformOperations };
 //# sourceMappingURL=platform-operation-recovery.js.map

package/dist/lib/task/review-fingerprint.js

@@ -1,7 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
-import { artifactName, maxArtifactRound } from "./artifact-name.js";
-import { invalidationBlocks, isArtifactInvalidated, parseInvalidationDocument } from "./invalidation.js";
+import { inspectArtifactDirectory } from "./artifact-lifecycle.js";
 const REVIEWED_TREE_RE = /^[a-f0-9]{40,64}$/;
 export function parseReviewedGitTree(value) {
     return REVIEWED_TREE_RE.test(value) ? value : null;
@@ -28,32 +27,11 @@ export function resolvePostReviewGlobs(config = {}, reviewConfig = {}) {
     return [":/", ...excludes.map((p) => `:(top,exclude)${p}`)];
 }
 export function findAuthoritativeReviewCodeArtifact(taskDir) {
-    const entries = fs.existsSync(taskDir) ? fs.readdirSync(taskDir) : [];
-    const round = maxArtifactRound(entries, "review-code");
-    if (round === 0) {
+    const inventory = inspectArtifactDirectory(taskDir, 'review-code');
+    if (inventory.status !== 'ready' || !inventory.latest) {
         return { ok: false, round: 0, fileName: null, path: null, error: null };
     }
-    const fileName = artifactName("review-code", round);
-    let taskContent;
-    try {
-        taskContent = fs.readFileSync(path.join(taskDir, "task.md"), "utf8");
-    }
-    catch (error) {
-        return {
-            ok: false, round, fileName, path: null,
-            error: error instanceof Error ? error.message : String(error)
-        };
-    }
-    const invalidation = parseInvalidationDocument(taskContent);
-    if (!invalidation.ok) {
-        return { ok: false, round, fileName, path: null, error: invalidation.message };
-    }
-    if (invalidationBlocks(invalidation.document)) {
-        return { ok: false, round, fileName, path: null, error: "artifact invalidation is incomplete; reconcile task.md before using review-code" };
-    }
-    if (isArtifactInvalidated(invalidation.document, "review-code", fileName)) {
-        return { ok: false, round, fileName, path: null, error: `${fileName} is invalidated; re-run review-code` };
-    }
+    const { round, name: fileName } = inventory.latest;
     return {
         ok: true,
         round,

package/dist/lib/task/verification-engine.js

@@ -19,7 +19,7 @@ import { inspectDecisionDetailDuplicates } from "./decision-details.js";
 import { parseImplementationInputs } from "./implementation-inputs.js";
 import { scanVisibleMarkdown } from "./markdown.js";
 import { loadVerificationConfig } from "./verification-config.js";
-import { inspectActivityLog } from "./activity-log.js";
+import { inspectActivityLog, pairEntries } from "./activity-log.js";
 import { parseWorkflowWarnings } from "./workflow-warnings.js";
 import { OrchestrationStateError, readRun } from "./orchestration.js";
 import { readPrDeliveryFact } from "./pr-delivery-fact.js";
@@ -30,9 +30,11 @@ import { normalizeVerificationRecord } from './gate-policy.js';
 import { manualValidationFinalSummaryProjectionMatches } from "./manual-validation-receipt.js";
 import { readManualValidationCompletion } from "./manual-validation-completion.js";
 import { sha256File } from "./artifact-receipts.js";
+import { inspectArtifactDirectory } from "./artifact-lifecycle.js";
+import { parseArtifactName } from "./artifact-name.js";
 import { summaryCommentState } from "../platform/pr-summary.js";
 import { taskIssueIdentity } from "../platform/task-identities.js";
-import { hasArtifactCompletionFact, hasArtifactCompletionLog } from './completion-facts.js';
+import { hasArtifactCompletionFact, hasArtifactCompletionLog, parseCompletionFacts } from './completion-facts.js';
 import { inspectReviewIdentity } from './review-identity.js';
 const TASK_ENUMS = {
     type: ["feature", "bugfix", "refactor", "docs", "chore"],
@@ -264,7 +266,7 @@ function checkOrchestrationEvidence({ taskDir }) {
     return passResult('orchestration-evidence', 'Persisted orchestration model and delegation evidence is internally consistent');
 }
 // === Check Functions ===
-function checkTaskMeta({ taskDir, config, repositoryRoot }) {
+function checkTaskMeta({ taskDir, config, repositoryRoot, skillName, artifactFile }) {
     const task = loadTask(taskDir);
     if (!task.ok) {
         return failResult("task-meta", task.message);
@@ -306,7 +308,22 @@ function checkTaskMeta({ taskDir, config, repositoryRoot }) {
     }
     const expectedStep = config.expected_step;
     if (expectedStep && metadata.current_step !== expectedStep) {
-        return failResult("task-meta", `Expected current_step '${expectedStep}', got '${metadata.current_step || "(empty)"}'`);
+        let validLifecycleArtifact = false;
+        if (currentTask) {
+            const activityConfig = loadVerificationConfig(repositoryRoot, skillName).checks?.["activity-log"];
+            const { section, invalidEntries } = inspectActivityLog(task.content);
+            if (activityConfig && section && invalidEntries.length === 0) {
+                let latestAction = "";
+                for (const entry of section.entries) {
+                    if (!ACTIVITY_LOG_STARTED_RE.test(entry.step))
+                        latestAction = entry.step;
+                }
+                validLifecycleArtifact = checkArtifactLifecycleActivityLog(taskDir, artifactFile, skillName, activityConfig, task, section.entries, latestAction)?.status === "pass";
+            }
+        }
+        if (!validLifecycleArtifact) {
+            return failResult("task-meta", `Expected current_step '${expectedStep}', got '${metadata.current_step || "(empty)"}'`);
+        }
     }
     const expectedStatus = config.expected_status;
     if (expectedStatus && metadata.status !== expectedStatus) {
@@ -604,7 +621,73 @@ function checkImplementationInput({ taskDir, artifactFile }) {
     }
     return passResult("implementation-input", `${actionDecision} matches Activity Log, report, and task table`);
 }
-function checkActivityLog({ taskDir, config }) {
+const ARTIFACT_ACTIVITY_STAGES = {
+    "analyze-task": { family: "analysis", event: "analyze.completed" },
+    "plan-task": { family: "plan", event: "plan.completed" },
+    "review-analysis": { family: "review-analysis", event: "review-analysis.completed" },
+    "review-plan": { family: "review-plan", event: "review-plan.completed" },
+    "code-task": { family: "code", event: "code.completed" },
+    "review-code": { family: "review-code", event: "review-code.completed" }
+};
+function checkArtifactLifecycleActivityLog(taskDir, artifactFile, skillName, config, task, entries, latestAction) {
+    const stage = ARTIFACT_ACTIVITY_STAGES[skillName];
+    if (!stage)
+        return null;
+    const inventory = inspectArtifactDirectory(taskDir, stage.family);
+    if (inventory.status !== "ready" || !inventory.latest) {
+        return failResult("activity-log", `Current ${stage.family} artifact is unavailable: ${inventory.error?.message ?? "no artifact exists"}`);
+    }
+    const output = artifactFile || inventory.latest.name;
+    if (output !== inventory.latest.name) {
+        return failResult("activity-log", `Artifact '${output}' is not the current ${stage.family} artifact; rerun ${skillName} for '${inventory.latest.name}'`);
+    }
+    const identity = parseArtifactName(output);
+    if (!identity || identity.family !== stage.family) {
+        return failResult("activity-log", `Artifact '${output}' does not belong to ${stage.family}`);
+    }
+    if (!hasArtifactCompletionFact(task.content, path.join(taskDir, output), stage.event)) {
+        return failResult("activity-log", `Completion fact for '${output}' is missing or stale; rerun ${skillName} to record a current completion`);
+    }
+    const frontmatter = parseTypedTaskFrontmatter(task.content);
+    const fact = parseCompletionFacts(frontmatter.completion_facts).find((item) => item.event === stage.event && item.output === output);
+    if (!fact)
+        return failResult("activity-log", `Completion fact for '${output}' is missing; rerun ${skillName}`);
+    if (!Array.isArray(fact.lifecycleInputs)) {
+        return failResult("activity-log", `Completion fact for '${output}' has no input snapshot; rerun ${skillName}`);
+    }
+    for (const input of fact.lifecycleInputs) {
+        if (!input || typeof input.name !== "string" || !/^[a-f0-9]{64}$/u.test(input.sha256)) {
+            return failResult("activity-log", `Completion fact for '${output}' has an invalid input snapshot; rerun ${skillName}`);
+        }
+        const inputIdentity = parseArtifactName(input.name);
+        if (!inputIdentity)
+            return failResult("activity-log", `Completion fact for '${output}' has invalid input '${input.name}'; rerun ${skillName}`);
+        const inputInventory = inspectArtifactDirectory(taskDir, inputIdentity.family);
+        if (inputInventory.status !== "ready" || inputInventory.latest?.name !== input.name
+            || sha256File(path.join(taskDir, input.name)) !== input.sha256) {
+            return failResult("activity-log", `Input '${input.name}' changed or is no longer current; rerun ${skillName} to refresh '${output}'`);
+        }
+    }
+    const expectedAction = new RegExp(config.expected_action_pattern);
+    const roundAction = entries.find((entry) => {
+        if (ACTIVITY_LOG_STARTED_RE.test(entry.step))
+            return false;
+        if (!expectedAction.test(entry.step))
+            return false;
+        expectedAction.lastIndex = 0;
+        const actionRound = /\(Round (\d+)/.exec(entry.step)?.[1];
+        return actionRound === String(identity.round) && entry.note.includes(`→ ${output}`);
+    });
+    if (!roundAction) {
+        return failResult("activity-log", `No completed Activity Log row records '${output}' for ${skillName} Round ${identity.round}`);
+    }
+    if (skillName === "plan-task" && /^(?:Human Decision|Decision)\b/.test(latestAction)
+        && expectedAction.test(latestAction)) {
+        return passResult("activity-log", `Plan completion '${output}' is current; latest action '${latestAction}' is a human decision`);
+    }
+    return passResult("activity-log", `Current ${stage.family} completion '${output}' is valid for Round ${identity.round}`);
+}
+function checkActivityLog({ taskDir, config, skillName, artifactFile }) {
     const task = loadTask(taskDir);
     if (!task.ok) {
         return failResult("activity-log", task.message);
@@ -638,6 +721,9 @@ function checkActivityLog({ taskDir, config }) {
             doneActions.push(action);
         }
     }
+    const artifactLifecycleResult = checkArtifactLifecycleActivityLog(taskDir, artifactFile, skillName, config, task, entries, latestAction);
+    if (artifactLifecycleResult)
+        return artifactLifecycleResult;
     if (config.expected_action_pattern && !new RegExp(config.expected_action_pattern).test(latestAction)) {
         const expected = new RegExp(config.expected_action_pattern);
         let index = doneActions.length - 1;
@@ -799,7 +885,10 @@ async function checkManualValidation({ taskDir, repositoryRoot }) {
     const inspectedLog = inspectActivityLog(task.content);
     if (!inspectedLog.section)
         return failResult("manual-validation", "Activity Log is missing or invalid");
-    const reviewDoneIndex = inspectedLog.section.entries.findIndex((entry) => entry.step === `Review Code (Round ${review.round})`);
+    const reviewRow = pairEntries(inspectedLog.section.entries).find((row) => row.step === `Review Code (Round ${review.round})` && row.started !== '' && row.done !== '');
+    const reviewDoneIndex = reviewRow
+        ? inspectedLog.section.entries.findIndex((entry) => entry.step === reviewRow.step && entry.time === reviewRow.done)
+        : -1;
     const completedIndex = inspectedLog.section.entries.findIndex((entry) => entry.step === "Complete Manual Validation"
         && entry.note.includes(`Manual validation passed → ${artifactName};`)
         && entry.note.includes(`transaction=${receipt.transactionId};`)

package/dist/lib/task/write.js

@@ -6,7 +6,6 @@ import { parseTypedTaskFrontmatter, updateTaskFrontmatter } from './frontmatter.
 import { resolveTaskRef } from './resolve-ref.js';
 import { mutateTableRow, upsertSection } from './sections.js';
 import { validateCurrentTaskContract } from './current-contract.js';
-import { invalidationBlocks, parseInvalidationDocument } from './invalidation.js';
 const DEFAULT_FILE_SYSTEM = {
     readFileSync: (file) => fs.readFileSync(file, 'utf8'),
     statModeSync: (file) => fs.statSync(file).mode,
@@ -91,16 +90,6 @@ function writeTaskCore(request, options = {}) {
         if (!contract.ok) {
             return failure(request, identity, contract.code, contract.message);
         }
-        if (invalidationBlocks(contract.invalidation)
-            && options.invalidationContext !== 'source-completion'
-            && options.invalidationContext !== 'reconcile') {
-            return failure(request, identity, 'TASK_INVALIDATION_BLOCKED', 'task has an incomplete artifact invalidation operation; reconcile it before writing downstream state');
-        }
-    }
-    else {
-        const invalidation = parseInvalidationDocument(original);
-        if (!invalidation.ok)
-            return failure(request, identity, 'TASK_INVALIDATION_INVALID', invalidation.message);
     }
     let candidate = original;
     const operations = [];

package/dist/lifecycle-build-manifest.json

@@ -1,6 +1,6 @@
 {
   "protocolVersion": 3,
-  "packageVersion": "0.11.9",
-  "sourceInputHash": "17fe6c91408c93e3aa5185e816025d590ded7db7e6a305fdce00751e78723abc",
-  "internalExecutableBuildHash": "8de9870e4ece1050564d7a3e77ee211a789dd975e3f94593300b7362ed815a00"
+  "packageVersion": "0.11.10",
+  "sourceInputHash": "3500e8eb7fac8bbad3d95124002f8042af3d160185a5b635eb9b4d8f88a991cb",
+  "internalExecutableBuildHash": "51a4c472b6a54b3ca3c28ab049683175d3ea4730fe560868f853cd603b5a98f1"
 }

package/lib/git/workflow.ts

@@ -100,7 +100,7 @@ function commitExplicitPaths(input: { cwd: string; paths: readonly string[]; mes
     const tree = value(runner, input.cwd, ['write-tree']);
     if (tree !== input.expectedTree) return { status: 'failed' as const, changed: false, snapshot: inspectGitWorkflow(input.cwd, runner).snapshot, operations: [{ name: 'stage', status: 'applied' as const }], error: { code: 'GIT_TREE_MISMATCH', message: `Expected staged tree ${input.expectedTree}, received ${tree ?? 'unavailable'}` } };
   }
-  const commit = run(runner, input.cwd, ['commit', '-m', input.message]);
+  const commit = run(runner, input.cwd, ['commit', '--cleanup=verbatim', '-m', input.message]);
   const after = inspectGitWorkflow(input.cwd, runner);
   if (commit.status !== 0) return { status: 'failed' as const, changed: false, snapshot: after.snapshot, operations: [{ name: 'commit', status: 'failed' as const, message: commit.stderr.trim() }], error: { code: 'GIT_COMMIT_FAILED', message: commit.stderr.trim() } };
   return { status: 'applied' as const, changed: true, snapshot: after.snapshot, operations: [{ name: 'stage', status: 'applied' as const }, { name: 'commit', status: 'applied' as const }], error: null };

package/lib/internal/cli-route-inventory.ts

@@ -60,7 +60,6 @@ export const INTERNAL_HANDLER_ROUTE_SELECTORS = Object.freeze({
   'task-orchestration': ['status', 'progress'],
   'task-review': ['preflight', 'finalize-summary'],
   'task-event': ['event'],
-  'task-invalidation': ['reconcile'],
   'task-lifecycle': ['intent'],
   'task-finalization': ['complete'],
   'task-platform-recovery': ['inspect', 'recover'],
@@ -98,7 +97,6 @@ export function internalRouteSelector(command: string, args: readonly string[]):
   if (command === 'task-short-id') return first(args) === 'list' && args.includes('--verify') ? 'list-verify' : first(args);
   if (command === 'task-orchestration') return args[1] === 'status' ? 'status' : args[1] ? 'progress' : '';
   if (command === 'task-review') return args[1] ?? '';
-  if (command === 'task-invalidation') return args[1] ?? '';
   if (command === 'task-artifact') return args[1] ?? '';
   if (command === 'platform-pr-review' && first(args) === 'publish') {
     const scope = optionValue(args, '--scope') ?? '';

package/lib/internal/sandbox-control.ts

@@ -9,6 +9,7 @@ import { serveSandboxControl } from '../sandbox/control/server.ts';
 import { runSandboxControlExecutor } from '../sandbox/control/executor.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
 import { parseTaskCreateResult, taskCreateExitCode } from '../task/create-service.ts';
+import { serializeTaskFinalizationEnvelope, type TaskFinalizationEnvelope } from '../task/finalization-envelope.ts';
 
 type FinalizationStatus = 'completed' | 'failed' | 'blocked' | 'unknown';
 
@@ -16,10 +17,11 @@ function writeFinalizationEnvelope(
   status: FinalizationStatus,
   accepted: boolean,
   error: { code: string; message: string; retryable: boolean },
-  changed = false,
-  result: unknown = null
+  changed: boolean | null = false,
+  result: unknown = null,
+  requestId: string | null = null
 ): void {
-  process.stdout.write(`${JSON.stringify({ version: 1, status, changed, accepted, result, error })}\n`);
+  process.stdout.write(serializeTaskFinalizationEnvelope({ status, changed, accepted, requestId, result, error }));
 }
 
 function finalizationErrorStatus(error: { retryable: boolean; code: string }): FinalizationStatus {
@@ -43,6 +45,28 @@ function recoveredExitCode(response: Awaited<ReturnType<typeof recoverSandboxCon
   return response.exitCode ?? 1;
 }
 
+function finalizationResponseOutput(response: Awaited<ReturnType<typeof requestSandboxTaskFinalization>>): string {
+  try {
+    const value = JSON.parse(response.stdout) as Partial<TaskFinalizationEnvelope>;
+    if (value.version === 2
+      && value.status
+      && ['completed', 'failed', 'blocked', 'unknown'].includes(value.status)
+      && (typeof value.changed === 'boolean' || value.changed === null)) {
+      return serializeTaskFinalizationEnvelope({
+        status: value.status,
+        changed: value.changed,
+        accepted: true,
+        requestId: response.id,
+        result: value.result ?? null,
+        error: value.error ?? null
+      });
+    }
+  } catch {
+    // Preserve non-envelope output for diagnostics from the executor.
+  }
+  return response.stdout;
+}
+
 function sandboxFinalizationClient(args: string[]): void {
   if (args.length !== 4 || !args[0] || args[1] !== 'complete' || args[2] !== '--agent' || !args[3]) {
     const error = { code: 'TASK_FINALIZATION_PAYLOAD_INVALID', message: 'task ref, complete intent, and --agent are required', retryable: false };
@@ -63,7 +87,8 @@ function sandboxFinalizationClient(args: string[]): void {
     response = requestSandboxTaskFinalization({ agent });
   } catch (error) {
     if (!(error instanceof SandboxControlClientError)) throw error;
-    writeFinalizationEnvelope(finalizationErrorStatus(error.detail), error.accepted, error.detail);
+    const status = finalizationErrorStatus(error.detail);
+    writeFinalizationEnvelope(status, error.accepted, error.detail, status === 'unknown' ? null : false, null, error.requestId);
     writeClientError(error);
     process.exitCode = error.detail.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN' ? 1 : error.detail.retryable ? 2 : 1;
     return;
@@ -74,12 +99,20 @@ function sandboxFinalizationClient(args: string[]): void {
       message: 'sandbox control rejected the finalization request',
       retryable: false
     };
-    writeFinalizationEnvelope(finalizationErrorStatus(error), error.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN', error);
+    const status = finalizationErrorStatus(error);
+    writeFinalizationEnvelope(
+      status,
+      error.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN',
+      error,
+      status === 'unknown' ? null : false,
+      null,
+      response.id
+    );
     process.stderr.write(`${error.message}\n`);
     process.exitCode = error.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN' ? 1 : error.retryable ? 2 : 1;
     return;
   }
-  process.stdout.write(response.stdout);
+  process.stdout.write(finalizationResponseOutput(response));
   process.stderr.write(response.stderr);
   process.exitCode = response.exitCode ?? 1;
 }