@fitlab-ai/agent-infra 0.9.14 → 0.10.0

package/dist/lib/task/artifact-operations.js

@@ -1,43 +1,14 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
-import { scanVisibleMarkdown } from './decision-details.js';
-import { locateActivityLog, pairEntries, startedBackedRows } from './activity-log.js';
-import { readArtifactRepairIntent } from './artifact-repair-intent.js';
+import { readStableFileSync } from '../host-control/secure-fs.js';
+import { parseArtifactName } from './artifact-name.js';
+import { scanVisibleMarkdown } from './markdown.js';
 import { getArtifactSchema, renderArtifactSkeleton } from './artifact-schema.js';
 import { withTaskExecutionLock } from './task-execution-lock.js';
 function sha256Content(content) {
     return createHash('sha256').update(content, 'utf8').digest('hex');
 }
-function sourceLines(content) {
-    const lines = [];
-    let start = 0;
-    while (start < content.length) {
-        const newline = content.indexOf('\n', start);
-        const end = newline === -1 ? content.length : newline;
-        lines.push({ start, end, text: content.slice(start, end).replace(/\r$/, '') });
-        start = newline === -1 ? content.length : newline + 1;
-    }
-    if (content.length === 0)
-        lines.push({ start: 0, end: 0, text: '' });
-    return lines;
-}
-function hasUnclosedFence(content) {
-    let fence = null;
-    for (const line of sourceLines(content)) {
-        if (fence) {
-            const close = line.text.match(/^ {0,3}(`{3,}|~{3,})\s*$/);
-            if (close && close[1][0] === fence.character && close[1].length >= fence.length)
-                fence = null;
-            continue;
-        }
-        const open = line.text.match(/^ {0,3}(`{3,}|~{3,})(.*)$/);
-        if (open && !(open[1][0] === '`' && open[2].includes('`'))) {
-            fence = { character: open[1][0], length: open[1].length };
-        }
-    }
-    return fence !== null;
-}
 function lineNumber(content, offset) {
     return content.slice(0, offset).split('\n').length;
 }
@@ -47,9 +18,9 @@ function markerPattern(marker) {
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-function markerEntries(content) {
+function markerEntries(content, scanned) {
     const entries = [];
-    for (const line of scanVisibleMarkdown(content).lines) {
+    for (const line of scanned.lines) {
         const match = line.text.match(/<!--\s*(artifact-section:[^\s>]+)\s*-->/g);
         if (!match)
             continue;
@@ -67,10 +38,9 @@ function markerEntries(content) {
     }
     return entries;
 }
-function sectionBodyBounds(content, heading) {
-    const next = scanVisibleMarkdown(content).headings.find((candidate) => (candidate.start > heading.start && candidate.level <= 2));
-    const headingEnd = scanVisibleMarkdown(content).headings.find((candidate) => candidate.start === heading.start)?.end ?? heading.start;
-    return { start: headingEnd, end: next?.start ?? content.length };
+function sectionBodyBounds(content, heading, scanned) {
+    const next = scanned.headings.find((candidate) => candidate.start > heading.start && candidate.level <= 2);
+    return { start: heading.end, end: next?.start ?? content.length };
 }
 function stripHtmlComments(content) {
     let result = '';
@@ -87,95 +57,48 @@ function stripHtmlComments(content) {
     }
     return result;
 }
-function diagnostic(code, message, sectionId, line, repairable = false, operation) {
-    return {
-        code, message, sectionId, line, repairable,
-        ...(operation ? { operation } : {})
-    };
+function diagnostic(code, message, sectionId, line) {
+    return { code, message, sectionId, line };
 }
 function sectionHeadings(schema, section) {
     return [section.headings.zh, section.headings.en];
 }
-function createHeadingRepair(content, section, heading) {
-    const to = heading.text.slice(0, -1);
-    return {
-        kind: 'replace-line',
-        sectionId: section.id,
-        line: lineNumber(content, heading.start),
-        from: heading.text,
-        to,
-        start: heading.start,
-        end: heading.end
-    };
-}
-function createSectionInsertionRepair(content, section, marker, locale) {
-    return {
-        kind: 'insert-section',
-        sectionId: section.id,
-        line: marker.line,
-        from: '',
-        to: `## ${section.headings[locale === 'en' ? 'en' : 'zh']}\n`,
-        start: marker.start,
-        end: marker.start
-    };
-}
-function applyRepairOperation(content, operation) {
-    if (operation.start < 0 || operation.end < operation.start || operation.end > content.length)
-        return null;
-    if (operation.kind === 'insert-section') {
-        if (operation.from !== '' || operation.start !== operation.end || !operation.to)
-            return null;
-        return `${content.slice(0, operation.start)}${operation.to}${content.slice(operation.end)}`;
-    }
-    const raw = content.slice(operation.start, operation.end);
-    const offset = raw.indexOf(operation.from);
-    if (!operation.from || offset < 0 || raw.indexOf(operation.from, offset + operation.from.length) >= 0)
-        return null;
-    return `${content.slice(0, operation.start)}${raw.slice(0, offset)}${operation.to}${raw.slice(offset + operation.from.length)}${content.slice(operation.end)}`;
-}
-function canonicalContent(content, operation = null) {
+function canonicalContent(content) {
     let normalized = content;
-    if (operation) {
-        normalized = applyRepairOperation(normalized, operation) ?? normalized;
-    }
     normalized = normalized.replace(/\r\n/g, '\n');
     normalized = normalized.replace(/^<!--\s*artifact-context:[^\n]+-->\s*\n?/gm, '');
     normalized = normalized.replace(/^\s*<!--\s*artifact-section:[^\n]+-->\s*\n?/gm, '');
     normalized = normalized.replace(/^\s*<!--\s*artifact-slot:empty\s*-->\s*\n?/gm, '');
     return normalized;
 }
-function canonicalSemanticDigest(content, operation = null) {
-    return sha256Content(canonicalContent(content, operation));
+function canonicalSemanticDigest(content) {
+    return sha256Content(canonicalContent(content));
 }
 function inspectArtifactStructure(content, schema) {
     const diagnostics = [];
     const scanned = scanVisibleMarkdown(content);
-    const repairCandidates = [];
     if (!content.trim())
         diagnostics.push(diagnostic('ARTIFACT_EMPTY', 'artifact is empty', null, null));
-    if (hasUnclosedFence(content))
+    if (scanned.hasUnclosedFence)
         diagnostics.push(diagnostic('ARTIFACT_UNCLOSED_FENCE', 'artifact contains an unclosed Markdown fence', null, null));
     const headingsBySection = new Map();
     for (const section of schema.sections) {
         const aliases = sectionHeadings(schema, section);
         const exact = scanned.headings.filter((heading) => heading.level === 2 && aliases.includes(heading.text));
         const punctuated = scanned.headings.filter((heading) => heading.level === 2 && aliases.some((alias) => heading.text === `${alias}:` || heading.text === `${alias}：`));
-        headingsBySection.set(section.id, exact.length === 0 && punctuated.length === 1 ? punctuated : exact);
+        headingsBySection.set(section.id, exact.length > 0 ? exact : punctuated);
         if (exact.length > 1 || punctuated.length > 0 && exact.length > 0 || punctuated.length > 1) {
             const first = exact[1] ?? punctuated[0] ?? exact[0];
             diagnostics.push(diagnostic('ARTIFACT_DUPLICATE_SECTION', `required section '${aliases[0]}' is duplicated or has an ambiguous punctuation variant`, section.id, first ? lineNumber(content, first.start) : null));
         }
         else if (exact.length === 0 && punctuated.length === 1) {
-            repairCandidates.push(createHeadingRepair(content, section, punctuated[0]));
+            diagnostics.push(diagnostic('ARTIFACT_HEADING_TRAILING_PUNCTUATION', `visible required H2 '${punctuated[0].text}' has trailing punctuation`, section.id, lineNumber(content, punctuated[0].start)));
         }
         else if (exact.length === 0) {
             diagnostics.push(diagnostic('ARTIFACT_MISSING_SECTION', `required section '${aliases[0]}' is missing`, section.id, null));
         }
     }
-    const markers = markerEntries(content);
-    const englishHeadings = scanned.headings.filter((heading) => heading.level === 2 && schema.sections.some((section) => section.headings.en === heading.text)).length;
-    const chineseHeadings = scanned.headings.filter((heading) => heading.level === 2 && schema.sections.some((section) => section.headings.zh === heading.text)).length;
-    const locale = englishHeadings > chineseHeadings ? 'en' : 'zh-CN';
+    const markers = markerEntries(content, scanned);
     for (const section of schema.sections) {
         const matches = markers.filter((entry) => entry.marker === section.marker);
         if (matches.length === 0) {
@@ -190,7 +113,7 @@ function inspectArtifactStructure(content, schema) {
             diagnostics.push(diagnostic('ARTIFACT_MARKER_MISMATCH', `section marker '${section.marker}' must occupy its own visible line`, section.id, marker.line));
         }
         if (marker && heading) {
-            const bounds = sectionBodyBounds(content, heading);
+            const bounds = sectionBodyBounds(content, heading, scanned);
             if (marker.start < bounds.start || marker.start >= bounds.end) {
                 diagnostics.push(diagnostic('ARTIFACT_MARKER_MISMATCH', `section marker '${section.marker}' is outside its section`, section.id, marker.line));
             }
@@ -201,10 +124,7 @@ function inspectArtifactStructure(content, schema) {
         if (marker && !heading && marker.standalone) {
             const nextHeading = scanned.headings.find((candidate) => candidate.start > marker.start && candidate.level <= 2);
             const body = stripHtmlComments(content.slice(marker.end, nextHeading?.start ?? content.length)).trim();
-            if (body && repairCandidates.length === 0) {
-                repairCandidates.push(createSectionInsertionRepair(content, section, marker, locale));
-            }
-            else if (!body) {
+            if (!body) {
                 diagnostics.push(diagnostic('ARTIFACT_EMPTY_SECTION', `section '${section.headings.zh}' has no semantic body`, section.id, marker.line));
             }
         }
@@ -214,17 +134,6 @@ function inspectArtifactStructure(content, schema) {
             diagnostics.push(diagnostic('ARTIFACT_MARKER_MISMATCH', `unknown section marker '${marker.marker}'`, null, marker.line));
         }
     }
-    for (const candidate of repairCandidates) {
-        if (candidate.kind === 'replace-line') {
-            diagnostics.push(diagnostic('ARTIFACT_HEADING_TRAILING_PUNCTUATION', `visible required H2 '${candidate.from}' may be normalized to '${candidate.to}'`, candidate.sectionId, candidate.line, true, candidate));
-            continue;
-        }
-        const missing = diagnostics.findIndex((item) => item.code === 'ARTIFACT_MISSING_SECTION' && item.sectionId === candidate.sectionId);
-        if (missing >= 0) {
-            const section = schema.sections.find((item) => item.id === candidate.sectionId);
-            diagnostics.splice(missing, 1, diagnostic('ARTIFACT_MISSING_SECTION', `required section '${section.headings.zh}' is missing and can be inserted at its unique marker`, candidate.sectionId, candidate.line, true, candidate));
-        }
-    }
     const orderedHeadings = schema.sections.flatMap((section) => {
         const heading = headingsBySection.get(section.id)?.[0];
         return heading ? [{ section, start: heading.start }] : [];
@@ -239,14 +148,11 @@ function inspectArtifactStructure(content, schema) {
     if (orderedMarkers.some((item, index) => index > 0 && item.start <= orderedMarkers[index - 1].start)) {
         diagnostics.push(diagnostic('ARTIFACT_SECTION_ORDER_INVALID', 'section markers are not in schema order', null, null));
     }
-    const repair = repairCandidates.length === 1 && (diagnostics.length === 0 ||
-        (diagnostics.length === 1 && diagnostics[0]?.operation?.kind === repairCandidates[0]?.kind)) ? repairCandidates[0] : null;
     return {
         ok: diagnostics.length === 0,
         family: schema.family,
-        semanticDigest: canonicalSemanticDigest(content, repair),
-        diagnostics,
-        repair
+        semanticDigest: canonicalSemanticDigest(content),
+        diagnostics
     };
 }
 function inspectArtifactPatterns(content, schema) {
@@ -257,25 +163,22 @@ function inspectArtifactPatterns(content, schema) {
         ok: diagnostics.length === 0,
         family: schema.family,
         semanticDigest: canonicalSemanticDigest(content),
-        diagnostics,
-        repair: null
+        diagnostics
     };
 }
 function inspectArtifactContract(content, schema) {
     const structure = inspectArtifactStructure(content, schema);
     const patterns = inspectArtifactPatterns(content, schema);
     const diagnostics = [...structure.diagnostics, ...patterns.diagnostics];
-    const repair = patterns.diagnostics.length === 0 ? structure.repair : null;
     return {
         ok: diagnostics.length === 0,
         family: schema.family,
-        semanticDigest: canonicalSemanticDigest(content, repair),
-        diagnostics,
-        repair
+        semanticDigest: canonicalSemanticDigest(content),
+        diagnostics
     };
 }
 function resultFailure(code, message) {
-    return { status: 'failed', changed: false, artifactSha256: null, semanticDigest: null, operation: null, error: { code, message } };
+    return { status: 'failed', changed: false, artifactSha256: null, semanticDigest: null, error: { code, message } };
 }
 function resultNoOp(content) {
     return {
@@ -283,174 +186,12 @@ function resultNoOp(content) {
         changed: false,
         artifactSha256: sha256Content(content),
         semanticDigest: canonicalSemanticDigest(content),
-        operation: null,
         error: null
     };
 }
-function validateRepairContext(request, content) {
-    const round = artifactRound(request.family, request.artifact);
-    if (round === null)
-        return { ok: false, code: 'ARTIFACT_REPAIR_CONTEXT_INVALID', message: 'artifact round is not canonical' };
-    const contextPattern = /^<!--\s*artifact-context:([^:\s]+):([^:\s]+):(\d+)\s*-->\s*$/;
-    const contexts = scanVisibleMarkdown(content).lines
-        .map((line) => line.text.trim().match(contextPattern))
-        .filter((match) => match !== null);
-    if (contexts.length !== 1
-        || contexts[0][1] !== request.taskId
-        || contexts[0][2] !== request.family
-        || Number(contexts[0][3]) !== round) {
-        return { ok: false, code: 'ARTIFACT_REPAIR_CONTEXT_INVALID', message: 'artifact context marker does not match the requested task, family, and round' };
-    }
-    let taskContent;
-    try {
-        taskContent = fs.readFileSync(path.join(request.taskDir, 'task.md'), 'utf8');
-    }
-    catch (error) {
-        return { ok: false, code: 'ARTIFACT_REPAIR_CONTEXT_INVALID', message: `cannot read task lifecycle context: ${String(error)}` };
-    }
-    const activity = locateActivityLog(taskContent);
-    if (!activity)
-        return { ok: false, code: 'ARTIFACT_REPAIR_CONTEXT_INVALID', message: 'task has no unique Activity Log section' };
-    const label = {
-        analysis: 'Analyze Task',
-        'review-analysis': 'Review Analysis',
-        plan: 'Plan Task',
-        'review-plan': 'Review Plan',
-        code: 'Code Task',
-        'review-code': 'Review Code'
-    };
-    const escaped = escapeRegExp(label[request.family]);
-    const qualifier = request.family === 'code'
-        ? '(?:, (?:fix for review-code(?:-r(?:[2-9]|[1-9]\\d+))?\\.md|decision II-[1-9]\\d+))?'
-        : '';
-    const expected = new RegExp(`^${escaped} \\(Round ${round}${qualifier}\\)$`);
-    const open = startedBackedRows(pairEntries(activity.entries)).filter((row) => expected.test(row.step) && !row.done);
-    if (open.length !== 1) {
-        return { ok: false, code: 'ARTIFACT_REPAIR_CONTEXT_INVALID', message: `artifact '${request.artifact}' does not have exactly one matching open started lifecycle event` };
-    }
-    let intent;
-    try {
-        intent = readArtifactRepairIntent(request.repoRoot, request.taskId, request.family, request.artifact);
-    }
-    catch (error) {
-        return { ok: false, code: 'ARTIFACT_REPAIR_PROVENANCE_INVALID', message: String(error) };
-    }
-    if (!intent || intent.state !== 'awaiting-repair') {
-        return { ok: false, code: 'ARTIFACT_REPAIR_PROVENANCE_INVALID', message: 'artifact has no awaiting-repair finalization provenance' };
-    }
-    if (intent.artifactSha256 !== request.expectedSha256 || intent.semanticDigest !== request.expectedSemanticDigest) {
-        return { ok: false, code: 'ARTIFACT_REPAIR_PROVENANCE_INVALID', message: 'repair request does not match the current finalization provenance' };
-    }
-    return { ok: true };
-}
 function artifactRound(family, artifact) {
-    if (artifact === `${family}.md`)
-        return 1;
-    const match = artifact.match(new RegExp(`^${escapeRegExp(family)}-r([2-9]|[1-9]\\d+)\\.md$`));
-    if (!match)
-        return null;
-    const round = Number(match[1]);
-    return Number.isSafeInteger(round) ? round : null;
-}
-function validateTarget(taskDir, family, artifact) {
-    if (path.basename(artifact) !== artifact || artifactRound(family, artifact) === null || !artifact.endsWith('.md'))
-        return resultFailure('ARTIFACT_REPAIR_TARGET_INVALID', 'artifact must be a canonical top-level Markdown file');
-    if (!/^TASK-\d{8}-\d{6}$/.test(path.basename(path.resolve(taskDir))))
-        return resultFailure('ARTIFACT_REPAIR_TARGET_INVALID', 'target directory is not a task directory');
-    const target = path.join(taskDir, artifact);
-    if (path.dirname(path.resolve(target)) !== path.resolve(taskDir))
-        return resultFailure('ARTIFACT_REPAIR_TARGET_INVALID', 'artifact must be inside the current task directory');
-    let stat;
-    try {
-        stat = fs.lstatSync(target);
-    }
-    catch (error) {
-        return resultFailure('ARTIFACT_REPAIR_TARGET_INVALID', `artifact cannot be read: ${String(error)}`);
-    }
-    if (stat.isSymbolicLink() || !stat.isFile())
-        return resultFailure('ARTIFACT_REPAIR_TARGET_INVALID', 'artifact is not a regular file');
-    try {
-        fs.accessSync(target, fs.constants.R_OK | fs.constants.W_OK);
-    }
-    catch (error) {
-        return resultFailure('ARTIFACT_REPAIR_TARGET_INVALID', `artifact is not readable and writable: ${String(error)}`);
-    }
-    return { path: target };
-}
-function applyRepairUnlocked(request) {
-    const schema = getArtifactSchema(request.family);
-    if (!schema)
-        return resultFailure('ARTIFACT_FAMILY_UNKNOWN', `unknown artifact family '${request.family}'`);
-    const target = validateTarget(request.taskDir, request.family, request.artifact);
-    if ('status' in target)
-        return target;
-    let content;
-    try {
-        content = fs.readFileSync(target.path, 'utf8');
-    }
-    catch (error) {
-        return resultFailure('ARTIFACT_REPAIR_TARGET_INVALID', String(error));
-    }
-    const actualSha256 = sha256Content(content);
-    if (actualSha256 !== request.expectedSha256)
-        return resultFailure('ARTIFACT_REPAIR_BASELINE_MISMATCH', 'artifact SHA-256 does not match the expected repair baseline');
-    const context = validateRepairContext(request, content);
-    if (!context.ok)
-        return resultFailure(context.code, context.message);
-    const inspection = inspectArtifactStructure(content, schema);
-    if (!inspection.repair || inspection.diagnostics.length !== 1) {
-        return resultFailure('ARTIFACT_REPAIR_UNSAFE', inspection.diagnostics.map((item) => `${item.code}: ${item.message}`).join('; ') || 'no deterministic structural repair is available');
-    }
-    if (inspection.repair.kind !== request.operation.kind
-        || inspection.repair.sectionId !== request.operation.sectionId
-        || inspection.repair.from !== request.operation.from
-        || inspection.repair.to !== request.operation.to
-        || inspection.repair.start !== request.operation.start
-        || inspection.repair.end !== request.operation.end) {
-        return resultFailure('ARTIFACT_REPAIR_OPERATION_MISMATCH', 'repair operation does not match the current artifact structure');
-    }
-    if (inspection.semanticDigest !== request.expectedSemanticDigest)
-        return resultFailure('ARTIFACT_REPAIR_BASELINE_MISMATCH', 'artifact semantic digest does not match the expected repair baseline');
-    const transformed = applyRepairOperation(content, inspection.repair);
-    if (transformed === null)
-        return resultFailure('ARTIFACT_REPAIR_OPERATION_MISMATCH', 'repair operation does not match the current artifact bytes');
-    if (transformed === content)
-        return resultFailure('ARTIFACT_REPAIR_NO_PROGRESS', 'repair operation produced no byte change');
-    const tempPath = path.join(request.taskDir, `.${request.artifact}.repair-${process.pid}-${Date.now()}.tmp`);
-    let mode = 0o600;
-    try {
-        mode = fs.statSync(target.path).mode & 0o777;
-        fs.writeFileSync(tempPath, transformed, { encoding: 'utf8', mode, flag: 'wx' });
-        const currentStat = fs.lstatSync(target.path);
-        if (currentStat.isSymbolicLink() || !currentStat.isFile() || sha256Content(fs.readFileSync(target.path, 'utf8')) !== actualSha256) {
-            fs.unlinkSync(tempPath);
-            return resultFailure('ARTIFACT_REPAIR_CONFLICT', 'artifact changed or was replaced during repair');
-        }
-        fs.renameSync(tempPath, target.path);
-    }
-    catch (error) {
-        try {
-            fs.unlinkSync(tempPath);
-        }
-        catch { /* preserve primary error */ }
-        return resultFailure('ARTIFACT_REPAIR_WRITE_FAILED', String(error));
-    }
-    return {
-        status: 'applied',
-        changed: true,
-        artifactSha256: sha256Content(transformed),
-        semanticDigest: canonicalSemanticDigest(transformed),
-        operation: inspection.repair,
-        error: null
-    };
-}
-function applyArtifactRepair(request) {
-    try {
-        return withTaskExecutionLock(request.repoRoot, request.taskId, 'task-artifact.repair', () => applyRepairUnlocked(request));
-    }
-    catch (error) {
-        return resultFailure('ARTIFACT_REPAIR_LOCK_FAILED', String(error));
-    }
+    const identity = parseArtifactName(artifact);
+    return identity?.family === family ? identity.round : null;
 }
 function initializeArtifactSkeleton(request) {
     const schema = getArtifactSchema(request.family);
@@ -469,7 +210,7 @@ function initializeArtifactSkeleton(request) {
                 const existing = fs.lstatSync(target);
                 if (existing.isSymbolicLink() || !existing.isFile())
                     return resultFailure('ARTIFACT_INIT_TARGET_INVALID', 'artifact target is not a regular file');
-                return resultNoOp(fs.readFileSync(target, 'utf8'));
+                return resultNoOp(readStableFileSync(target, { maxBytes: 1024 * 1024 }).bytes.toString('utf8'));
             }
             catch (error) {
                 if (error.code !== 'ENOENT')
@@ -507,7 +248,6 @@ function initializeArtifactSkeleton(request) {
                 changed: true,
                 artifactSha256: sha256Content(content),
                 semanticDigest: canonicalSemanticDigest(content),
-                operation: null,
                 error: null
             };
         });
@@ -516,5 +256,5 @@ function initializeArtifactSkeleton(request) {
         return resultFailure('ARTIFACT_INIT_LOCK_FAILED', String(error));
     }
 }
-export { applyArtifactRepair, canonicalSemanticDigest, initializeArtifactSkeleton, inspectArtifactContract, inspectArtifactPatterns, inspectArtifactStructure, sha256Content };
+export { canonicalSemanticDigest, initializeArtifactSkeleton, inspectArtifactContract, inspectArtifactPatterns, inspectArtifactStructure, sha256Content };
 //# sourceMappingURL=artifact-operations.js.map

package/dist/lib/task/artifact-receipts.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import { createHash } from 'node:crypto';
+import { parseArtifactName } from './artifact-name.js';
 import { extractSection, findSectionHeading, parseTable } from './sections.js';
 const RECEIPT_SECTION_ALIASES = ['产物生命周期收据', 'Artifact Lifecycle Receipts'];
 const RECEIPT_COLUMNS = ['event', 'output', 'input', 'input_sha256', 'completed_at'];
@@ -10,7 +11,6 @@ const RECEIPT_EVENTS = new Set([
     'code.completed'
 ]);
 const SHA256_RE = /^[a-f0-9]{64}$/;
-const ARTIFACT_NAME_RE = /^(analysis|review-analysis|plan|review-plan|code|review-code|manual-validation|validation-run|pr-review)(?:-r([2-9]|[1-9]\d+))?\.md$/;
 const RECEIPT_SHAPES = {
     'review-analysis.completed': { output: 'review-analysis', input: 'analysis' },
     'review-plan.completed': { output: 'review-plan', input: 'plan' },
@@ -30,21 +30,9 @@ function sha256Bytes(value) {
 function sha256File(filePath) {
     return sha256Bytes(fs.readFileSync(filePath));
 }
-function parseReceiptArtifactName(name) {
-    const match = ARTIFACT_NAME_RE.exec(name);
-    if (!match)
-        return null;
-    const roundText = match[2];
-    if (roundText !== undefined) {
-        const round = Number(roundText);
-        if (!Number.isSafeInteger(round) || String(round) !== roundText)
-            return null;
-    }
-    return { family: match[1] };
-}
 function validateReceiptShape(event, output, input) {
-    const outputIdentity = parseReceiptArtifactName(output);
-    const inputIdentity = parseReceiptArtifactName(input);
+    const outputIdentity = parseArtifactName(output);
+    const inputIdentity = parseArtifactName(input);
     if (!outputIdentity || !inputIdentity)
         throw new ArtifactReceiptError(`receipt artifact identity is invalid: ${output} -> ${input}`);
     const shape = RECEIPT_SHAPES[event];