@fitlab-ai/agent-infra 0.9.11 → 0.9.13

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

@@ -0,0 +1,138 @@
+const REWORK_INTENT_HEADINGS = ['返工意图', 'Rework Intent'];
+const REWORK_INTENT_COLUMNS = [
+    'intent_id', 'finding_id', 'source_artifact', 'source_sha256', 'target',
+    'status', 'declared_at', 'consumed_at'
+];
+function cells(line) {
+    const first = line.indexOf('|');
+    const last = line.lastIndexOf('|');
+    if (first < 0 || first === last || line.slice(0, first).trim() || line.slice(last + 1).trim())
+        return null;
+    const inner = line.slice(first + 1, last);
+    const result = [];
+    let start = 0;
+    let escaped = false;
+    for (let index = 0; index < inner.length; index += 1) {
+        const char = inner[index];
+        if (char === '|' && !escaped) {
+            result.push(inner.slice(start, index));
+            start = index + 1;
+        }
+        escaped = char === '\\' && !escaped;
+        if (char !== '\\')
+            escaped = false;
+    }
+    result.push(inner.slice(start));
+    return result.map((cell) => cell.replace(/\\([\\|])/g, '$1').trim());
+}
+function sectionBody(content) {
+    const heading = REWORK_INTENT_HEADINGS.map((value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|');
+    const match = new RegExp(`^##\\s+(${heading})\\s*$`, 'm').exec(content);
+    if (!match)
+        return null;
+    const start = (match.index ?? 0) + match[0].length;
+    const rest = content.slice(start);
+    const end = rest.search(/^##\s+/m);
+    return rest.slice(0, end < 0 ? rest.length : end);
+}
+function parseReworkIntentDocument(content) {
+    const body = sectionBody(content);
+    if (body === null)
+        return { ok: true, present: false, intents: [] };
+    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 !== REWORK_INTENT_COLUMNS.length || !header.every((value, index) => value === REWORK_INTENT_COLUMNS[index]) || !separator.every((value) => /^:?-{3,}:?$/.test(value))) {
+        return { ok: false, code: 'TASK_REWORK_INTENT_INVALID', message: 'rework intent section must contain its canonical table' };
+    }
+    try {
+        const intents = lines.slice(2).map((line) => {
+            const values = cells(line);
+            if (!values || values.length !== REWORK_INTENT_COLUMNS.length)
+                throw new Error('rework intent row has the wrong column count');
+            const row = Object.fromEntries(REWORK_INTENT_COLUMNS.map((column, index) => [column, values[index]]));
+            if (!/^RI-[1-9]\d*$/.test(row.intent_id))
+                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))
+                throw new Error(`invalid rework target '${row.target}'`);
+            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 (!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';
+            if (terminal !== Boolean(row.consumed_at))
+                throw new Error(`rework intent '${row.intent_id}' has invalid consumed_at`);
+            return {
+                intentId: row.intent_id, findingId: row.finding_id, sourceArtifact: row.source_artifact,
+                sourceSha256: row.source_sha256, target: row.target,
+                status: row.status, declaredAt: row.declared_at, consumedAt: row.consumed_at
+            };
+        });
+        const ids = new Set();
+        for (const intent of intents) {
+            if (ids.has(intent.intentId))
+                throw new Error(`duplicate intent '${intent.intentId}'`);
+            ids.add(intent.intentId);
+        }
+        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 renderReworkIntents(intents) {
+    const escape = (value) => value.replace(/\\/g, '\\\\').replace(/\|/g, '\\|').replace(/[\r\n]/g, ' ');
+    return [
+        `| ${REWORK_INTENT_COLUMNS.join(' | ')} |`,
+        `| ${REWORK_INTENT_COLUMNS.map(() => '---').join(' | ')} |`,
+        ...intents.map((intent) => `| ${[
+            intent.intentId, intent.findingId, intent.sourceArtifact, intent.sourceSha256,
+            intent.target, intent.status, intent.declaredAt, intent.consumedAt
+        ].map(escape).join(' | ')} |`)
+    ].join('\n');
+}
+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];
+    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 consumeReworkIntents(intents, target, sourceHashes, consumedAt) {
+    let changed = false;
+    const next = intents.map((intent) => {
+        if (intent.status !== 'pending'
+            || intent.target !== target
+            || sourceHashes[intent.sourceArtifact] !== intent.sourceSha256)
+            return intent;
+        changed = true;
+        return { ...intent, status: 'consumed', consumedAt };
+    });
+    return { changed, intents: next };
+}
+function supersedeReworkIntents(intents, sourceArtifact, sourceSha256, supersededAt) {
+    let changed = false;
+    const next = intents.map((intent) => {
+        if (intent.status !== 'pending' || intent.sourceArtifact !== sourceArtifact || intent.sourceSha256 === sourceSha256)
+            return intent;
+        changed = true;
+        return { ...intent, status: 'superseded', consumedAt: supersededAt };
+    });
+    return { changed, intents: next };
+}
+function reworkIntentMutation(content, intents) {
+    return {
+        kind: 'section',
+        aliases: REWORK_INTENT_HEADINGS,
+        heading: /^##\s+Rework Intent\s*$/m.test(content) ? REWORK_INTENT_HEADINGS[1] : REWORK_INTENT_HEADINGS[0],
+        body: renderReworkIntents(intents)
+    };
+}
+export { REWORK_INTENT_COLUMNS, REWORK_INTENT_HEADINGS, parseReworkIntentDocument, renderReworkIntents, reworkIntentMutation, consumeReworkIntents, supersedeReworkIntents, upsertReworkIntent };
+//# sourceMappingURL=rework-intent.js.map

package/dist/lib/task/skill-scope.js

@@ -0,0 +1,23 @@
+const TASK_SCOPE_SKILLS = new Set([
+    'analyze-task',
+    'block-task',
+    'cancel-task',
+    'check-task',
+    'code-task',
+    'commit',
+    'complete-manual-validation',
+    'complete-task',
+    'create-pr',
+    'plan-task',
+    'review-analysis',
+    'review-code',
+    'review-plan',
+    'run-manual-validation',
+    'run-task',
+    'watch-pr'
+]);
+function isTaskScopeSkill(skillName) {
+    return TASK_SCOPE_SKILLS.has(skillName);
+}
+export { TASK_SCOPE_SKILLS, isTaskScopeSkill };
+//# sourceMappingURL=skill-scope.js.map

package/dist/lib/task/task-execution-lock.js

@@ -160,6 +160,25 @@ function withTaskExecutionLock(repoRoot, taskId, ownerName, callback, options =
     };
     const serialized = `${JSON.stringify(owner)}\n`;
     let ownsFixed = false;
+    let deferRelease = false;
+    const release = () => {
+        try {
+            unlinkIfPresent(candidate);
+        }
+        catch {
+            // Candidate cleanup is best-effort and must not replace the primary result.
+        }
+        if (ownsFixed) {
+            try {
+                const current = parseOwner(fs.readFileSync(fixed, 'utf8'), key);
+                if (current.token === token)
+                    unlinkIfPresent(fixed);
+            }
+            catch {
+                // A missing or replaced fixed lock is not owned by this invocation.
+            }
+        }
+    };
     try {
         fs.mkdirSync(lockRoot, { recursive: true });
         cleanStaleCandidates(lockRoot, key, options.identityMatches ?? processIdentityMatches);
@@ -202,7 +221,12 @@ function withTaskExecutionLock(repoRoot, taskId, ownerName, callback, options =
             throw new TaskExecutionLockError('ORCHESTRATION_LOCK_BUSY', 'lifecycle task lock could not be acquired after stale recovery', { operation: 'acquire', errno: 'EEXIST', key });
         }
         unlinkIfPresent(candidate);
-        return callback();
+        const value = callback();
+        if (value && typeof value.then === 'function') {
+            deferRelease = true;
+            return value.finally(release);
+        }
+        return value;
     }
     catch (error) {
         if (error instanceof TaskExecutionLockError)
@@ -212,22 +236,8 @@ function withTaskExecutionLock(repoRoot, taskId, ownerName, callback, options =
         throw new TaskExecutionLockError('ORCHESTRATION_LOCK_FAILED', 'lifecycle task lock operation failed', { operation: ownsFixed ? 'callback' : 'acquire', errno: errno(error), key });
     }
     finally {
-        try {
-            unlinkIfPresent(candidate);
-        }
-        catch {
-            // Candidate cleanup is best-effort and must not replace the primary result.
-        }
-        if (ownsFixed) {
-            try {
-                const current = parseOwner(fs.readFileSync(fixed, 'utf8'), key);
-                if (current.token === token)
-                    unlinkIfPresent(fixed);
-            }
-            catch {
-                // A missing or replaced fixed lock is not owned by this invocation.
-            }
-        }
+        if (!deferRelease)
+            release();
     }
 }
 function withRepositoryMutationLock(repoRoot, callback, options = {}) {

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

@@ -4,7 +4,7 @@ import path from "node:path";
 import process from "node:process";
 import { execFileSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { extractReviewBaseline, extractReviewDiffBase, extractReviewDiffFingerprint, extractReviewedSnapshotTree, findAuthoritativeReviewCodeArtifact, loadPostReviewConfig, parseReviewVerdict, resolvePostReviewGlobs } from "./verification-review.js";
+import { extractReviewBaseline, extractReviewTargetHead, extractReviewedHead, extractReviewDiffBase, extractReviewDiffFingerprint, extractReviewedSnapshotTree, findAuthoritativeReviewCodeArtifact, loadPostReviewConfig, parseReviewVerdict, resolvePostReviewGlobs } from "./verification-review.js";
 import { check as checkPlatformSync } from "../platform/verification-sync.js";
 import { check as checkRequiredChecks } from "../platform/verification-required.js";
 import { inspectPlatformPullRequest } from "../platform/pull-requests.js";
@@ -19,6 +19,9 @@ import { inspectDecisionDetailDuplicates } from "./decision-details.js";
 import { loadVerificationConfig } from "./verification-config.js";
 import { snapshotReview } from "../git/review-snapshot.js";
 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";
 const TASK_ENUMS = {
     type: ["feature", "bugfix", "refactor", "docs", "chore"],
     workflow: ["feature-development", "bug-fix", "refactoring"],
@@ -67,7 +70,7 @@ const scriptPath = fileURLToPath(import.meta.url);
 let repoRoot = path.resolve(path.dirname(scriptPath), "..", "..");
 const PLATFORM_ADAPTERS = {
     "platform-sync": checkPlatformSync,
-    "platform-sync-preflight": (context, shared) => ({ ...checkPlatformSync(context, shared), type: "platform-sync-preflight" }),
+    "platform-sync-preflight": async (context, shared) => ({ ...await checkPlatformSync(context, shared), type: "platform-sync-preflight" }),
     "required-checks": checkRequiredChecks
 };
 const OPTIONAL_PLATFORM_CHECKS = new Set(["platform-sync"]);
@@ -84,7 +87,7 @@ const sharedUtils = {
     parseIssueNumber,
     parsePrNumber
 };
-function runCheck(type, context, shared) {
+async function runCheck(type, context, shared) {
     switch (type) {
         case "task-meta":
             return checkTaskMeta(context);
@@ -122,7 +125,7 @@ function runCheck(type, context, shared) {
                 }
                 return failResult(type, `Unsupported check type '${type}'.`);
             }
-            return adapter(context, shared);
+            return await adapter(context, shared);
         }
     }
 }
@@ -176,13 +179,12 @@ function validateCleanCompletionEvidence(run) {
         || !shaPattern.test(evidence.headTree)
         || !shaPattern.test(evidence.worktreeTree)
         || !shaPattern.test(evidence.lastReviewedCommit)
-        || !Number.isInteger(evidence.prNumber)
-        || evidence.prNumber <= 0
-        || !shaPattern.test(evidence.prHead)) {
+        || !(evidence.prNumber === null || (Number.isInteger(evidence.prNumber) && evidence.prNumber > 0))
+        || !(evidence.prHead === null || shaPattern.test(evidence.prHead))) {
         return 'Clean completion evidence has an invalid structure';
     }
     if (evidence.head !== evidence.lastReviewedCommit
-        || evidence.head !== evidence.prHead
+        || (evidence.prHead !== null && evidence.head !== evidence.prHead)
         || evidence.headTree !== evidence.worktreeTree) {
         return 'Clean completion evidence does not bind matching commit and tree identities';
     }
@@ -251,10 +253,8 @@ function checkOrchestrationEvidence({ taskDir }) {
         if (evidenceError)
             return failResult('orchestration-evidence', evidenceError);
     }
-    else if (run.status === 'completed' && (run.receipts.length === 0
-        || run.receipts.at(-1)?.stage !== 'commit'
-        || run.receipts.at(-1)?.status !== 'consumed')) {
-        return failResult('orchestration-evidence', 'Completed run requires a final consumed commit receipt');
+    else if (run.status === 'completed') {
+        return failResult('orchestration-evidence', 'Completed run requires reviewed-head-clean completion evidence');
     }
     if (run.pendingDelegation && !['prepared', 'activated', 'stage-completed'].includes(run.pendingDelegation.status)) {
         return failResult('orchestration-evidence', `Pending receipt has unsafe status '${run.pendingDelegation.status}'`);
@@ -420,7 +420,7 @@ function checkTaskMeta({ taskDir, config }) {
     const warningSuffix = warnings.length > 0 ? `; warnings: ${warnings.join("; ")}` : "";
     return passResult("task-meta", `Task metadata valid (${requiredFields.length} required fields checked${warningSuffix})`, warnings);
 }
-function checkRequiredPrDelivery({ taskDir, repositoryRoot, mode }) {
+async function checkRequiredPrDelivery({ taskDir, repositoryRoot, mode }) {
     const task = loadTask(taskDir);
     if (!task.ok)
         return failResult('required-pr-delivery', task.message);
@@ -434,43 +434,47 @@ function checkRequiredPrDelivery({ taskDir, repositoryRoot, mode }) {
         return failResult('required-pr-delivery', 'Project configuration is invalid');
     }
     const flow = projectConfig.prFlow;
-    const status = String(task.metadata.pr_status || 'pending');
-    const prNumber = parsePrNumber(task.metadata.pr_number);
+    const factRead = readPrDeliveryFact(task.metadata);
+    if (factRead.status === 'invalid')
+        return failResult('required-pr-delivery', factRead.error.message);
+    const fact = factRead.status === 'valid' ? factRead.fact : null;
+    const status = fact?.state || 'unbound';
+    const prIdentity = fact?.state === 'bound' ? fact.identity.resource : null;
+    const prNumber = prIdentity?.kind === 'number' ? prIdentity.value : null;
     if (flow === 'disabled')
         return passResult('required-pr-delivery', 'Pull request delivery is disabled by project policy');
-    if (flow === 'required' && (status !== 'created' || prNumber === null)) {
+    if (flow === 'required' && (status !== 'bound' || !prIdentity)) {
         return failResult('required-pr-delivery', 'Project policy requires a bound pull request before completion');
     }
-    if (flow !== 'required' && status === 'pending') {
+    if (flow !== 'required' && status === 'unbound') {
         return failResult('required-pr-delivery', 'Pull request delivery is pending; create a PR or explicitly skip it');
     }
-    if (status === 'created' && prNumber === null) {
-        return failResult('required-pr-delivery', 'Task claims a created pull request without a valid pr_number');
-    }
     if (flow === 'required') {
         if (mode === 'gate') {
             return passResult('required-pr-delivery', 'Bound pull request shape is valid; merged-state inspection is reserved for hard preflight');
         }
-        const inspected = inspectPlatformPullRequest(task.metadata.id, { cwd: repositoryRoot });
+        const inspected = await inspectPlatformPullRequest(task.metadata.id, { cwd: repositoryRoot });
         if (inspected.status === 'blocked') {
             return blockedResult('required-pr-delivery', inspected.error?.message || 'Unable to inspect the required pull request', inspected.error?.code || 'PR_INSPECTION_BLOCKED');
         }
         const pullRequest = inspected.pullRequest;
         const repository = inspected.platform.repository?.toLowerCase() || '';
         const taskBranch = String(task.metadata.branch || '').trim();
-        if (inspected.status !== 'no-op' || !pullRequest || pullRequest.number !== prNumber) {
+        const deliveryBaseRef = String(task.metadata.delivery_base_ref || projectConfig.delivery?.baseRef || '').trim();
+        if (inspected.status !== 'no-op' || !pullRequest) {
             return failResult('required-pr-delivery', 'Bound pull request identity could not be verified');
         }
         if (!repository
             || pullRequest.repository.toLowerCase() !== repository
             || pullRequest.base.repository.toLowerCase() !== repository
-            || (taskBranch && pullRequest.head.ref !== taskBranch)) {
+            || (taskBranch && pullRequest.head.ref !== taskBranch)
+            || (deliveryBaseRef && pullRequest.base.ref !== deliveryBaseRef)) {
             return failResult('required-pr-delivery', 'Bound pull request identity does not match the task');
         }
         if (pullRequest.state !== 'closed' || !pullRequest.mergedAt || !pullRequest.mergeCommitSha) {
             return failResult('required-pr-delivery', 'Project policy requires the bound pull request to be merged');
         }
-        return passResult('required-pr-delivery', `Pull request delivery policy satisfied (merged PR #${prNumber})`);
+        return passResult('required-pr-delivery', `Pull request delivery policy satisfied (merged PR ${prNumber === null ? 'identity' : `#${prNumber}`})`);
     }
     return passResult('required-pr-delivery', `Pull request delivery policy satisfied (${status})`);
 }
@@ -502,7 +506,7 @@ function loadProjectName() {
         return "";
     }
 }
-function checkArtifact({ taskDir, config, artifactFile }) {
+function checkArtifact({ taskDir, config, artifactFile, skillName }) {
     const resolvedArtifact = resolveArtifactPath(taskDir, config.file_pattern, artifactFile);
     if (!resolvedArtifact.ok) {
         return failResult("artifact", resolvedArtifact.message);
@@ -517,6 +521,20 @@ function checkArtifact({ taskDir, config, artifactFile }) {
     }
     const content = fs.readFileSync(artifactPath, "utf8");
     const requiredSections = config.required_sections || [];
+    const localFamily = skillName === "analyze-task"
+        ? "analysis"
+        : skillName === "plan-task" ? "plan" : skillName === "code-task" ? "code" : null;
+    if (localFamily) {
+        const local = validateLocalArtifact(content, {
+            family: localFamily,
+            requiredSections: requiredSections.filter((section) => typeof section === "string"),
+            requiredPatterns: (config.required_patterns || []).filter((pattern) => typeof pattern === "string")
+        });
+        if (!local.ok) {
+            return failResult("artifact", `${path.basename(artifactPath)} has local structural errors: ${local.diagnostics.map((item) => `${item.code}: ${item.message}`).join('; ')}`);
+        }
+        return passResult("artifact", `${path.basename(artifactPath)} passed (${requiredSections.length} sections)`);
+    }
     const missingSections = requiredSections.filter((section) => !new RegExp(`^##\\s+${escapeRegExp(section)}\\s*$`, "m").test(content));
     if (missingSections.length > 0) {
         return failResult("artifact", `${path.basename(artifactPath)} is missing sections: ${missingSections.join(", ")}`);
@@ -900,6 +918,8 @@ function checkManualValidation({ taskDir }) {
     // 1. Latest review-code artifact; none -> pass (no review, check not applicable).
     const review = findAuthoritativeReviewCodeArtifact(taskDir);
     if (!review.ok) {
+        if (review.error)
+            return failResult("manual-validation", `Review-code artifact is unavailable: ${review.error}`);
         return passResult("manual-validation", "No review-code artifact; manual validation not applicable");
     }
     // 2. Parse the numeric manual-validation count; unparseable/null -> fail closed
@@ -951,9 +971,11 @@ function checkManualValidation({ taskDir }) {
     }
     return passResult("manual-validation", `Manual validation completed → ${artifactName}`);
 }
-function checkPostReviewCommit({ taskDir, config }) {
+async function checkPostReviewCommit({ taskDir, config }) {
     const reviewArtifact = findAuthoritativeReviewCodeArtifact(taskDir);
     if (!reviewArtifact.ok) {
+        if (reviewArtifact.error)
+            return failResult("post-review-commit", `Review-code artifact is unavailable: ${reviewArtifact.error}`);
         return passResult("post-review-commit", "No review-code artifact; check inactive");
     }
     let gitRoot;
@@ -966,12 +988,16 @@ function checkPostReviewCommit({ taskDir, config }) {
     const task = loadTask(taskDir);
     if (!task.ok)
         return failResult("post-review-commit", task.message);
+    const factRead = readPrDeliveryFact(task.metadata);
+    if (factRead.status === 'invalid')
+        return failResult("post-review-commit", factRead.error.message);
+    const fact = factRead.status === 'valid' ? factRead.fact : null;
     const lastReviewedCommit = task.ok ? (task.metadata.last_reviewed_commit || "").trim() : "";
     const globs = resolvePostReviewGlobs(config, loadPostReviewConfig(repoRoot));
-    const hasPullRequest = Number(task.metadata.pr_number) > 0;
+    const hasPullRequest = fact?.state === 'bound';
     let inspected = null;
     if (hasPullRequest) {
-        inspected = inspectPlatformPullRequest(task.metadata.id, { cwd: gitRoot });
+        inspected = await inspectPlatformPullRequest(task.metadata.id, { cwd: gitRoot });
         if (!inspected.pullRequest) {
             const message = inspected.error?.message || "PR merge snapshot is unavailable";
             const code = inspected.error?.code || "PR_INSPECTION_INVALID";
@@ -982,7 +1008,7 @@ function checkPostReviewCommit({ taskDir, config }) {
         if (inspected.pullRequest.state === "closed" &&
             inspected.pullRequest.mergedAt &&
             inspected.pullRequest.mergeCommitSha) {
-            const relation = resolveMaterializedReviewedHeadRelation({
+            const relation = await resolveMaterializedReviewedHeadRelation({
                 cwd: gitRoot,
                 platformType: inspected.platform.type,
                 lastReviewedCommit,
@@ -1118,34 +1144,59 @@ function checkReviewFact({ taskDir, artifactFile }) {
     if (!resolvedArtifact.ok) {
         return failResult("review-fact", resolvedArtifact.message);
     }
+    const authoritative = findAuthoritativeReviewCodeArtifact(taskDir);
+    if (!authoritative.ok) {
+        return failResult("review-fact", authoritative.error ?? "No active review-code artifact is available");
+    }
+    if (path.basename(resolvedArtifact.path) !== authoritative.fileName) {
+        return failResult("review-fact", `review-code artifact ${path.basename(resolvedArtifact.path)} is not the current active artifact ${authoritative.fileName}; re-run review-code`);
+    }
     const task = loadTask(taskDir);
     if (!task.ok) {
         return failResult("review-fact", task.message);
     }
     const content = fs.readFileSync(resolvedArtifact.path, "utf8");
     const verdict = parseReviewVerdict(content);
-    const reviewBaseline = extractReviewBaseline(content);
+    const reviewTargetHead = extractReviewTargetHead(content);
+    const reviewReviewedHead = extractReviewedHead(content);
     const reviewDiffBase = extractReviewDiffBase(content);
     const reviewedFingerprint = extractReviewDiffFingerprint(content);
     const reviewedTree = extractReviewedSnapshotTree(content);
     if (!["通过", "需要修改", "拒绝", "Approved", "Changes Requested", "Rejected"].includes(verdict)) {
         return failResult("review-fact", `Unsupported review verdict '${verdict}'`);
     }
+    const deliveryRemote = String(task.metadata.delivery_remote || "").trim();
+    const deliveryBaseRef = String(task.metadata.delivery_base_ref || "").trim();
+    if (!deliveryRemote || !deliveryBaseRef) {
+        return failResult("review-fact", "Task delivery target is not bound; re-run task branch preparation before review-code");
+    }
+    if (!reviewTargetHead || !reviewReviewedHead || !reviewDiffBase) {
+        return failResult("review-fact", "Review fact must record target head, reviewed head, and diff base");
+    }
     let gitRoot;
     let head;
     let baseline;
+    let targetHead;
     let diffBase;
     try {
         gitRoot = execFileSync("git", ["-C", taskDir, "rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim();
         head = execFileSync("git", ["-C", gitRoot, "rev-parse", "HEAD"], { encoding: "utf8" }).trim();
-        baseline = execFileSync("git", ["-C", gitRoot, "rev-parse", `${reviewBaseline}^{commit}`], { encoding: "utf8" }).trim();
-        diffBase = execFileSync("git", ["-C", gitRoot, "rev-parse", `${reviewDiffBase || reviewBaseline}^{commit}`], { encoding: "utf8" }).trim();
+        const target = resolveDeliveryTarget(gitRoot, { remote: deliveryRemote, baseRef: deliveryBaseRef });
+        if (!target.ok)
+            throw new Error(target.message);
+        const reviewedRef = reviewReviewedHead;
+        baseline = execFileSync("git", ["-C", gitRoot, "rev-parse", `${reviewedRef}^{commit}`], { encoding: "utf8" }).trim();
+        targetHead = execFileSync("git", ["-C", gitRoot, "rev-parse", `${reviewTargetHead}^{commit}`], { encoding: "utf8" }).trim();
+        const computed = execFileSync("git", ["-C", gitRoot, "merge-base", baseline, targetHead], { encoding: "utf8" }).trim();
+        diffBase = execFileSync("git", ["-C", gitRoot, "rev-parse", `${reviewDiffBase}^{commit}`], { encoding: "utf8" }).trim();
+        if (diffBase !== computed)
+            throw new Error('saved review diff base does not match merge-base(reviewed head, target head)');
     }
     catch {
-        return blockedResult("review-fact", `Unable to resolve review baseline '${reviewBaseline}' in the task repository; re-run review-code`);
+        return blockedResult("review-fact", `Unable to resolve saved review commits in the task repository; re-run review-code`);
     }
     if (baseline !== head) {
-        return failResult("review-fact", `Review baseline ${baseline.slice(0, 8)} does not match current HEAD ${head.slice(0, 8)}; re-run review-code`);
+        return failResult("review-fact", `Reviewed head ${baseline.slice(0, 8)} does not match current HEAD ${head.slice(0, 8)}; re-run review-code`);
     }
     let actualSnapshot;
     try {
@@ -1170,7 +1221,7 @@ function checkReviewFact({ taskDir, artifactFile }) {
         const lastReviewedCommit = String(task.metadata.last_reviewed_commit || "").trim();
         const cleanSnapshot = actualSnapshot.tree === execFileSync("git", ["-C", gitRoot, "rev-parse", `${baseline}^{tree}`], { encoding: "utf8" }).trim();
         if (cleanSnapshot && lastReviewedCommit !== baseline) {
-            return failResult("review-fact", `Approved clean review must set task last_reviewed_commit to baseline ${baseline.slice(0, 8)}`);
+            return failResult("review-fact", `Approved clean review must set task last_reviewed_commit to reviewed head ${baseline.slice(0, 8)}`);
         }
         if (!cleanSnapshot && lastReviewedCommit) {
             return failResult("review-fact", "Approved review with uncommitted changes must remain unanchored until commit");
@@ -1377,7 +1428,7 @@ function escapeRegExp(value) {
 function isBlank(value) {
     return value === undefined || value === null || String(value).trim() === "";
 }
-function verifyInProcess({ mode, skillName, taskDir, artifactFile, checks: requestedChecks, repositoryRoot }) {
+async function verifyInProcess({ mode, skillName, taskDir, artifactFile, checks: requestedChecks, repositoryRoot }) {
     if (repositoryRoot)
         repoRoot = path.resolve(repositoryRoot);
     else {
@@ -1394,7 +1445,7 @@ function verifyInProcess({ mode, skillName, taskDir, artifactFile, checks: reque
         for (const [type, checkConfig] of Object.entries(verifyConfig.checks || {})) {
             if (checkConfig === null)
                 continue;
-            const result = runCheck(type, {
+            const result = await runCheck(type, {
                 mode,
                 skillName,
                 taskDir: path.resolve(taskDir),
@@ -1417,7 +1468,7 @@ function verifyInProcess({ mode, skillName, taskDir, artifactFile, checks: reque
         return { skill: skillName, ...passResult(type, `Check '${type}' is disabled for skill '${skillName}'.`) };
     return {
         skill: skillName,
-        ...runCheck(type, {
+        ...await runCheck(type, {
             skillName,
             taskDir: path.resolve(taskDir),
             artifactFile,

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

@@ -1,3 +1,3 @@
-export { extractReviewBaseline, extractReviewDiffBase, extractReviewDiffFingerprint, extractReviewedSnapshotTree, findAuthoritativeReviewCodeArtifact, loadPostReviewConfig, parseReviewVerdict, resolvePostReviewGlobs } from './review-fingerprint.js';
+export { extractReviewBaseline, extractReviewTargetHead, extractReviewedHead, extractReviewDiffBase, extractReviewDiffFingerprint, extractReviewedSnapshotTree, findAuthoritativeReviewCodeArtifact, loadPostReviewConfig, parseReviewVerdict, resolvePostReviewGlobs } from './review-fingerprint.js';
 export { parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
 //# sourceMappingURL=verification-review.js.map

package/dist/lib/task/verification.js

@@ -41,7 +41,7 @@ function failure(request, code, message, extra = {}) {
         artifact: request.artifact ?? null, invocations: [], error: { code, message }, ...extra
     };
 }
-function verifyTaskEvent(request, options = {}) {
+async function verifyTaskEvent(request, options = {}) {
     const spec = VERIFICATION_CATALOG[request.event];
     if (!spec)
         return failure(request, 'VERIFY_EVENT_UNKNOWN', `unknown verification event '${request.event}'`);
@@ -66,7 +66,7 @@ function verifyTaskEvent(request, options = {}) {
     const invocations = [];
     const engine = options.engine ?? verifyInProcess;
     if (spec.mode === 'gate') {
-        const payload = engine({ mode: 'gate', skillName: spec.skill, taskDir: resolved.taskDir, artifactFile: request.artifact, checks: [], repositoryRoot: resolved.repoRoot });
+        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 } });
@@ -79,7 +79,7 @@ function verifyTaskEvent(request, options = {}) {
     }
     else {
         for (const check of spec.checks ?? []) {
-            const payload = engine({ mode: 'checks', skillName: spec.skill, taskDir: resolved.taskDir, artifactFile: request.artifact, checks: [check], repositoryRoot: resolved.repoRoot });
+            const payload = await engine({ mode: 'checks', skillName: spec.skill, taskDir: resolved.taskDir, artifactFile: request.artifact, checks: [check], repositoryRoot: resolved.repoRoot });
             const status = 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 } });

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

@@ -38,7 +38,7 @@ function sectionMutation(content) {
     const english = /^##\s+Activity Log\s*$/m.test(content);
     return [{
             kind: 'section', aliases: WORKFLOW_WARNING_HEADINGS, heading: english ? 'Workflow Warnings' : '工作流告警',
-            body: `| ${WORKFLOW_WARNING_COLUMNS.join(' | ')} |\n|----|------|------|----------|------|--------|--------|---------|--------|-------------|------------|`
+            body: `| ${WORKFLOW_WARNING_COLUMNS.join(' | ')} |\n|----|------|------|----------|------|--------|---------|--------|-------------|------------|------------|`
         }];
 }
 function rowMutation(row) {

package/dist/lib/task/write.js

@@ -6,6 +6,7 @@ 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';
 const DEFAULT_FILE_SYSTEM = {
     readFileSync: (file) => fs.readFileSync(file, 'utf8'),
     statModeSync: (file) => fs.statSync(file).mode,
@@ -90,6 +91,16 @@ function writeTask(request, options = {}) {
         if (!contract.ok) {
             return failure(request, identity, contract.code, contract.message);
         }
+        if (invalidationBlocks(contract.invalidation)
+            && options.invalidationContext !== 'source-completion'
+            && options.invalidationContext !== 'reconcile') {
+            return failure(request, identity, 'TASK_INVALIDATION_BLOCKED', 'task has an incomplete artifact invalidation operation; reconcile it before writing downstream state');
+        }
+    }
+    else {
+        const invalidation = parseInvalidationDocument(original);
+        if (!invalidation.ok)
+            return failure(request, identity, 'TASK_INVALIDATION_INVALID', invalidation.message);
     }
     let candidate = original;
     const operations = [];