@fitlab-ai/agent-infra 0.9.14 → 0.10.0

package/dist/lib/task/intermediate-cleanup.js

@@ -0,0 +1,441 @@
+import { inspectOwnedPath } from '../owned-path.js';
+import { taskFinalizationReceiptState } from './finalization-state.js';
+import { withTaskExecutionLock } from './task-execution-lock.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { checkpointCommitMatches } from './commit-identity.js';
+import { readCheckpointIntent } from './commit-intent.js';
+import { parseTaskFrontmatter } from './frontmatter.js';
+import { readTaskFinalizationReceipt } from './finalization.js';
+import { semanticDigest, sha256Content } from './local-artifact-finalization.js';
+import { artifactRecoveryRoot, readArtifactRecoveryIntent } from './artifact-repair-intent.js';
+import { parseArtifactName } from './artifact-name.js';
+import { enumerateAllTaskDirs } from './resolve-ref.js';
+const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
+const LOCAL_INTENT_RE = /^(TASK-\d{8}-\d{6})-(analysis|review-analysis|plan|review-plan|code|review-code)-(.+\.md)\.json$/;
+const COMMIT_INTENT_RE = /^(TASK-\d{8}-\d{6})\.json$/;
+const AUXILIARY_ROOTS = [
+    '.local-artifact-finalization-intents',
+    '.task-commit-intents'
+];
+function auxiliaryRoot(repoRoot, name) {
+    return path.join(repoRoot, '.agents', 'workspace', name);
+}
+function taskRoot(repoRoot) {
+    return path.join(repoRoot, '.agents', 'workspace');
+}
+function fileIdentity(stat) {
+    return {
+        dev: String(stat.dev),
+        ino: String(stat.ino),
+        size: stat.size,
+        mtimeMs: stat.mtimeMs
+    };
+}
+function sameFileIdentity(left, right) {
+    return left.dev === right.dev && left.ino === right.ino
+        && left.size === right.size && left.mtimeMs === right.mtimeMs;
+}
+function errorCode(error) {
+    const code = error?.code;
+    return typeof code === 'string' ? code : null;
+}
+function safeLstat(root, target, expect) {
+    const stat = inspectOwnedPath(root, target, expect);
+    return stat ? fileIdentity(stat) : null;
+}
+function inspectTaskRecords(repoRoot, taskIds) {
+    const records = new Map();
+    for (const entry of enumerateAllTaskDirs(repoRoot)) {
+        if (taskIds && !taskIds.has(entry.taskId))
+            continue;
+        const taskMdPath = path.join(entry.taskDir, 'task.md');
+        if (safeLstat(taskRoot(repoRoot), taskMdPath, 'file') === null)
+            continue;
+        const content = fs.readFileSync(taskMdPath, 'utf8');
+        records.set(entry.taskId, {
+            taskId: entry.taskId,
+            taskDir: entry.taskDir,
+            state: entry.state,
+            frontmatter: parseTaskFrontmatter(content)
+        });
+    }
+    return records;
+}
+function item(kind, taskId, filePath, disposition, reason, identity = null) {
+    return { kind, taskId, path: path.resolve(filePath), disposition, reason, identity };
+}
+function taskGate(task) {
+    if (!task)
+        return 'TASK_NOT_FOUND';
+    if (task.state !== 'completed' && task.state !== 'archive')
+        return 'TASK_STATE_PROTECTED';
+    if (task.frontmatter.id !== task.taskId || task.frontmatter.status !== 'completed')
+        return 'TASK_STATE_PROTECTED';
+    if (!task.frontmatter.branch)
+        return 'TASK_IDENTITY_INVALID';
+    return null;
+}
+function receiptGate(repoRoot, task, options) {
+    let receipt;
+    try {
+        receipt = readTaskFinalizationReceipt(repoRoot, task.taskId);
+    }
+    catch {
+        return 'FINALIZATION_RECEIPT_INVALID';
+    }
+    if (!receipt)
+        return 'FINALIZATION_RECEIPT_MISSING';
+    const state = taskFinalizationReceiptState(receipt);
+    if (state === 'pending')
+        return 'FINALIZATION_RECEIPT_PENDING';
+    if (state === 'unresolved')
+        return 'LFAI_RETRY_OR_WARNING_OPEN';
+    if (receipt.controlBinding) {
+        const evidence = options.controlBindingEvidence?.(task.taskId, receipt.controlBinding);
+        if (evidence !== 'terminal' && !(options.preflight && evidence === 'pending'))
+            return 'CONTROL_BINDING_MISMATCH';
+    }
+    return null;
+}
+function canonicalLocalIntentPath(taskId, family, artifact) {
+    return `${taskId}-${family}-${artifact}.json`;
+}
+function localIntentCandidate(repoRoot, task, filePath, taskId, family, artifact, identity, options) {
+    const protectedReason = taskGate(task);
+    if (protectedReason)
+        return item('LFAI-CONSUMED', taskId, filePath, 'protected', protectedReason, identity);
+    if (path.basename(filePath) !== canonicalLocalIntentPath(taskId, family, artifact)
+        || !parseArtifactName(artifact)?.family || parseArtifactName(artifact).family !== family) {
+        return item('LFAI-CONSUMED', taskId, filePath, 'protected', 'PATH_IDENTITY_MISMATCH', identity);
+    }
+    let intent;
+    try {
+        intent = readArtifactRecoveryIntent(repoRoot, taskId, family, artifact);
+    }
+    catch {
+        return item('LFAI-CONSUMED', taskId, filePath, 'protected', 'LFAI_SCHEMA_INVALID', identity);
+    }
+    if (!intent || intent.state !== 'consumed') {
+        return item('LFAI-CONSUMED', taskId, filePath, 'protected', 'LFAI_STATE_PROTECTED', identity);
+    }
+    const artifactPath = path.join(task.taskDir, artifact);
+    if (safeLstat(task.taskDir, artifactPath, 'file') === null) {
+        return item('LFAI-CONSUMED', taskId, filePath, 'protected', 'ARTIFACT_IDENTITY_MISMATCH', identity);
+    }
+    let content;
+    try {
+        content = fs.readFileSync(artifactPath, 'utf8');
+    }
+    catch {
+        return item('LFAI-CONSUMED', taskId, filePath, 'protected', 'ARTIFACT_UNREADABLE', identity);
+    }
+    if (intent.finalArtifactSha256 !== sha256Content(content) || intent.finalSemanticDigest !== semanticDigest(content)) {
+        return item('LFAI-CONSUMED', taskId, filePath, 'protected', 'ARTIFACT_DIGEST_MISMATCH', identity);
+    }
+    const receiptReason = receiptGate(repoRoot, task, options);
+    if (receiptReason)
+        return item('LFAI-CONSUMED', taskId, filePath, 'protected', receiptReason, identity);
+    return item('LFAI-CONSUMED', taskId, filePath, 'planned', 'LFAI_CONSUMED_AND_VERIFIED', identity);
+}
+function commitIntentCandidate(repoRoot, task, filePath, taskId, identity, options) {
+    const protectedReason = taskGate(task);
+    if (protectedReason)
+        return item('COMMIT-SYNCED', taskId, filePath, 'protected', protectedReason, identity);
+    let intent;
+    try {
+        intent = readCheckpointIntent(repoRoot, taskId);
+    }
+    catch {
+        return item('COMMIT-SYNCED', taskId, filePath, 'protected', 'COMMIT_INTENT_INVALID', identity);
+    }
+    if (!intent || intent.state !== 'synced' || intent.taskId !== taskId
+        || intent.branch !== task.frontmatter.branch || !intent.committedHead
+        || task.frontmatter.checkpoint_commit !== intent.committedHead
+        || !checkpointCommitMatches(repoRoot, intent, intent.committedHead)) {
+        return item('COMMIT-SYNCED', taskId, filePath, 'protected', 'COMMIT_EVIDENCE_MISMATCH', identity);
+    }
+    const receiptReason = receiptGate(repoRoot, task, options);
+    if (receiptReason)
+        return item('COMMIT-SYNCED', taskId, filePath, 'protected', receiptReason, identity);
+    return item('COMMIT-SYNCED', taskId, filePath, 'planned', 'COMMIT_SYNCED_AND_VERIFIED', identity);
+}
+function readAuxiliaryCandidates(repoRoot, tasks, options) {
+    const candidates = [];
+    const selected = options.taskIds ? new Set(options.taskIds) : null;
+    for (const rootName of AUXILIARY_ROOTS) {
+        const root = auxiliaryRoot(repoRoot, rootName);
+        let rootIdentity;
+        try {
+            rootIdentity = safeLstat(taskRoot(repoRoot), root, 'directory');
+        }
+        catch {
+            rootIdentity = null;
+        }
+        if (rootIdentity === null) {
+            let stat = null;
+            try {
+                stat = fs.lstatSync(root);
+            }
+            catch {
+                stat = null;
+            }
+            if (stat?.isSymbolicLink())
+                candidates.push(item('AUXILIARY-UNKNOWN', null, root, 'protected', 'PATH_SYMLINK'));
+            else if (stat)
+                candidates.push(item('AUXILIARY-UNKNOWN', null, root, 'protected', 'PATH_IDENTITY_MISMATCH'));
+            continue;
+        }
+        let entries;
+        try {
+            entries = fs.readdirSync(root, { withFileTypes: true });
+        }
+        catch {
+            candidates.push(item('AUXILIARY-UNKNOWN', null, root, 'protected', 'AUXILIARY_ROOT_UNREADABLE', rootIdentity));
+            continue;
+        }
+        for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+            const filePath = path.join(root, entry.name);
+            if (entry.isSymbolicLink()) {
+                candidates.push(item('AUXILIARY-UNKNOWN', null, filePath, 'protected', 'PATH_SYMLINK'));
+                continue;
+            }
+            if (!entry.isFile()) {
+                candidates.push(item('AUXILIARY-UNKNOWN', null, filePath, 'protected', 'PATH_IDENTITY_MISMATCH'));
+                continue;
+            }
+            const identity = safeLstat(root, filePath, 'file');
+            if (!identity) {
+                candidates.push(item('AUXILIARY-UNKNOWN', null, filePath, 'protected', 'PATH_IDENTITY_MISMATCH'));
+                continue;
+            }
+            if (rootName === '.local-artifact-finalization-intents') {
+                const match = LOCAL_INTENT_RE.exec(entry.name);
+                if (!match || (selected && !selected.has(match[1]))) {
+                    if (!selected || !match)
+                        candidates.push(item('AUXILIARY-UNKNOWN', null, filePath, 'protected', 'PATH_IDENTITY_MISMATCH', identity));
+                    continue;
+                }
+                candidates.push(localIntentCandidate(repoRoot, tasks.get(match[1]), filePath, match[1], match[2], match[3], identity, options));
+            }
+            else {
+                const match = COMMIT_INTENT_RE.exec(entry.name);
+                if (!match || (selected && !selected.has(match[1]))) {
+                    if (!selected || !match)
+                        candidates.push(item('AUXILIARY-UNKNOWN', null, filePath, 'protected', 'PATH_IDENTITY_MISMATCH', identity));
+                    continue;
+                }
+                candidates.push(commitIntentCandidate(repoRoot, tasks.get(match[1]), filePath, match[1], identity, options));
+            }
+        }
+        if (entries.length === 0) {
+            candidates.push(item('EMPTY-AUX-PARENT', null, root, 'planned', 'EMPTY_CANONICAL_AUXILIARY_ROOT', rootIdentity));
+        }
+    }
+    return candidates;
+}
+function buildIntermediateCleanupReport(items, dryRun = false, partial = false) {
+    const remaining = items.filter((candidate) => candidate.disposition !== 'deleted' && candidate.disposition !== 'skipped');
+    return {
+        status: dryRun ? 'dry-run' : partial || remaining.some((candidate) => candidate.disposition === 'failed') ? 'partial' : 'completed',
+        items,
+        remaining
+    };
+}
+function scanInternal(repoRootInput, options) {
+    const repoRoot = path.resolve(repoRootInput);
+    if (safeLstat(path.dirname(repoRoot), repoRoot, 'directory') === null) {
+        throw new Error('INTERMEDIATE_CLEANUP_REPOSITORY_INVALID');
+    }
+    const selected = options.taskIds ? new Set(options.taskIds.filter((taskId) => TASK_ID_RE.test(taskId))) : undefined;
+    const tasks = inspectTaskRecords(repoRoot, selected);
+    return readAuxiliaryCandidates(repoRoot, tasks, options);
+}
+function scanIntermediateCleanup(repoRoot, options = {}) {
+    const candidates = scanInternal(repoRoot, options);
+    return buildIntermediateCleanupReport(candidates, true);
+}
+function cleanupConsumedRecoveryFiles(repoRoot, task, candidate) {
+    if (candidate.kind !== 'LFAI-CONSUMED' || !candidate.taskId)
+        return true;
+    if (!task)
+        return false;
+    const match = LOCAL_INTENT_RE.exec(path.basename(candidate.path));
+    if (!match)
+        return false;
+    let intent;
+    try {
+        intent = readArtifactRecoveryIntent(repoRoot, candidate.taskId, match[2], match[3]);
+    }
+    catch {
+        return false;
+    }
+    if (!intent || intent.state !== 'consumed')
+        return false;
+    const recovery = artifactRecoveryRoot(task.taskDir, intent.recoveryOperationId);
+    let stat = null;
+    try {
+        stat = fs.lstatSync(recovery);
+    }
+    catch (error) {
+        if (errorCode(error) === 'ENOENT')
+            return true;
+        return false;
+    }
+    if (!stat.isDirectory() || stat.isSymbolicLink())
+        return false;
+    let entries;
+    try {
+        entries = fs.readdirSync(recovery, { withFileTypes: true });
+    }
+    catch {
+        return false;
+    }
+    for (const entry of entries) {
+        if (entry.isSymbolicLink() || !entry.isFile() || !['baseline.md', 'candidate.md', 'final.md', 'publish.md'].includes(entry.name))
+            return false;
+    }
+    try {
+        for (const entry of entries)
+            fs.unlinkSync(path.join(recovery, entry.name));
+        fs.rmdirSync(recovery);
+        const recoveryRoot = path.dirname(recovery);
+        if (fs.readdirSync(recoveryRoot).length === 0)
+            fs.rmdirSync(recoveryRoot);
+        return true;
+    }
+    catch (error) {
+        return errorCode(error) === 'ENOENT';
+    }
+}
+function removeCandidate(repoRoot, candidate, task) {
+    if (candidate.disposition !== 'planned')
+        return candidate;
+    const root = candidate.kind === 'EMPTY-AUX-PARENT'
+        ? path.dirname(path.dirname(candidate.path))
+        : path.dirname(candidate.path);
+    const expected = candidate.identity;
+    if (!expected)
+        return { ...candidate, disposition: 'protected', reason: 'PATH_IDENTITY_MISSING' };
+    let raw;
+    try {
+        raw = fs.lstatSync(candidate.path);
+    }
+    catch (error) {
+        if (errorCode(error) === 'ENOENT')
+            return { ...candidate, disposition: 'skipped', reason: 'ALREADY_GONE' };
+        return { ...candidate, disposition: 'failed', reason: 'CLEANUP_RECHECK_FAILED' };
+    }
+    if (raw.isSymbolicLink())
+        return { ...candidate, disposition: 'protected', reason: 'PATH_IDENTITY_CHANGED' };
+    const actual = safeLstat(root, candidate.path, candidate.kind === 'EMPTY-AUX-PARENT' ? 'directory' : 'file');
+    if (!actual)
+        return { ...candidate, disposition: 'protected', reason: 'PATH_IDENTITY_CHANGED' };
+    if (!sameFileIdentity(expected, actual))
+        return { ...candidate, disposition: 'protected', reason: 'PATH_IDENTITY_CHANGED' };
+    if (!cleanupConsumedRecoveryFiles(repoRoot, task, candidate)) {
+        return { ...candidate, disposition: 'protected', reason: 'RECOVERY_STAGING_NOT_SAFE_TO_REMOVE' };
+    }
+    try {
+        if (candidate.kind === 'EMPTY-AUX-PARENT') {
+            if (fs.readdirSync(candidate.path).length !== 0)
+                return { ...candidate, disposition: 'protected', reason: 'AUXILIARY_ROOT_NOT_EMPTY' };
+            fs.rmdirSync(candidate.path);
+        }
+        else {
+            fs.unlinkSync(candidate.path);
+        }
+        return { ...candidate, disposition: 'deleted', reason: 'DELETED_AFTER_LOCKED_RECHECK' };
+    }
+    catch (error) {
+        if (errorCode(error) === 'ENOENT')
+            return { ...candidate, disposition: 'skipped', reason: 'ALREADY_GONE' };
+        return { ...candidate, disposition: 'failed', reason: 'CLEANUP_DELETE_FAILED' };
+    }
+}
+function intermediateCleanupKey(item) {
+    return `${item.kind}\0${item.path}`;
+}
+function cleanupIntermediateUnderRemovalCoordinator(repoRoot, options = {}) {
+    const scanOptions = {
+        ...(options.taskIds === undefined ? {} : { taskIds: options.taskIds }),
+        ...(options.controlBindingEvidence === undefined ? {} : { controlBindingEvidence: options.controlBindingEvidence })
+    };
+    const initial = scanIntermediateCleanup(repoRoot, scanOptions);
+    if (options.dryRun)
+        return initial;
+    const items = [...initial.items];
+    const lockedTaskIds = options.lockedTaskIds ?? new Set();
+    const byTask = new Map();
+    for (const [index, candidate] of items.entries()) {
+        if (!candidate.taskId || candidate.disposition !== 'planned')
+            continue;
+        const indexes = byTask.get(candidate.taskId) ?? [];
+        indexes.push(index);
+        byTask.set(candidate.taskId, indexes);
+    }
+    const tasks = inspectTaskRecords(repoRoot, new Set(byTask.keys()));
+    for (const taskId of [...byTask.keys()].sort()) {
+        const execute = () => {
+            const refreshed = scanIntermediateCleanup(repoRoot, {
+                ...scanOptions,
+                taskIds: [taskId]
+            });
+            const refreshedByKey = new Map(refreshed.items.map((candidate) => [intermediateCleanupKey(candidate), candidate]));
+            for (const index of byTask.get(taskId) ?? []) {
+                const initialCandidate = items[index];
+                if (initialCandidate.disposition !== 'planned')
+                    continue;
+                const current = refreshedByKey.get(intermediateCleanupKey(initialCandidate));
+                items[index] = current
+                    ? removeCandidate(repoRoot, current, tasks.get(taskId))
+                    : { ...initialCandidate, disposition: 'protected', reason: 'CANDIDATE_NO_LONGER_ELIGIBLE' };
+            }
+        };
+        try {
+            if (lockedTaskIds.has(taskId))
+                execute();
+            else
+                withTaskExecutionLock(repoRoot, taskId, 'sandbox-removal', execute);
+        }
+        catch {
+            for (const index of byTask.get(taskId) ?? []) {
+                const candidate = items[index];
+                if (candidate.disposition === 'planned')
+                    items[index] = { ...candidate, disposition: 'protected', reason: 'TASK_LOCK_BUSY' };
+            }
+        }
+    }
+    for (const [index, candidate] of items.entries()) {
+        if (candidate.taskId || candidate.disposition !== 'planned')
+            continue;
+        items[index] = removeCandidate(repoRoot, candidate);
+    }
+    const knownPaths = new Set(items.map((candidate) => intermediateCleanupKey(candidate)));
+    for (const candidate of scanIntermediateCleanup(repoRoot, scanOptions).items) {
+        if (candidate.kind !== 'EMPTY-AUX-PARENT' || candidate.disposition !== 'planned'
+            || knownPaths.has(intermediateCleanupKey(candidate)))
+            continue;
+        items.push(removeCandidate(repoRoot, candidate));
+    }
+    return buildIntermediateCleanupReport(items);
+}
+function protectIntermediateCleanupReport(report, reason) {
+    const items = report.items.map((item) => item.disposition === 'planned'
+        ? { ...item, disposition: 'protected', reason }
+        : item);
+    return buildIntermediateCleanupReport(items, false, true);
+}
+function mergeIntermediateCleanupReports(reports) {
+    const items = reports.flatMap((report) => report.items);
+    return buildIntermediateCleanupReport(items, false, reports.some((report) => report.status === 'partial'));
+}
+function formatIntermediateCleanupReport(report) {
+    return [
+        `remaining ${report.remaining.length} item(s)`,
+        ...report.items.map((candidate) => (`${candidate.disposition} ${candidate.kind} ${candidate.path}`
+            + ` (${candidate.taskId ?? 'unbound'}; ${candidate.reason})`))
+    ];
+}
+export { formatIntermediateCleanupReport, cleanupIntermediateUnderRemovalCoordinator, protectIntermediateCleanupReport, mergeIntermediateCleanupReports, scanIntermediateCleanup };
+//# sourceMappingURL=intermediate-cleanup.js.map

package/dist/lib/task/invalidation.js

@@ -1,4 +1,6 @@
 import { createHash } from 'node:crypto';
+import { findSectionRange, parseTable } from './sections.js';
+import { scanVisibleMarkdown } from './markdown.js';
 const INVALIDATION_HEADINGS = ['产物失效记录', 'Artifact Invalidation'];
 const OPERATION_COLUMNS = [
     'operation_id', 'source_family', 'source_artifact', 'source_round', 'source_sha256',
@@ -29,61 +31,14 @@ function createInvalidationOperation(source, targets = []) {
         createdAt: source.createdAt, updatedAt: source.updatedAt, completedAt: '', error: ''
     };
 }
-function lineCells(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 cells = [];
-    let start = 0;
-    let escaped = false;
-    for (let index = 0; index < inner.length; index += 1) {
-        const char = inner[index];
-        if (char === '|' && !escaped) {
-            cells.push(inner.slice(start, index));
-            start = index + 1;
-        }
-        escaped = char === '\\' && !escaped;
-        if (char !== '\\')
-            escaped = false;
-    }
-    cells.push(inner.slice(start));
-    return cells.map((cell) => cell.replace(/\\([\\|])/g, '$1').trim());
-}
-function isSeparator(cells, count) {
-    return cells.length === count && cells.every((cell) => /^:?-{3,}:?$/.test(cell));
-}
-function sectionBody(content) {
-    const heading = INVALIDATION_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 parseTable(body, heading, columns) {
-    const marker = new RegExp(`^###\\s+${heading}\\s*$`, 'm').exec(body);
-    if (!marker)
-        return null;
-    const start = (marker.index ?? 0) + marker[0].length;
-    const rest = body.slice(start);
-    const end = rest.search(/^###\s+/m);
-    const lines = rest.slice(0, end < 0 ? rest.length : end).split(/\r?\n/).filter((line) => line.trim());
-    const header = lines.length > 0 ? lineCells(lines[0]) : null;
-    const separator = lines.length > 1 ? lineCells(lines[1]) : null;
-    if (!header || !separator || header.length !== columns.length || !header.every((value, index) => value === columns[index]) || !isSeparator(separator, columns.length))
-        return false;
-    const rows = [];
-    for (const line of lines.slice(2)) {
-        const cells = lineCells(line);
-        if (!cells || cells.length !== columns.length)
-            return false;
-        rows.push(Object.fromEntries(columns.map((column, index) => [column, cells[index]])));
+function parseInvalidationTable(body, heading, columns) {
+    const section = findSectionRange(body, [heading], 3);
+    const lines = scanVisibleMarkdown(body).lines.filter((line) => line.text.trim());
+    const table = parseTable(lines.map((line) => line.text).join('\n'), { sectionAliases: [heading], columns });
+    if (!section || !table || lines.filter((line) => line.start >= section.bodyStart && line.start < section.end).length !== table.rows.length + 2) {
+        throw new Error(`invalidation ${heading} section must contain only its canonical table`);
     }
-    return rows;
+    return table.rows;
 }
 function required(value, field) {
     if (!value)
@@ -102,16 +57,14 @@ function numberValue(value, field, allowZero = true) {
     return parsed;
 }
 function parseInvalidationDocument(content) {
-    const body = sectionBody(content);
-    if (body === null)
+    const section = findSectionRange(content, INVALIDATION_HEADINGS);
+    if (section === null)
         return { ok: true, present: false, document: { operations: [], targets: [] } };
     try {
-        const operationRows = parseTable(body, 'Operations', OPERATION_COLUMNS);
-        const targetRows = parseTable(body, 'Targets', TARGET_COLUMNS);
-        if (operationRows === null || targetRows === null || operationRows === false || targetRows === false) {
-            return invalid('invalidation section must contain Operations and Targets tables');
-        }
-        const operations = operationRows.map((row) => ({
+        const body = content.slice(section.bodyStart, section.end);
+        const operationRows = parseInvalidationTable(body, 'Operations', OPERATION_COLUMNS);
+        const targetRows = parseInvalidationTable(body, 'Targets', TARGET_COLUMNS);
+        const operations = operationRows.map(({ values: row }) => ({
             operationId: required(row.operation_id, 'operation_id'), sourceFamily: required(row.source_family, 'source_family'),
             sourceArtifact: required(row.source_artifact, 'source_artifact'), sourceRound: numberValue(row.source_round, 'source_round', false),
             sourceSha256: required(row.source_sha256, 'source_sha256'), status: status(row.status, 'operation status'),
@@ -119,7 +72,7 @@ function parseInvalidationDocument(content) {
             createdAt: required(row.created_at, 'created_at'), updatedAt: required(row.updated_at, 'updated_at'),
             completedAt: row.completed_at ?? '', error: row.error ?? ''
         }));
-        const targets = targetRows.map((row) => ({
+        const targets = targetRows.map(({ values: row }) => ({
             targetId: required(row.target_id, 'target_id'), operationId: required(row.operation_id, 'operation_id'),
             targetKind: row.target_kind, targetFamily: required(row.target_family, 'target_family'),
             targetArtifact: required(row.target_artifact, 'target_artifact'), targetRound: numberValue(row.target_round, 'target_round', false),
@@ -248,11 +201,11 @@ function isArtifactInvalidated(document, family, artifact) {
         && target.targetArtifact === artifact);
 }
 function invalidationMutation(content, document) {
-    const existing = sectionBody(content) !== null;
+    const existing = findSectionRange(content, INVALIDATION_HEADINGS);
     return {
         kind: 'section',
         aliases: INVALIDATION_HEADINGS,
-        heading: existing && /^##\s+Artifact Invalidation\s*$/m.test(content) ? INVALIDATION_HEADINGS[1] : INVALIDATION_HEADINGS[0],
+        heading: existing?.heading ?? INVALIDATION_HEADINGS[0],
         body: renderInvalidation(document)
     };
 }

package/dist/lib/task/ledger-intents.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { declareImplementationInput, IMPLEMENTATION_INPUT_ALIASES, parseImplementationInputs, renderImplementationInputs } from './implementation-inputs.js';
+import { parseArtifactName } from './artifact-name.js';
 import { LEDGER_COLUMNS, LEDGER_HEADINGS, LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, nextHdId, parseLedgerDocument, validateLedgerRows } from './ledger.js';
 import { resolveTaskRef } from './resolve-ref.js';
 import { writeTask } from './write.js';
@@ -10,16 +11,6 @@ import { parseReworkIntentDocument, reworkIntentMutation, upsertReworkIntent } f
 const PREFIX = { analysis: 'AN', plan: 'PL', code: 'CD' };
 const RESPONSE = new Set(['accepted', 'adjusted', 'refuted', 'cannot-judge']);
 const DISPOSITION = new Set(['confirmed', 'closed', 'open', 'needs-human-decision']);
-const REVIEW_ARTIFACT = {
-    analysis: /^review-analysis(?:-r(?:[2-9]|[1-9]\d+))?\.md$/,
-    plan: /^review-plan(?:-r(?:[2-9]|[1-9]\d+))?\.md$/,
-    code: /^review-code(?:-r(?:[2-9]|[1-9]\d+))?\.md$/
-};
-const ARTIFACT = {
-    analysis: /^analysis(?:-r(?:[2-9]|[1-9]\d+))?\.md$/,
-    plan: /^plan(?:-r(?:[2-9]|[1-9]\d+))?\.md$/,
-    code: /^code(?:-r(?:[2-9]|[1-9]\d+))?\.md$/
-};
 function failed(intent, code, message, taskId = null, entityId = null) {
     return { status: 'failed', changed: false, intent: intent.kind, taskId, entityId, before: null, after: null, operations: [], error: { code, message } };
 }
@@ -52,10 +43,6 @@ function nextFindingId(rows, stage) {
     }
     return `${prefix}-${max + 1}`;
 }
-function reviewArtifactRound(reviewArtifact) {
-    const match = /-r([1-9]\d*)\.md$/.exec(reviewArtifact);
-    return match ? Number(match[1]) : 1;
-}
 function rowMutation(row) {
     return {
         kind: 'table-row', action: 'upsert', sectionAliases: LEDGER_HEADINGS,
@@ -63,9 +50,6 @@ function rowMutation(row) {
         values: { stage: row.stage, round: row.round, severity: row.severity, status: row.status, evidence: row.evidence }
     };
 }
-function ledgerSectionMutation(content) {
-    return [];
-}
 function implementationInputMutation(content, rows) {
     const english = /^##\s+Activity Log\s*$/m.test(content);
     return {
@@ -112,7 +96,7 @@ function applyLedgerIntent(intent, options = {}) {
         if (!finding || finding.severity === 'decision')
             return failed(intent, 'LEDGER_NOT_FOUND', `finding '${intent.findingId}' was not found`, resolved.taskId, intent.findingId);
         const sourceFromEvidence = finding.evidence.split('#')[0];
-        if (sourceFromEvidence !== intent.sourceArtifact || !REVIEW_ARTIFACT[finding.stage]?.test(intent.sourceArtifact)) {
+        if (sourceFromEvidence !== intent.sourceArtifact || parseArtifactName(intent.sourceArtifact)?.family !== `review-${finding.stage}`) {
             return failed(intent, 'LEDGER_IDENTITY_CONFLICT', 'rework intent source artifact does not match finding evidence', resolved.taskId, intent.intentId);
         }
         try {
@@ -142,7 +126,8 @@ function applyLedgerIntent(intent, options = {}) {
     let before = null;
     let after;
     if (intent.kind === 'finding-upsert') {
-        if (!REVIEW_ARTIFACT[intent.stage]?.test(intent.reviewArtifact) || !Number.isInteger(intent.ordinal) || intent.ordinal < 1 || !['blocker', 'major', 'minor'].includes(intent.severity)) {
+        const identity = parseArtifactName(intent.reviewArtifact);
+        if (identity?.family !== `review-${intent.stage}` || !Number.isInteger(intent.ordinal) || intent.ordinal < 1 || !['blocker', 'major', 'minor'].includes(intent.severity)) {
             return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'finding identity, stage, ordinal, or severity is invalid', resolved.taskId);
         }
         const evidence = normalizedEvidence(intent.evidence);
@@ -162,13 +147,13 @@ function applyLedgerIntent(intent, options = {}) {
         else {
             const id = nextFindingId(rows, intent.stage);
             after = {
-                id, stage: intent.stage, round: String(reviewArtifactRound(intent.reviewArtifact)),
+                id, stage: intent.stage, round: String(identity.round),
                 severity: intent.severity, status: 'open', evidence, sourceLine: -1
             };
         }
     }
     else if (intent.kind === 'decision-upsert') {
-        if (!/^HD-[1-9]\d*$/.test(intent.id) || !ARTIFACT[intent.stage]?.test(intent.artifact)) {
+        if (!/^HD-[1-9]\d*$/.test(intent.id) || !['analysis', 'plan', 'code'].includes(intent.stage) || parseArtifactName(intent.artifact)?.family !== intent.stage) {
             return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'decision id, stage, or artifact is invalid', resolved.taskId, intent.id);
         }
         const evidence = `${intent.artifact}#${intent.id}`;
@@ -249,7 +234,7 @@ function applyLedgerIntent(intent, options = {}) {
     }
     const result = writeTask({
         taskRef: intent.taskRef, expectedState: stateOverride ? resolved.state : 'active',
-        mutations: [...ledgerSectionMutation(content), rowMutation(after), ...(implementationMutation ? [implementationMutation] : [])],
+        mutations: [rowMutation(after), ...(implementationMutation ? [implementationMutation] : [])],
         dryRun: 'dryRun' in intent ? intent.dryRun : false
     }, { ...options, taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state } });
     return mapWrite(intent, after.id, before, after, result);

package/dist/lib/task/ledger.js

@@ -17,9 +17,7 @@ const LEDGER_SECTION_MISSING_MESSAGE = 'review disagreement ledger section is mi
 function isReviewStage(stage) {
     return stage === 'analysis' || stage === 'plan' || stage === 'code';
 }
-// Parse all rows of the disagreement ledger table. Skips the heading, the
-// header row (`| id | ... |`) and the `|---|` separator; ignores non-`|` lines.
-// Rows with fewer than 6 columns are skipped (mirrors the JS gate parser).
+// Parse ledger rows using the shared strict table structure contract.
 function parseLedgerDocument(content) {
     const table = parseTable(content, { sectionAliases: LEDGER_HEADINGS, columns: LEDGER_COLUMNS });
     if (!table)