@fitlab-ai/agent-infra 0.9.14 → 0.10.0

package/lib/task/artifact-operations.ts

@@ -1,30 +1,20 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
+import { readStableFileSync } from '../host-control/secure-fs.ts';
+import { parseArtifactName } from './artifact-name.ts';
 
-import { scanVisibleMarkdown } from './decision-details.ts';
-import { locateActivityLog, pairEntries, startedBackedRows } from './activity-log.ts';
-import { readArtifactRepairIntent } from './artifact-repair-intent.ts';
+import { scanVisibleMarkdown, type VisibleMarkdown, type VisibleHeading } from './markdown.ts';
 import {
   getArtifactSchema,
   renderArtifactSkeleton
 } from './artifact-schema.ts';
+import { withTaskExecutionLock } from './task-execution-lock.ts';
 import type {
   ArtifactSchema,
   ArtifactSchemaFamily,
   ArtifactSection
 } from './artifact-schema.ts';
-import { withTaskExecutionLock } from './task-execution-lock.ts';
-
-type ArtifactRepairOperation = Readonly<{
-  kind: 'replace-line' | 'insert-section';
-  sectionId: string;
-  line: number;
-  from: string;
-  to: string;
-  start: number;
-  end: number;
-}>;
 
 type ArtifactStructuralDiagnosticCode =
   | 'ARTIFACT_EMPTY'
@@ -44,8 +34,6 @@ type ArtifactStructuralDiagnostic = Readonly<{
   message: string;
   sectionId: string | null;
   line: number | null;
-  repairable: boolean;
-  operation?: ArtifactRepairOperation;
 }>;
 
 type ArtifactStructureResult = Readonly<{
@@ -53,7 +41,6 @@ type ArtifactStructureResult = Readonly<{
   family: ArtifactSchemaFamily;
   semanticDigest: string;
   diagnostics: readonly ArtifactStructuralDiagnostic[];
-  repair: ArtifactRepairOperation | null;
 }>;
 
 type ArtifactFileResult = Readonly<{
@@ -61,21 +48,9 @@ type ArtifactFileResult = Readonly<{
   changed: boolean;
   artifactSha256: string | null;
   semanticDigest: string | null;
-  operation: ArtifactRepairOperation | null;
   error: { code: string; message: string } | null;
 }>;
 
-type ArtifactRepairRequest = Readonly<{
-  repoRoot: string;
-  taskId: string;
-  taskDir: string;
-  family: ArtifactSchemaFamily;
-  artifact: string;
-  expectedSha256: string;
-  expectedSemanticDigest: string;
-  operation: ArtifactRepairOperation;
-}>;
-
 type ArtifactInitRequest = Readonly<{
   repoRoot: string;
   taskId: string;
@@ -89,35 +64,6 @@ function sha256Content(content: string): string {
   return createHash('sha256').update(content, 'utf8').digest('hex');
 }
 
-function sourceLines(content: string): Array<{ start: number; end: number; text: string }> {
-  const lines: Array<{ start: number; end: number; text: string }> = [];
-  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: string): boolean {
-  let fence: { character: '`' | '~'; length: number } | null = 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] as '`' | '~', length: open[1]!.length };
-    }
-  }
-  return fence !== null;
-}
-
 function lineNumber(content: string, offset: number): number {
   return content.slice(0, offset).split('\n').length;
 }
@@ -130,9 +76,9 @@ function escapeRegExp(value: string): string {
   return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
-function markerEntries(content: string): Array<{ marker: string; start: number; end: number; line: number; standalone: boolean }> {
+function markerEntries(content: string, scanned: VisibleMarkdown): Array<{ marker: string; start: number; end: number; line: number; standalone: boolean }> {
   const entries: Array<{ marker: string; start: number; end: number; line: number; standalone: boolean }> = [];
-  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;
     for (const raw of match) {
@@ -150,12 +96,9 @@ function markerEntries(content: string): Array<{ marker: string; start: number;
   return entries;
 }
 
-function sectionBodyBounds(content: string, heading: { start: number }): { start: number; end: number } {
-  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: string, heading: VisibleHeading, scanned: VisibleMarkdown): { start: number; end: number } {
+  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: string): string {
@@ -176,71 +119,17 @@ function diagnostic(
   code: ArtifactStructuralDiagnosticCode,
   message: string,
   sectionId: string | null,
-  line: number | null,
-  repairable = false,
-  operation?: ArtifactRepairOperation
+  line: number | null
 ): ArtifactStructuralDiagnostic {
-  return {
-    code, message, sectionId, line, repairable,
-    ...(operation ? { operation } : {})
-  };
+  return { code, message, sectionId, line };
 }
 
 function sectionHeadings(schema: ArtifactSchema, section: ArtifactSection): readonly string[] {
   return [section.headings.zh, section.headings.en];
 }
 
-function createHeadingRepair(
-  content: string,
-  section: ArtifactSection,
-  heading: { start: number; end: number; text: string }
-): ArtifactRepairOperation {
-  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: string,
-  section: ArtifactSection,
-  marker: { start: number; line: number },
-  locale: 'zh-CN' | 'en'
-): ArtifactRepairOperation {
-  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: string, operation: ArtifactRepairOperation): string | null {
-  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: string, operation: ArtifactRepairOperation | null = null): string {
+function canonicalContent(content: string): string {
   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, '');
@@ -248,8 +137,8 @@ function canonicalContent(content: string, operation: ArtifactRepairOperation |
   return normalized;
 }
 
-function canonicalSemanticDigest(content: string, operation: ArtifactRepairOperation | null = null): string {
-  return sha256Content(canonicalContent(content, operation));
+function canonicalSemanticDigest(content: string): string {
+  return sha256Content(canonicalContent(content));
 }
 
 function inspectArtifactStructure(
@@ -258,16 +147,15 @@ function inspectArtifactStructure(
 ): ArtifactStructureResult {
   const diagnostics: ArtifactStructuralDiagnostic[] = [];
   const scanned = scanVisibleMarkdown(content);
-  const repairCandidates: ArtifactRepairOperation[] = [];
   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));
+  if (scanned.hasUnclosedFence) diagnostics.push(diagnostic('ARTIFACT_UNCLOSED_FENCE', 'artifact contains an unclosed Markdown fence', null, null));
 
   const headingsBySection = new Map<string, typeof scanned.headings>();
   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(
@@ -277,16 +165,18 @@ function inspectArtifactStructure(
         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) {
@@ -300,7 +190,7 @@ function inspectArtifactStructure(
       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));
       }
@@ -310,9 +200,7 @@ function inspectArtifactStructure(
     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));
       }
     }
@@ -323,32 +211,6 @@ function inspectArtifactStructure(
     }
   }
 
-  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 }] : [];
@@ -364,16 +226,11 @@ function inspectArtifactStructure(
     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
   };
 }
 
@@ -393,8 +250,7 @@ function inspectArtifactPatterns(
     ok: diagnostics.length === 0,
     family: schema.family,
     semanticDigest: canonicalSemanticDigest(content),
-    diagnostics,
-    repair: null
+    diagnostics
   };
 }
 
@@ -405,18 +261,16 @@ function inspectArtifactContract(
   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: string, message: string): ArtifactFileResult {
-  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: string): ArtifactFileResult {
@@ -425,139 +279,13 @@ function resultNoOp(content: string): ArtifactFileResult {
     changed: false,
     artifactSha256: sha256Content(content),
     semanticDigest: canonicalSemanticDigest(content),
-    operation: null,
     error: null
   };
 }
 
-function validateRepairContext(request: ArtifactRepairRequest, content: string): { ok: true } | { ok: false; code: string; message: string } {
-  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 is RegExpMatchArray => 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: string;
-  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: Record<ArtifactSchemaFamily, string> = {
-    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: ArtifactSchemaFamily, artifact: string): number | null {
-  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: string, family: ArtifactSchemaFamily, artifact: string): { path: string } | ArtifactFileResult {
-  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: fs.Stats;
-  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: ArtifactRepairRequest): ArtifactFileResult {
-  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: string;
-  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: ArtifactRepairRequest): ArtifactFileResult {
-  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: ArtifactInitRequest): ArtifactFileResult {
@@ -572,7 +300,7 @@ function initializeArtifactSkeleton(request: ArtifactInitRequest): ArtifactFileR
       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'));
+        return resultNoOp(readStableFileSync(target, { maxBytes: 1024 * 1024 }).bytes.toString('utf8'));
       } catch (error) {
         if ((error as NodeJS.ErrnoException).code !== 'ENOENT') return resultFailure('ARTIFACT_INIT_TARGET_INVALID', String(error));
       }
@@ -597,7 +325,6 @@ function initializeArtifactSkeleton(request: ArtifactInitRequest): ArtifactFileR
         changed: true,
         artifactSha256: sha256Content(content),
         semanticDigest: canonicalSemanticDigest(content),
-        operation: null,
         error: null
       };
     });
@@ -607,7 +334,6 @@ function initializeArtifactSkeleton(request: ArtifactInitRequest): ArtifactFileR
 }
 
 export {
-  applyArtifactRepair,
   canonicalSemanticDigest,
   initializeArtifactSkeleton,
   inspectArtifactContract,
@@ -618,8 +344,6 @@ export {
 export type {
   ArtifactFileResult,
   ArtifactInitRequest,
-  ArtifactRepairOperation,
-  ArtifactRepairRequest,
   ArtifactStructuralDiagnostic,
   ArtifactStructuralDiagnosticCode,
   ArtifactStructureResult

package/lib/task/artifact-receipts.ts

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import { createHash } from 'node:crypto';
 
+import { parseArtifactName } from './artifact-name.ts';
 import { extractSection, findSectionHeading, parseTable } from './sections.ts';
 
 const RECEIPT_SECTION_ALIASES = ['产物生命周期收据', 'Artifact Lifecycle Receipts'] as const;
@@ -12,7 +13,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' },
@@ -59,20 +59,9 @@ function sha256File(filePath: string): string {
   return sha256Bytes(fs.readFileSync(filePath));
 }
 
-function parseReceiptArtifactName(name: string): { family: string } | null {
-  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: ArtifactReceiptEvent, output: string, input: string): void {
-  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];
   if (outputIdentity.family !== shape.output || inputIdentity.family !== shape.input) {