@fitlab-ai/agent-infra 0.9.13 → 0.9.14

package/dist/lib/server/index.js

@@ -1,5 +1,7 @@
 import { runDaemon } from './daemon.js';
 import { start, stop, status, logs } from './process-control.js';
+import { PUBLIC_CLI_ROUTE_SELECTORS } from '../internal/cli-route-inventory.js';
+const SERVER_OPERATIONS = PUBLIC_CLI_ROUTE_SELECTORS.server;
 const USAGE = `Usage: ai server <command> [options]
 
 Commands:
@@ -21,6 +23,12 @@ export async function runServer(args) {
         process.stdout.write(`${USAGE}\n`);
         return;
     }
+    if (!SERVER_OPERATIONS.includes(subcommand)) {
+        process.stderr.write(`Unknown server command: ${subcommand}\n`);
+        process.stdout.write(`${USAGE}\n`);
+        process.exitCode = 1;
+        return;
+    }
     switch (subcommand) {
         case 'start':
             await start({ foreground: rest.includes('--foreground') });

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

@@ -7,17 +7,9 @@ import { parseVerdict } from './review-artifacts.js';
 import { extractSection, findSectionHeading } from './sections.js';
 import { receiptForOutput, sha256File } from './artifact-receipts.js';
 import { isArtifactInvalidated, parseInvalidationDocument } from './invalidation.js';
-const artifactFamilyCatalog = [
-    { family: 'analysis', sectionAliases: ['分析', 'Analysis'], heading: '分析', labels: ['需求分析报告', 'Requirements Analysis'] },
-    { family: 'review-analysis', sectionAliases: ['审查反馈', 'Review Feedback'], heading: '审查反馈', labels: ['需求分析审查', 'Analysis Review'] },
-    { family: 'plan', sectionAliases: ['设计', 'Design'], heading: '设计', labels: ['技术方案', 'Technical Plan'] },
-    { family: 'review-plan', sectionAliases: ['审查反馈', 'Review Feedback'], heading: '审查反馈', labels: ['技术方案审查', 'Plan Review'] },
-    { family: 'code', sectionAliases: ['实现备注', 'Implementation Notes'], heading: '实现备注', labels: ['实现报告', 'Implementation Report'] },
-    { family: 'review-code', sectionAliases: ['审查反馈', 'Review Feedback'], heading: '审查反馈', labels: ['代码审查', 'Code Review'] },
-    { family: 'manual-validation', sectionAliases: ['实现备注', 'Implementation Notes'], heading: '实现备注', labels: ['人工验证', 'Manual Validation'] },
-    { family: 'validation-run', sectionAliases: ['实现备注', 'Implementation Notes'], heading: '实现备注', labels: ['验证运行证据', 'Validation Run Evidence'] },
-    { family: 'pr-review', sectionAliases: ['审查反馈', 'Review Feedback'], heading: '审查反馈', labels: ['PR 审查报告', 'PR Review Report'] }
-];
+import { validateQualificationAudit } from './qualification-audit.js';
+import { ARTIFACT_FAMILY_CATALOG } from './artifact-schema.js';
+const artifactFamilyCatalog = ARTIFACT_FAMILY_CATALOG;
 const FAMILY_SET = new Set(artifactFamilyCatalog.map((item) => item.family));
 const BLOCKING_DIAGNOSTICS = new Set([
     'NONCANONICAL_NAME', 'ROUND_OUT_OF_RANGE', 'MISSING_BASE', 'ROUND_GAP',
@@ -286,6 +278,7 @@ const OPTIONAL_CONTEXT = {
     'manual-validation': { family: 'review-code' },
     'validation-run': { family: 'review-code' }
 };
+const QUALIFICATION_RECOVERY_OPTIONAL_CONTEXT_CONSUMERS = new Set(['analysis', 'plan']);
 function resolveArtifactContext(taskRef, family, options = {}) {
     const inventory = inspectTaskArtifacts(taskRef, family, options);
     if (inventory.status === 'failed')
@@ -302,6 +295,9 @@ function resolveArtifactContext(taskRef, family, options = {}) {
         if (input.status === 'failed' || !input.latest) {
             return { ...inventory, status: 'failed', inputs, codeMode: null, error: { code: 'ARTIFACT_INPUT_MISSING', message: `latest ${required} artifact is required` } };
         }
+        const qualificationError = qualificationErrorForArtifact(input.latest);
+        if (qualificationError)
+            return { ...inventory, status: 'failed', inputs, codeMode: null, error: { code: 'ARTIFACT_REFERENCE_INVALID', message: qualificationError } };
         inputs.push(input.latest);
     }
     const optional = OPTIONAL_CONTEXT[inventory.family];
@@ -311,11 +307,26 @@ function resolveArtifactContext(taskRef, family, options = {}) {
             if (optional.requireReference && !context.reviewedInput) {
                 return { ...inventory, status: 'failed', inputs, codeMode: null, error: { code: 'ARTIFACT_REFERENCE_INVALID', message: `${context.latest.name} has no valid reviewed input` } };
             }
+            const qualificationError = qualificationErrorForArtifact(context.latest);
+            if (qualificationError && !QUALIFICATION_RECOVERY_OPTIONAL_CONTEXT_CONSUMERS.has(inventory.family)) {
+                return { ...inventory, status: 'failed', inputs, codeMode: null, error: { code: 'ARTIFACT_REFERENCE_INVALID', message: qualificationError } };
+            }
             inputs.push(context.latest);
         }
     }
     return { ...inventory, inputs, codeMode: null };
 }
+function qualificationErrorForArtifact(artifact) {
+    try {
+        const taskContent = fs.readFileSync(path.join(path.dirname(artifact.path), 'task.md'), 'utf8');
+        const artifactContent = fs.readFileSync(artifact.path, 'utf8');
+        const result = validateQualificationAudit(taskContent, artifactContent);
+        return result.ok ? null : `${result.code}: ${result.message}`;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
 function resolveCodeContext(inventory, options) {
     const taskRef = inventory.requestRef;
     const plan = inspectTaskArtifacts(taskRef, 'plan', options);
@@ -327,6 +338,19 @@ function resolveCodeContext(inventory, options) {
     const codeMax = latestCode?.round ?? 0;
     const reviewMax = reviewCode.latest?.round ?? 0;
     const inputs = [plan.latest];
+    const planQualificationError = qualificationErrorForArtifact(plan.latest);
+    if (planQualificationError)
+        return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', planQualificationError);
+    if (latestCode) {
+        const qualificationError = qualificationErrorForArtifact(latestCode);
+        if (qualificationError)
+            return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', qualificationError, latestCode.name);
+    }
+    if (reviewCode.latest) {
+        const qualificationError = qualificationErrorForArtifact(reviewCode.latest);
+        if (qualificationError)
+            return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', qualificationError, reviewCode.latest.name);
+    }
     if (!latestCode) {
         if (!reviewPlan.latest || reviewPlan.reviewedInput?.name !== plan.latest.name) {
             return contextFailure(inventory, 'ARTIFACT_INPUT_MISSING', `latest plan '${plan.latest.name}' requires a matching approved review-plan`);
@@ -346,6 +370,11 @@ function resolveCodeContext(inventory, options) {
     if (reviewPlan.latest && !reviewPlan.reviewedInput) {
         return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', `${reviewPlan.latest.name} has no valid reviewed input`, reviewPlan.latest.name);
     }
+    if (reviewPlan.latest) {
+        const qualificationError = qualificationErrorForArtifact(reviewPlan.latest);
+        if (qualificationError)
+            return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', qualificationError, reviewPlan.latest.name);
+    }
     if (reviewPlan.latest && reviewPlan.reviewedInput?.name === plan.latest.name) {
         const verdict = parseVerdict(reviewPlan.latest.path);
         if (!verdict.ok)
@@ -355,8 +384,8 @@ function resolveCodeContext(inventory, options) {
             return withCodeMode(inventory, inputs, 'ready', 'init', codeMax, reviewMax, verdict.verdict, reviewPlan.latest.name, `Latest ${reviewPlan.latest.name} approves plan content not captured by the latest code input receipt. Entering replan-driven init.`);
         }
     }
-    if (reviewMax < codeMax) {
-        const expected = artifactName('review-code', codeMax);
+    if (!reviewCode.latest || reviewCode.reviewedInput?.name !== latestCode.name) {
+        const expected = reviewCode.next?.name ?? artifactName('review-code', reviewMax + 1);
         return contextFailure(inventory, 'ARTIFACT_INPUT_MISSING', `${expected} is required before another code round`, expected);
     }
     const review = reviewCode.latest;

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

@@ -0,0 +1,520 @@
+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 { 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;
+}
+function markerPattern(marker) {
+    return new RegExp(`<!--\\s*${escapeRegExp(marker)}\\s*-->`);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function markerEntries(content) {
+    const entries = [];
+    for (const line of scanVisibleMarkdown(content).lines) {
+        const match = line.text.match(/<!--\s*(artifact-section:[^\s>]+)\s*-->/g);
+        if (!match)
+            continue;
+        for (const raw of match) {
+            const marker = raw.match(/artifact-section:[^\s>]+/)[0];
+            const offset = line.text.indexOf(raw);
+            entries.push({
+                marker,
+                start: line.start + offset,
+                end: line.start + offset + raw.length,
+                line: lineNumber(content, line.start),
+                standalone: line.text.trim() === raw
+            });
+        }
+    }
+    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 stripHtmlComments(content) {
+    let result = '';
+    let cursor = 0;
+    while (cursor < content.length) {
+        const start = content.indexOf('<!--', cursor);
+        if (start < 0)
+            return result + content.slice(cursor);
+        result += content.slice(cursor, start);
+        const end = content.indexOf('-->', start + 4);
+        if (end < 0)
+            return result;
+        cursor = end + 3;
+    }
+    return result;
+}
+function diagnostic(code, message, sectionId, line, repairable = false, operation) {
+    return {
+        code, message, sectionId, line, repairable,
+        ...(operation ? { operation } : {})
+    };
+}
+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) {
+    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 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))
+        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);
+        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]));
+        }
+        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';
+    for (const section of schema.sections) {
+        const matches = markers.filter((entry) => entry.marker === section.marker);
+        if (matches.length === 0) {
+            diagnostics.push(diagnostic('ARTIFACT_MARKER_MISSING', `section marker '${section.marker}' is missing`, section.id, null));
+        }
+        else if (matches.length > 1) {
+            diagnostics.push(diagnostic('ARTIFACT_MARKER_DUPLICATE', `section marker '${section.marker}' is duplicated`, section.id, matches[1].line));
+        }
+        const marker = matches[0];
+        const heading = headingsBySection.get(section.id)?.[0];
+        if (marker && !marker.standalone) {
+            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);
+            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));
+            }
+            const body = stripHtmlComments(content.slice(bounds.start, bounds.end)).trim();
+            if (!body)
+                diagnostics.push(diagnostic('ARTIFACT_EMPTY_SECTION', `section '${section.headings.zh}' has no semantic body`, section.id, lineNumber(content, heading.start)));
+        }
+        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) {
+                diagnostics.push(diagnostic('ARTIFACT_EMPTY_SECTION', `section '${section.headings.zh}' has no semantic body`, section.id, marker.line));
+            }
+        }
+    }
+    for (const marker of markers) {
+        if (!schema.sections.some((section) => markerPattern(section.marker).test(`<!-- ${marker.marker} -->`))) {
+            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 }] : [];
+    });
+    if (orderedHeadings.some((item, index) => index > 0 && item.start <= orderedHeadings[index - 1].start)) {
+        diagnostics.push(diagnostic('ARTIFACT_SECTION_ORDER_INVALID', 'required sections are not in schema order', null, null));
+    }
+    const orderedMarkers = schema.sections.flatMap((section) => {
+        const marker = markers.find((entry) => entry.marker === section.marker);
+        return marker ? [{ section, start: marker.start }] : [];
+    });
+    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
+    };
+}
+function inspectArtifactPatterns(content, schema) {
+    const diagnostics = schema.requiredPatterns
+        .filter((pattern) => !new RegExp(pattern, 'm').test(content))
+        .map((pattern) => diagnostic('ARTIFACT_REQUIRED_PATTERN_MISSING', `artifact is missing required pattern '${pattern}'`, null, null));
+    return {
+        ok: diagnostics.length === 0,
+        family: schema.family,
+        semanticDigest: canonicalSemanticDigest(content),
+        diagnostics,
+        repair: null
+    };
+}
+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
+    };
+}
+function resultFailure(code, message) {
+    return { status: 'failed', changed: false, artifactSha256: null, semanticDigest: null, operation: null, error: { code, message } };
+}
+function resultNoOp(content) {
+    return {
+        status: 'no-op',
+        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));
+    }
+}
+function initializeArtifactSkeleton(request) {
+    const schema = getArtifactSchema(request.family);
+    if (!schema)
+        return resultFailure('ARTIFACT_FAMILY_UNKNOWN', `unknown artifact family '${request.family}'`);
+    if (artifactRound(request.family, request.artifact) === null)
+        return resultFailure('ARTIFACT_INIT_TARGET_INVALID', 'artifact must be a canonical top-level Markdown file');
+    if (!/^TASK-\d{8}-\d{6}$/.test(path.basename(path.resolve(request.taskDir))) || path.basename(path.resolve(request.taskDir)) !== request.taskId)
+        return resultFailure('ARTIFACT_INIT_TARGET_INVALID', 'target directory is not the requested task directory');
+    const target = path.join(request.taskDir, request.artifact);
+    if (path.dirname(path.resolve(target)) !== path.resolve(request.taskDir))
+        return resultFailure('ARTIFACT_INIT_TARGET_INVALID', 'artifact must be inside the current task directory');
+    try {
+        return withTaskExecutionLock(request.repoRoot, request.taskId, 'task-artifact.init', () => {
+            try {
+                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'));
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    return resultFailure('ARTIFACT_INIT_TARGET_INVALID', String(error));
+            }
+            const content = renderArtifactSkeleton({
+                taskId: request.taskId,
+                family: request.family,
+                artifact: request.artifact,
+                ...(request.locale ? { locale: request.locale } : {})
+            });
+            const tempPath = path.join(request.taskDir, `.${request.artifact}.init-${process.pid}-${Date.now()}.tmp`);
+            try {
+                fs.writeFileSync(tempPath, content, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+                try {
+                    fs.lstatSync(target);
+                    fs.unlinkSync(tempPath);
+                    return resultFailure('ARTIFACT_INIT_TARGET_EXISTS', 'artifact was created concurrently');
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT')
+                        throw error;
+                }
+                fs.renameSync(tempPath, target);
+            }
+            catch (error) {
+                try {
+                    fs.unlinkSync(tempPath);
+                }
+                catch { /* preserve primary error */ }
+                return resultFailure('ARTIFACT_INIT_WRITE_FAILED', String(error));
+            }
+            return {
+                status: 'applied',
+                changed: true,
+                artifactSha256: sha256Content(content),
+                semanticDigest: canonicalSemanticDigest(content),
+                operation: null,
+                error: null
+            };
+        });
+    }
+    catch (error) {
+        return resultFailure('ARTIFACT_INIT_LOCK_FAILED', String(error));
+    }
+}
+export { applyArtifactRepair, canonicalSemanticDigest, initializeArtifactSkeleton, inspectArtifactContract, inspectArtifactPatterns, inspectArtifactStructure, sha256Content };
+//# sourceMappingURL=artifact-operations.js.map