@fitlab-ai/agent-infra 0.11.3 → 0.11.5

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";
@@ -26,7 +27,6 @@ import { OrchestrationStateError, readRun } from "./orchestration.js";
 import { resolveDeliveryTarget } from "./delivery-target.js";
 import { readPrDeliveryFact } from "./pr-delivery-fact.js";
 import { validateLocalArtifact } from "./local-artifact-finalization.js";
-import { validateQualificationAudit } from "./qualification-audit.js";
 import { getArtifactSchema } from "./artifact-schema.js";
 import { inspectArtifactContract } from "./artifact-operations.js";
 import { normalizeVerificationRecord } from './gate-policy.js';
@@ -59,7 +59,6 @@ const ACTIVITY_LOG_STARTED_RE = /\s*\[started\]\s*$/;
 const BRANCH_SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 // Review disagreement ledger (see .agents/rules/review-handshake.md).
 const LEDGER_SECTION_NAMES = ["审查分歧账本", "Review Disagreement Ledger"];
-const DEFAULT_MAX_HANDSHAKE_ROUNDS = 3;
 const POST_REVIEW_COMMIT_STAGE = "post-review-commit";
 const SHA_PATTERN = /^[0-9a-f]{7,40}$/i;
 const scriptPath = fileURLToPath(import.meta.url);
@@ -441,21 +440,6 @@ function checkArtifact({ taskDir, config, artifactFile, skillName }) {
         return failResult("artifact", `Artifact is empty: ${path.basename(artifactPath)}`);
     }
     const content = fs.readFileSync(artifactPath, "utf8");
-    let taskContent = "";
-    const taskPath = path.join(taskDir, "task.md");
-    if (fs.existsSync(taskPath)) {
-        try {
-            taskContent = fs.readFileSync(taskPath, "utf8");
-        }
-        catch (error) {
-            return failResult("artifact", `Cannot read task qualification contract: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    if (taskContent && /^review-(?:analysis|plan|code)$/.test(skillName)) {
-        const qualification = validateQualificationAudit(taskContent, content, { artifact: path.basename(artifactPath) });
-        if (!qualification.ok)
-            return failResult("artifact", `${path.basename(artifactPath)} has qualification audit errors: ${qualification.code}: ${qualification.message}`);
-    }
     const schemaFamily = skillName === "analyze-task"
         ? "analysis"
         : skillName === "review-analysis"
@@ -479,9 +463,7 @@ function checkArtifact({ taskDir, config, artifactFile, skillName }) {
     }
     if (localFamily) {
         const local = validateLocalArtifact(content, {
-            family: localFamily,
-            ...(taskContent ? { taskContent } : {}),
-            artifact: path.basename(artifactPath)
+            family: localFamily
         });
         if (!local.ok) {
             return failResult("artifact", `${path.basename(artifactPath)} has local structural errors: ${local.diagnostics.map((item) => `${item.code}: ${item.message}`).join('; ')}`);
@@ -502,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 }) {
@@ -715,11 +709,10 @@ function checkReviewLedger({ taskDir, config, repositoryRoot }) {
         return passResult("review-ledger", "Disagreement ledger has no entries");
     }
     const stageScope = Array.isArray(config.stage_scope) ? config.stage_scope : null;
-    const maxRounds = Number(resolveReviewSetting(config, "maxHandshakeRounds", DEFAULT_MAX_HANDSHAKE_ROUNDS, repositoryRoot));
     const problems = [];
     let inScopeCount = 0;
     for (const row of rows) {
-        const { id, stage, round: roundRaw, status, evidence } = row;
+        const { id, stage, status, evidence } = row;
         const stageScoped = stageScope ? stageScope.includes(stage) : true;
         // post-review-commit exemption rows are consumed by the post-review-commit
         // check, not enforced here.
@@ -738,13 +731,6 @@ function checkReviewLedger({ taskDir, config, repositoryRoot }) {
         if (status !== "open" && evidence === "") {
             problems.push(`${id}: status '${status}' requires evidence`);
         }
-        const round = Number.parseInt(roundRaw, 10);
-        if (Number.isFinite(round) &&
-            round >= maxRounds &&
-            !LEDGER_TERMINAL.has(status) &&
-            status !== "needs-human-decision") {
-            problems.push(`${id}: round ${round} reached limit ${maxRounds} without convergence; escalate to needs-human-decision`);
-        }
         if (!LEDGER_TERMINAL.has(status)) {
             problems.push(`${id}: unresolved (status '${status}')`);
         }
@@ -1051,7 +1037,8 @@ function checkReviewFact({ taskDir, artifactFile, repositoryRoot }) {
     let targetHead;
     let diffBase;
     try {
-        gitRoot = execFileSync("git", ["-C", taskDir, "rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim();
+        const taskRepositoryRoot = execFileSync("git", ["-C", taskDir, "rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim();
+        gitRoot = reviewWorktreeForTask(taskRepositoryRoot, String(task.metadata.branch || "").trim()) ?? taskRepositoryRoot;
         head = execFileSync("git", ["-C", gitRoot, "rev-parse", "HEAD"], { encoding: "utf8" }).trim();
         const target = resolveDeliveryTarget(gitRoot, { remote: deliveryRemote, baseRef: deliveryBaseRef });
         if (!target.ok)
@@ -1101,6 +1088,14 @@ function checkReviewFact({ taskDir, artifactFile, repositoryRoot }) {
     }
     return passResult("review-fact", `Review fact valid for ${path.basename(resolvedArtifact.path)} at ${baseline.slice(0, 8)}`);
 }
+function reviewWorktreeForTask(repositoryRoot, branch) {
+    if (!branch)
+        return null;
+    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 }) {
     if (SHA_PATTERN.test(lastReviewedCommit) && gitCommitExists(gitRoot, lastReviewedCommit)) {
         return { ok: true, sha: lastReviewedCommit };

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 } : {})
 });
@@ -23,6 +22,7 @@ const VERIFICATION_CATALOG = {
     'commit.completed': gate('commit', 'active'),
     'complete-task.preflight': { skill: 'complete-task', expectedState: 'active', mode: 'checks', checks: ['required-pr-delivery'] },
     'complete-task.hard-preflight': { skill: 'complete-task', expectedState: 'active', mode: 'checks', checks: ['required-pr-delivery'] },
+    'complete-task.prepared': gate('complete-task', 'active'),
     'complete-task.completed': gate('complete-task', 'completed'),
     'create-pr.completed': gate('create-pr', 'active'),
     'create-task.completed': gate('create-task', 'active'),
@@ -49,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) {
@@ -68,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

@@ -1,8 +1,8 @@
 import fs from 'node:fs';
 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 } };
@@ -43,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;
@@ -101,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 },
@@ -118,8 +117,18 @@ function projectFinalizationWarning(taskRef, warning, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return { status: 'failed', changed: false, error: { code: resolved.code, message: resolved.message } };
-    if (resolved.state !== 'completed')
-        return { status: 'failed', changed: false, error: { code: 'TASK_STATE_MISMATCH', message: `task ${resolved.taskId} is ${resolved.state}, expected completed` } };
+    let prepared = resolved.state === 'completed';
+    if (!prepared && resolved.state === 'active') {
+        try {
+            prepared = parseTaskFrontmatter(fs.readFileSync(resolved.taskMdPath, 'utf8')).status === 'completed';
+        }
+        catch {
+            prepared = false;
+        }
+    }
+    if (!prepared) {
+        return { status: 'failed', changed: false, error: { code: 'TASK_STATE_MISMATCH', message: `task ${resolved.taskId} is ${resolved.state}, expected a prepared or completed task` } };
+    }
     let content;
     let rows;
     try {
@@ -139,23 +148,27 @@ function projectFinalizationWarning(taskRef, warning, options = {}) {
             message: warning.message,
             action: retryHintForWarning(warning),
             resolvedAt: warning.resolvedAt || (warning.status === 'resolved' ? metadata.timestamp : ''),
-            resolution: warning.status === 'resolved' ? 'Resolved by a successful finalization retry' : ''
+            resolution: warning.status === 'resolved'
+                ? options.resolution === 'superseded' ? 'Superseded by a later verification observation' : 'Resolved by a successful finalization retry'
+                : ''
         }
         : {
             id: nextWarningId(rows), time: metadata.timestamp, step: warning.step,
             severity: warning.severity, code: warning.code, status: warning.status,
             target: warning.target, message: warning.message, action: retryHintForWarning(warning),
-            resolvedAt: warning.resolvedAt || '', resolution: warning.status === 'resolved' ? 'Resolved by a successful finalization retry' : ''
+            resolvedAt: warning.resolvedAt || '', resolution: warning.status === 'resolved'
+                ? options.resolution === 'superseded' ? 'Superseded by a later verification observation' : 'Resolved by a successful finalization retry'
+                : ''
         };
     if (existing && JSON.stringify(existing) === JSON.stringify(after))
         return { status: 'no-op', changed: false, error: null };
     const written = writeTask({
         taskRef: resolved.taskId,
-        expectedState: 'completed',
+        expectedState: resolved.state,
         mutations: [...sectionMutation(content), rowMutation(after)]
     }, {
         ...options,
-        taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: 'completed' },
+        taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state },
         metadataProvider: () => metadata
     });
     if (written.status === 'failed')

package/dist/lib/task/workspace-snapshot.js

@@ -15,7 +15,12 @@ function captureWorktreeTree(repoRoot, forcedPath) {
     const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-infra-orchestration-index-'));
     const indexFile = path.join(tempDir, 'index');
     try {
-        git(repoRoot, indexFile, ['read-tree', 'HEAD']);
+        try {
+            git(repoRoot, indexFile, ['read-tree', 'HEAD']);
+        }
+        catch {
+            git(repoRoot, indexFile, ['read-tree', '--empty']);
+        }
         git(repoRoot, indexFile, ['add', '-A', '--', ':/']);
         if (forcedPath && fs.existsSync(path.join(repoRoot, forcedPath))) {
             git(repoRoot, indexFile, ['add', '-f', '--', forcedPath]);
@@ -111,5 +116,5 @@ function diffWorkspaceSnapshots(repoRoot, before, after) {
     }
     return [...changed].sort();
 }
-export { captureRepositorySnapshot, captureWorkspaceSnapshot, diffWorkspaceSnapshots };
+export { captureRepositorySnapshot, captureWorkspaceSnapshot, captureWorktreeTree, diffWorkspaceSnapshots };
 //# sourceMappingURL=workspace-snapshot.js.map

package/dist/lib/task/write.js

@@ -3,7 +3,6 @@ import path from 'node:path';
 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';
@@ -73,7 +72,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 };

package/dist/lifecycle-build-manifest.json

@@ -1,6 +1,6 @@
 {
   "protocolVersion": 3,
-  "packageVersion": "0.11.3",
-  "sourceInputHash": "99efbc575d475879773bf1676cc2de5ea628b9c193f69a9812a723313ba5ae7f",
-  "internalExecutableBuildHash": "6912a66863d013c476699b88cc1d4154082971164cbae3f98ea79dda39a46e7a"
+  "packageVersion": "0.11.5",
+  "sourceInputHash": "2f29b7f1f134733c3bc1bb7c92ea6c11e57462ed51a5a96b0198b8824a3f455d",
+  "internalExecutableBuildHash": "cb9d00aa3fa974cf936a8aad310e1fa5f28842351f52a53fed43345fe9c46439"
 }

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

@@ -53,7 +53,7 @@ export const INTERNAL_HANDLER_ROUTE_SELECTORS = Object.freeze({
   'pr-review-grade': ['decide', 'resolve-host', 'verify-artifact'],
   'platform-checks': ['inspect', 'watch', 'resolve-run', 'logs'],
   'task-context': ['resolve'],
-  'task-ledger': ['decision-next-id', 'stage-status', 'finding-upsert', 'finding-respond', 'finding-review', 'decision-upsert', 'rework-intent-upsert'],
+  'task-ledger': ['decision-next-id', 'stage-status', 'finding-upsert', 'finding-respond', 'finding-review', 'decision-upsert', 'rework-intent-upsert', 'rework-intent-rebuild'],
   'task-warning': ['list', 'add', 'set-status'],
   'task-activity': ['pr-review-inspect', 'pr-review-start', 'pr-review-complete', 'pr-review-terminate'],
   'task-artifact': ['inspect', 'init', 'preflight', 'finalize-local'],
@@ -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') ?? '';

package/lib/internal/task-activity.ts

@@ -6,7 +6,6 @@ import type {
   PrReviewActivityIntent,
   PrReviewInspectIntent
 } from '../task/activity-intent.ts';
-import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task/human-override.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
@@ -28,14 +27,13 @@ const FLAGS: Record<string, string> = {
   '--minor': 'minor',
   '--outcome': 'outcome',
   '--reason': 'reason'
-  , '--override-ticket': 'overrideTicket', '--override-target': 'overrideTarget', '--override-scope': 'overrideScope'
 };
 const COMMON = ['agent', 'artifact', 'head'] as const;
 const ALLOWED: Record<string, ReadonlySet<string>> = {
   'pr-review-inspect': new Set(['kind', 'taskRef']),
-  'pr-review-start': new Set(['kind', 'taskRef', 'agent', 'artifact', 'head', 'dryRun', 'overrideTicket', 'overrideTarget', 'overrideScope']),
-  'pr-review-complete': new Set(['kind', 'taskRef', 'agent', 'artifact', 'head', 'verdict', 'blockers', 'major', 'minor', 'dryRun', 'overrideTicket', 'overrideTarget', 'overrideScope']),
-  'pr-review-terminate': new Set(['kind', 'taskRef', 'agent', 'artifact', 'head', 'outcome', 'reason', 'dryRun', 'overrideTicket', 'overrideTarget', 'overrideScope'])
+  'pr-review-start': new Set(['kind', 'taskRef', 'agent', 'artifact', 'head', 'dryRun']),
+  'pr-review-complete': new Set(['kind', 'taskRef', 'agent', 'artifact', 'head', 'verdict', 'blockers', 'major', 'minor', 'dryRun']),
+  'pr-review-terminate': new Set(['kind', 'taskRef', 'agent', 'artifact', 'head', 'outcome', 'reason', 'dryRun'])
 };
 
 function usageFailure(message: string): void {
@@ -95,45 +93,19 @@ async function taskActivity(args: string[] = []): Promise<void> {
   for (const key of operationRequired) {
     if (values[key] === undefined) { usageFailure(`${kind} requires '${key}'`); return; }
   }
-  const dryRunConflict = overrideDryRunConflict(values);
-  if (dryRunConflict) { usageFailure(dryRunConflict.message); return; }
   const resolved = resolveTaskRef(taskRef);
   if (!resolved.ok) { usageFailure(resolved.message); return; }
   let result;
-  let humanOverride: unknown = null;
   try {
-    result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-activity.${kind}`, async () => {
-      let current = applyPrReviewActivityIntent(values as PrReviewActivityIntent, { lockAlreadyHeld: true });
-      if (current.status !== 'failed' || !values.overrideTicket) return current;
-      if (!values.overrideTarget || !values.overrideScope) { usageFailure('override ticket requires target and scope'); return current; }
-      const consumed = await consumeHumanOverride({
-        taskRef, ticketId: String(values.overrideTicket),
-        failureId: failureId('activity-intent', current.error?.code ?? 'TASK_STATE_MISMATCH'),
-        target: String(values.overrideTarget), scope: String(values.overrideScope)
-      }, {
-        effectExecutor: (capability) => {
-          const retried = applyPrReviewActivityIntent(values as PrReviewActivityIntent, { lockAlreadyHeld: true, manualOverride: capability });
-          current = retried;
-          return retried.status === 'failed' || retried.status === 'planned'
-            ? { code: 'OVERRIDE_EFFECT_FAILED', message: retried.status === 'planned' ? 'producer returned planned; no activity effect was committed' : `${retried.error?.code ?? 'ACTIVITY_FAILED'}: ${retried.error?.message ?? 'manual activity effect failed'}` }
-            : null;
-        }
-      });
-      humanOverride = consumed;
-      return current;
-    });
+    result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-activity.${kind}`, async () => applyPrReviewActivityIntent(values as PrReviewActivityIntent, { lockAlreadyHeld: true }));
   } catch (error) {
     if (!(error instanceof TaskExecutionLockError)) throw error;
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: error.code, message: error.message } })}\n`);
     process.exitCode = 1;
     return;
   }
-  process.stdout.write(`${JSON.stringify(humanOverride ? { ...result, humanOverride } : result)}\n`);
-  const overrideFailed = Boolean(
-    humanOverride && typeof humanOverride === 'object' &&
-    (humanOverride as { status?: unknown }).status === 'failed'
-  );
-  if (result.status === 'failed' || overrideFailed) process.exitCode = 1;
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+  if (result.status === 'failed') process.exitCode = 1;
 }
 
 export { taskActivity };

package/lib/internal/task-artifact.ts

@@ -1,7 +1,7 @@
 import { parseArtifactCommand, executeArtifactCommand } from '../task/artifact-command.ts';
 import { ensureInternalHandlerRoute } from './cli-route-inventory.ts';
 
-const USAGE = `Usage: agent-infra-internal task-artifact <N | TASK-id> inspect --family <family>\n       agent-infra-internal task-artifact <N | TASK-id> init --family <family> --artifact <artifact> [--locale <zh-CN|en>]\n       agent-infra-internal task-artifact <N | TASK-id> preflight|finalize-local --family <analysis|plan|code> --artifact <artifact>\n\nInspect, initialize, preflight, or finalize a workflow artifact without changing task state.\n`;
+const USAGE = `Usage: agent-infra-internal task-artifact <N | TASK-id> inspect --family <family> [--source-finding <id> --source-artifact <name> --source-sha256 <digest>]\n       agent-infra-internal task-artifact <N | TASK-id> init --family <family> --artifact <artifact> [--locale <zh-CN|en>]\n       agent-infra-internal task-artifact <N | TASK-id> preflight|finalize-local --family <analysis|plan|code> --artifact <artifact>\n\nInspect, initialize, preflight, or finalize workflow artifact facts.\n`;
 
 
 function taskArtifact(args: string[] = []): void {

package/lib/internal/task-event.ts

@@ -1,7 +1,6 @@
 import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.ts';
 import { applyTaskEvent, eventCatalog } from '../task/events.ts';
 import type { TaskEventRequest, Verdict } from '../task/events.ts';
-import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task/human-override.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
@@ -21,8 +20,7 @@ const FLAGS: Record<string, keyof TaskEventRequest> = {
   '--verdict': 'verdict', '--blockers': 'blockers', '--major': 'major',
   '--minor': 'minor', '--manual-validation': 'manualValidation', '--files-modified': 'filesModified',
   '--tests-passed': 'testsPassed', '--summary-result': 'summaryResult',
-  '--transaction-id': 'transactionId', '--receipt-digest': 'receiptDigest', '--pr-head-sha': 'prHeadSha',
-  '--override-ticket': 'overrideTicket', '--override-target': 'overrideTarget', '--override-scope': 'overrideScope'
+  '--transaction-id': 'transactionId', '--receipt-digest': 'receiptDigest', '--pr-head-sha': 'prHeadSha'
 };
 const NUMERIC = new Set(['round', 'question', 'blockers', 'major', 'minor', 'manualValidation', 'filesModified', 'testsPassed']);
 
@@ -59,8 +57,6 @@ export function parseTaskEventRequest(args: readonly string[]): TaskEventRequest
   const agent = normalizeAgentToken(String(request.agent ?? ''));
   if (!agent) throw new Error(`invalid --agent '${request.agent}': ${AGENT_USAGE_HINT}`);
   request.agent = agent;
-  const dryRunConflict = overrideDryRunConflict(request as unknown as Record<string, unknown>);
-  if (dryRunConflict) throw new Error(dryRunConflict.message);
   return request;
 }
 
@@ -78,45 +74,16 @@ async function taskEvent(args: string[] = []): Promise<void> {
     return;
   }
   let result;
-  let humanOverride: unknown = null;
   try {
-    result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-event.${request.event}`, async () => {
-      let current = applyTaskEvent(request, { lockAlreadyHeld: true });
-      const values = request as Record<string, unknown>;
-      if (current.status !== 'failed' || !values.overrideTicket) return current;
-      if (!values.overrideTarget || !values.overrideScope) {
-        return { ...current, humanOverride: { status: 'failed', error: { code: 'OVERRIDE_PAYLOAD_INVALID', message: 'override ticket requires target and scope' } } } as typeof current & { humanOverride: unknown };
-      }
-      const consumed = await consumeHumanOverride({
-        taskRef: request.taskRef,
-        ticketId: String(values.overrideTicket),
-        failureId: failureId('task-event', current.error?.code ?? 'EVENT_TRANSITION_INVALID'),
-        target: String(values.overrideTarget),
-        scope: String(values.overrideScope)
-      }, {
-        effectExecutor: (capability) => {
-          const retried = applyTaskEvent(request, { lockAlreadyHeld: true, manualOverride: capability });
-          current = retried;
-          return retried.status === 'failed' || retried.status === 'planned'
-            ? { code: 'OVERRIDE_EFFECT_FAILED', message: retried.status === 'planned' ? 'producer returned planned; no task event was committed' : `${retried.error?.code ?? 'EVENT_FAILED'}: ${retried.error?.message ?? 'manual task event effect failed'}` }
-            : null;
-        }
-      });
-      humanOverride = consumed;
-      return current;
-    });
+    result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-event.${request.event}`, async () => applyTaskEvent(request, { lockAlreadyHeld: true }));
   } catch (error) {
     if (!(error instanceof TaskExecutionLockError)) throw error;
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: error.code, message: error.message } })}\n`);
     process.exitCode = 1;
     return;
   }
-  process.stdout.write(`${JSON.stringify(humanOverride ? { ...result, humanOverride } : result)}\n`);
-  const overrideFailed = Boolean(
-    humanOverride && typeof humanOverride === 'object' &&
-    (humanOverride as { status?: unknown }).status === 'failed'
-  );
-  if (result.status === 'failed' || overrideFailed) process.exitCode = 1;
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+  if (result.status === 'failed') process.exitCode = 1;
 }
 
 export { taskEvent };