@fitlab-ai/agent-infra 0.11.4 → 0.11.6

package/dist/lib/task/local-artifact-finalization.js

@@ -1,10 +1,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { inspectDecisionDetailDuplicates } from './decision-details.js';
-import { scanVisibleMarkdown } from './markdown.js';
 import { parseArtifactName } from './artifact-name.js';
+import { parseLifecyclePathDecision } from './lifecycle-path.js';
 import { resolveTaskRef } from './resolve-ref.js';
-import { canonicalSemanticDigest, inspectArtifactPatterns, inspectArtifactStructure, sha256Content } from './artifact-operations.js';
+import { canonicalSemanticDigest, inspectArtifactContract, sha256Content } from './artifact-operations.js';
 import { getArtifactSchema } from './artifact-schema.js';
 const LOCAL_ARTIFACT_REQUIRED_SECTIONS = {
     analysis: getArtifactSchema('analysis').sections.map((section) => section.headings.zh),
@@ -16,45 +16,30 @@ function localDiagnosticCode(code) {
         ARTIFACT_EMPTY: 'LOCAL_ARTIFACT_EMPTY',
         ARTIFACT_MISSING_SECTION: 'LOCAL_ARTIFACT_MISSING_SECTION',
         ARTIFACT_DUPLICATE_SECTION: 'LOCAL_ARTIFACT_DUPLICATE_SECTION',
-        ARTIFACT_HEADING_TRAILING_PUNCTUATION: 'LOCAL_SECTION_HEADING_TRAILING_PUNCTUATION'
+        ARTIFACT_HEADING_TRAILING_PUNCTUATION: 'LOCAL_SECTION_HEADING_TRAILING_PUNCTUATION',
+        ARTIFACT_STATE_CHECK_PATTERN_MISSING: 'LOCAL_STATUS_COMMAND_MISSING',
+        ARTIFACT_REQUIRED_PATTERN_MISSING: 'LOCAL_REQUIRED_PATTERN_MISSING'
     };
     return map[code] ?? 'LOCAL_STRUCTURAL_INVALID';
 }
 function localDiagnostic(item) {
     return { code: localDiagnosticCode(item.code), message: item.message, line: item.line };
 }
-function isStatusPattern(pattern) {
-    return pattern === '^\\$ ';
-}
 function validateLocalArtifact(content, options) {
     const schema = getArtifactSchema(options.family);
     const diagnostics = [];
-    const scanned = scanVisibleMarkdown(content);
-    const structure = inspectArtifactStructure(content, schema);
-    for (const item of structure.diagnostics)
+    const inspection = inspectArtifactContract(content, schema, { scopeStateCheckSection: true });
+    for (const item of inspection.diagnostics)
         diagnostics.push(localDiagnostic(item));
-    const statusSection = schema.sections.find((section) => section.id === 'state-check');
-    if (statusSection) {
-        const statusHeading = scanned.headings.find((heading) => (heading.level === 2 && [statusSection.headings.zh, statusSection.headings.en].some((name) => (heading.text === name || heading.text === `${name}:` || heading.text === `${name}：`))));
-        if (statusHeading) {
-            const next = scanned.headings.find((candidate) => candidate.start > statusHeading.start && candidate.level <= 2);
-            const body = content.slice(statusHeading.end, next?.start ?? content.length);
-            for (const pattern of schema.requiredPatterns.filter(isStatusPattern)) {
-                if (!new RegExp(pattern, 'm').test(body)) {
-                    diagnostics.push({ code: 'LOCAL_STATUS_COMMAND_MISSING', message: `status section '${statusHeading.text}' is missing required command output`, line: content.slice(0, statusHeading.start).split('\n').length });
-                }
-            }
-        }
-    }
-    const patternInspection = inspectArtifactPatterns(content, {
-        ...schema,
-        requiredPatterns: schema.requiredPatterns.filter((item) => !isStatusPattern(item))
-    });
-    for (const item of patternInspection.diagnostics)
-        diagnostics.push({ code: 'LOCAL_REQUIRED_PATTERN_MISSING', message: item.message, line: null });
     const decisionDetails = inspectDecisionDetailDuplicates(content);
     if (!decisionDetails.ok)
         diagnostics.push({ code: 'LOCAL_DECISION_DETAIL_DUPLICATE', message: decisionDetails.message, line: null });
+    if (options.family === 'analysis') {
+        const flowDecision = parseLifecyclePathDecision(content);
+        if (flowDecision.status !== 'valid') {
+            diagnostics.push({ code: 'LOCAL_FLOW_DECISION_INVALID', message: flowDecision.message, line: null });
+        }
+    }
     return {
         ok: diagnostics.length === 0,
         family: options.family,

package/dist/lib/task/resolve-ref.js

@@ -41,7 +41,7 @@ function listSortedNumeric(dir, width) {
         .reverse();
 }
 function findInArchive(repoRoot, taskId) {
-    // archive-tasks SKILL writes to .agents/workspace/archive/YYYY/MM/DD/{taskId}/task.md
+    // archive-tasks stores local material at .agents/workspace/archive/YYYY/MM/DD/{taskId}/local/task.md
     // where YYYY/MM/DD comes from completed_at (or updated_at fallback) — NOT from
     // the task id's creation date. So we cannot derive the path from taskId alone;
     // walk the bounded YYYY/MM/DD tree instead. Newest-first to favor recent archives.
@@ -51,7 +51,7 @@ function findInArchive(repoRoot, taskId) {
         for (const month of listSortedNumeric(yearDir, 2)) {
             const monthDir = path.join(yearDir, month);
             for (const day of listSortedNumeric(monthDir, 2)) {
-                const candidate = path.join(monthDir, day, taskId, 'task.md');
+                const candidate = path.join(monthDir, day, taskId, 'local', 'task.md');
                 if (fs.existsSync(candidate))
                     return candidate;
             }
@@ -125,7 +125,7 @@ function enumerateAllTaskDirs(repoRoot) {
             for (const day of listSortedNumeric(monthDir, 2).reverse()) {
                 const dayDir = path.join(monthDir, day);
                 for (const taskId of fs.readdirSync(dayDir).sort())
-                    add(taskId, path.join(dayDir, taskId), 'archive');
+                    add(taskId, path.join(dayDir, taskId, 'local'), 'archive');
             }
         }
     }

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

@@ -3,8 +3,7 @@ export function parseReviewCommand(args) {
         throw new Error('task ref and a supported review operation are required');
     const values = {};
     const flags = {
-        '--stage': 'stage', '--artifact': 'artifact', '--orchestrated': 'orchestrated', '--dry-run': 'dryRun',
-        '--override-ticket': 'overrideTicket', '--override-target': 'overrideTarget', '--override-scope': 'overrideScope'
+        '--stage': 'stage', '--artifact': 'artifact', '--orchestrated': 'orchestrated', '--dry-run': 'dryRun'
     };
     for (let index = 2; index < args.length; index += 1) {
         const flag = args[index];

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

@@ -9,7 +9,6 @@ import { inspectDecisionDetailDuplicates } from './decision-details.js';
 import { resolveTaskRef } from './resolve-ref.js';
 import { validateLifecycleExecution } from './lifecycle-execution.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
-import { allowsManualOverride } from './guard-override.js';
 import { getArtifactSchema } from './artifact-schema.js';
 import { canonicalSemanticDigest, inspectArtifactContract, sha256Content } from './artifact-operations.js';
 const STAGES = {
@@ -138,7 +137,7 @@ function prepareReviewSummaryCandidate(request, artifactContent, options = {}) {
     taskId = resolved.taskId ?? null;
     if (!resolved.ok)
         return reject(resolved.code, resolved.message);
-    if (resolved.state !== 'active' && !allowsManualOverride(options.manualOverride, 'review-finalization', 'TASK_STATE_MISMATCH')) {
+    if (resolved.state !== 'active') {
         return reject('TASK_STATE_MISMATCH', `task ${taskId} is ${resolved.state}, expected active`);
     }
     const parsed = parseArtifactName(request.artifact);

package/dist/lib/task/snapshot.js

@@ -56,25 +56,25 @@ function collectTaskSnapshot(taskRef, options = {}) {
     const observations = [];
     try {
         const output = stripOneTrailingNewline((options.gitStatus ?? defaultGitStatus)(resolved.repoRoot));
-        observations.push({ name: 'git', status: 'ready', command: '$ git status -s', output, error: null });
+        observations.push({ name: 'git', status: 'ready', command: 'git status --short --untracked-files=all', output, error: null });
     }
     catch (error) {
-        return failedSnapshot(resolved, taskRef, observations, 'git', '$ git status -s', 'SNAPSHOT_GIT_FAILED', error);
+        return failedSnapshot(resolved, taskRef, observations, 'git', 'git status --short --untracked-files=all', 'SNAPSHOT_GIT_FAILED', error);
     }
     try {
         const entries = (options.readDirectory ?? ((dir) => fs.readdirSync(dir, { withFileTypes: true })))(resolved.taskDir);
         const output = renderDirectory(entries, resolved.taskDir, options.lstat ?? fs.lstatSync);
-        observations.push({ name: 'task-directory', status: 'ready', command: `$ ls -la ${taskDirPath}/`, output, error: null });
+        observations.push({ name: 'task-directory', status: 'ready', command: `fs.readdirSync ${taskDirPath}/`, output, error: null });
     }
     catch (error) {
-        return failedSnapshot(resolved, taskRef, observations, 'task-directory', `$ ls -la ${taskDirPath}/`, 'SNAPSHOT_DIRECTORY_READ_FAILED', error);
+        return failedSnapshot(resolved, taskRef, observations, 'task-directory', `fs.readdirSync ${taskDirPath}/`, 'SNAPSHOT_DIRECTORY_READ_FAILED', error);
     }
     try {
         const content = (options.readTask ?? ((file) => fs.readFileSync(file, 'utf8')))(resolved.taskMdPath);
-        observations.push({ name: 'task-tail', status: 'ready', command: `$ tail ${taskPath}`, output: renderTail(content), error: null });
+        observations.push({ name: 'task-tail', status: 'ready', command: `fs.readFileSync ${taskPath} (last 10 lines)`, output: renderTail(content), error: null });
     }
     catch (error) {
-        return failedSnapshot(resolved, taskRef, observations, 'task-tail', `$ tail ${taskPath}`, 'SNAPSHOT_TASK_READ_FAILED', error);
+        return failedSnapshot(resolved, taskRef, observations, 'task-tail', `fs.readFileSync ${taskPath} (last 10 lines)`, 'SNAPSHOT_TASK_READ_FAILED', error);
     }
     return {
         status: 'ready', changed: false, requestRef: taskRef, taskId: resolved.taskId,

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

@@ -11,6 +11,7 @@ import { inspectPlatformPullRequest } from "../platform/pull-requests.js";
 import { resolveMaterializedReviewedHeadRelation } from "../platform/change-request-git-evidence.js";
 import { resolveReviewedHeadRelation } from "../platform/merged-pr-equivalence.js";
 import { resolveLocalReviewedCommitRelation } from "../git/reviewed-commit-equivalence.js";
+import { resolveBranchWorktree } from "../git/branch-worktree.js";
 import { parseTypedTaskFrontmatter } from "./frontmatter.js";
 import { LEDGER_TERMINAL, LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from "./ledger.js";
 import { isValidAgentInfraVersion } from "../version.js";
@@ -483,6 +484,18 @@ function checkArtifact({ taskDir, config, artifactFile, skillName }) {
             return failResult("artifact", `${path.basename(artifactPath)} is missing required pattern: ${pattern}`);
         }
     }
+    const stateCheckPatterns = config.state_check_patterns || [];
+    if (stateCheckPatterns.length > 0) {
+        const scanned = scanVisibleMarkdown(content);
+        const stateCheckHeading = scanned.headings.find((heading) => (heading.level === 2 && (heading.text === "状态核对" || heading.text === "State Check")));
+        const nextHeading = stateCheckHeading && scanned.headings.find((heading) => (heading.start > stateCheckHeading.start && heading.level <= 2));
+        const stateCheckBody = stateCheckHeading ? content.slice(stateCheckHeading.end, nextHeading?.start ?? content.length) : "";
+        for (const pattern of stateCheckPatterns) {
+            if (!new RegExp(pattern, "m").test(stateCheckBody)) {
+                return failResult("artifact", `${path.basename(artifactPath)} state-check section is missing required command: ${pattern}`);
+            }
+        }
+    }
     return passResult("artifact", `${path.basename(artifactPath)} passed (${requiredSections.length} sections)`);
 }
 function checkDecisionDetails({ taskDir, artifactFile }) {
@@ -1078,17 +1091,9 @@ function checkReviewFact({ taskDir, artifactFile, repositoryRoot }) {
 function reviewWorktreeForTask(repositoryRoot, branch) {
     if (!branch)
         return null;
-    const expectedRef = `refs/heads/${branch}`;
-    const records = execFileSync("git", ["-C", repositoryRoot, "worktree", "list", "--porcelain"], {
-        encoding: "utf8",
-        stdio: ["pipe", "pipe", "pipe"]
-    }).trim().split(/\r?\n\r?\n/);
-    for (const record of records) {
-        const worktree = /^worktree (.+)$/m.exec(record)?.[1];
-        const branchRef = /^branch (.+)$/m.exec(record)?.[1];
-        if (worktree && branchRef === expectedRef)
-            return worktree;
-    }
+    const worktree = resolveBranchWorktree(repositoryRoot, branch);
+    if (worktree)
+        return worktree;
     throw new Error(`Task branch '${branch}' is not checked out in a registered worktree`);
 }
 function resolvePostReviewBaseline({ gitRoot, lastReviewedCommit, reviewArtifact }) {

package/dist/lib/task/verification.js

@@ -4,7 +4,6 @@ import path from 'node:path';
 import { verifyInProcess } from './verification-engine.js';
 import { parseArtifactName } from './artifact-name.js';
 import { resolveTaskRef } from './resolve-ref.js';
-import { allowsManualOverride } from './guard-override.js';
 const gate = (skill, expectedState, artifactFamily) => ({
     skill, expectedState, mode: 'gate', ...(artifactFamily ? { artifactFamily } : {})
 });
@@ -50,7 +49,7 @@ async function verifyTaskEvent(request, options = {}) {
     if (!resolved.ok)
         return failure(request, resolved.code, resolved.message, { taskId: resolved.taskId, skill: spec.skill, mode: spec.mode });
     const identity = { taskId: resolved.taskId, taskDir: resolved.taskDir, taskState: resolved.state, skill: spec.skill, mode: spec.mode };
-    if (resolved.state !== spec.expectedState && !allowsManualOverride(options.manualOverride, 'task-verify', 'VERIFY_TASK_STATE_MISMATCH')) {
+    if (resolved.state !== spec.expectedState) {
         return failure(request, 'VERIFY_TASK_STATE_MISMATCH', `event '${request.event}' requires workspace '${spec.expectedState}', received '${resolved.state}'`, identity);
     }
     if (spec.artifactFamily) {
@@ -69,23 +68,12 @@ async function verifyTaskEvent(request, options = {}) {
     if (spec.mode === 'gate') {
         const payload = await engine({ mode: 'gate', skillName: spec.skill, taskDir: resolved.taskDir, artifactFile: request.artifact, checks: [], repositoryRoot: resolved.repoRoot });
         const status = payload.gate;
-        if (status !== 'pass' && allowsManualOverride(options.manualOverride, 'verification-engine', status === 'blocked' ? 'CHECK_BLOCKED' : 'CHECK_FAILED')) {
-            invocations.push({ status: 'pass', exitCode: 0, payload: { ...payload, gate: 'pass', humanOverride: 'human-approved', originalGate: status } });
-            return {
-                status: 'pass', changed: false, event: request.event, requestRef: request.taskRef,
-                ...identity, artifact: request.artifact ?? null, invocations, error: null
-            };
-        }
         invocations.push({ status, exitCode: { pass: 0, fail: 1, blocked: 2 }[status], payload });
     }
     else {
         for (const check of spec.checks ?? []) {
             const payload = await engine({ mode: 'checks', skillName: spec.skill, taskDir: resolved.taskDir, artifactFile: request.artifact, checks: [check], repositoryRoot: resolved.repoRoot });
             const status = (payload.effectiveStatus ?? payload.status);
-            if (status !== 'pass' && allowsManualOverride(options.manualOverride, 'verification-engine', status === 'blocked' ? 'CHECK_BLOCKED' : 'CHECK_FAILED')) {
-                invocations.push({ status: 'pass', exitCode: 0, payload: { ...payload, status: 'pass', humanOverride: 'human-approved', originalStatus: status } });
-                break;
-            }
             invocations.push({ status, exitCode: { pass: 0, fail: 1, blocked: 2 }[status], payload });
             if (status !== 'pass')
                 break;

package/dist/lib/task/workflow-warning-intents.js

@@ -3,7 +3,6 @@ import { resolveTaskRef } from './resolve-ref.js';
 import { parseTaskFrontmatter } from './frontmatter.js';
 import { WORKFLOW_WARNING_COLUMNS, WORKFLOW_WARNING_HEADINGS, WORKFLOW_WARNING_SEVERITIES, WORKFLOW_WARNING_STATUSES, parseWorkflowWarnings } from './workflow-warnings.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
-import { allowsManualOverride } from './guard-override.js';
 import { retryHintForWarning } from './operation-outcome.js';
 function failed(intent, code, message, taskId = null, entityId = null) {
     return { status: 'failed', changed: false, intent: intent.kind, taskId, entityId, before: null, after: null, warnings: [], operations: [], error: { code, message } };
@@ -44,8 +43,7 @@ function applyWorkflowWarningIntent(intent, options = {}) {
     const resolved = resolveTaskRef(intent.taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return failed(intent, resolved.code, resolved.message, resolved.taskId);
-    const stateOverride = allowsManualOverride(options.manualOverride, 'workflow-warning', 'TASK_STATE_MISMATCH');
-    if (resolved.state !== 'active' && !stateOverride)
+    if (resolved.state !== 'active')
         return failed(intent, 'TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected active`, resolved.taskId);
     let content;
     let rows;
@@ -102,7 +100,7 @@ function applyWorkflowWarningIntent(intent, options = {}) {
             after = { ...before, status: intent.status, resolvedAt: metadata.timestamp, resolution };
     }
     const writeResult = writeTask({
-        taskRef: intent.taskRef, expectedState: stateOverride ? resolved.state : 'active', mutations: [...sectionMutation(content), rowMutation(after)], dryRun: intent.dryRun
+        taskRef: intent.taskRef, expectedState: 'active', mutations: [...sectionMutation(content), rowMutation(after)], dryRun: intent.dryRun
     }, {
         ...options,
         taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state },

package/dist/lib/task/write.js

@@ -1,9 +1,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import crypto from 'node:crypto';
 import { isValidAgentInfraVersion, VERSION } from '../version.js';
 import { parseTypedTaskFrontmatter, updateTaskFrontmatter } from './frontmatter.js';
 import { resolveTaskRef } from './resolve-ref.js';
-import { allowsManualOverride } from './guard-override.js';
 import { mutateTableRow, upsertSection } from './sections.js';
 import { validateCurrentTaskContract } from './current-contract.js';
 import { invalidationBlocks, parseInvalidationDocument } from './invalidation.js';
@@ -54,7 +54,7 @@ function errorDetails(error, fallback) {
         message: error instanceof Error ? error.message : String(error)
     };
 }
-function writeTask(request, options = {}) {
+function writeTaskCore(request, options = {}) {
     const resolved = options.taskLocation
         ? {
             ok: true,
@@ -73,7 +73,7 @@ function writeTask(request, options = {}) {
         taskMdPath: resolved.taskMdPath,
         actualState: resolved.state
     };
-    if (resolved.state !== request.expectedState && !allowsManualOverride(options.manualOverride, 'task.write', 'TASK_STATE_MISMATCH')) {
+    if (resolved.state !== request.expectedState) {
         return failure(request, identity, 'TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected ${request.expectedState}`);
     }
     const io = { ...DEFAULT_FILE_SYSTEM, ...options.fileSystem };
@@ -259,5 +259,124 @@ function writeTask(request, options = {}) {
     }
     return { ...successBase, status: 'applied', changed: true };
 }
+function archiveContentsHash(localDir) {
+    const files = [];
+    const walk = (dir) => {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            if (entry.name.includes('\n') || entry.name.includes('\r') || entry.name === 'manifest.md') {
+                throw new Error(`Archive source path is not valid: ${path.join(dir, entry.name)}`);
+            }
+            const target = path.join(dir, entry.name);
+            const stat = fs.lstatSync(target);
+            if (stat.isSymbolicLink())
+                throw new Error(`Archive source cannot contain symbolic links: ${target}`);
+            if (stat.isDirectory())
+                walk(target);
+            else if (stat.isFile()) {
+                if (entry.name !== 'contents.sha256')
+                    files.push(target);
+            }
+            else
+                throw new Error(`Archive source cannot contain special files: ${target}`);
+        }
+    };
+    walk(localDir);
+    const rows = files
+        .map((file) => ({ file, relative: path.relative(localDir, file).split(path.sep).join('/') }))
+        .sort((left, right) => Buffer.compare(Buffer.from(left.relative), Buffer.from(right.relative)))
+        .map(({ file, relative }) => `${crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex')}  ${relative}`);
+    return `${rows.join('\n')}${rows.length ? '\n' : ''}`;
+}
+function writeArchiveContentsHash(localDir) {
+    const contents = archiveContentsHash(localDir);
+    const hashPath = path.join(localDir, 'contents.sha256');
+    const tempPath = path.join(localDir, `.contents.sha256.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`);
+    try {
+        fs.writeFileSync(tempPath, contents, { flag: 'wx' });
+        fs.renameSync(tempPath, hashPath);
+    }
+    catch (error) {
+        try {
+            fs.unlinkSync(tempPath);
+        }
+        catch (cleanupError) {
+            if (cleanupError.code !== 'ENOENT') {
+                throw new Error(`${error instanceof Error ? error.message : String(error)}; failed to remove ${tempPath}: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+            }
+        }
+        throw error;
+    }
+}
+function restoreArchivedTask(taskMdPath, contents, mode) {
+    const tempPath = `${taskMdPath}.${process.pid}.${Math.random().toString(36).slice(2)}.rollback`;
+    fs.writeFileSync(tempPath, contents, { flag: 'wx', mode });
+    try {
+        fs.renameSync(tempPath, taskMdPath);
+    }
+    catch (error) {
+        try {
+            fs.unlinkSync(tempPath);
+        }
+        catch (cleanupError) {
+            if (cleanupError.code !== 'ENOENT') {
+                throw new Error(`${error instanceof Error ? error.message : String(error)}; failed to remove ${tempPath}: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+            }
+        }
+        throw error;
+    }
+}
+function writeTask(request, options = {}) {
+    const resolved = options.taskLocation
+        ? {
+            ok: true,
+            repoRoot: options.taskLocation.repoRoot,
+            taskId: options.taskLocation.taskId,
+            taskDir: path.dirname(options.taskLocation.taskMdPath),
+            taskMdPath: options.taskLocation.taskMdPath,
+            state: options.taskLocation.state
+        }
+        : resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok) {
+        return failure(request, { taskId: resolved.taskId, taskMdPath: null, actualState: null }, resolved.code, resolved.message);
+    }
+    if (resolved.state !== 'archive' || request.expectedState !== 'archive' || request.dryRun) {
+        return writeTaskCore(request, { ...options, taskLocation: {
+                repoRoot: resolved.repoRoot,
+                taskId: resolved.taskId,
+                taskMdPath: resolved.taskMdPath,
+                state: resolved.state
+            } });
+    }
+    const identity = { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, actualState: resolved.state };
+    try {
+        const originalTask = fs.readFileSync(resolved.taskMdPath);
+        const originalMode = fs.statSync(resolved.taskMdPath).mode;
+        archiveContentsHash(resolved.taskDir);
+        const result = writeTaskCore(request, { ...options, taskLocation: {
+                repoRoot: resolved.repoRoot,
+                taskId: resolved.taskId,
+                taskMdPath: resolved.taskMdPath,
+                state: resolved.state
+            } });
+        if (result.status === 'applied') {
+            try {
+                writeArchiveContentsHash(resolved.taskDir);
+            }
+            catch (error) {
+                try {
+                    restoreArchivedTask(resolved.taskMdPath, originalTask, originalMode);
+                }
+                catch (rollbackError) {
+                    throw new Error(`Archive checksum update failed: ${error instanceof Error ? error.message : String(error)}; task rollback failed: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
+                }
+                throw error;
+            }
+        }
+        return result;
+    }
+    catch (error) {
+        return failure(request, identity, 'TASK_READ_FAILED', error instanceof Error ? error.message : String(error));
+    }
+}
 export { writeTask, captureTaskWriteMetadata, canonicalTimestamp };
 //# sourceMappingURL=write.js.map

package/dist/lifecycle-build-manifest.json

@@ -1,6 +1,6 @@
 {
   "protocolVersion": 3,
-  "packageVersion": "0.11.4",
-  "sourceInputHash": "46c0a39f354bff8c80fe19354cdda89a91a4acad060b1f134b6d599bc0ba6806",
-  "internalExecutableBuildHash": "1bc9e5755c857ee9f13a702452b2ce7c85da94444dc5a8d1305ae80d5899b001"
+  "packageVersion": "0.11.6",
+  "sourceInputHash": "402048e73650c5ac4edfb1bc4b48ca3fceb7b9068790b1321281c4994121e80c",
+  "internalExecutableBuildHash": "47ecd04ac30183443b2b86f83d1668b8bdf9e59162cc9e2cedd333d3011843e9"
 }

package/lib/decide.ts

@@ -2,7 +2,6 @@ import { VERSION } from './version.ts';
 import { parseTaskScope } from './task/command-options.ts';
 import { applyHumanDecision } from './task/decision-intents.ts';
 import { canonicalTimestamp } from './task/write.ts';
-import { consumeHumanOverride, failureId } from './task/human-override.ts';
 import { resolveTaskContext } from './task/resolve-ref.ts';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task/task-execution-lock.ts';
 
@@ -12,12 +11,9 @@ type DecideOptions = {
   version?: string;
 };
 
-function parseDecisionParts(parts: string[]): { decision: string; needsImplementation: boolean | undefined; overrideTicket?: string; overrideTarget?: string; overrideScope?: string } {
+function parseDecisionParts(parts: string[]): { decision: string; needsImplementation: boolean | undefined } {
   const decision: string[] = [];
   let needsImplementation: boolean | undefined;
-  let overrideTicket: string | undefined;
-  let overrideTarget: string | undefined;
-  let overrideScope: string | undefined;
   for (let index = 0; index < parts.length; index += 1) {
     const part = parts[index];
     if (part === '--needs-implementation') {
@@ -27,18 +23,14 @@ function parseDecisionParts(parts: string[]): { decision: string; needsImplement
         throw new Error("--needs-implementation must be 'true' or 'false'");
       }
       needsImplementation = value === 'true';
-    } else if (part === '--override-ticket' || part === '--override-target' || part === '--override-scope') {
-      const value = parts[++index];
-      if (!value) throw new Error(`${part} requires a value`);
-      if (part === '--override-ticket') overrideTicket = value;
-      else if (part === '--override-target') overrideTarget = value;
-      else overrideScope = value;
+    } else if (part?.startsWith('--')) {
+      throw new Error(`unknown option '${part}'`);
     } else {
       decision.push(parts[index]!);
     }
   }
   if (decision.length === 0) throw new Error('decision content is required');
-  return { decision: decision.join(' '), needsImplementation, overrideTicket, overrideTarget, overrideScope };
+  return { decision: decision.join(' '), needsImplementation };
 }
 
 export async function decide(args: string[], options: DecideOptions = {}): Promise<number> {
@@ -79,29 +71,7 @@ export async function decide(args: string[], options: DecideOptions = {}): Promi
       metadataProvider: () => ({ timestamp: now, agentInfraVersion: options.version ?? VERSION })
     };
     let result;
-    const execute = async () => {
-      let current = applyHumanDecision(request, writeOptions);
-      if (current.status !== 'failed' || !parsedDecision.overrideTicket) return current;
-      if (!parsedDecision.overrideTarget || !parsedDecision.overrideScope) throw new Error('override ticket requires --override-target and --override-scope');
-      const consumed = await consumeHumanOverride({
-        taskRef: resolved.taskId,
-        ticketId: parsedDecision.overrideTicket,
-        failureId: failureId('decision-intent', current.error?.code ?? 'TASK_STATE_MISMATCH'),
-        target: parsedDecision.overrideTarget,
-        scope: parsedDecision.overrideScope
-      }, {
-        ...writeOptions,
-        effectExecutor: (capability) => {
-          const retried = applyHumanDecision(request, { ...writeOptions, manualOverride: capability });
-          current = retried;
-          return retried.status === 'failed' || retried.status === 'planned'
-            ? { code: 'OVERRIDE_EFFECT_FAILED', message: retried.status === 'planned' ? 'producer returned planned; no decision effect was committed' : `${retried.error?.code ?? 'DECISION_FAILED'}: ${retried.error?.message ?? 'manual decision effect failed'}` }
-            : null;
-        }
-      });
-      if (consumed.status === 'failed') throw new Error(consumed.error.message);
-      return current;
-    };
+    const execute = async () => applyHumanDecision(request, writeOptions);
     result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-decision', execute);
     if (result.error) throw new Error(result.error.message);
     return 0;

package/lib/git/branch-worktree.ts

@@ -0,0 +1,41 @@
+import { execFileSync } from 'node:child_process';
+
+function gitText(repositoryRoot: string, args: string[]): string | null {
+  try {
+    return execFileSync('git', ['-C', repositoryRoot, ...args], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe']
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function verifiedWorktreeRoot(candidate: string, expectedBranch: string, expectedCommonDirectory: string): string | null {
+  const commonDirectory = gitText(candidate, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+  if (commonDirectory !== expectedCommonDirectory) return null;
+  const root = gitText(candidate, ['rev-parse', '--show-toplevel']);
+  if (!root) return null;
+  const branch = gitText(root, ['symbolic-ref', '--short', 'HEAD']);
+  return branch === expectedBranch ? root : null;
+}
+
+export function resolveBranchWorktree(repositoryRoot: string, expectedBranch: string): string | null {
+  const commonDirectory = gitText(repositoryRoot, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+  if (!commonDirectory) return null;
+  const currentRoot = verifiedWorktreeRoot(repositoryRoot, expectedBranch, commonDirectory);
+  if (currentRoot) return currentRoot;
+
+  const records = gitText(repositoryRoot, ['worktree', 'list', '--porcelain']);
+  if (!records) return null;
+  const expectedRef = `refs/heads/${expectedBranch}`;
+  for (const record of records.split(/\r?\n\r?\n/)) {
+    const candidate = /^worktree (.+)$/m.exec(record)?.[1];
+    const branch = /^branch (.+)$/m.exec(record)?.[1];
+    if (candidate && branch === expectedRef) {
+      const verifiedRoot = verifiedWorktreeRoot(candidate, expectedBranch, commonDirectory);
+      if (verifiedRoot) return verifiedRoot;
+    }
+  }
+  return null;
+}

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

@@ -61,7 +61,6 @@ export const INTERNAL_HANDLER_ROUTE_SELECTORS = Object.freeze({
   'task-review': ['preflight', 'finalize-summary'],
   'task-event': ['event'],
   'task-invalidation': ['reconcile'],
-  'task-override': ['diagnose', 'issue', 'consume'],
   'task-lifecycle': ['intent'],
   'task-finalization': ['complete'],
   'task-short-id': ['list', 'list-verify', 'alloc', 'release', 'resolve'],
@@ -98,7 +97,6 @@ export function internalRouteSelector(command: string, args: readonly string[]):
   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-override') return args[1] ?? '';
   if (command === 'task-artifact') return args[1] ?? '';
   if (command === 'platform-pr-review' && first(args) === 'publish') {
     const scope = optionValue(args, '--scope') ?? '';