@fitlab-ai/agent-infra 0.9.12 → 0.9.13

package/dist/lib/sandbox/control/state.js

@@ -1,9 +1,10 @@
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { buildProcessTreeStopCommand } from '../../server/process-control.js';
 import { getProcessIdentityState } from '../../server/process-state.js';
+import { parseSandboxControlResultEvidence, parseSandboxControlPayload, parseSandboxControlReservation, SANDBOX_CONTROL_MAX_RESPONSE_BYTES, SANDBOX_CONTROL_MAX_LOGICAL_RECORDS, SANDBOX_CONTROL_MAX_TERMINAL_RECORD_BYTES, SANDBOX_CONTROL_RESERVATION_BYTES } from './protocol.js';
 export const SANDBOX_CONTROL_AUDIT_MAX_BYTES = 1024 * 1024;
 export const SANDBOX_CONTROL_EXECUTION_STOP_MS = 2_000;
 function assertRegularFile(filePath) {
@@ -23,10 +24,212 @@ export function atomicWriteJson(filePath, value, mode = 0o600, createParent = tr
         fs.rmSync(temporary, { force: true });
     }
 }
+export function sandboxControlEncodedJsonBytes(value) {
+    return Buffer.byteLength(`${JSON.stringify(value)}\n`, 'utf8');
+}
+export function atomicWriteJsonNoReplace(filePath, value, mode = 0o600, createParent = true) {
+    atomicCreateJson(filePath, value, 'SANDBOX_CONTROL_TERMINAL_ALREADY_EXISTS', mode, createParent);
+}
+function atomicCreateJson(filePath, value, duplicateCode, mode = 0o600, createParent = true) {
+    if (createParent)
+        fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    const temporary = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${randomUUID()}.tmp`);
+    try {
+        fs.writeFileSync(temporary, `${JSON.stringify(value)}\n`, { mode, flag: 'wx' });
+        try {
+            fs.linkSync(temporary, filePath);
+        }
+        catch (error) {
+            if (error.code === 'EEXIST') {
+                throw new Error(duplicateCode);
+            }
+            throw error;
+        }
+    }
+    finally {
+        fs.rmSync(temporary, { force: true });
+    }
+}
 export function readJsonFile(filePath) {
     assertRegularFile(filePath);
     return JSON.parse(fs.readFileSync(filePath, 'utf8'));
 }
+export function resultEvidencePath(manifest, requestId) {
+    if (!/^[a-f0-9-]{16,64}$/u.test(requestId))
+        throw new Error('SANDBOX_CONTROL_RESULT_EVIDENCE_INVALID');
+    return path.join(manifest.processingDir, requestId, 'result.json');
+}
+export function payloadPath(manifest, requestId) {
+    if (!/^[a-f0-9-]{16,64}$/u.test(requestId))
+        throw new Error('SANDBOX_CONTROL_PAYLOAD_INVALID');
+    return path.join(manifest.channelDir, 'responses', `${requestId}.payload.json`);
+}
+export function reservationPath(manifest, requestId) {
+    if (!/^[a-f0-9-]{16,64}$/u.test(requestId))
+        throw new Error('SANDBOX_CONTROL_RESERVATION_INVALID');
+    return path.join(manifest.processingDir, requestId, 'reservation.json');
+}
+export function readSandboxControlResultEvidence(filePath) {
+    assertRegularFile(filePath);
+    const raw = fs.readFileSync(filePath, 'utf8');
+    if (Buffer.byteLength(raw, 'utf8') > SANDBOX_CONTROL_MAX_TERMINAL_RECORD_BYTES) {
+        throw new Error('SANDBOX_CONTROL_RESULT_EVIDENCE_TOO_LARGE');
+    }
+    try {
+        return parseSandboxControlResultEvidence(JSON.parse(raw));
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === 'SANDBOX_CONTROL_RESULT_EVIDENCE_INVALID')
+            throw error;
+        throw new Error('SANDBOX_CONTROL_RESULT_EVIDENCE_INVALID');
+    }
+}
+export function sanitizeSandboxControlOutput(manifest, output) {
+    return manifest.token.length === 0 ? output : output.split(manifest.token).join('[REDACTED]');
+}
+export function sanitizeSandboxControlResult(manifest, result) {
+    return {
+        exitCode: result.exitCode,
+        stdout: sanitizeSandboxControlOutput(manifest, result.stdout),
+        stderr: sanitizeSandboxControlOutput(manifest, result.stderr)
+    };
+}
+export function writeSandboxControlResultEvidence(manifest, requestId, result) {
+    const normalized = sanitizeSandboxControlResult(manifest, result);
+    const stdout = normalized.stdout;
+    const stderr = normalized.stderr;
+    if (!/^[a-f0-9-]{16,64}$/u.test(requestId)
+        || !Number.isSafeInteger(result.exitCode)
+        || Buffer.byteLength(stdout, 'utf8') + Buffer.byteLength(stderr, 'utf8') > SANDBOX_CONTROL_MAX_RESPONSE_BYTES) {
+        throw new Error('SANDBOX_CONTROL_RESULT_EVIDENCE_INVALID');
+    }
+    const evidence = {
+        version: 1,
+        id: requestId,
+        generation: manifest.generation,
+        exitCode: result.exitCode,
+        stdoutBytes: Buffer.byteLength(stdout, 'utf8'),
+        stderrBytes: Buffer.byteLength(stderr, 'utf8'),
+        stdoutSha256: createHash('sha256').update(stdout, 'utf8').digest('hex'),
+        stderrSha256: createHash('sha256').update(stderr, 'utf8').digest('hex'),
+        captureState: 'metadata-only'
+    };
+    if (sandboxControlEncodedJsonBytes(evidence) > SANDBOX_CONTROL_MAX_TERMINAL_RECORD_BYTES) {
+        throw new Error('SANDBOX_CONTROL_RESULT_EVIDENCE_TOO_LARGE');
+    }
+    atomicCreateJson(resultEvidencePath(manifest, requestId), evidence, 'SANDBOX_CONTROL_RESULT_EVIDENCE_ALREADY_EXISTS');
+    return readSandboxControlResultEvidence(resultEvidencePath(manifest, requestId));
+}
+export function writeSandboxControlPayload(manifest, requestId, result) {
+    const payload = createSandboxControlPayload(manifest, requestId, result);
+    atomicCreateJson(payloadPath(manifest, requestId), payload, 'SANDBOX_CONTROL_PAYLOAD_ALREADY_EXISTS');
+    return readSandboxControlPayload(payloadPath(manifest, requestId));
+}
+export function createSandboxControlPayload(manifest, requestId, result) {
+    const stdout = sanitizeSandboxControlOutput(manifest, result.stdout);
+    const stderr = sanitizeSandboxControlOutput(manifest, result.stderr);
+    const payload = {
+        version: 1,
+        id: requestId,
+        generation: manifest.generation,
+        stdout,
+        stderr,
+        stdoutBytes: Buffer.byteLength(stdout, 'utf8'),
+        stderrBytes: Buffer.byteLength(stderr, 'utf8'),
+        stdoutSha256: createHash('sha256').update(stdout, 'utf8').digest('hex'),
+        stderrSha256: createHash('sha256').update(stderr, 'utf8').digest('hex')
+    };
+    if (payload.stdoutBytes + payload.stderrBytes > SANDBOX_CONTROL_MAX_RESPONSE_BYTES) {
+        throw new Error('SANDBOX_CONTROL_PAYLOAD_TOO_LARGE');
+    }
+    if (sandboxControlEncodedJsonBytes(payload) > SANDBOX_CONTROL_MAX_RESPONSE_BYTES) {
+        throw new Error('SANDBOX_CONTROL_PAYLOAD_TOO_LARGE');
+    }
+    return payload;
+}
+export function readSandboxControlPayload(filePath) {
+    assertRegularFile(filePath);
+    const raw = fs.readFileSync(filePath, 'utf8');
+    if (Buffer.byteLength(raw, 'utf8') > SANDBOX_CONTROL_MAX_RESPONSE_BYTES) {
+        throw new Error('SANDBOX_CONTROL_PAYLOAD_TOO_LARGE');
+    }
+    try {
+        return parseSandboxControlPayload(JSON.parse(raw));
+    }
+    catch {
+        throw new Error('SANDBOX_CONTROL_PAYLOAD_INVALID');
+    }
+}
+export function writeSandboxControlReservation(manifest, requestId, usage, now = Date.now()) {
+    if (usage.logicalRecords >= SANDBOX_CONTROL_MAX_LOGICAL_RECORDS
+        || usage.bytes + SANDBOX_CONTROL_RESERVATION_BYTES > SANDBOX_CONTROL_MAX_RESPONSE_BYTES) {
+        throw new Error('SANDBOX_CONTROL_CAPACITY_EXHAUSTED');
+    }
+    const reservation = {
+        version: 1,
+        id: requestId,
+        generation: manifest.generation,
+        logicalRecords: 1,
+        bytes: SANDBOX_CONTROL_RESERVATION_BYTES,
+        createdAt: now
+    };
+    atomicCreateJson(reservationPath(manifest, requestId), reservation, 'SANDBOX_CONTROL_RESERVATION_ALREADY_EXISTS');
+    return parseSandboxControlReservation(readJsonFile(reservationPath(manifest, requestId)));
+}
+export function readSandboxControlReservation(filePath) {
+    return parseSandboxControlReservation(readJsonFile(filePath));
+}
+export function sandboxControlGenerationUsage(manifest) {
+    const records = new Map();
+    const responsesDir = path.join(manifest.channelDir, 'responses');
+    if (fs.existsSync(responsesDir)) {
+        for (const entry of fs.readdirSync(responsesDir, { withFileTypes: true })) {
+            if (!entry.isFile())
+                continue;
+            const terminal = entry.name.match(/^([a-f0-9-]{16,64})\.json$/u);
+            const accepted = entry.name.match(/^([a-f0-9-]{16,64})\.accepted\.json$/u);
+            const payload = entry.name.match(/^([a-f0-9-]{16,64})\.payload\.json$/u);
+            if (!terminal && !accepted && !payload)
+                continue;
+            const id = (terminal ?? accepted ?? payload)[1];
+            const previous = records.get(id) ?? { baseBytes: 0, payloadBytes: 0, logical: false };
+            const fileBytes = fs.statSync(path.join(responsesDir, entry.name)).size;
+            if (payload)
+                previous.payloadBytes += fileBytes;
+            else
+                previous.baseBytes += fileBytes;
+            previous.logical ||= Boolean(terminal || accepted);
+            records.set(id, previous);
+        }
+    }
+    if (fs.existsSync(manifest.processingDir)) {
+        for (const entry of fs.readdirSync(manifest.processingDir, { withFileTypes: true })) {
+            if (!entry.isDirectory() || !/^[a-f0-9-]{16,64}$/u.test(entry.name))
+                continue;
+            const resultPath = resultEvidencePath(manifest, entry.name);
+            const filePath = reservationPath(manifest, entry.name);
+            const previous = records.get(entry.name) ?? { baseBytes: 0, payloadBytes: 0, logical: false };
+            if (fs.existsSync(resultPath)) {
+                const result = readSandboxControlResultEvidence(resultPath);
+                if (result.id !== entry.name || result.generation !== manifest.generation) {
+                    throw new Error('SANDBOX_CONTROL_RESULT_EVIDENCE_INVALID');
+                }
+                previous.baseBytes += fs.statSync(resultPath).size;
+                previous.logical = true;
+            }
+            if (fs.existsSync(filePath)) {
+                const reservation = readSandboxControlReservation(filePath);
+                previous.baseBytes = Math.max(previous.baseBytes, reservation.bytes);
+                previous.logical = true;
+            }
+            records.set(entry.name, previous);
+        }
+    }
+    return {
+        logicalRecords: [...records.values()].filter((record) => record.logical).length,
+        bytes: [...records.values()].reduce((total, record) => total + record.baseBytes + record.payloadBytes, 0)
+    };
+}
 export function statusPath(manifest) {
     return path.join(manifest.publicStatusDir, 'status.json');
 }

package/dist/lib/server/protocol.js

@@ -9,6 +9,28 @@ function splitWords(text) {
 function taskSubcommand(subcommand) {
     return subcommand === 'list' ? 'ls' : subcommand;
 }
+function splitRunArguments(args) {
+    const hostArgs = [];
+    const skillArgs = [];
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === '--tui') {
+            hostArgs.push(arg);
+            const value = args[i + 1];
+            if (value !== undefined) {
+                hostArgs.push(value);
+                i += 1;
+            }
+        }
+        else if (arg === '--recreate') {
+            hostArgs.push(arg);
+        }
+        else {
+            skillArgs.push(arg);
+        }
+    }
+    return { hostArgs, skillArgs };
+}
 export function commandHelp() {
     return [
         `agent-infra ${VERSION}`,
@@ -78,7 +100,22 @@ export function parseCommand(text) {
         const spec = getSkillRunSpec(subcommand);
         if (!spec)
             return { kind: 'error', message: `Unknown skill: ${subcommand}` };
-        return { kind: 'ai', role: spec.role, argv: ['run', subcommand, ...rest] };
+        if (spec.kind === 'create') {
+            return { kind: 'ai', role: spec.role, argv: ['run', '--skill', subcommand, ...rest] };
+        }
+        const [taskRef, ...skillArgs] = rest;
+        if (!taskRef)
+            return { kind: 'error', message: '/run task skills require a task-ref' };
+        const { hostArgs, skillArgs: forwardedSkillArgs } = splitRunArguments(skillArgs);
+        return {
+            kind: 'ai',
+            role: spec.role,
+            argv: [
+                'run', '--skill', subcommand, '--task', taskRef,
+                ...hostArgs,
+                ...(forwardedSkillArgs.length > 0 ? ['--', ...forwardedSkillArgs] : [])
+            ]
+        };
     }
     return { kind: 'error', message: `Unknown command: ${command}` };
 }

package/dist/lib/task/activity-log.js

@@ -5,6 +5,7 @@ const STARTED_SUFFIX_RE = /\s*\[started\]\s*$/;
 const ABORTED_SUFFIX_RE = /\s*\[aborted\]\s*$/;
 const ATTEMPT_RE = /(?:^|;\s*)attempt=([A-Za-z0-9-]{8,64})(?:;|$)/;
 const COMMIT_STARTED_RE = /^started; attempt=([A-Za-z0-9-]{8,64}); baseline=([a-f0-9]{40,64}); agent=([a-z-]+)$/;
+const LIFECYCLE_STEP_RE = /^(?:Complete Manual Validation|(?:Analyze Task|Review Analysis|Plan Task|Review Plan|Code Task|Review Code|Run Manual Validation) \(Round [1-9]\d*(?:(?:, fix for review-code(?:-r[2-9]|-r[1-9]\d+)?\.md)|(?:, decision II-[1-9]\d*))?\))$/;
 function parseActivityLog(content) {
     const section = locateActivityLog(content);
     return section ? { sectionFound: true, entries: section.entries } : { sectionFound: false, entries: [] };
@@ -87,5 +88,11 @@ function pairEntries(entries) {
 function startedBackedRows(rows) {
     return rows.filter((row) => row.started !== '');
 }
-export { activityAttempt, appendActivityEntry, commitAttemptStartedNote, locateActivityLog, pairEntries, parseActivityLog, parseCommitAttemptStarted, startedBackedRows };
+function hasOpenLifecycleExecution(content) {
+    const section = locateActivityLog(content);
+    if (!section)
+        return false;
+    return pairEntries(section.entries).some((row) => row.done === '' && LIFECYCLE_STEP_RE.test(row.step));
+}
+export { activityAttempt, appendActivityEntry, hasOpenLifecycleExecution, commitAttemptStartedNote, locateActivityLog, pairEntries, parseActivityLog, parseCommitAttemptStarted, startedBackedRows };
 //# sourceMappingURL=activity-log.js.map

package/dist/lib/task/artifact-lifecycle.js

@@ -6,6 +6,7 @@ import { parseImplementationInputs, selectPendingImplementationInput } from './i
 import { parseVerdict } from './review-artifacts.js';
 import { extractSection, findSectionHeading } from './sections.js';
 import { receiptForOutput, sha256File } from './artifact-receipts.js';
+import { isArtifactInvalidated, parseInvalidationDocument } from './invalidation.js';
 const artifactFamilyCatalog = [
     { family: 'analysis', sectionAliases: ['分析', 'Analysis'], heading: '分析', labels: ['需求分析报告', 'Requirements Analysis'] },
     { family: 'review-analysis', sectionAliases: ['审查反馈', 'Review Feedback'], heading: '审查反馈', labels: ['需求分析审查', 'Analysis Review'] },
@@ -85,7 +86,24 @@ function inspectArtifactDirectory(taskDir, family, identity = {}) {
             taskId: identity.taskId ?? null, taskDir, taskState: identity.taskState ?? null
         });
     }
+    let invalidation = { operations: [], targets: [] };
+    try {
+        const taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
+        const parsed = parseInvalidationDocument(taskContent);
+        if (!parsed.ok) {
+            return failure(requestRef, family, { code: 'ARTIFACT_INVALIDATION_INVALID', message: parsed.message }, {
+                taskId: identity.taskId ?? null, taskDir, taskState: identity.taskState ?? null
+            });
+        }
+        invalidation = parsed.document;
+    }
+    catch (error) {
+        return failure(requestRef, family, { code: 'ARTIFACT_INVALIDATION_INVALID', message: String(error) }, {
+            taskId: identity.taskId ?? null, taskDir, taskState: identity.taskState ?? null
+        });
+    }
     const artifacts = [];
+    const knownArtifacts = [];
     const diagnostics = [];
     for (const entry of entries) {
         const parsed = parseArtifactName(entry.name);
@@ -117,19 +135,23 @@ function inspectArtifactDirectory(taskDir, family, identity = {}) {
                 diagnostics.push(diagnostic('FILESYSTEM_RACE', family, entry.name, `artifact is not readable: ${entry.name}`));
                 continue;
             }
-            artifacts.push({ ...parsed, path: abs, size: stat.size, mtimeMs: stat.mtimeMs });
+            const identity = { ...parsed, path: abs, size: stat.size, mtimeMs: stat.mtimeMs };
+            knownArtifacts.push(identity);
+            if (!isArtifactInvalidated(invalidation, family, entry.name))
+                artifacts.push(identity);
         }
         catch (error) {
             diagnostics.push(diagnostic('FILESYSTEM_RACE', family, entry.name, String(error)));
         }
     }
     artifacts.sort((left, right) => left.round - right.round);
-    const rounds = new Set(artifacts.map((item) => item.round));
-    if (artifacts.length > 0 && !rounds.has(1))
+    knownArtifacts.sort((left, right) => left.round - right.round);
+    const knownRounds = new Set(knownArtifacts.map((item) => item.round));
+    if (knownArtifacts.length > 0 && !knownRounds.has(1))
         diagnostics.push(diagnostic('MISSING_BASE', family, null, `${family}.md is missing`));
-    const max = artifacts.at(-1)?.round ?? 0;
+    const max = knownArtifacts.at(-1)?.round ?? 0;
     for (let round = 1; round <= max; round += 1) {
-        if (!rounds.has(round))
+        if (!knownRounds.has(round))
             diagnostics.push(diagnostic('ROUND_GAP', family, null, `${artifactName(family, round)} is missing`));
     }
     const latest = artifacts.at(-1) ?? null;
@@ -163,6 +185,12 @@ function resolveReviewedInput(taskDir, review, expectedFamily, diagnostics) {
         if (!stat.isFile() || stat.isSymbolicLink())
             throw new Error('referenced input is not a regular file');
         const taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
+        const invalidation = parseInvalidationDocument(taskContent);
+        if (!invalidation.ok)
+            throw new Error(invalidation.message);
+        if (isArtifactInvalidated(invalidation.document, expectedFamily, parsed.name)) {
+            throw new Error(`${parsed.name} is invalidated`);
+        }
         const receipt = receiptForOutput(taskContent, review.name);
         if (!receipt)
             throw new Error(`receipt for ${review.name} is missing`);

package/dist/lib/task/capabilities.js

@@ -0,0 +1,239 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { invalidationBlocks, isArtifactInvalidated, parseInvalidationDocument } from './invalidation.js';
+import { receiptForOutput } from './artifact-receipts.js';
+import { parseTypedTaskFrontmatter } from './frontmatter.js';
+import { parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
+import { parseReviewSummary, resolveCanonicalVerdict } from './review-artifacts.js';
+import { parseReworkIntentDocument } from './rework-intent.js';
+import { sha256File } from './artifact-receipts.js';
+import { hasOpenLifecycleExecution } from './activity-log.js';
+const REASONS = new Set([
+    'user-request', 'new-requirement', 'upstream-fact-doubt', 'review-finding', 'retry', 'validation-rerun'
+]);
+function deny(reasonCode, ...evidence) {
+    return { allowed: false, reasonCode, evidence };
+}
+function allow(...evidence) {
+    return { allowed: true, reasonCode: 'CAPABILITY_ALLOWED', evidence };
+}
+function hasArtifact(facts, action) {
+    return (facts.artifacts[action]?.length ?? 0) > 0;
+}
+function canStart(action, facts, trigger) {
+    if (!trigger || trigger.requestedAction !== action)
+        return deny('TRIGGER_ACTION_MISMATCH', `requested=${trigger?.requestedAction ?? 'missing'}`);
+    if (!trigger.requestId || !trigger.requestId.trim())
+        return deny('TRIGGER_REQUEST_ID_REQUIRED');
+    if (!REASONS.has(trigger.reasonCode))
+        return deny('TRIGGER_REASON_INVALID');
+    if (trigger.sourceArtifact && !trigger.sourceSha256)
+        return deny('SOURCE_ARTIFACT_HASH_REQUIRED');
+    if (trigger.sourceSha256 && !trigger.sourceArtifact)
+        return deny('SOURCE_ARTIFACT_REQUIRED');
+    if (trigger.sourceArtifact && trigger.sourceSha256) {
+        const actual = facts.artifactHashes[trigger.sourceArtifact];
+        if (!actual)
+            return deny('SOURCE_ARTIFACT_MISSING', trigger.sourceArtifact);
+        if (actual !== trigger.sourceSha256)
+            return deny('SOURCE_ARTIFACT_HASH_MISMATCH', trigger.sourceArtifact);
+    }
+    if (facts.taskState !== 'active')
+        return deny('TASK_NOT_ACTIVE', `state=${facts.taskState}`);
+    if (invalidationBlocks(facts.invalidation))
+        return deny('INVALIDATION_INCOMPLETE');
+    if (facts.executionBusy)
+        return deny('EXECUTION_BUSY');
+    const implicit = trigger.explicitRequest === false;
+    if (action === 'analysis') {
+        if (!implicit || hasArtifact(facts, 'analysis') || facts.recommendedAction === 'analysis')
+            return allow('analysis-capability');
+        return deny('ANALYSIS_REQUEST_REQUIRES_EXPLICIT_TRIGGER');
+    }
+    if (action === 'review-analysis') {
+        return hasArtifact(facts, 'analysis') ? allow('analysis-artifact') : deny('ANALYSIS_ARTIFACT_REQUIRED');
+    }
+    if (action === 'plan') {
+        if (!hasArtifact(facts, 'review-analysis'))
+            return deny('ANALYSIS_REVIEW_REQUIRED');
+        if (!reviewMatchesLatest(facts, 'analysis', 'review-analysis'))
+            return deny('ANALYSIS_REVIEW_NOT_LATEST');
+        if (facts.reviews['review-analysis'] !== 'approved')
+            return deny('ANALYSIS_REVIEW_NOT_APPROVED');
+        if (facts.unresolvedLedger.analysis > 0)
+            return deny('ANALYSIS_LEDGER_BLOCKED', `unresolved=${facts.unresolvedLedger.analysis}`);
+        return allow('analysis-review-approved');
+    }
+    if (action === 'review-plan') {
+        return hasArtifact(facts, 'plan') ? allow('plan-artifact') : deny('PLAN_ARTIFACT_REQUIRED');
+    }
+    if (action === 'code') {
+        if (trigger.implementationInput) {
+            if (!hasArtifact(facts, 'review-code'))
+                return deny('CODE_REVIEW_REQUIRED');
+            if (!reviewMatchesLatest(facts, 'code', 'review-code'))
+                return deny('CODE_REVIEW_NOT_LATEST');
+            if (facts.reviews['review-code'] !== 'approved')
+                return deny('CODE_REVIEW_NOT_APPROVED');
+            return allow('implementation-input');
+        }
+        if (!hasArtifact(facts, 'review-plan'))
+            return deny('PLAN_REVIEW_REQUIRED');
+        if (!reviewMatchesLatest(facts, 'plan', 'review-plan'))
+            return deny('PLAN_REVIEW_NOT_LATEST');
+        if (facts.reviews['review-plan'] !== 'approved')
+            return deny('PLAN_REVIEW_NOT_APPROVED');
+        if (facts.unresolvedLedger.plan > 0)
+            return deny('PLAN_LEDGER_BLOCKED', `unresolved=${facts.unresolvedLedger.plan}`);
+        return allow('plan-review-approved');
+    }
+    if (action === 'review-code') {
+        return hasArtifact(facts, 'code') ? allow('code-artifact') : deny('CODE_ARTIFACT_REQUIRED');
+    }
+    if (action === 'manual-validation' || action === 'validation-run') {
+        if (!hasArtifact(facts, 'review-code'))
+            return deny('CODE_REVIEW_REQUIRED');
+        if (!reviewMatchesLatest(facts, 'code', 'review-code'))
+            return deny('CODE_REVIEW_NOT_LATEST');
+        if (facts.reviews['review-code'] !== 'approved')
+            return deny('CODE_REVIEW_NOT_APPROVED');
+        if (facts.unresolvedLedger.code > 0)
+            return deny('CODE_LEDGER_BLOCKED', `unresolved=${facts.unresolvedLedger.code}`);
+        return allow('code-review-approved');
+    }
+    return deny('CAPABILITY_ACTION_UNKNOWN');
+}
+function artifactRound(name) {
+    const match = /-r(\d+)\.md$/.exec(name);
+    return match ? Number(match[1]) : 1;
+}
+function latestArtifact(names) {
+    return [...names].sort((left, right) => artifactRound(right) - artifactRound(left) || left.localeCompare(right))[0] ?? null;
+}
+function reviewedInputName(content, expectedFamily) {
+    const header = content.split(/\r?\n/).findIndex((line) => /\*\*(?:审查输入|Review Input)\*\*[:：]/.test(line));
+    if (header < 0)
+        return null;
+    const referenceBlock = content.split(/\r?\n/).slice(header, header + 12).join('\n');
+    const expected = new RegExp('`' + expectedFamily + '(?:-r[2-9]|-r[1-9]\\d+)?\\.md`');
+    return expected.exec(referenceBlock)?.[0].slice(1, -1) ?? null;
+}
+function reviewMatchesLatest(facts, source, review) {
+    const latestSource = latestArtifact(facts.artifacts[source] ?? []);
+    return Boolean(latestSource && facts.reviewedInputs?.[review] === latestSource);
+}
+function recommendNext(facts) {
+    if (invalidationBlocks(facts.invalidation))
+        return { action: null, reasonCode: 'INVALIDATION_INCOMPLETE', evidence: ['reconcile task invalidation before routing'] };
+    const pendingIntent = (facts.reworkIntents ?? []).find((intent) => intent.status === 'pending');
+    if (pendingIntent)
+        return { action: pendingIntent.target, reasonCode: 'REWORK_INTENT_PENDING', evidence: [pendingIntent.intentId, pendingIntent.findingId] };
+    if (!hasArtifact(facts, 'analysis'))
+        return { action: 'analysis', reasonCode: 'ANALYSIS_ARTIFACT_MISSING', evidence: ['analysis artifact is absent'] };
+    if (!hasArtifact(facts, 'review-analysis') || !reviewMatchesLatest(facts, 'analysis', 'review-analysis')) {
+        return { action: 'review-analysis', reasonCode: 'ANALYSIS_REVIEW_MISSING', evidence: ['analysis review does not bind the latest analysis artifact'] };
+    }
+    if (facts.reviews['review-analysis'] !== 'approved' || facts.unresolvedLedger.analysis > 0) {
+        return { action: 'analysis', reasonCode: 'ANALYSIS_REWORK_REQUIRED', evidence: ['analysis review or ledger is not clear'] };
+    }
+    if (!hasArtifact(facts, 'plan'))
+        return { action: 'plan', reasonCode: 'PLAN_ARTIFACT_MISSING', evidence: ['plan artifact is absent'] };
+    if (!hasArtifact(facts, 'review-plan') || !reviewMatchesLatest(facts, 'plan', 'review-plan')) {
+        return { action: 'review-plan', reasonCode: 'PLAN_REVIEW_MISSING', evidence: ['plan review does not bind the latest plan artifact'] };
+    }
+    if (facts.reviews['review-plan'] !== 'approved' || facts.unresolvedLedger.plan > 0) {
+        return { action: 'plan', reasonCode: 'PLAN_REWORK_REQUIRED', evidence: ['plan review or ledger is not clear'] };
+    }
+    if (!hasArtifact(facts, 'code'))
+        return { action: 'code', reasonCode: 'CODE_ARTIFACT_MISSING', evidence: ['code artifact is absent'] };
+    if (!hasArtifact(facts, 'review-code') || !reviewMatchesLatest(facts, 'code', 'review-code')) {
+        return { action: 'review-code', reasonCode: 'CODE_REVIEW_MISSING', evidence: ['code review does not bind the latest code artifact'] };
+    }
+    if (facts.reviews['review-code'] !== 'approved') {
+        return { action: 'code', reasonCode: 'CODE_REWORK_REQUIRED', evidence: ['code review or ledger is not clear'] };
+    }
+    return { action: null, reasonCode: 'LIFECYCLE_REVIEWED', evidence: ['latest code review is approved'] };
+}
+function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBusy = false) {
+    try {
+        const metadata = parseTypedTaskFrontmatter(content);
+        const invalidation = parseInvalidationDocument(content);
+        if (!invalidation.ok)
+            return { ok: false, code: 'TASK_CAPABILITY_FACTS_INVALID', message: invalidation.message };
+        const rework = parseReworkIntentDocument(content);
+        if (!rework.ok)
+            return { ok: false, code: 'TASK_CAPABILITY_FACTS_INVALID', message: rework.message };
+        const ledger = parseLedgerDocument(content);
+        if (ledger.present) {
+            const invalid = validateLedgerRows(ledger.rows);
+            if (invalid)
+                return { ok: false, code: 'TASK_CAPABILITY_FACTS_INVALID', message: invalid.message };
+        }
+        const files = fs.readdirSync(taskDir).filter((name) => {
+            if (!name.endsWith('.md'))
+                return false;
+            const stat = fs.lstatSync(path.join(taskDir, name));
+            return stat.isFile() && !stat.isSymbolicLink();
+        });
+        const artifactFamilies = {
+            analysis: /^analysis(?:-r\d+)?\.md$/,
+            'review-analysis': /^review-analysis(?:-r\d+)?\.md$/,
+            plan: /^plan(?:-r\d+)?\.md$/,
+            'review-plan': /^review-plan(?:-r\d+)?\.md$/,
+            code: /^code(?:-r\d+)?\.md$/,
+            'review-code': /^review-code(?:-r\d+)?\.md$/
+        };
+        const familyFor = (name) => Object.keys(artifactFamilies)
+            .find((family) => artifactFamilies[family].test(name)) ?? null;
+        const activeFiles = files.filter((name) => {
+            const family = familyFor(name);
+            return !family || !isArtifactInvalidated(invalidation.document, family, name);
+        });
+        const artifactHashes = {};
+        for (const name of activeFiles)
+            artifactHashes[name] = sha256File(path.join(taskDir, name));
+        const artifacts = Object.fromEntries(Object.keys(artifactFamilies).map((family) => [
+            family, activeFiles.filter((name) => artifactFamilies[family].test(name))
+        ]));
+        const staleArtifacts = Object.fromEntries(Object.keys(artifactFamilies).map((family) => [
+            family, files.filter((name) => artifactFamilies[family].test(name) && isArtifactInvalidated(invalidation.document, family, name))
+        ]));
+        const reviews = {};
+        const reviewedInputs = {};
+        for (const family of ['review-analysis', 'review-plan', 'review-code']) {
+            const latest = latestArtifact(artifacts[family] ?? []);
+            if (!latest)
+                continue;
+            const reviewContent = fs.readFileSync(path.join(taskDir, latest), 'utf8');
+            const expectedFamily = family === 'review-analysis' ? 'analysis' : family === 'review-plan' ? 'plan' : 'code';
+            const input = reviewedInputName(reviewContent, expectedFamily);
+            const receipt = input ? receiptForOutput(content, latest) : null;
+            if (input && receipt?.input === input && artifactHashes[input] === receipt.inputSha256)
+                reviewedInputs[family] = input;
+            const parsed = parseReviewSummary(reviewContent);
+            if (!parsed.ok)
+                continue;
+            const verdict = resolveCanonicalVerdict(parsed.summary);
+            if (verdict.ok)
+                reviews[family] = verdict.verdict === 'Approved' ? 'approved' : verdict.verdict === 'Changes Requested' ? 'changes-requested' : 'rejected';
+        }
+        const unresolvedLedger = { analysis: 0, plan: 0, code: 0 };
+        if (ledger.present) {
+            for (const stage of ['analysis', 'plan', 'code'])
+                unresolvedLedger[stage] = summarizeLedgerStage(ledger.rows, stage).unresolved.length;
+        }
+        const facts = {
+            taskState, currentStep: String(metadata.current_step ?? ''), artifacts, reviews,
+            staleArtifacts, reviewedInputs, artifactHashes,
+            invalidation: invalidation.document, reworkIntents: rework.intents,
+            unresolvedLedger, executionBusy: executionBusy || hasOpenLifecycleExecution(content), recommendedAction: null
+        };
+        facts.recommendedAction = recommendNext(facts).action;
+        return { ok: true, facts };
+    }
+    catch (error) {
+        return { ok: false, code: 'TASK_CAPABILITY_FACTS_INVALID', message: error instanceof Error ? error.message : String(error) };
+    }
+}
+export { buildLifecycleFacts, canStart, recommendNext };
+//# sourceMappingURL=capabilities.js.map