@fitlab-ai/agent-infra 0.9.13 → 0.9.15

package/dist/lib/task/lifecycle.js

@@ -2,7 +2,8 @@ import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { appendActivityEntry, locateActivityLog } from './activity-log.js';
-import { artifactFamilyCatalog, inspectArtifactDirectory, parseArtifactName } from './artifact-lifecycle.js';
+import { artifactFamilyCatalog, inspectArtifactDirectory } from './artifact-lifecycle.js';
+import { parseArtifactName } from './artifact-name.js';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { locateHotTaskDirs, resolveTaskRef, TASK_ID_RE } from './resolve-ref.js';
 import { configuredShortIdLength, executeShortIdCommand, loadShortIdByTaskId, mutateShortIdRegistry } from './short-id.js';
@@ -296,6 +297,23 @@ function parseJournal(content) {
     }
     return value;
 }
+/** Recovery reads the same journal contract as the lifecycle writer. */
+export function readLifecycleJournalEvidence(repoRoot, taskId) {
+    const journalPath = locateHotTaskDirs(repoRoot, taskId)
+        .map((entry) => path.join(entry.taskDir, '.task-lifecycle.json'))
+        .find((candidate) => fs.existsSync(candidate));
+    if (!journalPath)
+        return { exists: false, completedSteps: [], failure: null };
+    try {
+        const journal = parseJournal(fs.readFileSync(journalPath, 'utf8'));
+        if (journal.taskId !== taskId)
+            throw new Error('journal task identity mismatch');
+        return { exists: true, completedSteps: journal.completedSteps, failure: journal.failure?.code ?? null };
+    }
+    catch {
+        return { exists: true, completedSteps: [], failure: 'SANDBOX_CONTROL_LIFECYCLE_JOURNAL_INVALID' };
+    }
+}
 function directoryManifest(root) {
     const entries = [];
     const visit = (current, relative = '') => {

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

@@ -1,198 +1,131 @@
 import fs from 'node:fs';
-import { createHash } from 'node:crypto';
-import path from 'node:path';
-import { inspectDecisionDetailDuplicates, scanVisibleMarkdown } from './decision-details.js';
-import { parseArtifactName, validateCompletedArtifact } from './artifact-lifecycle.js';
+import { inspectDecisionDetailDuplicates } from './decision-details.js';
+import { scanVisibleMarkdown } from './markdown.js';
+import { parseArtifactName } from './artifact-name.js';
+import { hasOpenArtifactRound, validateArtifactPublication, 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';
+import { consumeLifecycleRecoveryAttestation, lifecycleRecoveryAttestationDigest, validateLifecycleRecoveryAttestation } from './control-authority.js';
 const LOCAL_ARTIFACT_REQUIRED_SECTIONS = {
-    analysis: [
-        '需求来源', '需求理解', '相关文件', '影响评估', '技术风险',
-        '工作量和复杂度评估', '状态核对'
-    ],
-    plan: [
-        '问题理解', '约束条件', '方案对比', '技术方法', '实施步骤',
-        '文件清单', '验证策略', '状态核对'
-    ],
-    code: [
-        '实现输入', '变更文件', '关键代码说明', '测试结果', '与方案的差异',
-        '供审查关注的内容', '状态核对', '证据原文'
-    ]
+    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)
 };
-const LOCAL_ARTIFACT_REQUIRED_PATTERNS = ['^\\$ '];
-function finalizationIntentRoot(repoRoot) {
-    return path.join(repoRoot, '.agents', 'workspace', '.local-artifact-finalization-intents');
+function authorityDigest(authority) {
+    return lifecycleRecoveryAttestationDigest(authority);
 }
-function finalizationIntentPath(repoRoot, taskId, family, artifact) {
-    return path.join(finalizationIntentRoot(repoRoot), `${taskId}-${family}-${artifact}.json`);
-}
-function isFinalizationIntent(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
+function validFinalizerAuthority(authority, request, taskId) {
+    if (!authority)
         return false;
-    const intent = value;
-    return intent.version === 1
-        && typeof intent.taskId === 'string' && intent.taskId.length > 0
-        && (intent.family === 'analysis' || intent.family === 'plan' || intent.family === 'code')
-        && typeof intent.artifact === 'string' && intent.artifact.length > 0
-        && (intent.state === 'awaiting-repair' || intent.state === 'passed' || intent.state === 'consumed')
-        && (intent.baselineSemanticDigest === null || (typeof intent.baselineSemanticDigest === 'string' && /^[a-f0-9]{64}$/.test(intent.baselineSemanticDigest)))
-        && typeof intent.artifactSha256 === 'string' && /^[a-f0-9]{64}$/.test(intent.artifactSha256)
-        && typeof intent.semanticDigest === 'string' && /^[a-f0-9]{64}$/.test(intent.semanticDigest)
-        && (intent.state === 'awaiting-repair' ? intent.baselineSemanticDigest === intent.semanticDigest : true);
-}
-function readLocalArtifactFinalizationIntent(repoRoot, taskId, family, artifact) {
-    const target = finalizationIntentPath(repoRoot, taskId, family, artifact);
-    if (!fs.existsSync(target))
-        return null;
-    const value = JSON.parse(fs.readFileSync(target, 'utf8'));
-    if (!isFinalizationIntent(value) || value.taskId !== taskId || value.family !== family || value.artifact !== artifact) {
-        throw new Error('LOCAL_FINALIZATION_INTENT_INVALID: finalization provenance schema is invalid');
-    }
-    return value;
-}
-function writeLocalArtifactFinalizationIntent(repoRoot, value) {
-    if (!isFinalizationIntent(value))
-        throw new Error('LOCAL_FINALIZATION_INTENT_INVALID: finalization provenance schema is invalid');
-    const directory = finalizationIntentRoot(repoRoot);
-    fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
-    const target = finalizationIntentPath(repoRoot, value.taskId, value.family, value.artifact);
-    const temporary = `${target}.${process.pid}.${Date.now()}.tmp`;
-    fs.writeFileSync(temporary, `${JSON.stringify(value)}\n`, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
     try {
-        fs.renameSync(temporary, target);
+        validateLifecycleRecoveryAttestation(authority);
     }
-    catch (error) {
-        try {
-            fs.unlinkSync(temporary);
-        }
-        catch { /* preserve primary error */ }
-        throw error;
+    catch {
+        return false;
     }
+    return authority.version === 1
+        && authority.phase === 'artifact.finalize-local'
+        && authority.taskId === taskId
+        && authority.family === request.family
+        && authority.artifact === request.artifact
+        && authority.round === (parseArtifactName(request.artifact)?.round ?? 0)
+        && authority.requestId.length > 0
+        && authority.operationId.length > 0;
 }
 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);
+    const consumed = { ...intent, state: 'consumed', updatedAt: Date.now() };
+    writeArtifactRepairIntent(repoRoot, consumed, { expected: intent });
     return consumed;
 }
-function requiredSections(family) {
-    return LOCAL_ARTIFACT_REQUIRED_SECTIONS[family];
-}
-function lineNumber(content, offset) {
-    return content.slice(0, offset).split('\n').length;
-}
-function sectionBody(content, heading) {
-    const next = scanVisibleMarkdown(content).headings.find((candidate) => (candidate.start > heading.start && candidate.level <= 2));
-    return content.slice(heading.end, next?.start ?? content.length);
-}
-function semanticDigest(content, candidate) {
-    let normalized = content;
-    if (candidate) {
-        const raw = content.slice(candidate.start, candidate.end);
-        const marker = raw.match(/([:：])\s*$/);
-        if (marker?.index !== undefined) {
-            const canonical = raw.slice(0, marker.index) + raw.slice(marker.index + 1);
-            normalized = `${content.slice(0, candidate.start)}${canonical}${content.slice(candidate.end)}`;
-        }
-    }
-    return createHash('sha256').update(normalized, 'utf8').digest('hex');
-}
-function sha256Content(content) {
-    return createHash('sha256').update(content, 'utf8').digest('hex');
-}
-function visibleSectionHeadings(content, section) {
-    return scanVisibleMarkdown(content).headings.filter((heading) => (heading.level === 2 && heading.text === section));
-}
-function trailingPunctuationCandidates(content, section) {
-    return scanVisibleMarkdown(content).headings.filter((heading) => (heading.level === 2 && (heading.text === `${section}:` || heading.text === `${section}：`)));
+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 diagnostic(code, message, content, heading, extra = {}) {
+function localDiagnostic(item) {
+    const code = localDiagnosticCode(item.code);
+    if (!code)
+        return null;
     return {
-        code, message, repairable: false,
-        line: heading ? lineNumber(content, heading.start) : null,
-        ...extra
+        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 sections = options.requiredSections ?? requiredSections(options.family);
-    const patterns = options.requiredPatterns ?? LOCAL_ARTIFACT_REQUIRED_PATTERNS;
+    const schema = getArtifactSchema(options.family);
+    const patterns = schema.requiredPatterns;
     const diagnostics = [];
-    const candidates = [];
     const scanned = scanVisibleMarkdown(content);
-    if (!content.trim()) {
-        diagnostics.push(diagnostic('LOCAL_ARTIFACT_EMPTY', 'artifact is empty', content));
-    }
-    for (const section of sections) {
-        const exact = scanned.headings.filter((heading) => heading.level === 2 && heading.text === section);
-        const punctuated = trailingPunctuationCandidates(content, section);
-        if (exact.length > 1 || punctuated.length > 0 && exact.length > 0 || punctuated.length > 1) {
-            const first = exact[1] ?? punctuated[0] ?? exact[0];
-            diagnostics.push(diagnostic('LOCAL_ARTIFACT_DUPLICATE_SECTION', `required section '${section}' is duplicated or has an ambiguous punctuation variant`, content, first));
-        }
-        else if (exact.length === 0 && punctuated.length === 1) {
-            candidates.push(punctuated[0]);
-        }
-        else if (exact.length === 0) {
-            diagnostics.push(diagnostic('LOCAL_ARTIFACT_MISSING_SECTION', `required section '${section}' is missing`, content));
-        }
+    const structure = inspectArtifactStructure(content, schema);
+    for (const item of structure.diagnostics) {
+        const mapped = localDiagnostic(item);
+        if (mapped)
+            diagnostics.push(mapped);
     }
-    const statusSection = sections.find((section) => section === '状态核对' || section.toLowerCase() === 'state check');
+    const statusSection = schema.sections.find((section) => section.id === 'state-check');
     if (statusSection) {
-        const statusHeading = visibleSectionHeadings(content, statusSection)[0]
-            ?? candidates.find((heading) => heading.text === `${statusSection}:` || heading.text === `${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 body = sectionBody(content, 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(diagnostic('LOCAL_STATUS_COMMAND_MISSING', `status section '${statusSection}' is missing required command output`, content, statusHeading));
+                    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 });
                 }
             }
         }
     }
-    for (const pattern of patterns.filter((item) => !isStatusPattern(item))) {
-        if (!new RegExp(pattern, 'm').test(content)) {
-            diagnostics.push(diagnostic('LOCAL_REQUIRED_PATTERN_MISSING', `artifact is missing required pattern '${pattern}'`, content));
-        }
+    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(diagnostic('LOCAL_DECISION_DETAIL_DUPLICATE', decisionDetails.message, content, decisionDetails.duplicates[0]?.blocks[0]
-            ? scanned.headings.find((heading) => heading.start === decisionDetails.duplicates[0].blocks[0].start)
-            : undefined));
+        diagnostics.push({ code: 'LOCAL_DECISION_DETAIL_DUPLICATE', message: decisionDetails.message, repairable: false, line: null });
     }
-    if (candidates.length === 1 && diagnostics.length === 0) {
-        const candidate = candidates[0];
-        const section = candidate.text.slice(0, -1);
-        const repair = diagnostic('LOCAL_SECTION_HEADING_TRAILING_PUNCTUATION', `visible required H2 '${candidate.text}' may be normalized to '${section}'`, content, candidate, {
-            repairable: true,
-            from: candidate.text,
-            to: section,
-            operation: 'replace-line'
+    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
         });
-        return {
-            ok: false,
-            family: options.family,
-            semanticDigest: semanticDigest(content, candidate),
-            repairable: true,
-            diagnostics: [repair]
-        };
-    }
-    if (candidates.length > 0) {
-        for (const candidate of candidates) {
-            const section = candidate.text.slice(0, -1);
-            diagnostics.push(diagnostic('LOCAL_ARTIFACT_MISSING_SECTION', `required section '${section}' is missing and cannot be repaired while other structural defects exist`, content, candidate));
+        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: semanticDigest(content),
-        repairable: false,
+        semanticDigest: semanticDigestValue,
+        repairable,
         diagnostics
     };
 }
@@ -205,170 +138,137 @@ function failedFinalization(request, error, extra = {}) {
         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: [diagnostic(code, message, content)]
+/** Read and validate once; callers publish this content before committing provenance. */
+function prepareLocalArtifact(request, candidate, authority) {
+    const failed = (code, message) => ({
+        result: failedFinalization(request, { code, message }), content: candidate ?? ''
     });
-}
-function finalizeLocalArtifact(request) {
     const resolved = resolveTaskRef(request.taskRef, { repoRoot: request.repoRoot });
     if (!resolved.ok)
-        return failedFinalization(request, { code: resolved.code, message: resolved.message });
+        return failed(resolved.code, 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 });
-    }
+    if (!parsed || parsed.family !== request.family)
+        return failed('ARTIFACT_IDENTITY_INVALID', `artifact '${request.artifact}' does not match ${request.family}`);
     let content;
+    let taskContent;
     try {
-        content = fs.readFileSync(validated.artifact.path, 'utf8');
+        taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
+        if (candidate !== undefined) {
+            const error = validateArtifactPublication(resolved.taskDir, request.family, request.artifact);
+            if (error)
+                return failed(error.code, error.message);
+            if (resolved.state !== 'active' || !hasOpenArtifactRound(taskContent, request.family, parsed.round)) {
+                return failed('ARTIFACT_IDENTITY_INVALID', 'candidate must match one open started round in an active task');
+            }
+            content = candidate;
+        }
+        else {
+            const validated = validateCompletedArtifact(resolved.taskDir, request.family, request.artifact, parsed.round);
+            if (!validated.ok)
+                return failed(validated.error.code, validated.error.message);
+            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
-        });
+        return failed('ARTIFACT_NOT_READABLE', String(error));
     }
-    const result = validateLocalArtifact(content, {
-        family: request.family,
-        requiredSections: request.requiredSections,
-        requiredPatterns: request.requiredPatterns
+    const validation = validateLocalArtifact(content, {
+        family: request.family, requiredSections: request.requiredSections, taskContent, artifact: request.artifact
     });
     const artifactSha256 = sha256Content(content);
+    const { semanticDigest, repairable, diagnostics } = validation;
+    const result = failedFinalization(request, {
+        code: 'LOCAL_ARTIFACT_INVALID', message: diagnostics.map((item) => `${item.code}: ${item.message}`).join('; ')
+    }, { taskId: resolved.taskId, taskDir: resolved.taskDir, artifactSha256, semanticDigest, repairable, diagnostics });
+    const preparedBase = { result, content, repoRoot: resolved.repoRoot };
+    if (authority !== undefined && !validFinalizerAuthority(authority, request, resolved.taskId)) {
+        return {
+            ...preparedBase,
+            result: { ...result, repairable: false, error: {
+                    code: 'LOCAL_EXECUTION_AUTHORITY_INVALID',
+                    message: 'finalizer authority does not match the artifact tuple'
+                }, diagnostics: [] }
+        };
+    }
+    const reject = (code, message) => ({
+        ...prepared, result: { ...result, repairable: false, error: { code, message },
+            diagnostics: [{ code, message, repairable: false, line: null }] }
+    });
     let intent;
     try {
-        intent = readLocalArtifactFinalizationIntent(resolved.repoRoot, resolved.taskId, request.family, request.artifact);
+        intent = readArtifactRepairIntent(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 });
+        return { ...preparedBase, result: { ...result, repairable: false, diagnostics: [],
+                error: { code: 'LOCAL_FINALIZATION_INTENT_INVALID', message: String(error) } } };
     }
-    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('; ')
-            }
-        };
+    const prepared = { ...preparedBase, expectedIntent: intent };
+    if (intent && intent.recoveryOperationId !== null
+        && (!authority || intent.recoveryOperationId !== authority.operationId)) {
+        return reject('LOCAL_REPAIR_PROVENANCE_CONFLICT', 'local repair provenance is owned by another recovery operation');
     }
-    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 (repairable) {
+        if (intent && (intent.state !== 'awaiting-repair' || intent.baselineSemanticDigest !== semanticDigest)) {
+            return reject('LOCAL_REPAIR_PROVENANCE_CONFLICT', 'a different local repair baseline is already recorded for this artifact');
+        }
+        if (intent && !authority)
+            return prepared;
     }
-    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
-        };
+    else {
+        if (!validation.ok)
+            return prepared;
+        if (intent?.state === 'awaiting-repair' && intent.baselineSemanticDigest !== semanticDigest) {
+            return reject('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 !== semanticDigest)) {
+            return reject('LOCAL_REPAIR_PROVENANCE_CONFLICT', 'the artifact changed after its finalization provenance was recorded');
+        }
+        prepared.result = { ...result, status: 'passed', error: null };
+        if (intent?.state === 'consumed')
+            return prepared;
     }
+    const timestamp = Date.now();
+    return { ...prepared, provenance: {
+            version: 2, taskId: resolved.taskId, family: request.family, artifact: request.artifact,
+            state: repairable ? 'awaiting-repair' : 'passed',
+            baselineSemanticDigest: repairable ? semanticDigest : intent?.baselineSemanticDigest ?? null,
+            artifactSha256, semanticDigest,
+            recoveryOperationId: authority?.operationId ?? intent?.recoveryOperationId ?? null,
+            phase: authority?.phase ?? intent?.phase ?? null,
+            authorityDigest: authority ? authorityDigest(authority) : intent?.authorityDigest ?? null,
+            requestId: authority?.lifecycleRequestId ?? intent?.requestId ?? `local-finalize:${resolved.taskId}`,
+            createdAt: intent?.createdAt ?? timestamp,
+            updatedAt: timestamp
+        } };
+}
+function commitLocalArtifactProvenance(prepared) {
     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
-        });
+        if (prepared.provenance) {
+            writeArtifactRepairIntent(prepared.repoRoot, prepared.provenance, { expected: prepared.expectedIntent ?? null });
+        }
+        return prepared.result;
     }
     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 { ...prepared.result, status: 'failed', error: {
+                code: 'LOCAL_FINALIZATION_INTENT_WRITE_FAILED', message: String(error)
+            } };
     }
-    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('; ')
+}
+function finalizeLocalArtifact(request, authority, options = {}) {
+    const result = commitLocalArtifactProvenance(prepareLocalArtifact(request, undefined, authority));
+    if (authority && !options.deferLifecycleRecoveryConsumption && result.status === 'passed') {
+        try {
+            consumeLifecycleRecoveryAttestation(authority);
         }
-    };
+        catch (error) {
+            return { ...result, status: 'failed', error: {
+                    code: 'LOCAL_EXECUTION_AUTHORITY_CONSUME_FAILED',
+                    message: error instanceof Error ? error.message : String(error)
+                } };
+        }
+    }
+    return result;
 }
-export { LOCAL_ARTIFACT_REQUIRED_PATTERNS, LOCAL_ARTIFACT_REQUIRED_SECTIONS, consumeLocalArtifactFinalizationIntent, finalizeLocalArtifact, readLocalArtifactFinalizationIntent, semanticDigest, sha256Content, validateLocalArtifact };
+export { LOCAL_ARTIFACT_REQUIRED_SECTIONS, consumeLocalArtifactFinalizationIntent, finalizeLocalArtifact, prepareLocalArtifact, commitLocalArtifactProvenance, readArtifactRepairIntent as readLocalArtifactFinalizationIntent, canonicalSemanticDigest as semanticDigest, sha256Content, validateLocalArtifact };
 //# sourceMappingURL=local-artifact-finalization.js.map

package/dist/lib/task/manual-validation-completion.js

@@ -0,0 +1,26 @@
+import { readManualValidationReceipt } from './manual-validation-receipt.js';
+import { readManualValidationTransaction } from './manual-validation-transaction.js';
+function readManualValidationCompletion(taskDir, expected = {}) {
+    const { receiptDigest: expectedReceiptDigest, ...receiptIdentity } = expected;
+    const receipt = readManualValidationReceipt(taskDir, receiptIdentity);
+    if (!receipt.ok)
+        return receipt;
+    if (expectedReceiptDigest !== undefined && receipt.value.receiptDigest !== expectedReceiptDigest) {
+        return { ok: false, error: { code: 'MANUAL_VALIDATION_RECEIPT_IDENTITY_MISMATCH', message: 'receipt digest does not match the expected completion' } };
+    }
+    const transaction = readManualValidationTransaction(taskDir, {
+        transactionId: receipt.value.transactionId,
+        taskId: receipt.value.taskId,
+        prNumber: receipt.value.prNumber,
+        prHeadSha: receipt.value.prHeadSha,
+        artifact: receipt.value.artifact
+    });
+    if (!transaction.ok)
+        return transaction;
+    if (transaction.value.committedReceipt !== receipt.value.receiptDigest) {
+        return { ok: false, error: { code: 'MANUAL_VALIDATION_TRANSACTION_PHASE_INVALID', message: 'completion transaction is not bound to the canonical receipt' } };
+    }
+    return { ok: true, value: { receipt: receipt.value, transaction: transaction.value } };
+}
+export { readManualValidationCompletion };
+//# sourceMappingURL=manual-validation-completion.js.map