@fitlab-ai/agent-infra 0.11.9 → 0.11.11

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

@@ -1,327 +0,0 @@
-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 { enumerateAllTaskDirs } from './resolve-ref.js';
-const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
-const COMMIT_INTENT_RE = /^(TASK-\d{8}-\d{6})\.json$/;
-const AUXILIARY_ROOTS = ['.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 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;
-            }
-            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 removeCandidate(repoRoot, candidate) {
-    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' };
-    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)
-                    : { ...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-command.js

@@ -1,88 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { parseArtifactReceipts, sha256File } from './artifact-receipts.js';
-import { invalidationMutation, parseInvalidationDocument, reconcileInvalidation } from './invalidation.js';
-import { resolveTaskRef } from './resolve-ref.js';
-import { writeTask } from './write.js';
-function reconcileTaskInvalidation(taskRef, options = {}) {
-    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
-    if (!resolved.ok)
-        return { status: 'failed', changed: false, taskId: resolved.taskId, processed: 0, remaining: 0, error: { code: resolved.code, message: resolved.message } };
-    let content;
-    try {
-        content = fs.readFileSync(resolved.taskMdPath, 'utf8');
-    }
-    catch (error) {
-        return { status: 'failed', changed: false, taskId: resolved.taskId, processed: 0, remaining: 0, error: { code: 'TASK_READ_FAILED', message: error instanceof Error ? error.message : String(error) } };
-    }
-    const parsed = parseInvalidationDocument(content);
-    if (!parsed.ok)
-        return { status: 'failed', changed: false, taskId: resolved.taskId, processed: 0, remaining: 0, error: { code: parsed.code, message: parsed.message } };
-    if (!parsed.present)
-        return { status: 'no-op', changed: false, taskId: resolved.taskId, processed: 0, remaining: 0, error: null };
-    const beforePending = parsed.document.targets.filter((target) => target.status !== 'completed').length;
-    let receipts;
-    try {
-        receipts = parseArtifactReceipts(content).rows;
-    }
-    catch (error) {
-        if (parsed.document.targets.some((target) => target.status !== 'completed' && target.targetKind === 'receipt')) {
-            return {
-                status: 'failed', changed: false, taskId: resolved.taskId, processed: 0, remaining: beforePending,
-                error: { code: 'INVALIDATION_TARGET_HASH_CONFLICT', message: error instanceof Error ? error.message : String(error) }
-            };
-        }
-        receipts = [];
-    }
-    for (const target of parsed.document.targets) {
-        if (target.status === 'completed')
-            continue;
-        if (target.targetKind === 'receipt') {
-            const receiptExists = Boolean(target.targetInput) && receipts.some((candidate) => candidate.output === target.targetArtifact
-                && candidate.input === target.targetInput
-                && candidate.inputSha256 === target.targetSha256);
-            if (!receiptExists) {
-                return {
-                    status: 'failed', changed: false, taskId: resolved.taskId, processed: 0, remaining: beforePending,
-                    error: { code: 'INVALIDATION_TARGET_HASH_CONFLICT', message: `invalidation receipt target '${target.targetArtifact}' changed before reconcile` }
-                };
-            }
-            continue;
-        }
-        const targetPath = path.join(resolved.taskDir, target.targetArtifact);
-        try {
-            const stat = fs.lstatSync(targetPath);
-            if (!stat.isFile() || stat.isSymbolicLink() || sha256File(targetPath) !== target.targetSha256) {
-                return {
-                    status: 'failed', changed: false, taskId: resolved.taskId, processed: 0, remaining: beforePending,
-                    error: { code: 'INVALIDATION_TARGET_HASH_CONFLICT', message: `invalidation target '${target.targetArtifact}' changed before reconcile` }
-                };
-            }
-        }
-        catch {
-            return {
-                status: 'failed', changed: false, taskId: resolved.taskId, processed: 0, remaining: beforePending,
-                error: { code: 'INVALIDATION_TARGET_HASH_CONFLICT', message: `invalidation target '${target.targetArtifact}' is unavailable before reconcile` }
-            };
-        }
-    }
-    const reconciled = reconcileInvalidation(parsed.document, (options.now ?? (() => new Date().toISOString()))(), options.maxTargets);
-    if (!reconciled.ok)
-        return { status: 'failed', changed: false, taskId: resolved.taskId, processed: 0, remaining: beforePending, error: { code: reconciled.code, message: reconciled.message } };
-    if (!reconciled.changed)
-        return { status: 'no-op', changed: false, taskId: resolved.taskId, processed: 0, remaining: beforePending, error: null };
-    const result = writeTask({
-        taskRef, expectedState: resolved.state, dryRun: options.dryRun,
-        mutations: [invalidationMutation(content, reconciled.document)]
-    }, { ...options, invalidationContext: 'reconcile', taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state } });
-    if (result.status === 'failed')
-        return { status: 'failed', changed: false, taskId: resolved.taskId, processed: beforePending - reconciled.document.targets.filter((target) => target.status !== 'completed').length, remaining: reconciled.document.targets.filter((target) => target.status !== 'completed').length, error: result.error };
-    return {
-        status: result.status, changed: result.changed, taskId: resolved.taskId,
-        processed: beforePending - reconciled.document.targets.filter((target) => target.status !== 'completed').length,
-        remaining: reconciled.document.targets.filter((target) => target.status !== 'completed').length,
-        error: null
-    };
-}
-export { reconcileTaskInvalidation };
-//# sourceMappingURL=invalidation-command.js.map

package/dist/lib/task/invalidation.js

@@ -1,242 +0,0 @@
-import { createHash } from 'node:crypto';
-import { parseArtifactName } from './artifact-name.js';
-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',
-    'status', 'processed', 'total', 'created_at', 'updated_at', 'completed_at', 'error'
-];
-const TARGET_COLUMNS = [
-    'target_id', 'operation_id', 'target_kind', 'target_family', 'target_artifact', 'target_input',
-    'target_round', 'target_sha256', 'status', 'reason_code', 'updated_at'
-];
-const LEGACY_TARGET_COLUMNS = [
-    'target_id', 'operation_id', 'target_kind', 'target_family', 'target_artifact',
-    'target_round', 'target_sha256', 'status', 'reason_code', 'updated_at'
-];
-function invalid(message) {
-    return { ok: false, code: 'TASK_INVALIDATION_INVALID', message };
-}
-function hashIdentity(value) {
-    return createHash('sha256').update(JSON.stringify(value)).digest('hex').slice(0, 16);
-}
-function operationIdFor(source) {
-    return `INV-${hashIdentity([source.sourceFamily, source.sourceArtifact, source.sourceRound, source.sourceSha256])}`;
-}
-function targetIdFor(operationId, target) {
-    return `INV-T-${hashIdentity([operationId, target.targetKind, target.targetFamily, target.targetArtifact, ...(target.targetKind === 'receipt' && target.targetInput ? [target.targetInput] : []), target.targetRound, target.targetSha256])}`;
-}
-function createInvalidationOperation(source, targets = []) {
-    const operationId = source.operationId ?? operationIdFor(source);
-    return {
-        operationId, sourceFamily: source.sourceFamily, sourceArtifact: source.sourceArtifact,
-        sourceRound: source.sourceRound, sourceSha256: source.sourceSha256,
-        status: 'pending', processed: 0, total: targets.length,
-        createdAt: source.createdAt, updatedAt: source.updatedAt, completedAt: '', error: ''
-    };
-}
-function parseInvalidationTable(body, heading, columnChoices) {
-    const section = findSectionRange(body, [heading], 3);
-    const lines = scanVisibleMarkdown(body).lines.filter((line) => line.text.trim());
-    let table = null;
-    let legacy = false;
-    for (const columns of columnChoices) {
-        try {
-            const candidate = parseTable(lines.map((line) => line.text).join('\n'), { sectionAliases: [heading], columns });
-            if (candidate) {
-                table = candidate;
-                legacy = columns === LEGACY_TARGET_COLUMNS;
-                break;
-            }
-        }
-        catch {
-            // Try the next explicitly supported schema.
-        }
-    }
-    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: table.rows, legacy };
-}
-function required(value, field) {
-    if (!value)
-        throw new Error(`${field} is required`);
-    return value;
-}
-function status(value, field) {
-    if (value !== 'pending' && value !== 'in-progress' && value !== 'completed')
-        throw new Error(`${field} has an invalid status`);
-    return value;
-}
-function numberValue(value, field, allowZero = true) {
-    const parsed = Number(value);
-    if (!Number.isInteger(parsed) || (allowZero ? parsed < 0 : parsed < 1))
-        throw new Error(`${field} must be an integer`);
-    return parsed;
-}
-function parseInvalidationDocument(content) {
-    const section = findSectionRange(content, INVALIDATION_HEADINGS);
-    if (section === null)
-        return { ok: true, present: false, document: { operations: [], targets: [] } };
-    try {
-        const body = content.slice(section.bodyStart, section.end);
-        const operationRows = parseInvalidationTable(body, 'Operations', [OPERATION_COLUMNS]);
-        // TODO(compat): Remove legacy target table parsing and completed receipt targets without target_input once a workspace inventory confirms all persisted targets have input identities.
-        const targetRows = parseInvalidationTable(body, 'Targets', [TARGET_COLUMNS, LEGACY_TARGET_COLUMNS]);
-        const operations = operationRows.rows.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'),
-            processed: numberValue(row.processed, 'processed'), total: numberValue(row.total, 'total'),
-            createdAt: required(row.created_at, 'created_at'), updatedAt: required(row.updated_at, 'updated_at'),
-            completedAt: row.completed_at ?? '', error: row.error ?? ''
-        }));
-        const targets = targetRows.rows.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),
-            ...(row.target_input ? { targetInput: row.target_input } : {}),
-            targetSha256: required(row.target_sha256, 'target_sha256'), status: status(row.status, 'target status'),
-            reasonCode: required(row.reason_code, 'reason_code'), updatedAt: required(row.updated_at, 'updated_at')
-        }));
-        const operationIds = new Set();
-        for (const operation of operations) {
-            if (operationIds.has(operation.operationId))
-                throw new Error(`duplicate operation '${operation.operationId}'`);
-            operationIds.add(operation.operationId);
-            if (operation.operationId !== operationIdFor(operation))
-                throw new Error(`operation '${operation.operationId}' has a non-canonical identity`);
-            if (operation.processed > operation.total)
-                throw new Error(`operation '${operation.operationId}' progress is invalid`);
-            if (!/^[a-f0-9]{64}$/.test(operation.sourceSha256))
-                throw new Error(`operation '${operation.operationId}' source hash is invalid`);
-        }
-        const targetIds = new Set();
-        for (const target of targets) {
-            if (!['artifact', 'receipt', 'approval', 'reviewed-snapshot'].includes(target.targetKind))
-                throw new Error(`target '${target.targetId}' kind is invalid`);
-            if (targetIds.has(target.targetId))
-                throw new Error(`duplicate target '${target.targetId}'`);
-            targetIds.add(target.targetId);
-            if (!operationIds.has(target.operationId))
-                throw new Error(`target '${target.targetId}' references an unknown operation`);
-            if (target.targetKind === 'receipt') {
-                if (!target.targetInput && target.status !== 'completed')
-                    throw new Error(`receipt target '${target.targetId}' input identity is required`);
-                if (target.targetInput && !parseArtifactName(target.targetInput))
-                    throw new Error(`receipt target '${target.targetId}' input identity is invalid`);
-            }
-            else if (target.targetInput)
-                throw new Error(`non-receipt target '${target.targetId}' cannot have an input identity`);
-            if (target.targetId !== targetIdFor(target.operationId, target))
-                throw new Error(`target '${target.targetId}' has a non-canonical identity`);
-            if (!/^[a-f0-9]{64}$/.test(target.targetSha256))
-                throw new Error(`target '${target.targetId}' hash is invalid`);
-        }
-        for (const operation of operations) {
-            const scoped = targets.filter((target) => target.operationId === operation.operationId);
-            const completed = scoped.filter((target) => target.status === 'completed').length;
-            if (operation.total !== scoped.length || operation.processed !== completed)
-                throw new Error(`operation '${operation.operationId}' progress does not match its targets`);
-            if (operation.status === 'completed' && (completed !== scoped.length || !operation.completedAt))
-                throw new Error(`completed operation '${operation.operationId}' has incomplete targets`);
-            if (operation.status === 'pending' && completed !== 0)
-                throw new Error(`pending operation '${operation.operationId}' has completed targets`);
-            if (operation.status === 'in-progress' && (completed === scoped.length || (completed === 0 && !scoped.some((target) => target.status === 'in-progress'))))
-                throw new Error(`in-progress operation '${operation.operationId}' has invalid progress`);
-        }
-        return { ok: true, present: true, document: { operations, targets } };
-    }
-    catch (error) {
-        return invalid(error instanceof Error ? error.message : String(error));
-    }
-}
-function cell(value) {
-    return String(value).replace(/\\/g, '\\\\').replace(/\|/g, '\\|').replace(/[\r\n]/g, ' ');
-}
-function table(columns, rows) {
-    const header = `| ${columns.join(' | ')} |`;
-    const separator = `| ${columns.map(() => '---').join(' | ')} |`;
-    return [header, separator, ...rows.map((row) => `| ${row.map(cell).join(' | ')} |`)].join('\n');
-}
-function renderInvalidation(document) {
-    const operations = [...document.operations].sort((left, right) => left.operationId.localeCompare(right.operationId));
-    const targets = [...document.targets].sort((left, right) => left.targetId.localeCompare(right.targetId));
-    return [
-        '### Operations', '',
-        table(OPERATION_COLUMNS, operations.map((row) => [
-            row.operationId, row.sourceFamily, row.sourceArtifact, row.sourceRound, row.sourceSha256,
-            row.status, row.processed, row.total, row.createdAt, row.updatedAt, row.completedAt, row.error
-        ])), '',
-        '### Targets', '',
-        table(TARGET_COLUMNS, targets.map((row) => [
-            row.targetId, row.operationId, row.targetKind, row.targetFamily, row.targetArtifact,
-            row.targetInput ?? '', row.targetRound, row.targetSha256, row.status, row.reasonCode, row.updatedAt
-        ]))
-    ].join('\n');
-}
-function reconcileInvalidation(document, now, maxTargets = Number.POSITIVE_INFINITY) {
-    const nextTargets = document.targets.map((target) => {
-        if (target.status === 'completed' || maxTargets <= 0)
-            return target;
-        maxTargets -= 1;
-        return { ...target, status: 'completed', updatedAt: now };
-    });
-    const changed = nextTargets.some((target, index) => target !== document.targets[index]);
-    const nextOperations = document.operations.map((operation) => {
-        const scoped = nextTargets.filter((target) => target.operationId === operation.operationId);
-        const processed = scoped.filter((target) => target.status === 'completed').length;
-        const total = scoped.length;
-        const complete = total === processed;
-        const nextStatus = complete ? 'completed' : processed > 0 ? 'in-progress' : 'pending';
-        if (operation.status === nextStatus && operation.processed === processed && operation.total === total && (!complete || operation.completedAt))
-            return operation;
-        return {
-            ...operation, status: nextStatus, processed, total, updatedAt: changed ? now : operation.updatedAt,
-            completedAt: complete ? (operation.completedAt || now) : ''
-        };
-    });
-    const operationChanged = nextOperations.some((operation, index) => operation !== document.operations[index]);
-    return { ok: true, changed: changed || operationChanged, document: { operations: nextOperations, targets: nextTargets } };
-}
-function upsertInvalidation(document, operation, targets) {
-    const existing = document.operations.find((candidate) => candidate.operationId === operation.operationId);
-    if (existing && JSON.stringify(existing) !== JSON.stringify(operation)) {
-        return { ok: false, code: 'INVALIDATION_IDENTITY_CONFLICT', message: `operation '${operation.operationId}' identity conflicts with existing state` };
-    }
-    const existingTargets = document.targets.filter((target) => target.operationId === operation.operationId);
-    for (const target of targets) {
-        const old = existingTargets.find((candidate) => candidate.targetId === target.targetId);
-        if (old && JSON.stringify(old) !== JSON.stringify(target)) {
-            return { ok: false, code: 'INVALIDATION_IDENTITY_CONFLICT', message: `target '${target.targetId}' identity conflicts with existing state` };
-        }
-    }
-    if (existing)
-        return { ok: true, changed: false, document };
-    return {
-        ok: true, changed: true,
-        document: { operations: [...document.operations, operation], targets: [...document.targets, ...targets] }
-    };
-}
-function invalidationBlocks(document) {
-    return document.operations.some((operation) => operation.status !== 'completed')
-        || document.targets.some((target) => target.status !== 'completed');
-}
-function isArtifactInvalidated(document, family, artifact) {
-    return document.targets.some((target) => target.status === 'completed'
-        && target.targetKind === 'artifact'
-        && target.targetFamily === family
-        && target.targetArtifact === artifact);
-}
-function invalidationMutation(content, document) {
-    const existing = findSectionRange(content, INVALIDATION_HEADINGS);
-    return {
-        kind: 'section',
-        aliases: INVALIDATION_HEADINGS,
-        heading: existing?.heading ?? INVALIDATION_HEADINGS[0],
-        body: renderInvalidation(document)
-    };
-}
-export { INVALIDATION_HEADINGS, OPERATION_COLUMNS, TARGET_COLUMNS, createInvalidationOperation, isArtifactInvalidated, invalidationBlocks, invalidationMutation, operationIdFor, parseInvalidationDocument, reconcileInvalidation, renderInvalidation, targetIdFor, upsertInvalidation };
-//# sourceMappingURL=invalidation.js.map