@fitlab-ai/agent-infra 0.9.11 → 0.9.13

package/dist/lib/task/human-override.js

@@ -19,6 +19,9 @@ import { applyWorkflowWarningIntent } from './workflow-warning-intents.js';
 import { verifyTaskEvent } from './verification.js';
 import { verifyInProcess } from './verification-engine.js';
 import { canonicalTimestamp, writeTask } from './write.js';
+import { readPrDeliveryFact } from './pr-delivery-fact.js';
+import { resourceIdentity, resourceIdentityNumber } from '../platform/provider-bridge.js';
+import { taskIssueIdentity } from '../platform/task-identities.js';
 const LIFECYCLE_PRODUCER = 'lifecycle.apply';
 const HUMAN_OVERRIDE_SECTION_ALIASES = ['人工豁免账本', 'Human Override Ledger'];
 const HUMAN_OVERRIDE_COLUMNS = [
@@ -401,12 +404,20 @@ function snapshotEvidence(taskId, failureIdValue, target, content, frontmatter,
 }
 function resourceForSnapshot(policy, options, frontmatter) {
     if (policy.producerId === 'platform.issue') {
-        const number = options.probeIssueNumber ?? toPositiveInteger(frontmatter?.issue_number);
-        return number === null ? null : { kind: 'issue', number };
+        const identity = options.probeIssueNumber !== undefined
+            ? resourceIdentity(options.probeIssueNumber)
+            : taskIssueIdentity((frontmatter || {})) || (() => {
+                const number = toPositiveInteger(frontmatter?.issue_number);
+                return number === null ? null : resourceIdentity(number);
+            })();
+        return identity ? { kind: 'issue', identity, number: resourceIdentityNumber(identity) } : null;
     }
     if (policy.producerId === 'platform.pull-request') {
-        const number = options.probePullRequestNumber ?? toPositiveInteger(frontmatter?.pr_number);
-        return number === null ? null : { kind: 'pull-request', number };
+        const fact = frontmatter ? readPrDeliveryFact(frontmatter) : null;
+        const identity = options.probePullRequestNumber !== undefined
+            ? resourceIdentity(options.probePullRequestNumber)
+            : fact?.status === 'valid' && fact.fact.state === 'bound' ? fact.fact.identity.resource : null;
+        return identity ? { kind: 'pull-request', identity, number: resourceIdentityNumber(identity) } : null;
     }
     return null;
 }
@@ -459,7 +470,7 @@ function probeResult(policy, result, state) {
 function probeNotObserved(policy) {
     return error('OVERRIDE_FAILURE_NOT_PRESENT', `producer ${policy.producerId} did not produce ${policy.code}`);
 }
-function probePlatformFailure(taskRef, policy, resolved, options) {
+async function probePlatformFailure(taskRef, policy, resolved, options) {
     let frontmatter;
     try {
         frontmatter = parseTypedTaskFrontmatter(fs.readFileSync(path.join(resolved.taskDir, 'task.md'), 'utf8'));
@@ -467,29 +478,40 @@ function probePlatformFailure(taskRef, policy, resolved, options) {
     catch (cause) {
         return error('OVERRIDE_DOCUMENT_INVALID', cause instanceof Error ? cause.message : String(cause));
     }
-    const issueNumber = options.probeIssueNumber ?? toPositiveInteger(frontmatter.issue_number);
-    const pullRequestNumber = options.probePullRequestNumber ?? toPositiveInteger(frontmatter.pr_number);
-    const operation = policy.producerId === 'platform.issue'
-        ? issueNumber === null
+    const issueIdentity = options.probeIssueNumber !== undefined
+        ? resourceIdentity(options.probeIssueNumber)
+        : taskIssueIdentity(frontmatter) || (() => {
+            const number = toPositiveInteger(frontmatter.issue_number);
+            return number === null ? null : resourceIdentity(number);
+        })();
+    const fact = readPrDeliveryFact(frontmatter);
+    const pullRequestIdentity = options.probePullRequestNumber !== undefined
+        ? resourceIdentity(options.probePullRequestNumber)
+        : fact.status === 'valid' && fact.fact.state === 'bound' ? fact.fact.identity.resource : null;
+    const token = (identity) => identity ? String(identity.value) : null;
+    const issueToken = token(issueIdentity);
+    const pullRequestToken = token(pullRequestIdentity);
+    const operation = await (policy.producerId === 'platform.issue'
+        ? issueToken === null
             ? null
             : bindPlatformIssue(taskRef, {
-                issue: issueNumber,
+                issue: issueToken,
                 agent: options.probeOperator ?? 'local-operator',
                 dryRun: true,
                 cwd: resolved.repoRoot,
                 ...(options.platformClient ? { client: options.platformClient } : {})
             })
-        : pullRequestNumber === null
+        : pullRequestToken === null
             ? null
             : bindPlatformPullRequest(taskRef, {
-                pr: pullRequestNumber,
+                pr: pullRequestToken,
                 agent: options.probeOperator ?? 'local-operator',
                 dryRun: true,
                 cwd: resolved.repoRoot,
                 ...(options.platformClient ? { client: options.platformClient } : {})
-            });
+            }));
     if (!operation)
-        return error('OVERRIDE_PROBE_INPUT_MISSING', `${policy.producerId} requires a bound issue or pull request number`);
+        return error('OVERRIDE_PROBE_INPUT_MISSING', `${policy.producerId} requires a bound issue or pull request identity`);
     if (operation.status !== 'failed' && operation.status !== 'blocked')
         return probeNotObserved(policy);
     if (!operation.error)
@@ -527,6 +549,9 @@ function probeTaskEventFailure(taskRef, policy, resolved) {
             event: candidate.event,
             agent: 'codex',
             dryRun: true,
+            initiator: 'model',
+            requestId: `override-probe:${taskRef}:${candidate.event}`,
+            reasonCode: 'user-request',
             ...(candidate.artifact ? { artifact: candidate.artifact } : {})
         }, { repoRoot: resolved.repoRoot, lockAlreadyHeld: true });
         const matched = probeResult(policy, result, resolved.state);
@@ -535,8 +560,8 @@ function probeTaskEventFailure(taskRef, policy, resolved) {
     }
     return probeNotObserved(policy);
 }
-function probeVerificationFailure(taskRef, policy, resolved) {
-    const result = verifyTaskEvent({
+async function probeVerificationFailure(taskRef, policy, resolved) {
+    const result = await verifyTaskEvent({
         taskRef,
         event: 'review-code.completed',
         artifact: policy.code === 'VERIFY_ARTIFACT_INVALID' ? 'invalid-artifact.md' : 'review-code.md'
@@ -559,7 +584,7 @@ function latestArtifact(taskDir, family) {
     });
     return candidates[0];
 }
-function probeVerificationEngineFailure(policy, resolved) {
+async function probeVerificationEngineFailure(policy, resolved) {
     const candidates = [
         { skillName: 'review-code', family: 'review-code' },
         { skillName: 'review-plan', family: 'review-plan' },
@@ -574,7 +599,7 @@ function probeVerificationEngineFailure(policy, resolved) {
         if (candidate.family && !artifactFile)
             continue;
         try {
-            const payload = verifyInProcess({
+            const payload = await verifyInProcess({
                 mode: 'gate',
                 skillName: candidate.skillName,
                 taskDir: resolved.taskDir,
@@ -598,7 +623,7 @@ function probeVerificationEngineFailure(policy, resolved) {
     }
     return probeNotObserved(policy);
 }
-function probeGenericFailure(taskRef, policy, resolved, options = {}) {
+async function probeGenericFailure(taskRef, policy, resolved, options = {}) {
     switch (policy.producerId) {
         case 'task.resolve':
             return probeNotObserved(policy);
@@ -607,9 +632,9 @@ function probeGenericFailure(taskRef, policy, resolved, options = {}) {
         case 'task-event':
             return probeTaskEventFailure(taskRef, policy, resolved);
         case 'task-verify':
-            return probeVerificationFailure(taskRef, policy, resolved);
+            return await probeVerificationFailure(taskRef, policy, resolved);
         case 'verification-engine':
-            return probeVerificationEngineFailure(policy, resolved);
+            return await probeVerificationEngineFailure(policy, resolved);
         case 'activity-intent':
             return probeResult(policy, applyPrReviewActivityIntent({
                 kind: 'pr-review-start', taskRef, agent: 'codex', artifact: 'pr-review.md', head: '0'.repeat(40), dryRun: true
@@ -645,7 +670,7 @@ function probeGenericFailure(taskRef, policy, resolved, options = {}) {
         }
         case 'platform.issue':
         case 'platform.pull-request':
-            return probePlatformFailure(taskRef, policy, resolved, options);
+            return await probePlatformFailure(taskRef, policy, resolved, options);
         default:
             return error('OVERRIDE_PROBE_INPUT_MISSING', `no producer probe is registered for ${policy.producerId}`);
     }
@@ -653,7 +678,7 @@ function probeGenericFailure(taskRef, policy, resolved, options = {}) {
 function isProducerFailure(value) {
     return 'observedFacts' in value && 'state' in value && Array.isArray(value.observedFacts);
 }
-function captureFailureSnapshot(taskRef, failureIdValue, target, options = {}) {
+async function captureFailureSnapshot(taskRef, failureIdValue, target, options = {}) {
     const policy = policyFor(failureIdValue);
     if (!policy)
         return error('OVERRIDE_FAILURE_UNKNOWN', `failure policy '${failureIdValue}' is not registered`);
@@ -676,7 +701,7 @@ function captureFailureSnapshot(taskRef, failureIdValue, target, options = {}) {
     catch { /* probe reports an unconfirmed identity */ }
     const producer = policy.producerId === LIFECYCLE_PRODUCER
         ? probeLifecycleFailure(taskRef, policy, resolved, options)
-        : probeGenericFailure(taskRef, policy, resolved, options);
+        : await probeGenericFailure(taskRef, policy, resolved, options);
     if (!isProducerFailure(producer))
         return producer;
     const digest = computeFailureDigest(snapshotEvidence(resolved.taskId, failureIdValue, target, content, frontmatter, producer, resourceForSnapshot(policy, options, frontmatter)));
@@ -733,7 +758,7 @@ function validateResourceNumbers(request) {
     }
     return null;
 }
-function issueHumanOverride(request, options = {}) {
+async function issueHumanOverride(request, options = {}) {
     const invalid = validateCommon(request);
     if (invalid)
         return failedIssue(invalid.code, invalid.message);
@@ -762,7 +787,7 @@ function issueHumanOverride(request, options = {}) {
         return failedIssue(document.code, document.message, resolved.taskId);
     if (document.frontmatter.id !== resolved.taskId)
         return failedIssue('OVERRIDE_DOCUMENT_INVALID', 'task frontmatter id does not match resolved task', resolved.taskId);
-    const snapshotResult = captureFailureSnapshot(request.taskRef, request.failureId, request.target, {
+    const snapshotResult = await captureFailureSnapshot(request.taskRef, request.failureId, request.target, {
         ...options,
         probeIntent: request.intent,
         probeOperator: request.operator,
@@ -888,14 +913,14 @@ function lifecycleRequestFor(taskRef, intent, operator, reason, values = {}) {
         return error('OVERRIDE_EFFECT_INPUT_MISSING', 'restore requires the original staging directory and issue number');
     return { taskRef, intent: 'restore', agent: operator, stagingDir, issueNumber };
 }
-function applyOutcomeEffect(request, row, snapshot, outcome, options) {
+async function applyOutcomeEffect(request, row, snapshot, outcome, options) {
     if (outcome.effect === 'no-write' || outcome.effect === 'record-only')
         return null;
     const intent = outcome.target === 'safe-close' ? 'cancel' : row.intent || request.intent;
     if (!intent && outcome.target === 'continue-local') {
         if (!options.effectExecutor)
             return error('OVERRIDE_EFFECT_EXECUTOR_MISSING', 'the producer must supply an effect executor for a continue-local outcome');
-        return options.effectExecutor({
+        return await options.effectExecutor({
             failureId: request.failureId,
             operator: row.operator ?? 'local-operator',
             reason: row.reason ?? snapshot.message
@@ -988,7 +1013,7 @@ function snapshotFromTicket(taskId, row) {
         source: 'producer-result'
     };
 }
-function consumeHumanOverride(request, options = {}) {
+async function consumeHumanOverride(request, options = {}) {
     const values = [request.taskRef, request.ticketId, request.failureId, request.target, request.scope];
     if (values.some((value) => !singleLine(value))) {
         return failedConsume('OVERRIDE_PAYLOAD_INVALID', 'consume fields must be non-empty single-line values', request.ticketId || null);
@@ -1040,7 +1065,7 @@ function consumeHumanOverride(request, options = {}) {
         snapshot = recoverySnapshot;
     }
     else {
-        const snapshotResult = captureFailureSnapshot(request.taskRef, request.failureId, request.target, {
+        const snapshotResult = await captureFailureSnapshot(request.taskRef, request.failureId, request.target, {
             ...options,
             probeIntent: row.values.intent ? row.values.intent : request.intent,
             probeOperator: row.values.operator,
@@ -1094,7 +1119,7 @@ function consumeHumanOverride(request, options = {}) {
             return failedConsume('OVERRIDE_WRITE_INVALID', 'override writes cannot be planned', request.ticketId, resolved.taskId);
         effectRow = { ...row.values, status: 'consuming', effect: outcome.effect, result: outcome.result, context_id: outcome.contextId, residual: `effect pending: ${outcome.residual}` };
     }
-    const effectError = applyOutcomeEffect(request, effectRow, snapshot, outcome, options);
+    const effectError = await applyOutcomeEffect(request, effectRow, snapshot, outcome, options);
     if (effectError)
         return failedConsume(effectError.code, effectError.message, request.ticketId, resolved.taskId);
     const after = resolveTask(request.taskRef, options);
@@ -1134,7 +1159,7 @@ function diagnoseHumanOverride(failure, target) {
         error: null
     };
 }
-function diagnoseHumanOverrideForTask(taskRef, failure, target, options = {}) {
+async function diagnoseHumanOverrideForTask(taskRef, failure, target, options = {}) {
     const resolved = resolveTask(taskRef, options);
     if (!resolved.ok) {
         return {
@@ -1173,12 +1198,12 @@ function diagnoseHumanOverrideForTask(taskRef, failure, target, options = {}) {
             error: error('OVERRIDE_FAILURE_UNKNOWN', `failure policy '${failure}' is not registered`)
         };
     }
-    const probes = policies
+    const probes = await Promise.all(policies
         .filter((policy) => !target || policy.targets.includes(target))
-        .map((policy) => {
+        .map(async (policy) => {
         const producer = policy.producerId === LIFECYCLE_PRODUCER
             ? probeLifecycleFailure(taskRef, policy, resolved, options)
-            : probeGenericFailure(taskRef, policy, resolved, options);
+            : await probeGenericFailure(taskRef, policy, resolved, options);
         const observed = isProducerFailure(producer);
         return {
             failureId: policy.id,
@@ -1192,7 +1217,7 @@ function diagnoseHumanOverrideForTask(taskRef, failure, target, options = {}) {
             message: observed ? producer.message : producer.message,
             errorCode: observed ? null : producer.code
         };
-    });
+    }));
     const blockedBy = probes.filter((probe) => probe.status === 'observed');
     return {
         status: 'ready',

package/dist/lib/task/invalidation-command.js

@@ -0,0 +1,86 @@
+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 receipt = receipts.find((candidate) => candidate.output === target.targetArtifact);
+            if (!receipt || receipt.inputSha256 !== target.targetSha256) {
+                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

@@ -0,0 +1,260 @@
+import { createHash } from 'node:crypto';
+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_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.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 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]])));
+    }
+    return rows;
+}
+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 body = sectionBody(content);
+    if (body === 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) => ({
+            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.map((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),
+            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.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.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 = sectionBody(content) !== null;
+    return {
+        kind: 'section',
+        aliases: INVALIDATION_HEADINGS,
+        heading: existing && /^##\s+Artifact Invalidation\s*$/m.test(content) ? INVALIDATION_HEADINGS[1] : 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