@fitlab-ai/agent-infra 0.9.0 → 0.9.2

package/dist/lib/task/orchestration.js

@@ -0,0 +1,420 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { parseTypedTaskFrontmatter } from './frontmatter.js';
+import { parseReviewSummary } from './review-artifacts.js';
+import { inspectArtifactDirectory } from './artifact-lifecycle.js';
+import { parseLedger, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
+import { resolveTaskRef } from './resolve-ref.js';
+import { activateDelegation, completeDelegationStage, consumeDelegation, managedDelegationRole, prepareDelegation, sealDelegation } from './delegation-receipts.js';
+import { getAgentClientCapability } from '../agent-clients/registry.js';
+import { captureWorkspaceSnapshot, diffWorkspaceSnapshots } from './workspace-snapshot.js';
+function orchestrationPath(taskDir) {
+    return path.join(taskDir, 'orchestration.json');
+}
+function readRun(taskDir) {
+    const file = orchestrationPath(taskDir);
+    if (!fs.existsSync(file))
+        return null;
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+function atomicWrite(file, value) {
+    const temp = `${file}.${process.pid}.${randomUUID()}.tmp`;
+    fs.writeFileSync(temp, `${JSON.stringify(value, null, 2)}\n`, { encoding: 'utf8', flag: 'wx' });
+    fs.renameSync(temp, file);
+}
+function saveRun(taskDir, run) {
+    atomicWrite(orchestrationPath(taskDir), run);
+}
+function withUpdatedRun(run, updates) {
+    return Object.freeze({ ...run, ...updates, updatedAt: new Date().toISOString() });
+}
+function failed(code, message, taskId = null) {
+    return { status: 'failed', changed: false, taskId, run: null, next: null, error: { code, message } };
+}
+function beginOrResumeOrchestration(taskRef, options = {}) {
+    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return failed(resolved.code, resolved.message, resolved.taskId);
+    const existing = readRun(resolved.taskDir);
+    if (existing) {
+        if (existing.status === 'paused' && existing.pause?.recoverable && existing.pendingDelegation === null) {
+            const resumed = withUpdatedRun(existing, { status: 'running', pause: null });
+            saveRun(resolved.taskDir, resumed);
+            return { status: 'running', changed: true, taskId: resolved.taskId, run: resumed, next: null, error: null };
+        }
+        return { status: existing.status, changed: false, taskId: resolved.taskId, run: existing, next: null, error: null };
+    }
+    const now = (options.now ?? (() => new Date().toISOString()))();
+    const run = {
+        schemaVersion: 1,
+        taskId: resolved.taskId,
+        runId: (options.id ?? randomUUID)(),
+        status: 'running',
+        nextStage: null,
+        stepCount: 0,
+        maxSteps: options.maxSteps ?? 24,
+        baseline: '',
+        pendingDelegation: null,
+        receipts: [],
+        pause: null,
+        commitAuthorization: { issuedAt: null, consumedAt: null },
+        createdAt: now,
+        updatedAt: now
+    };
+    atomicWrite(orchestrationPath(resolved.taskDir), run);
+    return { status: 'running', changed: true, taskId: resolved.taskId, run, next: null, error: null };
+}
+function highestRound(taskDir, family) {
+    const pattern = new RegExp(`^${family}(?:-r(\\d+))?\\.md$`);
+    return fs.readdirSync(taskDir).reduce((max, name) => {
+        const match = pattern.exec(name);
+        return match ? Math.max(max, match[1] ? Number(match[1]) : 1) : max;
+    }, 0);
+}
+function artifactName(family, round) {
+    return round === 1 ? `${family}.md` : `${family}-r${round}.md`;
+}
+function hasReviewAfterArtifact(taskDir, family, reviewFamily) {
+    const artifact = inspectArtifactDirectory(taskDir, family);
+    const review = inspectArtifactDirectory(taskDir, reviewFamily);
+    return artifact.status === 'ready'
+        && review.status === 'ready'
+        && artifact.latest !== null
+        && review.reviewedInput?.name === artifact.latest.name;
+}
+function latestReviewApproved(taskDir, family) {
+    const round = highestRound(taskDir, family);
+    if (round === 0)
+        return false;
+    const parsed = parseReviewSummary(fs.readFileSync(path.join(taskDir, artifactName(family, round)), 'utf8'));
+    return parsed.ok && parsed.summary.verdict === 'Approved' && parsed.summary.counts !== null;
+}
+function routeFromFacts(taskDir) {
+    const analysisRound = highestRound(taskDir, 'analysis');
+    const analysisReviewRound = highestRound(taskDir, 'review-analysis');
+    const planRound = highestRound(taskDir, 'plan');
+    const planReviewRound = highestRound(taskDir, 'review-plan');
+    const codeRound = highestRound(taskDir, 'code');
+    const codeReviewRound = highestRound(taskDir, 'review-code');
+    if (analysisRound === 0) {
+        const round = analysisRound + 1;
+        return { action: 'analyze-task', role: 'executor', stage: 'analysis', round, artifact: artifactName('analysis', round) };
+    }
+    if (!hasReviewAfterArtifact(taskDir, 'analysis', 'review-analysis')) {
+        const round = analysisReviewRound + 1;
+        return { action: 'review-analysis', role: 'reviewer', stage: 'review-analysis', round, artifact: artifactName('review-analysis', round) };
+    }
+    if (!latestReviewApproved(taskDir, 'review-analysis')) {
+        const round = analysisRound + 1;
+        return { action: 'analyze-task', role: 'executor', stage: 'analysis', round, artifact: artifactName('analysis', round) };
+    }
+    if (planRound === 0) {
+        const round = planRound + 1;
+        return { action: 'plan-task', role: 'executor', stage: 'plan', round, artifact: artifactName('plan', round) };
+    }
+    if (!hasReviewAfterArtifact(taskDir, 'plan', 'review-plan')) {
+        const round = planReviewRound + 1;
+        return { action: 'review-plan', role: 'reviewer', stage: 'review-plan', round, artifact: artifactName('review-plan', round) };
+    }
+    if (!latestReviewApproved(taskDir, 'review-plan')) {
+        const round = planRound + 1;
+        return { action: 'plan-task', role: 'executor', stage: 'plan', round, artifact: artifactName('plan', round) };
+    }
+    if (codeRound === 0) {
+        const round = codeRound + 1;
+        return { action: 'code-task', role: 'executor', stage: 'code', round, artifact: artifactName('code', round) };
+    }
+    if (!hasReviewAfterArtifact(taskDir, 'code', 'review-code')) {
+        const round = codeReviewRound + 1;
+        return { action: 'review-code', role: 'reviewer', stage: 'review-code', round, artifact: artifactName('review-code', round) };
+    }
+    if (!latestReviewApproved(taskDir, 'review-code')) {
+        const round = codeRound + 1;
+        return { action: 'code-task', role: 'executor', stage: 'code', round, artifact: artifactName('code', round) };
+    }
+    return { action: 'commit', role: 'executor', stage: 'commit', round: 1, artifact: 'commit' };
+}
+function routeOrchestration(taskRef, options = {}) {
+    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return failed(resolved.code, resolved.message, resolved.taskId);
+    let content;
+    try {
+        content = fs.readFileSync(resolved.taskMdPath, 'utf8');
+    }
+    catch (error) {
+        return failed('ORCHESTRATION_TASK_READ_FAILED', String(error), resolved.taskId);
+    }
+    try {
+        parseTypedTaskFrontmatter(content);
+    }
+    catch (error) {
+        return failed('ORCHESTRATION_TASK_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId);
+    }
+    const next = routeFromFacts(resolved.taskDir);
+    if (!next)
+        return failed('ORCHESTRATION_ROUTE_UNKNOWN', 'cannot determine a unique lifecycle action', resolved.taskId);
+    if (next.stage === 'commit') {
+        const reviewRound = highestRound(resolved.taskDir, 'review-code');
+        const review = parseReviewSummary(fs.readFileSync(path.join(resolved.taskDir, artifactName('review-code', reviewRound)), 'utf8'));
+        if (!review.ok || review.summary.manualValidation === null) {
+            return failed('ORCHESTRATION_REVIEW_INVALID', 'latest code review has no numeric manual-validation count', resolved.taskId);
+        }
+        if (review.summary.manualValidation > 0) {
+            return failed('ORCHESTRATION_MANUAL_VALIDATION_PENDING', 'manual validation must be completed before commit', resolved.taskId);
+        }
+        const rows = parseLedger(content);
+        const ledgerError = validateLedgerRows(rows);
+        if (ledgerError)
+            return failed('ORCHESTRATION_LEDGER_INVALID', ledgerError.message, resolved.taskId);
+        if (!summarizeLedgerStage(rows, 'code').canAdvance) {
+            return failed('ORCHESTRATION_LEDGER_BLOCKED', 'code review ledger has unresolved findings or human decisions', resolved.taskId);
+        }
+    }
+    return { status: 'running', changed: false, taskId: resolved.taskId, run: readRun(resolved.taskDir), next, error: null };
+}
+function statusOrchestration(taskRef, options = {}) {
+    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return failed(resolved.code, resolved.message, resolved.taskId);
+    const run = readRun(resolved.taskDir);
+    if (!run)
+        return failed('ORCHESTRATION_RUN_MISSING', 'no orchestration run exists', resolved.taskId);
+    return { status: run.status, changed: false, taskId: resolved.taskId, run, next: null, error: null };
+}
+function prepareOrchestrationDelegation(taskRef, input, options = {}) {
+    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return failed(resolved.code, resolved.message, resolved.taskId);
+    if (getAgentClientCapability(input.client, 'subagents').level === 'unsupported'
+        || getAgentClientCapability(input.client, 'orchestration').level === 'unsupported') {
+        return failed('ORCHESTRATION_CLIENT_UNSUPPORTED', `client '${input.client}' does not support lifecycle orchestration`, resolved.taskId);
+    }
+    const run = readRun(resolved.taskDir);
+    if (!run || run.status !== 'running')
+        return failed('ORCHESTRATION_RUN_NOT_RUNNING', 'a running orchestration is required', resolved.taskId);
+    if (run.pendingDelegation)
+        return failed('ORCHESTRATION_DELEGATION_BUSY', 'the run already has a pending delegation', resolved.taskId);
+    const repositoryPending = ['claude-code', 'codex']
+        .flatMap((client) => matchingDelegations(client, () => true, options));
+    if (repositoryPending.length > 0) {
+        return failed('ORCHESTRATION_DELEGATION_BUSY', 'the repository already has a pending lifecycle delegation', resolved.taskId);
+    }
+    if (run.stepCount >= run.maxSteps)
+        return pauseOrchestration(taskRef, 'ORCHESTRATION_MAX_STEPS', 'maximum orchestration steps reached', true, options);
+    const routed = routeOrchestration(taskRef, options);
+    if (!routed.next)
+        return routed;
+    const next = routed.next;
+    let beforeFingerprint;
+    try {
+        beforeFingerprint = (options.captureWorkspace ?? captureWorkspaceSnapshot)(resolved.repoRoot);
+    }
+    catch (error) {
+        return failed('ORCHESTRATION_SNAPSHOT_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
+    }
+    const receipt = prepareDelegation({
+        taskId: resolved.taskId,
+        runId: run.runId,
+        role: next.role,
+        stage: next.stage,
+        round: next.round,
+        artifact: next.artifact,
+        client: input.client,
+        requestedModel: input.requestedModel ?? null,
+        beforeFingerprint
+    }, { id: options.id, now: options.now });
+    const updated = withUpdatedRun(run, {
+        nextStage: next.stage,
+        pendingDelegation: receipt,
+        commitAuthorization: next.stage === 'commit' && run.commitAuthorization.issuedAt === null
+            ? { issuedAt: (options.now ?? (() => new Date().toISOString()))(), consumedAt: null }
+            : run.commitAuthorization
+    });
+    saveRun(resolved.taskDir, updated);
+    return { status: 'running', changed: true, taskId: resolved.taskId, run: updated, next, error: null };
+}
+function matchingDelegations(client, predicate, options) {
+    const repoRoot = options.repoRoot ?? process.cwd();
+    const activeRoot = path.join(repoRoot, '.agents', 'workspace', 'active');
+    if (!fs.existsSync(activeRoot))
+        return [];
+    return fs.readdirSync(activeRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .flatMap((entry) => {
+        const run = readRun(path.join(activeRoot, entry.name));
+        if (!run?.pendingDelegation)
+            return [];
+        const receipt = run.pendingDelegation;
+        return receipt.client === client && predicate(receipt)
+            ? [{ taskId: entry.name, run }]
+            : [];
+    });
+}
+function uniqueMatchingDelegation(client, predicate, options) {
+    const matches = matchingDelegations(client, predicate, options);
+    if (matches.length === 0)
+        return failed('ORCHESTRATION_DELEGATION_MISSING', 'no matching lifecycle delegation exists');
+    if (matches.length > 1)
+        return failed('ORCHESTRATION_DELEGATION_AMBIGUOUS', 'multiple lifecycle delegations match the native hook event');
+    return matches[0];
+}
+function activateMatchingOrchestrationDelegation(client, event, options = {}) {
+    const role = managedDelegationRole(event.nativeAgent);
+    if (!role)
+        return failed('DELEGATION_IGNORED', `subagent '${event.nativeAgent}' is not lifecycle-managed`);
+    const matched = uniqueMatchingDelegation(client, (receipt) => receipt.status === 'prepared', options);
+    if ('status' in matched)
+        return matched;
+    if (matched.run.receipts.some((receipt) => receipt.childId === event.childId)) {
+        return pauseOrchestration(matched.taskId, 'DELEGATION_IDENTITY_REUSED', 'native child identity was already used by this run', true, options);
+    }
+    return activateOrchestrationDelegation(matched.taskId, event, options);
+}
+function sealMatchingOrchestrationDelegation(client, event, options = {}) {
+    const role = managedDelegationRole(event.nativeAgent);
+    if (!role)
+        return failed('DELEGATION_IGNORED', `subagent '${event.nativeAgent}' is not lifecycle-managed`);
+    const matched = uniqueMatchingDelegation(client, (receipt) => receipt.status !== 'prepared', options);
+    if ('status' in matched)
+        return matched;
+    const receipt = matched.run.pendingDelegation;
+    if (receipt.role !== role) {
+        return pauseOrchestration(matched.taskId, 'DELEGATION_ROLE_MISMATCH', `managed role ${role} does not match ${receipt.role}`, true, options);
+    }
+    const repoRoot = options.repoRoot ?? process.cwd();
+    try {
+        const afterFingerprint = (options.captureWorkspace ?? captureWorkspaceSnapshot)(repoRoot);
+        const changedPaths = (options.diffWorkspace ?? diffWorkspaceSnapshots)(repoRoot, receipt.beforeFingerprint, afterFingerprint);
+        return sealOrchestrationDelegation(matched.taskId, {
+            childId: event.childId,
+            exitCode: 0,
+            afterFingerprint,
+            changedPaths
+        }, options);
+    }
+    catch (error) {
+        return pauseOrchestration(matched.taskId, 'ORCHESTRATION_SNAPSHOT_FAILED', error instanceof Error ? error.message : String(error), true, options);
+    }
+}
+function activateOrchestrationDelegation(taskRef, event, options = {}) {
+    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return failed(resolved.code, resolved.message, resolved.taskId);
+    const run = readRun(resolved.taskDir);
+    if (!run?.pendingDelegation)
+        return failed('ORCHESTRATION_DELEGATION_MISSING', 'no pending delegation exists', resolved.taskId);
+    const result = activateDelegation(run.pendingDelegation, event, { now: options.now });
+    if (!result.ok) {
+        if (result.code === 'DELEGATION_IGNORED')
+            return { status: run.status, changed: false, taskId: resolved.taskId, run, next: null, error: null };
+        return pauseOrchestration(taskRef, result.code, result.message, true, options);
+    }
+    const updated = withUpdatedRun(run, { pendingDelegation: result.receipt });
+    saveRun(resolved.taskDir, updated);
+    return { status: 'running', changed: true, taskId: resolved.taskId, run: updated, next: null, error: null };
+}
+function completeOrchestrationStage(taskRef, event, options = {}) {
+    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return failed(resolved.code, resolved.message, resolved.taskId);
+    const run = readRun(resolved.taskDir);
+    if (!run)
+        return { status: 'running', changed: false, taskId: resolved.taskId, run: null, next: null, error: null };
+    if (!run.pendingDelegation)
+        return failed('ORCHESTRATION_DELEGATION_MISSING', 'active run has no pending delegation', resolved.taskId);
+    const result = completeDelegationStage(run.pendingDelegation, event);
+    if (!result.ok)
+        return pauseOrchestration(taskRef, result.code, result.message, true, options);
+    const updated = withUpdatedRun(run, { pendingDelegation: result.receipt });
+    saveRun(resolved.taskDir, updated);
+    return { status: 'running', changed: true, taskId: resolved.taskId, run: updated, next: null, error: null };
+}
+function completeCommitOrchestrationStage(taskRef, agent, options = {}) {
+    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return failed(resolved.code, resolved.message, resolved.taskId);
+    const run = readRun(resolved.taskDir);
+    if (!run)
+        return { status: 'running', changed: false, taskId: resolved.taskId, run: null, next: null, error: null };
+    const receipt = run.pendingDelegation;
+    if (!receipt || receipt.stage !== 'commit') {
+        return failed('ORCHESTRATION_DELEGATION_MISSING', 'active run has no pending commit delegation', resolved.taskId);
+    }
+    return completeOrchestrationStage(taskRef, {
+        stage: receipt.stage,
+        round: receipt.round,
+        artifact: receipt.artifact,
+        agent
+    }, options);
+}
+function validateOrchestrationStage(taskRef, event, options = {}) {
+    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return failed(resolved.code, resolved.message, resolved.taskId);
+    const run = readRun(resolved.taskDir);
+    if (!run)
+        return { status: 'running', changed: false, taskId: resolved.taskId, run: null, next: null, error: null };
+    const receipt = run.pendingDelegation;
+    if (!receipt
+        || receipt.status !== 'activated'
+        || receipt.stage !== event.stage
+        || receipt.round !== event.round
+        || receipt.artifact !== event.artifact
+        || receipt.role !== event.role) {
+        return pauseOrchestration(taskRef, 'ORCHESTRATION_PROVENANCE_MISMATCH', 'active run does not have one matching activated delegation', true, options);
+    }
+    return { status: 'running', changed: false, taskId: resolved.taskId, run, next: null, error: null };
+}
+function sealOrchestrationDelegation(taskRef, event, options = {}) {
+    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return failed(resolved.code, resolved.message, resolved.taskId);
+    const run = readRun(resolved.taskDir);
+    if (!run?.pendingDelegation)
+        return failed('ORCHESTRATION_DELEGATION_MISSING', 'no pending delegation exists', resolved.taskId);
+    const result = sealDelegation(run.pendingDelegation, event, { now: options.now });
+    if (!result.ok)
+        return pauseOrchestration(taskRef, result.code, result.message, true, options);
+    const updated = withUpdatedRun(run, { pendingDelegation: result.receipt });
+    saveRun(resolved.taskDir, updated);
+    return { status: 'running', changed: true, taskId: resolved.taskId, run: updated, next: null, error: null };
+}
+function advanceOrchestration(taskRef, options = {}) {
+    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return failed(resolved.code, resolved.message, resolved.taskId);
+    const run = readRun(resolved.taskDir);
+    if (!run?.pendingDelegation)
+        return failed('ORCHESTRATION_DELEGATION_MISSING', 'no pending delegation exists', resolved.taskId);
+    const result = consumeDelegation(run.pendingDelegation, { now: options.now });
+    if (!result.ok)
+        return pauseOrchestration(taskRef, result.code, result.message, true, options);
+    const completed = result.receipt.stage === 'commit';
+    const updated = withUpdatedRun(run, {
+        status: completed ? 'completed' : 'running',
+        nextStage: null,
+        stepCount: run.stepCount + 1,
+        pendingDelegation: null,
+        receipts: Object.freeze([...run.receipts, result.receipt]),
+        commitAuthorization: completed
+            ? { ...run.commitAuthorization, consumedAt: (options.now ?? (() => new Date().toISOString()))() }
+            : run.commitAuthorization
+    });
+    saveRun(resolved.taskDir, updated);
+    return { status: updated.status, changed: true, taskId: resolved.taskId, run: updated, next: null, error: null };
+}
+function pauseOrchestration(taskRef, code, message, recoverable, options = {}) {
+    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return failed(resolved.code, resolved.message, resolved.taskId);
+    const run = readRun(resolved.taskDir);
+    if (!run)
+        return failed('ORCHESTRATION_RUN_MISSING', 'no orchestration run exists', resolved.taskId);
+    const updated = withUpdatedRun(run, { status: 'paused', pause: { code, message, recoverable } });
+    saveRun(resolved.taskDir, updated);
+    return { status: 'paused', changed: true, taskId: resolved.taskId, run: updated, next: null, error: null };
+}
+export { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, beginOrResumeOrchestration, completeCommitOrchestrationStage, completeOrchestrationStage, orchestrationPath, pauseOrchestration, prepareOrchestrationDelegation, readRun, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, statusOrchestration, validateOrchestrationStage };
+//# sourceMappingURL=orchestration.js.map

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

@@ -1,13 +1,15 @@
-// Shared helpers for review-artifact parsing.
-// Imported by typed artifact lifecycle and verification so the round/verdict vocabulary stays
-// in a single source of truth (prevents the cross-file drift this lifecycle
-// is designed to eliminate).
-import fs from "node:fs";
-import path from "node:path";
-export function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+import fs from 'node:fs';
+import path from 'node:path';
+const SUMMARY_HEADINGS = new Set(['审查摘要', 'Review Summary']);
+const PLACEHOLDERS = [
+    '{unresolved-blockers}',
+    '{unresolved-major}',
+    '{unresolved-minor}'
+];
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-export function maxRound(entries, stem) {
+function maxRound(entries, stem) {
     let max = 0;
     for (const entry of entries) {
         if (entry === `${stem}.md`) {
@@ -15,87 +17,169 @@ export function maxRound(entries, stem) {
             continue;
         }
         const match = entry.match(new RegExp(`^${escapeRegExp(stem)}-r(\\d+)\\.md$`));
-        if (match) {
+        if (match)
             max = Math.max(max, Number(match[1]));
-        }
     }
     return max;
 }
-export function artifactName(stem, round) {
+function artifactName(stem, round) {
     return round === 1 ? `${stem}.md` : `${stem}-r${round}.md`;
 }
-export function normalizeVerdict(raw) {
+function normalizeVerdict(raw) {
     const value = String(raw).trim().toLowerCase();
-    if (value === "通过" || value === "approved") {
-        return "Approved";
-    }
-    if (value === "需要修改" || value === "changes requested") {
-        return "Changes Requested";
-    }
-    if (value === "拒绝" || value === "rejected") {
-        return "Rejected";
-    }
-    return "";
+    if (value === '通过' || value === 'approved')
+        return 'Approved';
+    if (value === '需要修改' || value === 'changes requested')
+        return 'Changes Requested';
+    if (value === '拒绝' || value === 'rejected')
+        return 'Rejected';
+    return '';
 }
-export function extractSection(content, names) {
+function extractSection(content, names) {
     const lines = content.split(/\r?\n/);
     const nameSet = new Set(names);
     const start = lines.findIndex((line) => {
         const match = line.trim().match(/^##\s+(.+?)\s*$/);
         return match ? nameSet.has(match[1]) : false;
     });
-    if (start === -1) {
-        return "";
-    }
+    if (start === -1)
+        return '';
     const sectionLines = [];
     for (let index = start + 1; index < lines.length; index += 1) {
-        if (/^##\s+/.test(lines[index])) {
+        if (/^##\s+/.test(lines[index]))
             break;
-        }
         sectionLines.push(lines[index]);
     }
-    return sectionLines.join("\n");
+    return sectionLines.join('\n');
 }
-// Parse the canonical verdict out of a review-* artifact.
-// Returns { ok, verdict, message }. Verdict collapses Approved into
-// "Approved-with-issues" when the findings counts are non-zero.
-export function parseVerdict(reviewPath) {
-    if (!fs.existsSync(reviewPath)) {
-        return { ok: false, verdict: null, message: `Review artifact not found: ${path.basename(reviewPath)}` };
+function summaryBounds(content) {
+    const headings = [...content.matchAll(/^##\s+(.+?)\s*$/gm)]
+        .map((match) => ({ index: match.index, end: match.index + match[0].length, name: match[1] }));
+    const summaries = headings.filter((heading) => SUMMARY_HEADINGS.has(heading.name));
+    if (summaries.length !== 1)
+        return null;
+    const summary = summaries[0];
+    const next = headings.find((heading) => heading.index > summary.index);
+    return { start: summary.end, end: next?.index ?? content.length };
+}
+function uniqueLine(content, bounds, pattern) {
+    const section = content.slice(bounds.start, bounds.end);
+    const matches = [...section.matchAll(pattern)];
+    if (matches.length !== 1)
+        return null;
+    const match = matches[0];
+    return {
+        value: match[1],
+        start: bounds.start + match.index,
+        end: bounds.start + match.index + match[0].length
+    };
+}
+function parseCounts(value) {
+    const zh = /^(\d+)\s*阻塞项，\s*(\d+)\s*主要，\s*(\d+)\s*次要(?:\s*\/.*)?$/.exec(value);
+    const en = /^(\d+)\s*blockers?,\s*(\d+)\s*majors?,\s*(\d+)\s*minors?(?:\s*\/.*)?$/i.exec(value);
+    const match = zh ?? en;
+    if (!match)
+        return null;
+    const [blocker, major, minor] = match.slice(1, 4).map(Number);
+    if (![blocker, major, minor].every(Number.isSafeInteger))
+        return null;
+    return { blocker: blocker, major: major, minor: minor };
+}
+function parseManualValidation(value) {
+    const match = /\*\*(?:人工校验|Manual[- ]validation)\*\*[:：]\s*(\d+)/i.exec(value);
+    if (!match)
+        return null;
+    const count = Number(match[1]);
+    return Number.isSafeInteger(count) ? count : null;
+}
+function hasCanonicalPlaceholders(value) {
+    const zh = /^\{unresolved-blockers\}\s*阻塞项，\s*\{unresolved-major\}\s*主要，\s*\{unresolved-minor\}\s*次要(?:\s*\/.*)?$/.test(value);
+    const en = /^\{unresolved-blockers\}\s*blockers?,\s*\{unresolved-major\}\s*majors?,\s*\{unresolved-minor\}\s*minors?(?:\s*\/.*)?$/i.test(value);
+    return zh || en;
+}
+function parseReviewSummary(content) {
+    const bounds = summaryBounds(content);
+    if (!bounds) {
+        return { ok: false, code: 'REVIEW_SUMMARY_NOT_FOUND', message: 'review artifact must contain one review summary section' };
     }
-    const content = fs.readFileSync(reviewPath, "utf8");
-    const summary = extractSection(content, ["审查摘要", "Review Summary"]);
-    const fileName = path.basename(reviewPath);
-    if (!summary) {
-        return { ok: false, verdict: null, message: `cannot locate review summary section in ${fileName}` };
+    const verdictLine = uniqueLine(content, bounds, /^[-*]?\s*\*\*(?:总体结论|Overall Verdict)\*\*[:：]\s*(.+?)\s*$/gim);
+    const findingsLine = uniqueLine(content, bounds, /^[-*]?\s*\*\*(?:发现（AI 可处理）|Findings \(AI-actionable\))\*\*[:：]\s*(.+?)\s*$/gim);
+    const verdict = verdictLine ? normalizeVerdict(verdictLine.value) : '';
+    if (!verdict || !findingsLine) {
+        return { ok: false, code: 'REVIEW_SUMMARY_NOT_FOUND', message: 'review summary verdict or finding count line is missing or repeated' };
     }
-    const verdictMatch = summary.match(/^[-*]?\s*\*\*(?:总体结论|Overall Verdict)\*\*[:：]\s*(.+?)\s*$/im);
-    if (!verdictMatch) {
-        return { ok: false, verdict: null, message: `cannot parse verdict in ${fileName}` };
+    const counts = parseCounts(findingsLine.value);
+    if (counts) {
+        return {
+            ok: true,
+            summary: { verdict, counts, manualValidation: parseManualValidation(findingsLine.value), countState: 'numeric' },
+            findingsStart: findingsLine.start,
+            findingsEnd: findingsLine.end
+        };
     }
-    const verdict = normalizeVerdict(verdictMatch[1]);
-    if (!verdict) {
+    const placeholderOccurrences = PLACEHOLDERS.map((token) => ([...findingsLine.value.matchAll(new RegExp(escapeRegExp(token), 'g'))].length));
+    if (hasCanonicalPlaceholders(findingsLine.value) && placeholderOccurrences.every((count) => count === 1)) {
         return {
-            ok: false,
-            verdict: null,
-            message: `unrecognized verdict '${verdictMatch[1].trim()}' in ${fileName}`
+            ok: true,
+            summary: { verdict, counts: null, manualValidation: parseManualValidation(findingsLine.value), countState: 'placeholders' },
+            findingsStart: findingsLine.start,
+            findingsEnd: findingsLine.end
         };
     }
-    if (verdict !== "Approved") {
-        return { ok: true, verdict };
+    return {
+        ok: false,
+        code: 'REVIEW_SUMMARY_PLACEHOLDER_INVALID',
+        message: 'review summary finding counts must be three canonical placeholders or non-negative integers'
+    };
+}
+function equalCounts(left, right) {
+    return left.blocker === right.blocker && left.major === right.major && left.minor === right.minor;
+}
+function finalizeReviewSummaryContent(content, counts) {
+    const parsed = parseReviewSummary(content);
+    if (!parsed.ok)
+        return parsed;
+    if (parsed.summary.countState === 'numeric') {
+        if (equalCounts(parsed.summary.counts, counts))
+            return { ok: true, changed: false, content };
+        return {
+            ok: false,
+            code: 'REVIEW_SUMMARY_COUNT_MISMATCH',
+            message: 'review summary finding counts do not match the ledger snapshot'
+        };
     }
-    const findingsMatch = summary.match(/^[-*]?\s*\*\*(?:发现（AI 可处理）|Findings \(AI-actionable\))\*\*[:：]\s*(.+?)\s*$/im);
-    if (!findingsMatch) {
-        return { ok: false, verdict, message: `cannot parse findings count in ${fileName}` };
+    let line = content.slice(parsed.findingsStart, parsed.findingsEnd);
+    line = line
+        .replace(PLACEHOLDERS[0], String(counts.blocker))
+        .replace(PLACEHOLDERS[1], String(counts.major))
+        .replace(PLACEHOLDERS[2], String(counts.minor));
+    return {
+        ok: true,
+        changed: true,
+        content: content.slice(0, parsed.findingsStart) + line + content.slice(parsed.findingsEnd)
+    };
+}
+function parseVerdict(reviewPath) {
+    if (!fs.existsSync(reviewPath)) {
+        return { ok: false, verdict: null, message: `Review artifact not found: ${path.basename(reviewPath)}` };
     }
-    const counts = findingsMatch[1].match(/(\d+)\s*(?:阻塞项|blockers?).*?(\d+)\s*(?:主要|majors?).*?(\d+)\s*(?:次要|minors?)/i);
-    if (!counts) {
-        return { ok: false, verdict, message: `cannot parse findings count in ${fileName}` };
+    const parsed = parseReviewSummary(fs.readFileSync(reviewPath, 'utf8'));
+    if (!parsed.ok) {
+        return {
+            ok: false,
+            verdict: null,
+            message: `cannot parse review summary in ${path.basename(reviewPath)}: ${parsed.message}`
+        };
     }
-    const [, blockers, majors, minors] = counts.map(Number);
+    const { verdict, counts } = parsed.summary;
+    if (verdict !== 'Approved')
+        return { ok: true, verdict };
     return {
         ok: true,
-        verdict: blockers === 0 && majors === 0 && minors === 0 ? "Approved" : "Approved-with-issues"
+        verdict: counts && equalCounts(counts, { blocker: 0, major: 0, minor: 0 })
+            ? 'Approved'
+            : 'Approved-with-issues'
     };
 }
+export { artifactName, equalCounts, escapeRegExp, extractSection, finalizeReviewSummaryContent, maxRound, normalizeVerdict, parseReviewSummary, parseVerdict };
 //# sourceMappingURL=review-artifacts.js.map