elanous 0.2.28 → 0.2.29

package/src/self-implement/goal-author.ts

@@ -1,7 +1,7 @@
 import { classifyObservation } from '../design/behaviour-signal.js';
 import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, writeFileSync, type Dirent } from 'node:fs';
 import { spawn } from 'node:child_process';
-import { createHash, randomBytes } from 'node:crypto';
+import { randomBytes } from 'node:crypto';
 import { dirname, isAbsolute, join, normalize, relative, resolve, sep } from 'node:path';
 import { isRepositoryImplementationCandidate, type CodebaseGrounding } from '../autopilot/codebase-grounding.js';
 import { extractSlugSource, generateMissionSlug, slugify } from '../autopilot/mission-registry.js';
@@ -41,7 +41,9 @@ import { resolveGoalAuthorClarification, parseGoalDocumentClarifications, serial
 import { acquireLockSync } from '../storage/file-lock.js';
 import { createRepositoryReferencedFileReader, type ReferencedFileReadResult } from './goal-file-reader.js';
 import { extractGoalDocSections, type GoalDocSourceLine } from './goal-doc/section.js';
-import { isGoalAuthorFileName } from './goal-document.js';
+import { buildGoalFileName, goalFileName, type GoalFileNameSource } from './goal-file-name.js';
+export { goalFileName } from './goal-file-name.js';
+export type { GoalFileNameSource } from './goal-file-name.js';
 import { resolveGoalDocumentsDir } from './goal-documents-dir.js';
 import { REQUIRED_EVIDENCE_COMMAND_SEPARATOR } from './off-diff-evidence.js';
 import { renderLaunchPreflight, siblingTestPath, type LaunchPreflightResult } from '../self-dev/launch-preflight-text.js';
@@ -792,10 +794,14 @@ export type ArtifactLaunchDeclarationClassification = 'declared' | 'absent-witho
 const SERVER_ENTRY_PATH = /(?:^|\/)server[^/]*\.(?:[cm]?[jt]sx?)$/i;
 const LOOPBACK_ADDRESS_WITH_PORT = /(?<![\p{L}\p{N}.-])(?:localhost|127\.0\.0\.1|\[::1\])(?::\d+)(?![\p{L}\p{N}_])/iu;
 
+function targetPathsInLabelPiece(piece: string): string[] {
+  return askPathTokens(piece).filter((path) => path.includes('/'));
+}
+
 function declaredTargetPaths(document: string): string[] {
   return linesOutsideFencedCode(document).flatMap(({ text }) => {
     const match = TARGET_PATH_LABEL.exec(text.trim());
-    return match ? askPathTokens(match[1]) : [];
+    return match ? match[1].split(/\s+[·,]\s*|[·,]\s+/).flatMap(targetPathsInLabelPiece) : [];
   });
 }
 
@@ -1303,6 +1309,8 @@ function isTracedPathsEvidenceUnavailable(entry: string): boolean {
 const TRACED_PATH_LINE = /^(.*?)(?::(\d+)(?:-(\d+))?)?$/;
 const INLINE_CODE_WRAPPED = /^(`+)([^`]*)\1$/;
 const TRACED_PATH_DESCRIPTION_DELIMITER = /\s+(?:—|-)\s+|:\s+/;
+/** Read tool output annotations are prose, never part of a repository path. */
+const TRACED_PATH_READ_ANNOTATION = /\s+\(Read,\s*\d+\s+lines?\)\s*$/i;
 /** 저작기가 「관련 있어 보이지만 여기가 아니다」를 말하려고 적은 항목 — 추적 경로가 아니다.
  *  ⚠️ 지금은 영어 문면만 문다(저작기 산출이 영어다). 한국어 배제 문장은 아직 안 잡는다. */
 const TRACED_PATH_EXCLUSION_DESCRIPTION = /\b(?:related|relevant)\b.*\b(?:but|however)\b.*\b(?:not here|elsewhere|another (?:location|place|path))\b|\b(?:not here|elsewhere|another (?:location|place|path))\b.*\b(?:related|relevant)\b/i;
@@ -1347,10 +1355,11 @@ export function tracedPathReferences(document: string): TracedPathReference[] {
   const section = markdownSection(document, 'TRACED PATHS');
   if (!section) return [];
   const references: TracedPathReference[] = [];
+  let normalizedAnnotationCount = 0;
   for (const line of section.split(/\r?\n/)) {
     const evidence = tracedPathListItem(line);
     if (!evidence) continue;
-    if (isTracedPathsEvidenceUnavailable(evidence) || isTracedPathExclusionDescription(evidence)) continue;
+    if (isTracedPathsEvidenceUnavailable(evidence) || evidence.startsWith('미해석:') || isTracedPathExclusionDescription(evidence)) continue;
     // 설명 구분자는 **공백으로 둘러싼** em dash 또는 hyphen 뿐이다 — 파일명 안의 dash 를 설명 구분자로 오인하지 않는다.
     // 경로 칸 안의 복수 경로는 **공백으로 둘러싼** 가운뎃점만 본다 — 파일명 안의 `·` 를 가르지 않는다.
     // ⭐ 인라인 코드 표기(`path`)를 벗긴다 — 저작기는 맨 경로를 쓰지만 사람이 쓴 골과 이 레포의 다른 문서는
@@ -1361,7 +1370,9 @@ export function tracedPathReferences(document: string): TracedPathReference[] {
       if (!trimmed) continue;
       // 10-11 재발 — 저작기가 «`- src/…`» 처럼 목록 기호를 백틱 «안»에 쓰면 바깥 기호만 벗긴 뒤 백틱을 벗겨
       //   «- src/…» 가 경로로 남았다(AUTHOR-DECOMPOSE-KNOB · MODEL-BENCH-SCORES 부검). 백틱을 벗긴 뒤 한 번 더 벗긴다.
-      const unwrapped = stripInlineCode(trimmed).replace(TRACED_PATH_LEADING_LIST_MARKERS, '');
+      const withoutAnnotation = trimmed.replace(TRACED_PATH_READ_ANNOTATION, '').trim();
+      if (withoutAnnotation !== trimmed) normalizedAnnotationCount += 1;
+      const unwrapped = stripInlineCode(withoutAnnotation).replace(TRACED_PATH_LEADING_LIST_MARKERS, '');
       const match = TRACED_PATH_LINE.exec(unwrapped);
       // 두 번 벗긴다 — 줄번호가 백틱 **안**(`p:42`)일 수도 **밖**(`p`:42)일 수도 있다.
       const path = match ? stripInlineCode(match[1].trim()).replace(TRACED_PATH_LEADING_LIST_MARKERS, '') : undefined;
@@ -1369,6 +1380,10 @@ export function tracedPathReferences(document: string): TracedPathReference[] {
       references.push({ path, line: match?.[2] ? Number(match[2]) : null, endLine: match?.[3] ? Number(match[3]) : null });
     }
   }
+  if (normalizedAnnotationCount > 0) {
+    try { debug.log('goal-author', 'traced-path-annotation-normalized', { count: normalizedAnnotationCount }); }
+    catch { /* observation must not prevent path validation */ }
+  }
   return references;
 }
 
@@ -1699,6 +1714,12 @@ export function lintGoalFile(document: string, branch: string, deps: GoalFileLin
         : `${unavailableTracedPathEvidence} GoalType ${goalType} does not require ## TRACED PATHS.`,
     });
   }
+  const unresolvedTracedPathEvidence = markdownSection(document, 'TRACED PATHS')?.split(/\r?\n/)
+    .map((line) => tracedPathListItem(line))
+    .filter((item): item is string => item !== undefined && item.startsWith('미해석:')) ?? [];
+  for (const item of unresolvedTracedPathEvidence) {
+    findings.push({ level: 'WARN', tag: 'traced-path', message: item });
+  }
   if (deps.readReferencedFile) {
     // AUTHOR-NEW-FILE-PATHS — 문서가 «새로 만들 파일»로 선언한 경로. 실행 쪽 범위 검사와 같은 줄을 읽는다.
     // 저작과 실행은 같은 Original ask 범위만 선언으로 인정한다. 문서의 다른 절은 근거일 뿐이다.
@@ -2277,11 +2298,94 @@ function observePersistentEvidenceSourceKinds(facts: CodebaseGrounding | null, a
   observeGoalAuthor('goal-author', 'persistent-grounding-evidence-source-count', { authorRunId, counts });
 }
 
-function tracedPathsSection(facts: CodebaseGrounding | null, unavailableEvidence: string): string[] {
+function tracedPathsSection(facts: CodebaseGrounding | null, ask: string, repositoryRoot: string | undefined, unavailableEvidence: string): string[] {
   const evidence = persistentEvidenceItems(facts);
-  return evidence.length
-    ? evidence.map(({ text, source }, index) => `${index + 1}. ${renderPersistentEvidence({ text, source })}`)
-    : [`- ${unavailableEvidence}`];
+  // Without a repository root we cannot verify paths. Keep the established
+  // rendering contract for callers that do not supply one.
+  if (repositoryRoot === undefined) {
+    const legacyPaths: string[] = [];
+    for (const item of evidence) {
+      const referenced = [...new Set(Array.from(item.text.matchAll(SOURCE_PATH), (match) => match[0]))]
+        .filter(isRepositoryImplementationCandidate);
+      if (referenced.length === 0 || (referenced.length === 1 && item.text.trim().startsWith(referenced[0]!))) {
+        legacyPaths.push(`${legacyPaths.length + 1}. ${renderPersistentEvidence(item)}`);
+        continue;
+      }
+      referenced.forEach((path, index) => legacyPaths.push(`${legacyPaths.length + 1}. ${path}${index === 0 ? ` — ${renderPersistentEvidence(item)}` : ''}`));
+    }
+    return legacyPaths.length ? legacyPaths : [`- ${unavailableEvidence}`];
+  }
+  const paths: string[] = [];
+  const declaredNew = new Set(declaredNewFilePaths(ask));
+  const targetLabels = linesOutsideFencedCode(ask)
+    .map(({ text }) => /^대상 경로:\s*(.*)$/.exec(text.trim())?.[1])
+    .filter((value): value is string => value !== undefined);
+  const unresolvedTargetPieces = targetLabels.flatMap((label) => label.split(/\s+[·,]\s*|[·,]\s+/))
+    .flatMap((piece) => {
+      const tokens = piece.trim().split(/\s+/).filter(Boolean);
+      return tokens.length === 0 ? ['(빈 대상 경로)'] : tokens.filter((token) => targetPathsInLabelPiece(token).length === 0);
+    });
+  const labeledTargets = declaredTargetPaths(ask);
+  const scopedAskPaths = [...new Set(askPathTokens(targetScopedGoalText(ask)).filter((path) => path.includes('/')))];
+  // A single repository path in an ask without a target label is still an explicit target.
+  // Multiple mentions are ambiguous; do not turn background references into targets.
+  const requestedTargets = targetLabels.length ? labeledTargets : scopedAskPaths.length === 1 ? scopedAskPaths : [];
+  const known = [...new Set([
+    ...requestedTargets, ...scopedAskPaths, ...(facts?.files ?? []),
+    ...evidence.flatMap((item) => Array.from(item.text.matchAll(SOURCE_PATH), (match) => match[0]).filter((path) => path.includes('/'))),
+  ])];
+  let root: string | null;
+  try { root = repositoryRoot === undefined ? null : realpathSync(resolve(repositoryRoot)); }
+  catch { root = null; }
+  const valid = (path: string, allowDeclaredNew: boolean): boolean => {
+    if (!path.includes('/') || isAbsolute(path) || path.split('/').some((part) => part === '..' || part === '.')) return false;
+    if (root === null) return false;
+    if (allowDeclaredNew && declaredNew.has(path) && isSafeNewTargetPath(path, root)) return true;
+    try {
+      const real = realpathSync(resolve(root, path));
+      return isSameOrNestedPath(real, root) && lstatSync(real).isFile();
+    } catch { return false; }
+  };
+  const resolvePath = (path: string, declaredTarget = false): string | null => {
+    if (declaredTarget) return valid(path, true) ? path : null;
+    if (path.includes('/') && valid(path, true)) return path;
+    if (path.includes('/')) return null;
+    const matches = known.filter((candidate) => candidate.endsWith(`/${path}`) && valid(candidate, false));
+    return matches.length === 1 ? matches[0]! : null;
+  };
+  const added = new Map<string, number>();
+  const addPath = (path: string, description?: string): void => {
+    const existing = added.get(path);
+    if (existing !== undefined) {
+      if (description !== undefined) paths[existing] += ` — ${description}`;
+      return;
+    }
+    added.set(path, paths.length);
+    paths.push(`${paths.length + 1}. ${path}${description === undefined ? '' : ` — ${description}`}`);
+  };
+  for (const path of requestedTargets) {
+    const resolved = resolvePath(path, true);
+    if (resolved) addPath(resolved);
+    else paths.push(`${paths.length + 1}. 미해석: ${path} — 요청에 선언된 대상 경로를 저장소 파일 또는 명시적 신설 파일로 확인하지 못함`);
+  }
+  for (const piece of unresolvedTargetPieces) {
+    paths.push(`${paths.length + 1}. 미해석: ${piece} — 요청에 선언된 대상 경로를 파싱하지 못함`);
+  }
+  for (const item of evidence) {
+    const referenced = [...new Set(Array.from(item.text.matchAll(SOURCE_PATH), (match) => match[0]))]
+      .filter(isRepositoryImplementationCandidate);
+    if (referenced.length === 0) {
+      paths.push(`${paths.length + 1}. 미해석: ${renderPersistentEvidence(item)} — 경로가 없는 접지 근거`);
+      continue;
+    }
+    referenced.forEach((path, index) => {
+      const resolved = resolvePath(path);
+      if (resolved) addPath(resolved, index === 0 ? renderPersistentEvidence(item) : undefined);
+      else paths.push(`${paths.length + 1}. 미해석: ${path} — ${renderPersistentEvidence(item)}`);
+    });
+  }
+  if (evidence.length === 0) paths.push(`- ${unavailableEvidence}`);
+  return paths;
 }
 
 const IDENTITY_PREFIX = /^(agent|session|submitted|authored-by|track|roadmap):/i;
@@ -5537,7 +5641,7 @@ async function authorGoalWithSupersededRootIntent(
     '## REQUIRED EVIDENCE',
     ...requiredEvidence(criteria, facts ? implementationCandidates(facts) : [], authorRunId),
     '',
-    ...(goalType === 'implement' ? ['## TRACED PATHS', ...tracedPathsSection(facts, narrative.tracedPathsUnavailableEvidence), ''] : []),
+    ...(goalType === 'implement' ? ['## TRACED PATHS', ...tracedPathsSection(facts, ask, deps.repositoryRoot, narrative.tracedPathsUnavailableEvidence), ''] : []),
     '## SCOPE BOUNDARY',
     ...scopeBoundarySection,
     '',
@@ -5723,23 +5827,8 @@ export function defaultGoalAuthorDeps(cwd: string): GoalAuthorDeps {
   };
 }
 
-const MAX_FILENAME_BYTES = 255;
-// Goal files are listed and reviewed in ASCII-only terminals, so keep the meaningful
-// prefix portable and short even when the request title is Korean.
-const MAX_GOAL_SLUG_BYTES = 64;
-const GOAL_FINGERPRINT_LENGTH = 8;
 const IDENTITY_LINE = /^(agent|track|session|submitted):\s*(.*?)\s*$/i;
 
-function localDate(now: Date): string {
-  return [now.getFullYear(), String(now.getMonth() + 1).padStart(2, '0'), String(now.getDate()).padStart(2, '0')].join('-');
-}
-
-function asciiGoalSlug(title: string): string {
-  return title.normalize('NFKC').toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '');
-}
-
 function missionSlugFallback(goal: string): string {
   return slugify(extractSlugSource(goal));
 }
@@ -5752,32 +5841,6 @@ async function goalSlug(goal: string, slugFn: (goal: string) => Promise<string>)
   }
 }
 
-function slugWithinUtf8Budget(normalizedSlug: string, byteBudget: number): string {
-  let slug = '';
-  let bytes = 0;
-  const graphemes = new Intl.Segmenter(undefined, { granularity: 'grapheme' }).segment(normalizedSlug);
-  for (const { segment } of graphemes) {
-    const segmentBytes = Buffer.byteLength(segment, 'utf8');
-    if (bytes + segmentBytes > byteBudget) break;
-    slug += segment;
-    bytes += segmentBytes;
-  }
-  return slug.replace(/-+$/g, '');
-}
-
-function goalFingerprint(source: string): string {
-  return createHash('sha256').update(source, 'utf8').digest('hex').slice(0, GOAL_FINGERPRINT_LENGTH);
-}
-
-export interface GoalFileNameSource {
-  /** Human-readable generated goal title used for the ASCII slug. */
-  title: string;
-  /** Complete generated artifact used to distinguish semantically different results from one ask. */
-  document: string;
-  /** Repository identifiers from the original ask, retained before a generated title slug. */
-  repositoryIdentifiers?: readonly string[];
-}
-
 function repositoryIdentifiers(ask: string): string[] {
   const lines = ask.split(/\r?\n/);
   const metadata = leadingIdentityMetadata(ask);
@@ -5790,27 +5853,6 @@ function repositoryIdentifiers(ask: string): string[] {
     .match(/[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*/g) ?? [];
 }
 
-function buildGoalFileName(source: GoalFileNameSource, now: Date, collisionSuffix = ''): string {
-  const date = localDate(now);
-  const fingerprint = goalFingerprint(source.document);
-  const fixed = `GOAL--${fingerprint}${collisionSuffix}-${date}.md`;
-  const byteBudget = Math.min(
-    MAX_GOAL_SLUG_BYTES,
-    MAX_FILENAME_BYTES - Buffer.byteLength(fixed, 'utf8'),
-  );
-  const identifierPrefix = source.repositoryIdentifiers?.map(asciiGoalSlug).filter(Boolean).join('-');
-  const titleSlug = asciiGoalSlug(source.title);
-  const slug = slugWithinUtf8Budget([identifierPrefix, titleSlug].filter(Boolean).join('-'), byteBudget) || 'goal';
-  return `GOAL-${slug}-${fingerprint}${collisionSuffix}-${date}.md`;
-}
-
-/** Single filename contract shared by helper callers and the filesystem writer. */
-export function goalFileName(source: GoalFileNameSource, now: Date): string {
-  const fileName = buildGoalFileName(source, now);
-  if (!isGoalAuthorFileName(fileName)) throw new Error(`goal filename violates document contract: ${fileName}`);
-  return fileName;
-}
-
 function leadingIdentityMetadata(ask: string): Map<string, string> {
   const lines = ask.split(/\r?\n/);
   let candidates: string[] = [];

package/src/self-implement/goal-authoring-grounding.ts

@@ -11,7 +11,7 @@ const MAX_MEMORY_ITEMS = 5;
 const MAX_EXTERNAL_SOURCES = 3;
 const LOCAL_REFERENCE_CANDIDATES = [
   'openclaw', 'codex', 'hermess', 'hermes', 'hermes-agent',
-  'claude', 'claude-code-fork', 'grok', 'grok-cli', 'grok-build',
+  'claude', 'grok', 'grok-cli', 'grok-build',
 ] as const;
 
 export interface GoalAuthoringExternalSource {

package/src/self-implement/goal-file-name.ts

@@ -0,0 +1,65 @@
+import { createHash } from 'node:crypto';
+import { isGoalAuthorFileName } from './goal-document.js';
+
+const MAX_FILENAME_BYTES = 255;
+// Goal files are listed and reviewed in ASCII-only terminals, so keep the meaningful
+// prefix portable and short even when the request title is Korean.
+const MAX_GOAL_SLUG_BYTES = 64;
+const GOAL_FINGERPRINT_LENGTH = 8;
+
+function localDate(now: Date): string {
+  return [now.getFullYear(), String(now.getMonth() + 1).padStart(2, '0'), String(now.getDate()).padStart(2, '0')].join('-');
+}
+
+function asciiGoalSlug(title: string): string {
+  return title.normalize('NFKC').toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+function slugWithinUtf8Budget(normalizedSlug: string, byteBudget: number): string {
+  let slug = '';
+  let bytes = 0;
+  const graphemes = new Intl.Segmenter(undefined, { granularity: 'grapheme' }).segment(normalizedSlug);
+  for (const { segment } of graphemes) {
+    const segmentBytes = Buffer.byteLength(segment, 'utf8');
+    if (bytes + segmentBytes > byteBudget) break;
+    slug += segment;
+    bytes += segmentBytes;
+  }
+  return slug.replace(/-+$/g, '');
+}
+
+function goalFingerprint(source: string): string {
+  return createHash('sha256').update(source, 'utf8').digest('hex').slice(0, GOAL_FINGERPRINT_LENGTH);
+}
+
+export interface GoalFileNameSource {
+  /** Human-readable generated goal title used for the ASCII slug. */
+  title: string;
+  /** Complete generated artifact used to distinguish semantically different results from one ask. */
+  document: string;
+  /** Repository identifiers from the original ask, retained before a generated title slug. */
+  repositoryIdentifiers?: readonly string[];
+}
+
+export function buildGoalFileName(source: GoalFileNameSource, now: Date, collisionSuffix = ''): string {
+  const date = localDate(now);
+  const fingerprint = goalFingerprint(source.document);
+  const fixed = `GOAL--${fingerprint}${collisionSuffix}-${date}.md`;
+  const byteBudget = Math.min(
+    MAX_GOAL_SLUG_BYTES,
+    MAX_FILENAME_BYTES - Buffer.byteLength(fixed, 'utf8'),
+  );
+  const identifierPrefix = source.repositoryIdentifiers?.map(asciiGoalSlug).filter(Boolean).join('-');
+  const titleSlug = asciiGoalSlug(source.title);
+  const slug = slugWithinUtf8Budget([identifierPrefix, titleSlug].filter(Boolean).join('-'), byteBudget) || 'goal';
+  return `GOAL-${slug}-${fingerprint}${collisionSuffix}-${date}.md`;
+}
+
+/** Single filename contract shared by helper callers and the filesystem writer. */
+export function goalFileName(source: GoalFileNameSource, now: Date): string {
+  const fileName = buildGoalFileName(source, now);
+  if (!isGoalAuthorFileName(fileName)) throw new Error(`goal filename violates document contract: ${fileName}`);
+  return fileName;
+}

package/src/self-implement/ground-goal.ts

@@ -45,7 +45,8 @@ export async function groundGoalInCodebase(goalText: string, deps: GroundGoalDep
     );
     const persistentElapsedMs = performance.now() - persistentStartedAt;
     if (!persistent?.files.length) {
-      safeObserve('empty', { cwd: deps.cwd, reason: persistent ? 'no-candidates' : 'failed-or-no-candidates', candidates: 0 });
+      safeObserve('empty', { cwd: deps.cwd, reason: persistent ? 'no-candidates' : 'failed-or-no-candidates',
+        persistentStopReason: persistent?.stopReason ?? null, candidates: 0 });
       return '';
     }
     const renderingStartedAt = performance.now();

package/src/self-implement/host-regate.ts

@@ -425,6 +425,20 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
         (bin, args, dir) => command(bin, args, dir));
       if (!exposure.passed) return result('failed', 'expose', exposure.log);
     }
+    // The checked checkout is shared with interference/exposure gates. Verify dependencies at the
+    // typecheck boundary as well: a missing PWA link here made #27414 fail as an unmeasured host regate.
+    if (buildPwa && !existsSync(join(worktree, 'apps/pwa/node_modules'))) {
+      let failure: string | null = null;
+      try {
+        if (existsSync(join(worktree, 'apps/pwa'))) {
+          provideCheckoutDependencies(worktree, input.repoRoot, 'apps/pwa', 'next', (cwd) => { run('bun', ['install', '--frozen-lockfile'], cwd); });
+        } else failure = 'apps/pwa absent before typecheck';
+      } catch (e) { failure = String(e); }
+      const ready = existsSync(join(worktree, 'apps/pwa/node_modules'));
+      if (!ready && !failure) failure = 'apps/pwa/node_modules absent after provision before typecheck';
+      try { debug.log('harness.host-regate', 'pwa-dependencies-before-typecheck', { pr: input.prNumber, restored: ready, failure }); } catch { /* observation must not block regate */ }
+      if (!ready) return result('unmeasured', 'dependencies', failure!);
+    }
     // verifyOnly: 통합 후보는 «지금 main 끝»(baseCommit)에 얹은 것이다 — 옛 merge-base 로 비교하면 그사이 main 착지분
     //   수백 파일이 «이 PR 의 변경»으로 잡혀 저장소 전체 검사로 승격된다(2026-09-28 #21239 실측: 456파일 · PWA 636건).
     try { run('bun', ['scripts/ci-typecheck-changed.ts'], worktree, { ...process.env, TSC_BASE_REF: input.verifyOnly ? baseCommit : base }); }

package/src/self-implement/review-mustfix-class.ts

@@ -0,0 +1,115 @@
+// ── REVIEW-MUSTFIX-CLASSIFY — 리뷰 must-fix 를 «수의 추이»가 아니라 «회차 짝»으로 가른다 ──
+//
+// 수의 추이(improving·stable·worsening·oscillating)는 «새 실결함이 매번 나오는 정상 수렴»과
+// «원리상 못 닫는 요구»를 못 가른다(#26644 · 10-12 · 5→3→2→3). 이 판정은 회차 짝으로 가른다:
+//
+//   ① new-defect        앞 회차에 없던 새 지적 — 그대로 수렴 간다(계속).
+//   ② post-land-evidence 착지 뒤에만 낼 수 있는 증거(운영 소비·실물 착지·live 호출자)를 요구하는
+//                          지적 — 같은 런 재수리 0 · «그림자 착지 → 관측 → live» 쪼개기 결정.
+//   ③ recurring          수리 뒤 같은 지적이 다시 나옴 — intent 경계 자동 명시 ⊕ 다른 모델 교차 리뷰 제안.
+//   unmeasured           이 회차 must-fix 를 안 쟀다 — 분류 불가, 슈퍼바이저 지금 동작 그대로.
+//
+// ⛔ 임의 임계(«두 번») 금지 — 짝은 «정규화 문면이 같다»는 사실 하나로 맞는다.
+
+/** Evidence a must-fix item demands that only a landing can produce. */
+export type MustFixEvidenceKind = 'ops-consumption' | 'artifact-landing' | 'live-caller';
+
+export interface MustFixItem {
+  /** Verbatim reviewer must-fix text. */
+  readonly text: string;
+  /** Evidence this item demands that only a landing can produce. */
+  readonly evidence?: MustFixEvidenceKind;
+  /** Pairing scope — the task that raised it (supervisor ledger); pairing never crosses tasks. */
+  readonly taskId?: string;
+}
+
+/** One round's observed must-fix list; `items` undefined/empty = the round's review was not observed. */
+export interface MustFixRoundObservation {
+  readonly items?: readonly MustFixItem[];
+}
+
+export type MustFixClass = 'new-defect' | 'post-land-evidence' | 'recurring' | 'unmeasured';
+
+export interface MustFixRoundClassification {
+  readonly class: MustFixClass;
+  readonly reason: string;
+  /** ② post-land-evidence — 같은 런 재수리 0, «그림자 착지 → 관측 → live» 쪼개기 결정. */
+  readonly split?: 'shadow-land → observe → live';
+  /** ③ recurring — intent 경계 자동 명시 ⊕ 다른 모델 교차 리뷰 제안. */
+  readonly crossReview?: true;
+  /** Evidence kinds this round's items demand (②). */
+  readonly evidence?: readonly MustFixEvidenceKind[];
+  /** Recurring item texts, normalized (③). */
+  readonly recurring?: readonly string[];
+}
+
+/** Evidence subjects, each matched as a whole word group. */
+const EVIDENCE_SUBJECTS: ReadonlyArray<readonly [MustFixEvidenceKind, string]> = [
+  ['live-caller', String.raw`(?:live|라이브)\s*(?:호출자|caller)`],
+  ['ops-consumption', String.raw`(?:운영(?:에서)?\s*소비|(?:prod(?:uction)?|ops)\s*consumption)`],
+  ['artifact-landing', String.raw`(?:(?:실물|실제)\s*착지|artifact\s*landing)`],
+];
+/** Korean: «<대상>[ 증거](를|을)? <요구>» or «<대상> 증거가 없다». */
+const KO_DEMAND = String.raw`(?:\s*(?:증거|증명)\s*(?:를|을)?|\s*(?:를|을))?\s*(?:보여라|보여\s*달라|대라|증명하라|입증하라|못\s*봤다|관측되지\s*않았다|확인되지\s*않았다)`;
+const KO_MISSING = String.raw`\s*(?:증거|증명)\s*(?:가|이)?\s*없다`;
+/** English: «show|prove|demonstrate [the] <subject> [evidence]» or «no <subject> evidence». */
+const EN_PREFIX = String.raw`(?:show|prove|demonstrate)\s+(?:the\s+)?`;
+
+/**
+ * Derive the post-land evidence kind a must-fix text *demands* — allow-list only: the WHOLE text (trimmed,
+ * one optional terminal «.»/«!») must be one of the pure evidence-demand forms above. Anything else — a second
+ * sentence, a comma, «그리고», a defect word, a different verb — stays undefined, i.e. ① same-run repair
+ * (의심스러우면 ① = 안전한 기본). Widening the recognised forms is a follow-up; outside them is ① on purpose.
+ */
+export function inferMustFixEvidence(text: string): MustFixEvidenceKind | undefined {
+  const t = text.trim().toLowerCase().replace(/\s+/gu, ' ').replace(/[.!]$/u, '');
+  for (const [kind, subject] of EVIDENCE_SUBJECTS) {
+    const forms = [
+      `${subject}${KO_DEMAND}`,
+      `${subject}${KO_MISSING}`,
+      `${EN_PREFIX}${subject}(?:\\s+evidence)?`,
+      `no\\s+${subject}\\s+evidence`,
+    ];
+    if (forms.some((form) => new RegExp(`^${form}$`, 'u').test(t))) return kind;
+  }
+  return undefined;
+}
+
+/** Pairing key: whitespace collapsed, lower-cased — same discipline as `noPrStreakKey`. */
+function mustFixKey(text: string): string {
+  return text.trim().replace(/\s+/gu, ' ').toLowerCase();
+}
+
+export function classifyMustFixRound(
+  prev: MustFixRoundObservation | undefined,
+  cur: MustFixRoundObservation,
+): MustFixRoundClassification {
+  const curItems = cur.items ?? [];
+  if (curItems.length === 0) {
+    return { class: 'unmeasured', reason: '이 회차 리뷰 must-fix 를 안 쟀다 — 분류 불가, 슈퍼바이저 지금 동작 그대로' };
+  }
+  const prevItems = prev?.items ?? [];
+  // Pairing never crosses tasks: same normalized text AND both sides name the same task — unknown origin never pairs.
+  const pairs = (p: MustFixItem, c: MustFixItem): boolean => mustFixKey(p.text) === mustFixKey(c.text)
+    && p.taskId !== undefined && c.taskId !== undefined && p.taskId === c.taskId;
+  const recurring = curItems.filter((item) => prevItems.some((p) => pairs(p, item)));
+  if (prevItems.length > 0 && recurring.length > 0) {
+    return {
+      class: 'recurring',
+      reason: `같은 지적이 수리 뒤에 다시 나왔다(${recurring.length}) — intent 경계를 명시하고 다른 모델 교차 리뷰를 제안한다`,
+      crossReview: true,
+      recurring: recurring.map((item) => mustFixKey(item.text)),
+    };
+  }
+  // ② only when every item demands post-land evidence — a real defect mixed in still gets its same-run repair (①).
+  const evidence = [...new Set(curItems.flatMap((item) => (item.evidence ? [item.evidence] : [])))];
+  if (curItems.every((item) => item.evidence !== undefined)) {
+    return {
+      class: 'post-land-evidence',
+      reason: `증거는 착지 뒤에만 난다(${evidence.join(' · ')}) — 같은 런 재수리 0, 그림자 착지 → 관측 → live 로 쪼갠다`,
+      evidence,
+      split: 'shadow-land → observe → live',
+    };
+  }
+  return { class: 'new-defect', reason: '앞 회차에 없던 새 지적 — 새 실결함 수렴으로 그대로 간다' };
+}