@fitlab-ai/agent-infra 0.11.2 → 0.11.4

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

@@ -1,5 +1,9 @@
 const REWORK_INTENT_HEADINGS = ['返工意图', 'Rework Intent'];
 const REWORK_INTENT_COLUMNS = [
+    'intent_id', 'finding_id', 'source_artifact', 'source_sha256', 'target',
+    'classification', 'evidence_digest', 'task_fact_digest', 'status', 'declared_at', 'consumed_at'
+];
+const LEGACY_REWORK_INTENT_COLUMNS = [
     'intent_id', 'finding_id', 'source_artifact', 'source_sha256', 'target',
     'status', 'declared_at', 'consumed_at'
 ];
@@ -55,12 +59,16 @@ function parseReworkIntentDocument(content) {
                 throw new Error(`invalid intent id '${row.intent_id}'`);
             if (!/^(AN|PL|CD)-[1-9]\d*$/.test(row.finding_id))
                 throw new Error(`invalid finding id '${row.finding_id}'`);
-            if (!['analysis', 'plan', 'code'].includes(row.target))
+            if (!['analysis', 'plan', 'code', 'pause'].includes(row.target))
                 throw new Error(`invalid rework target '${row.target}'`);
+            if (!['scope-or-requirement', 'design', 'implementation', 'human-decision', 'insufficient-evidence'].includes(row.classification))
+                throw new Error(`invalid rework classification '${row.classification}'`);
             if (!['pending', 'consumed', 'superseded'].includes(row.status))
                 throw new Error(`invalid rework status '${row.status}'`);
             if (!/^[a-f0-9]{64}$/.test(row.source_sha256))
                 throw new Error(`invalid source hash for '${row.intent_id}'`);
+            if (!/^[a-f0-9]{64}$/.test(row.evidence_digest) || !/^[a-f0-9]{64}$/.test(row.task_fact_digest))
+                throw new Error(`invalid semantic digest for '${row.intent_id}'`);
             if (!row.source_artifact || !row.declared_at)
                 throw new Error(`rework intent '${row.intent_id}' has invalid required fields`);
             const terminal = row.status === 'consumed' || row.status === 'superseded';
@@ -69,6 +77,8 @@ function parseReworkIntentDocument(content) {
             return {
                 intentId: row.intent_id, findingId: row.finding_id, sourceArtifact: row.source_artifact,
                 sourceSha256: row.source_sha256, target: row.target,
+                classification: row.classification,
+                evidenceDigest: row.evidence_digest, taskFactDigest: row.task_fact_digest,
                 status: row.status, declaredAt: row.declared_at, consumedAt: row.consumed_at
             };
         });
@@ -91,7 +101,10 @@ function renderReworkIntents(intents) {
         `| ${REWORK_INTENT_COLUMNS.map(() => '---').join(' | ')} |`,
         ...intents.map((intent) => `| ${[
             intent.intentId, intent.findingId, intent.sourceArtifact, intent.sourceSha256,
-            intent.target, intent.status, intent.declaredAt, intent.consumedAt
+            intent.target, intent.classification ?? (intent.target === 'analysis' ? 'scope-or-requirement' : intent.target === 'plan' ? 'design' : intent.target === 'code' ? 'implementation' : 'insufficient-evidence'),
+            intent.evidenceDigest ?? requireDigest(`${intent.findingId}|${intent.sourceArtifact}|${intent.sourceSha256}`),
+            intent.taskFactDigest ?? requireDigest(`current|${intent.findingId}|${intent.target}`),
+            intent.status, intent.declaredAt, intent.consumedAt
         ].map(escape).join(' | ')} |`)
     ].join('\n');
 }
@@ -99,11 +112,63 @@ function upsertReworkIntent(intents, intent) {
     const existing = intents.find((candidate) => candidate.intentId === intent.intentId);
     if (!existing)
         return { changed: true, intents: [...intents, intent] };
-    const identity = (value) => [value.intentId, value.findingId, value.sourceArtifact, value.sourceSha256, value.target];
+    const identity = (value) => [value.intentId, value.findingId, value.sourceArtifact, value.sourceSha256, value.target, value.classification, value.evidenceDigest, value.taskFactDigest];
     if (JSON.stringify(identity(existing)) !== JSON.stringify(identity(intent)))
         throw new Error(`intent '${intent.intentId}' identity conflicts with existing state`);
     return { changed: false, intents };
 }
+function consumeHumanDecisionReworkIntents(intents, findingId, consumedAt) {
+    let changed = false;
+    const next = intents.map((intent) => {
+        if (intent.status !== 'pending' || intent.target !== 'pause' || intent.classification !== 'human-decision' || intent.findingId !== findingId)
+            return intent;
+        changed = true;
+        return { ...intent, status: 'consumed', consumedAt };
+    });
+    return { changed, intents: next };
+}
+function parseLegacyReworkIntentDocument(content) {
+    // TODO(compat): Remove this explicit decoder once no task contains the eight-column rework-intent header.
+    const body = sectionBody(content);
+    if (body === null)
+        return { ok: false, code: 'TASK_REWORK_INTENT_INVALID', message: 'legacy rework intent section is missing' };
+    const lines = body.split(/\r?\n/).filter((line) => line.trim());
+    const header = lines[0] ? cells(lines[0]) : null;
+    const separator = lines[1] ? cells(lines[1]) : null;
+    if (!header || !separator || header.length !== LEGACY_REWORK_INTENT_COLUMNS.length || !header.every((value, index) => value === LEGACY_REWORK_INTENT_COLUMNS[index])) {
+        return { ok: false, code: 'TASK_REWORK_INTENT_INVALID', message: 'rework intent section is not the known legacy table' };
+    }
+    try {
+        const intents = lines.slice(2).map((line) => {
+            const values = cells(line);
+            if (!values || values.length !== LEGACY_REWORK_INTENT_COLUMNS.length)
+                throw new Error('legacy rework intent row has the wrong column count');
+            const row = Object.fromEntries(LEGACY_REWORK_INTENT_COLUMNS.map((column, index) => [column, values[index]]));
+            if (!/^RI-[1-9]\d*$/.test(row.intent_id) || !/^(AN|PL|CD)-[1-9]\d*$/.test(row.finding_id))
+                throw new Error('legacy rework intent identity is invalid');
+            if (!['analysis', 'plan', 'code'].includes(row.target) || !['pending', 'consumed', 'superseded'].includes(row.status))
+                throw new Error('legacy rework intent state is invalid');
+            if (!/^[a-f0-9]{64}$/.test(row.source_sha256))
+                throw new Error('legacy rework intent source hash is invalid');
+            const legacyDigest = (value) => requireDigest(value);
+            const classification = row.target === 'analysis' ? 'scope-or-requirement' : row.target === 'plan' ? 'design' : 'implementation';
+            return {
+                intentId: row.intent_id, findingId: row.finding_id, sourceArtifact: row.source_artifact, sourceSha256: row.source_sha256,
+                target: row.target, classification,
+                evidenceDigest: legacyDigest(`${row.finding_id}|${row.source_artifact}|${row.source_sha256}`),
+                taskFactDigest: legacyDigest(`legacy|${row.finding_id}|${row.target}`),
+                status: row.status, declaredAt: row.declared_at, consumedAt: row.consumed_at
+            };
+        });
+        return { ok: true, present: true, intents };
+    }
+    catch (error) {
+        return { ok: false, code: 'TASK_REWORK_INTENT_INVALID', message: error instanceof Error ? error.message : String(error) };
+    }
+}
+function requireDigest(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
 function consumeReworkIntents(intents, target, sourceHashes, consumedAt) {
     let changed = false;
     const next = intents.map((intent) => {
@@ -134,5 +199,6 @@ function reworkIntentMutation(content, intents) {
         body: renderReworkIntents(intents)
     };
 }
-export { REWORK_INTENT_COLUMNS, REWORK_INTENT_HEADINGS, parseReworkIntentDocument, renderReworkIntents, reworkIntentMutation, consumeReworkIntents, supersedeReworkIntents, upsertReworkIntent };
+export { REWORK_INTENT_COLUMNS, REWORK_INTENT_HEADINGS, parseReworkIntentDocument, renderReworkIntents, reworkIntentMutation, consumeReworkIntents, supersedeReworkIntents, upsertReworkIntent, consumeHumanDecisionReworkIntents, parseLegacyReworkIntentDocument };
+import { createHash } from 'node:crypto';
 //# sourceMappingURL=rework-intent.js.map

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

@@ -26,7 +26,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 +58,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 +439,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 +462,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('; ')}`);
@@ -715,11 +696,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 +718,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 +1024,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 +1075,22 @@ 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 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;
+    }
+    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

@@ -23,6 +23,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'),

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

@@ -1,5 +1,6 @@
 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';
@@ -118,8 +119,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 +150,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/lifecycle-build-manifest.json

@@ -1,6 +1,6 @@
 {
   "protocolVersion": 3,
-  "packageVersion": "0.11.2",
-  "sourceInputHash": "0a1ffa8b90a0d157f9b2aabea6a43f946d68a622bde337befe71059f63b3812b",
-  "internalExecutableBuildHash": "b6742e1b5d1b997bf7e21e644bfde2bafaa608f7ede7ca308ff61c2cd19da831"
+  "packageVersion": "0.11.4",
+  "sourceInputHash": "46c0a39f354bff8c80fe19354cdda89a91a4acad060b1f134b6d599bc0ba6806",
+  "internalExecutableBuildHash": "1bc9e5755c857ee9f13a702452b2ce7c85da94444dc5a8d1305ae80d5899b001"
 }

package/lib/agent-clients/adapter.ts

@@ -7,6 +7,10 @@ import type {
   AgentClientCapabilityMap,
   AgentClientId
 } from './types.ts';
+import type {
+  OrchestrationOptions,
+  OrchestrationResult
+} from '../task/orchestration.ts';
 import {
   SANDBOX_HOOK_PHASES
 } from '../sandbox/tool-types.ts';
@@ -43,6 +47,41 @@ type AgentClientDelegationEvidence = Readonly<{
   actualReasoningEffort: 'host-event' | 'app-server' | 'spawn-ack' | 'unavailable';
 }>;
 
+type AgentClientLifecycleRecoveryRequest = Readonly<{
+  taskRef: string;
+  intent: 'recover-started';
+  agent: string;
+  auto: true;
+}>;
+
+type AgentClientLifecycleRecoveryResult = Readonly<{
+  status: 'applied' | 'no-op' | 'owner-unknown' | 'conflict';
+  changed: boolean;
+  targetState: 'active';
+  requestRef: string;
+  intent: 'recover-started';
+  taskId: string | null;
+  receiptId: string | null;
+  childId: string | null;
+  error: Readonly<{ code: string; message: string }> | null;
+}>;
+
+type AgentClientOrchestrationAdapter = Readonly<{
+  prepareDelegation?: (
+    taskRef: string,
+    input: Readonly<{
+      client: AgentClientId;
+      requestedModel?: string;
+      requestedReasoningEffort?: string;
+    }>,
+    options?: Readonly<{ repoRoot?: string; orchestrationOptions?: OrchestrationOptions }>
+  ) => Promise<OrchestrationResult>;
+  recoverStarted?: (
+    request: AgentClientLifecycleRecoveryRequest,
+    options: Readonly<{ repoRoot: string }>
+  ) => AgentClientLifecycleRecoveryResult | Promise<AgentClientLifecycleRecoveryResult>;
+}>;
+
 type AgentClientSeedCommand = Readonly<{
   templates: Readonly<{
     en: string;
@@ -75,6 +114,7 @@ type AgentClientAdapter = Readonly<{
   capabilities: AgentClientCapabilities;
   modelSelection: AgentClientModelSelectionContext;
   delegationEvidence: AgentClientDelegationEvidence;
+  orchestrationAdapter?: AgentClientOrchestrationAdapter;
   project: AgentClientProjectDescriptor;
   sandbox: AgentClientSandboxDescriptor;
 }>;
@@ -628,6 +668,9 @@ function defineAgentClientAdapter(
     capabilities: Object.freeze(capabilities),
     modelSelection: frozenModelSelection,
     delegationEvidence: Object.freeze({ ...evidence }),
+    ...(candidate.orchestrationAdapter === undefined
+      ? {}
+      : { orchestrationAdapter: Object.freeze({ ...candidate.orchestrationAdapter }) }),
     project: Object.freeze({
       ownedPathPrefixes: Object.freeze(paths),
       ...projectAssets,
@@ -650,6 +693,9 @@ export type {
   AgentClientCapabilities,
   AgentClientCustomCommandDescriptor,
   AgentClientDelegationEvidence,
+  AgentClientLifecycleRecoveryRequest,
+  AgentClientLifecycleRecoveryResult,
+  AgentClientOrchestrationAdapter,
   AgentClientManifestEntry,
   AgentClientModelSelectionContext,
   AgentClientProjectDescriptor,