@fitlab-ai/agent-infra 0.9.12 → 0.9.14

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

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

@@ -1,10 +1,12 @@
 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 { 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';
 import { allowsManualOverride } from './guard-override.js';
+import { parseReworkIntentDocument, reworkIntentMutation, upsertReworkIntent } from './rework-intent.js';
 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']);
@@ -102,6 +104,41 @@ function applyLedgerIntent(intent, options = {}) {
     if (intent.kind === 'decision-next-id') {
         return { status: 'no-op', changed: false, intent: intent.kind, taskId: resolved.taskId, entityId: nextHdId(rows), before: null, after: null, operations: [], error: null };
     }
+    if (intent.kind === 'rework-intent-upsert') {
+        if (!/^RI-[1-9]\d*$/.test(intent.intentId) || !/^(AN|PL|CD)-[1-9]\d*$/.test(intent.findingId) || !['analysis', 'plan', 'code'].includes(intent.target) || !/^[a-f0-9]{64}$/.test(intent.sourceSha256)) {
+            return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'rework intent identity, target, or source hash is invalid', resolved.taskId, intent.intentId);
+        }
+        const finding = rows.find((row) => row.id === intent.findingId);
+        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)) {
+            return failed(intent, 'LEDGER_IDENTITY_CONFLICT', 'rework intent source artifact does not match finding evidence', resolved.taskId, intent.intentId);
+        }
+        try {
+            const actualHash = createHash('sha256').update(fs.readFileSync(path.join(resolved.taskDir, intent.sourceArtifact))).digest('hex');
+            if (actualHash !== intent.sourceSha256)
+                return failed(intent, 'LEDGER_IDENTITY_CONFLICT', 'rework intent source artifact hash does not match', resolved.taskId, intent.intentId);
+            const parsed = parseReworkIntentDocument(content);
+            if (!parsed.ok)
+                return failed(intent, parsed.code, parsed.message, resolved.taskId, intent.intentId);
+            const nextIntent = {
+                intentId: intent.intentId, findingId: intent.findingId, sourceArtifact: intent.sourceArtifact,
+                sourceSha256: intent.sourceSha256, target: intent.target, status: 'pending',
+                declaredAt: new Date().toISOString(), consumedAt: ''
+            };
+            const next = upsertReworkIntent(parsed.intents, nextIntent);
+            if (!next.changed)
+                return { status: 'no-op', changed: false, intent: intent.kind, taskId: resolved.taskId, entityId: intent.intentId, before: null, after: null, operations: [], error: null };
+            const result = writeTask({ taskRef: intent.taskRef, expectedState: 'active', dryRun: intent.dryRun, mutations: [reworkIntentMutation(content, next.intents)] }, { ...options, taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state } });
+            if (result.status === 'failed')
+                return failed(intent, result.error.code, result.error.message, result.taskId, intent.intentId);
+            return { status: result.status, changed: result.changed, intent: intent.kind, taskId: result.taskId, entityId: intent.intentId, before: null, after: null, operations: result.operations, error: null };
+        }
+        catch (error) {
+            return failed(intent, 'LEDGER_IDENTITY_CONFLICT', error instanceof Error ? error.message : String(error), resolved.taskId, intent.intentId);
+        }
+    }
     let before = null;
     let after;
     if (intent.kind === 'finding-upsert') {

package/dist/lib/task/local-artifact-finalization.js

@@ -0,0 +1,299 @@
+import fs from 'node:fs';
+import { inspectDecisionDetailDuplicates, scanVisibleMarkdown } from './decision-details.js';
+import { parseArtifactName, validateCompletedArtifact } from './artifact-lifecycle.js';
+import { resolveTaskRef } from './resolve-ref.js';
+import { expectedQualificationRelations, validateQualificationAudit } from './qualification-audit.js';
+import { canonicalSemanticDigest, inspectArtifactPatterns, inspectArtifactStructure, sha256Content } from './artifact-operations.js';
+import { getArtifactSchema } from './artifact-schema.js';
+import { readArtifactRepairIntent, writeArtifactRepairIntent } from './artifact-repair-intent.js';
+const LOCAL_ARTIFACT_REQUIRED_SECTIONS = {
+    analysis: getArtifactSchema('analysis').sections.map((section) => section.headings.zh),
+    plan: getArtifactSchema('plan').sections.map((section) => section.headings.zh),
+    code: getArtifactSchema('code').sections.map((section) => section.headings.zh)
+};
+function readLocalArtifactFinalizationIntent(repoRoot, taskId, family, artifact) {
+    return readArtifactRepairIntent(repoRoot, taskId, family, artifact);
+}
+function writeLocalArtifactFinalizationIntent(repoRoot, value) {
+    writeArtifactRepairIntent(repoRoot, value);
+}
+function consumeLocalArtifactFinalizationIntent(repoRoot, intent) {
+    if (intent.state === 'consumed')
+        return intent;
+    if (intent.state !== 'passed')
+        throw new Error('LOCAL_FINALIZATION_INTENT_INVALID: only passed provenance can be consumed');
+    const consumed = { ...intent, state: 'consumed' };
+    writeLocalArtifactFinalizationIntent(repoRoot, consumed);
+    return consumed;
+}
+function localDiagnosticCode(code) {
+    const map = {
+        ARTIFACT_EMPTY: 'LOCAL_ARTIFACT_EMPTY',
+        ARTIFACT_MISSING_SECTION: 'LOCAL_ARTIFACT_MISSING_SECTION',
+        ARTIFACT_DUPLICATE_SECTION: 'LOCAL_ARTIFACT_DUPLICATE_SECTION',
+        ARTIFACT_HEADING_TRAILING_PUNCTUATION: 'LOCAL_SECTION_HEADING_TRAILING_PUNCTUATION'
+    };
+    return map[code] ?? 'LOCAL_STRUCTURAL_INVALID';
+}
+function localDiagnostic(item) {
+    const code = localDiagnosticCode(item.code);
+    if (!code)
+        return null;
+    return {
+        code,
+        message: item.message,
+        repairable: item.repairable,
+        line: item.line,
+        ...(item.operation?.kind === 'replace-line'
+            ? { from: item.operation.from, to: item.operation.to, operation: 'replace-line' }
+            : {})
+    };
+}
+function isStatusPattern(pattern) {
+    return pattern === '^\\$ ';
+}
+function validateLocalArtifact(content, options) {
+    const schema = getArtifactSchema(options.family);
+    const patterns = schema.requiredPatterns;
+    const diagnostics = [];
+    const scanned = scanVisibleMarkdown(content);
+    const structure = inspectArtifactStructure(content, schema);
+    for (const item of structure.diagnostics) {
+        const mapped = localDiagnostic(item);
+        if (mapped)
+            diagnostics.push(mapped);
+    }
+    const statusSection = schema.sections.find((section) => section.id === 'state-check');
+    if (statusSection) {
+        const statusHeading = scanned.headings.find((heading) => (heading.level === 2 && [statusSection.headings.zh, statusSection.headings.en].some((name) => (heading.text === name || heading.text === `${name}:` || heading.text === `${name}：`))));
+        if (statusHeading) {
+            const next = scanned.headings.find((candidate) => candidate.start > statusHeading.start && candidate.level <= 2);
+            const body = content.slice(statusHeading.end, next?.start ?? content.length);
+            for (const pattern of patterns.filter(isStatusPattern)) {
+                if (!new RegExp(pattern, 'm').test(body)) {
+                    diagnostics.push({ code: 'LOCAL_STATUS_COMMAND_MISSING', message: `status section '${statusHeading.text}' is missing required command output`, repairable: false, line: content.slice(0, statusHeading.start).split('\n').length });
+                }
+            }
+        }
+    }
+    const patternInspection = inspectArtifactPatterns(content, {
+        ...schema,
+        requiredPatterns: patterns.filter((item) => !isStatusPattern(item))
+    });
+    for (const item of patternInspection.diagnostics) {
+        diagnostics.push({ code: 'LOCAL_REQUIRED_PATTERN_MISSING', message: item.message, repairable: false, line: null });
+    }
+    const decisionDetails = inspectDecisionDetailDuplicates(content);
+    if (!decisionDetails.ok) {
+        diagnostics.push({ code: 'LOCAL_DECISION_DETAIL_DUPLICATE', message: decisionDetails.message, repairable: false, line: null });
+    }
+    if (options.taskContent !== undefined) {
+        const expected = expectedQualificationRelations(options.taskContent, options.family);
+        if (!expected.ok) {
+            diagnostics.push({ code: 'LOCAL_QUALIFICATION_AUDIT_INVALID', message: `${expected.code}: ${expected.message}`, repairable: false, line: null });
+        }
+        const qualification = validateQualificationAudit(options.taskContent, content, {
+            family: options.family === 'analysis' ? 'analysis' : options.family === 'plan' ? 'plan' : 'code',
+            artifact: options.artifact,
+            expectedUpstreamRelations: expected.ok ? expected.relations : undefined
+        });
+        if (!qualification.ok) {
+            diagnostics.push({ code: 'LOCAL_QUALIFICATION_AUDIT_INVALID', message: `${qualification.code}: ${qualification.message}`, repairable: false, line: null });
+        }
+    }
+    const repairable = structure.repair !== null && diagnostics.length === 1 && diagnostics[0]?.repairable === true;
+    const semanticDigestValue = canonicalSemanticDigest(content, structure.repair);
+    return {
+        ok: diagnostics.length === 0,
+        family: options.family,
+        semanticDigest: semanticDigestValue,
+        repairable,
+        diagnostics
+    };
+}
+function failedFinalization(request, error, extra = {}) {
+    return {
+        status: 'failed', changed: false,
+        taskId: null, taskDir: null,
+        family: request.family, artifact: request.artifact,
+        artifactSha256: null, semanticDigest: null,
+        repairable: false, diagnostics: [], error, ...extra
+    };
+}
+function provenanceFailure(request, resolved, content, artifactSha256, semanticDigestValue, code, message) {
+    return failedFinalization(request, { code, message }, {
+        taskId: resolved.taskId,
+        taskDir: resolved.taskDir,
+        artifactSha256,
+        semanticDigest: semanticDigestValue,
+        diagnostics: [{ code, message, repairable: false, line: null }]
+    });
+}
+function finalizeLocalArtifact(request) {
+    const resolved = resolveTaskRef(request.taskRef, { repoRoot: request.repoRoot });
+    if (!resolved.ok)
+        return failedFinalization(request, { code: resolved.code, message: resolved.message });
+    const parsed = parseArtifactName(request.artifact);
+    if (!parsed || parsed.family !== request.family) {
+        return failedFinalization(request, {
+            code: 'ARTIFACT_IDENTITY_INVALID',
+            message: `artifact '${request.artifact}' does not match ${request.family}`
+        }, { taskId: resolved.taskId, taskDir: resolved.taskDir });
+    }
+    const validated = validateCompletedArtifact(resolved.taskDir, request.family, request.artifact, parsed.round);
+    if (!validated.ok) {
+        return failedFinalization(request, validated.error, { taskId: resolved.taskId, taskDir: resolved.taskDir });
+    }
+    let content;
+    try {
+        content = fs.readFileSync(validated.artifact.path, 'utf8');
+    }
+    catch (error) {
+        return failedFinalization(request, { code: 'ARTIFACT_NOT_READABLE', message: String(error) }, {
+            taskId: resolved.taskId, taskDir: resolved.taskDir
+        });
+    }
+    let taskContent;
+    try {
+        taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
+    }
+    catch (error) {
+        return failedFinalization(request, { code: 'TASK_READ_FAILED', message: error instanceof Error ? error.message : String(error) }, {
+            taskId: resolved.taskId, taskDir: resolved.taskDir
+        });
+    }
+    const result = validateLocalArtifact(content, {
+        family: request.family,
+        requiredSections: request.requiredSections,
+        taskContent,
+        artifact: request.artifact
+    });
+    const artifactSha256 = sha256Content(content);
+    let intent;
+    try {
+        intent = readLocalArtifactFinalizationIntent(resolved.repoRoot, resolved.taskId, request.family, request.artifact);
+    }
+    catch (error) {
+        return failedFinalization(request, {
+            code: 'LOCAL_FINALIZATION_INTENT_INVALID',
+            message: error instanceof Error ? error.message : String(error)
+        }, { taskId: resolved.taskId, taskDir: resolved.taskDir, artifactSha256, semanticDigest: result.semanticDigest });
+    }
+    if (result.repairable) {
+        if (intent && (intent.state !== 'awaiting-repair' || intent.baselineSemanticDigest !== result.semanticDigest)) {
+            return provenanceFailure(request, resolved, content, artifactSha256, result.semanticDigest, 'LOCAL_REPAIR_PROVENANCE_CONFLICT', 'a different local repair baseline is already recorded for this artifact');
+        }
+        if (!intent) {
+            try {
+                writeLocalArtifactFinalizationIntent(resolved.repoRoot, {
+                    version: 1,
+                    taskId: resolved.taskId,
+                    family: request.family,
+                    artifact: request.artifact,
+                    state: 'awaiting-repair',
+                    baselineSemanticDigest: result.semanticDigest,
+                    artifactSha256,
+                    semanticDigest: result.semanticDigest
+                });
+            }
+            catch (error) {
+                return failedFinalization(request, {
+                    code: 'LOCAL_FINALIZATION_INTENT_WRITE_FAILED',
+                    message: error instanceof Error ? error.message : String(error)
+                }, { taskId: resolved.taskId, taskDir: resolved.taskDir, artifactSha256, semanticDigest: result.semanticDigest });
+            }
+        }
+        return {
+            status: 'failed',
+            changed: false,
+            taskId: resolved.taskId,
+            taskDir: resolved.taskDir,
+            family: request.family,
+            artifact: request.artifact,
+            artifactSha256,
+            semanticDigest: result.semanticDigest,
+            repairable: true,
+            diagnostics: result.diagnostics,
+            error: {
+                code: 'LOCAL_ARTIFACT_INVALID',
+                message: result.diagnostics.map((item) => `${item.code}: ${item.message}`).join('; ')
+            }
+        };
+    }
+    if (!result.ok) {
+        return {
+            status: 'failed',
+            changed: false,
+            taskId: resolved.taskId,
+            taskDir: resolved.taskDir,
+            family: request.family,
+            artifact: request.artifact,
+            artifactSha256,
+            semanticDigest: result.semanticDigest,
+            repairable: false,
+            diagnostics: result.diagnostics,
+            error: {
+                code: 'LOCAL_ARTIFACT_INVALID',
+                message: result.diagnostics.map((item) => `${item.code}: ${item.message}`).join('; ')
+            }
+        };
+    }
+    if (intent?.state === 'awaiting-repair' && intent.baselineSemanticDigest !== result.semanticDigest) {
+        return provenanceFailure(request, resolved, content, artifactSha256, result.semanticDigest, 'LOCAL_REPAIR_BASELINE_MISMATCH', 'the repaired artifact semantic digest does not match the recorded repair baseline');
+    }
+    if ((intent?.state === 'passed' || intent?.state === 'consumed')
+        && (intent.artifactSha256 !== artifactSha256 || intent.semanticDigest !== result.semanticDigest)) {
+        return provenanceFailure(request, resolved, content, artifactSha256, result.semanticDigest, 'LOCAL_REPAIR_PROVENANCE_CONFLICT', 'the artifact changed after its finalization provenance was recorded');
+    }
+    if (intent?.state === 'consumed') {
+        return {
+            status: 'passed',
+            changed: false,
+            taskId: resolved.taskId,
+            taskDir: resolved.taskDir,
+            family: request.family,
+            artifact: request.artifact,
+            artifactSha256,
+            semanticDigest: result.semanticDigest,
+            repairable: false,
+            diagnostics: result.diagnostics,
+            error: null
+        };
+    }
+    try {
+        writeLocalArtifactFinalizationIntent(resolved.repoRoot, {
+            version: 1,
+            taskId: resolved.taskId,
+            family: request.family,
+            artifact: request.artifact,
+            state: 'passed',
+            baselineSemanticDigest: intent?.baselineSemanticDigest ?? null,
+            artifactSha256,
+            semanticDigest: result.semanticDigest
+        });
+    }
+    catch (error) {
+        return failedFinalization(request, {
+            code: 'LOCAL_FINALIZATION_INTENT_WRITE_FAILED',
+            message: error instanceof Error ? error.message : String(error)
+        }, { taskId: resolved.taskId, taskDir: resolved.taskDir, artifactSha256, semanticDigest: result.semanticDigest });
+    }
+    return {
+        status: result.ok ? 'passed' : 'failed',
+        changed: false,
+        taskId: resolved.taskId,
+        taskDir: resolved.taskDir,
+        family: request.family,
+        artifact: request.artifact,
+        artifactSha256,
+        semanticDigest: result.semanticDigest,
+        repairable: result.repairable,
+        diagnostics: result.diagnostics,
+        error: result.ok ? null : {
+            code: 'LOCAL_ARTIFACT_INVALID',
+            message: result.diagnostics.map((item) => `${item.code}: ${item.message}`).join('; ')
+        }
+    };
+}
+export { LOCAL_ARTIFACT_REQUIRED_SECTIONS, consumeLocalArtifactFinalizationIntent, finalizeLocalArtifact, readLocalArtifactFinalizationIntent, canonicalSemanticDigest as semanticDigest, sha256Content, validateLocalArtifact };
+//# sourceMappingURL=local-artifact-finalization.js.map