elanous 0.2.32 → 0.2.35

package/src/pty-shell/tui-run-state.ts

@@ -17,9 +17,14 @@ import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 import { debug } from '../debug/log.js';
+import { createHerdrAgentReporter, type HerdrAgentReporterLike } from './herdr-agent-report.js';
 import { runGitCommand } from '../git-fs/runner.js';
 import { codeRevision, packageVersion, readInstallMetadataCommit } from '../version/code-revision.js';
-import { versionedDashboardInstallDir } from '../dashboard/stale-install-check.js';
+import {
+  buildStaleInstallRelaunchCommand,
+  formatStaleInstallNotice,
+  versionedDashboardInstallDir,
+} from '../dashboard/stale-install-check.js';
 import {
   updatePtyManifestBuild, updatePtyManifestTurn,
   type PtyBuildIdentity, type PtyManifestRow, type PtyTurnState,
@@ -138,6 +143,86 @@ export function judgeBuildStaleness(input: {
   return { stale: null, reason: 'unknown' };
 }
 
+// ── 매 턴 자기 건강 한 줄(TUI-SELF-HEALTH-LINE · 0.2.34) ──
+//
+// 대시보드 턴 프리앰블에 매 턴 실리는 자기 관측 한 줄: «실행 판 vs 설치본» 낡음 판정
+// (judgeBuildStaleness ⊕ readCurrentInstallRecord — 이미 있는 실물)에 «직전 30분 자기 오류»
+// ·«크레딧 사용» 재료를 얹는다. 낡은 판이면 재기동 필요를 말하되 안내 문면·재기동 명령은
+// stale-install-check 의 기존 재료(formatStaleInstallNotice · buildStaleInstallRelaunchCommand)를
+// 그대로 쓴다 — 문면을 두벌로 만들지 않는다.
+//
+// ⚠️ 미결(이 모듈이 정하지 않는다): ① 직전 30분 창에서 «어떤 이벤트를 자기 오류로 세는지» —
+//   호출자가 집계해 count·sample 로 넘긴다. ② 크레딧 사용 재료를 무엇으로 잴지 — 호출자가 만든
+//   값을 넘긴다. 두 축은 계약이 정해지는 즉시 호출부에서 주입하면 된다.
+
+export interface SelfHealthErrors {
+  /** 직전 30분 창의 자기 오류 건수. 0 = 오류 없음. */
+  readonly count: number;
+  /** 오류를 대표하는 한 줄(첫 오류 요약 등). 없으면 개수만 말한다. */
+  readonly sample?: string;
+}
+
+export interface SelfHealthLineDeps {
+  /** 기동 판 — 기본 runningBuild(기동 때 한 번 잡힌 값). */
+  readonly build?: () => PtyBuildIdentity;
+  /** 지금 current 설치본 기록 — 기본 readCurrentInstallRecord. */
+  readonly readInstalled?: () => InstalledRecord;
+  /** 체크아웃 HEAD 재독기 — 기동 판이 checkout 일 때만 불린다. 기본 readCheckoutHead. */
+  readonly readCheckoutHead?: (codeRoot: string) => string | undefined;
+  /** 재기동 명령에 얹을 대화 id — 없으면 안내 문면만. */
+  readonly sessionId?: string;
+  /** 새 판 안내 회차(formatStaleInstallNotice notifiedCount) — 기본 1. */
+  readonly notifiedCount?: number;
+  /** 크레딧 사용 재료(호출자가 만든 값) — 없으면 그 축은 생략된다. */
+  readonly creditUsage?: string;
+}
+
+/** 매 턴 자기 건강 한 줄. 판 축 재료가 깨져도 오류·크레딧 축은 살리고, 말할 것이 없으면 null —
+ *  줄이 턴을 막지 않는다(fail-soft). */
+export function buildSelfHealthLine(
+  errors: SelfHealthErrors | null | undefined,
+  deps: SelfHealthLineDeps = {},
+): string | null {
+  const segments: string[] = [];
+  try {
+    const build = (deps.build ?? runningBuild)();
+    const installed = (deps.readInstalled ?? readCurrentInstallRecord)();
+    let checkoutHead: string | undefined;
+    if (build.source === 'checkout' && build.codeRoot) {
+      checkoutHead = (deps.readCheckoutHead ?? readCheckoutHead)(build.codeRoot);
+    }
+    const staleness = judgeBuildStaleness({ build, installed, ...(checkoutHead ? { checkoutHead } : {}) });
+    segments.push(`실행 판 ${build.version}@${shortSha(build.sha)}(${build.source})`);
+    if (staleness.stale === true) {
+      const relaunch = deps.sessionId
+        ? ` · 다시 띄우기: ${buildStaleInstallRelaunchCommand(deps.sessionId)}`
+        : '';
+      if (staleness.reason === 'installed-moved' && build.sha && installed.sha) {
+        segments.push(`낡은 판 — 재기동 필요: ${formatStaleInstallNotice(
+          { state: 'changed', bootCommit: build.sha, installedCommit: installed.sha },
+          deps.notifiedCount ?? 1,
+        )}${relaunch}`);
+      } else {
+        segments.push(`낡은 판(${staleness.reason}) — 재기동 필요${relaunch}`);
+      }
+    } else if (staleness.stale === false) {
+      segments.push(`판 최신(${staleness.reason})`);
+    } else {
+      // stale=null 은 «안 낡았다»가 아니다 — 못 잼을 못 잼으로 말한다.
+      segments.push(`판 낡음 모름(${staleness.reason})`);
+    }
+  } catch {
+    // 판 축 재료가 깨져도 오류·크레딧 축은 살린다 — 관측이 턴을 막지 않는다.
+  }
+  if (errors) {
+    segments.push(errors.count > 0
+      ? `직전 30분 자기 오류 ${errors.count}건${errors.sample ? ` — 대표: ${errors.sample}` : ''}`
+      : '직전 30분 자기 오류 0건');
+  }
+  if (deps.creditUsage) segments.push(`크레딧 사용 ${deps.creditUsage}`);
+  return segments.length > 0 ? `[자기 건강] ${segments.join(' · ')}` : null;
+}
+
 // ── 판독(CLI) ──
 
 export type PtyTurnView = PtyTurnState | 'unknown';
@@ -230,6 +315,12 @@ export interface TuiRunStateRecorderDeps {
   readonly writeBuild?: (id: string, build: PtyBuildIdentity) => boolean;
   readonly writeTurn?: (id: string, turn: PtyTurnState, at: number) => boolean;
   readonly log?: (event: string, data: Record<string, unknown>) => void;
+  /**
+   * herdr pane 신고기. 생략 시: `writeTurn` 을 주입하지 않은 기본 녹음기만
+   * `createHerdrAgentReporter` 를 만든다(시험이 실 herdr 를 안 건드리게).
+   * `null` 이면 신고하지 않는다.
+   */
+  readonly herdr?: HerdrAgentReporterLike | null;
 }
 
 interface ActiveRecorder {
@@ -237,7 +328,11 @@ interface ActiveRecorder {
   readonly now: () => number;
   readonly writeTurn: (id: string, turn: PtyTurnState, at: number) => boolean;
   readonly log: (event: string, data: Record<string, unknown>) => void;
+  readonly herdr: HerdrAgentReporterLike | null;
+  /** manifest 에 실제로 적힌 마지막 턴. 실패면 안 바뀐다(재시도). */
   last?: PtyTurnState;
+  /** herdr 에 마지막으로 알린 턴. manifest 성패와 따로 둔다. */
+  herdrLast?: PtyTurnState;
 }
 
 let active: ActiveRecorder | null = null;
@@ -249,6 +344,10 @@ export function startTuiRunStateRecorder(surfaceId: string, deps: TuiRunStateRec
   const now = deps.now ?? Date.now;
   const log = deps.log ?? defaultLog;
   const writeTurn = deps.writeTurn ?? updatePtyManifestTurn;
+  // 기본 신고기는 기본 manifest 쓰기와 짝일 때만. writeTurn 주입(시험)은 herdr 를 안 만든다.
+  const herdr = deps.herdr !== undefined
+    ? deps.herdr
+    : (deps.writeTurn ? null : createHerdrAgentReporter({ sessionId: surfaceId }));
   let build: PtyBuildIdentity | undefined;
   try { build = (deps.build ?? runningBuild)(); } catch (error) {
     log('build-resolve-failed', { ptyId: surfaceId, error: error instanceof Error ? error.message : String(error) });
@@ -257,10 +356,15 @@ export function startTuiRunStateRecorder(surfaceId: string, deps: TuiRunStateRec
     const ok = (() => { try { return (deps.writeBuild ?? updatePtyManifestBuild)(surfaceId, build); } catch { return false; } })();
     log(ok ? 'build-recorded' : 'build-write-failed', { ptyId: surfaceId, sha: build.sha, version: build.version, source: build.source });
   }
-  const recorder: ActiveRecorder = { surfaceId, now, writeTurn, log };
+  // 기동 순서: 판 → manifest 초기 idle → herdr 신고. herdr start 가 idle 을 신고하므로 초기 idle 을 turn 으로 다시 안 보낸다.
+  const recorder: ActiveRecorder = { surfaceId, now, writeTurn, log, herdr, herdrLast: herdr ? 'idle' : undefined };
   active = recorder;
   writeTurnState(recorder, 'idle');
-  return () => { if (active === recorder) active = null; };
+  if (herdr) { try { herdr.start(); } catch { /* 신고 실패가 녹음기를 깨지 않는다 */ } }
+  return () => {
+    if (herdr) { try { herdr.release(); } catch { /* 종료 경로를 깨지 않는다 */ } }
+    if (active === recorder) active = null;
+  };
 }
 
 /** 대시보드가 턴 시작(busy)·끝(idle)에 부른다. 녹음기가 없으면(자기보고 꺼짐) 아무것도 안 한다. */
@@ -276,6 +380,16 @@ function writeTurnState(recorder: ActiveRecorder, turn: PtyTurnState): void {
   if (ok) recorder.last = turn;
   // 실패는 관측으로 남긴다 — 바깥 제어자는 그 사이 «unknown/낡은 값»을 본다. 성공은 남기지 않는다(턴마다 두 줄은 소음).
   else recorder.log('turn-write-failed', { ptyId: recorder.surfaceId, turn, at });
+  // herdr 는 manifest 쓰기 성패와 무관하게, 값이 바뀔 때 알린다(같은 값 재시도는 한 번만).
+  if (recorder.herdr && recorder.herdrLast !== turn) {
+    // 신고가 동기로 던지면 «보낸 상태» 로 적지 않는다 — herdr 가 아는 값(herdrLast)과 다음 전이를 비교해 다시 보낸다(r4 리뷰 sf).
+    try {
+      recorder.herdr.turn(turn);
+      recorder.herdrLast = turn;
+    } catch (error) {
+      recorder.log('herdr-turn-threw', { turn, error: error instanceof Error ? error.message : String(error) });
+    }
+  }
 }
 
 export function resetTuiRunStateForTesting(): void {

package/src/release-loop/checklist.ts

@@ -1,4 +1,5 @@
 import { spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import { readFileSync, statSync } from 'node:fs';
 import { isAbsolute, join } from 'node:path';
 import * as store from './feature-store.js';
@@ -131,20 +132,77 @@ function mentionedPaths(text: string): string[] {
   return [...text.matchAll(PATH_TOKEN)].map((match) => match[1]!).filter((path) => !path.split('/').includes('..'));
 }
 
+/** `docs/goal-context/03-verification-menu.md` §선택 원칙: merge SHA·타입검사는 수용선이 아니다. */
+export const MERGE_OR_TYPECHECK_ONLY_REAL_WARNING = '- 완료 경계 실물: merge sha·타입검사만으로는 실물이 아니다 — docs/goal-context/03-verification-menu.md 에서 동작을 재는 방법을 고른다';
+/** 통합 이력·정적 타입 상태만 말하는 낱말(조사 뗀 꼴). 이 밖의 낱말이 하나라도 있으면 실물 주장으로 본다. */
+const MERGE_OR_TYPECHECK_WORD = /^(?:pr|merge|merged|머지|병합|착지|landed|land|sha|merge-sha|commit|커밋|origin|main|tsc|typecheck|type-check|typecheck-changed|타입검사|타입|검사|type|check|changed|통과|pass|passed|green|clean|errors?|error|오류|에러|없음|후|뒤|완료|확인|and|및|만|됨|된다)$/i;
+const MERGE_OR_TYPECHECK_SIGNAL = /^(?:merge|merged|머지|병합|착지|landed|land|sha|merge-sha|tsc|typecheck|type-check|타입검사)$/i;
+const KOREAN_PARTICLE_TAIL = /(?:했다|했음|하였다|했고|함|으로|로|이|가|은|는|을|를|와|과|에|의|만|됨|된|된다)$/u;
+
+/** 「완료 경계 실물」 값이 merge sha·PR 착지·타입검사 낱말로만 이뤄졌나(동작 관측이 하나도 없나). */
+export function isMergeOrTypecheckOnlyEvidence(value: string): boolean {
+  const words = value.split(/[\s.!?。…~`'"·,⊕+()[\]:;/=|→-]+/u).map((word) => word.replace(/^#/, '')).filter(Boolean);
+  if (!words.length) return false;
+  let signal = false;
+  for (const raw of words) {
+    if (/^\d+$/.test(raw) || /^[0-9a-f]{7,40}$/i.test(raw)) continue;
+    let word = raw;
+    for (let strip = 0; strip < 3 && !MERGE_OR_TYPECHECK_WORD.test(word); strip++) word = word.replace(KOREAN_PARTICLE_TAIL, '');
+    if (!MERGE_OR_TYPECHECK_WORD.test(word)) return false;
+    if (MERGE_OR_TYPECHECK_SIGNAL.test(word)) signal = true;
+  }
+  return signal;
+}
+
 /** Shadow check at checklist authorship. Callers supply the origin/main file probe and merged-PR file reader. */
 export function inspectChecklistTargetPaths(input: {
   title: string; evidence?: string; refs?: readonly string[]; dispatchKind?: ChecklistDispatchKind;
-}, deps: { existsAtMain: (path: string) => boolean; mergedPrFiles?: (number: number) => readonly string[] }): {
+}, deps: { existsAtMain: (path: string) => boolean; objectTypeAtMain?: (path: string) => 'blob' | 'tree' | 'commit' | 'blocked-blob' | 'blocked-gitlink' | 'unavailable' | null; mergedPrFiles?: (number: number) => readonly string[] }): {
   targets: string[]; warnings: string[]; candidates: string[];
 } {
   const lines = input.title.split(/\r?\n/);
   const first = /^대상 경로:\s*(.*)$/.exec(lines[0] ?? '');
-  const targets = first ? [...new Set(mentionedPaths(first[1]!))] : [];
-  const newFileDeclared = /^신설:\s*/.test(lines[1] ?? '');
+  const rawTargets = first?.[1]?.split(' · ').map((path) => path.trim()) ?? [];
+  const validPath = (path: string): boolean => path.length > 0 && path.length < 4096
+    && !path.startsWith('/') && !path.includes('\\') && !/[\u0000-\u001f\u007f]/u.test(path)
+    && path.split('/').every((segment) => segment !== '' && segment !== '.' && segment !== '..');
+  const targets = [...new Set(rawTargets.filter(validPath))];
+  const misplacedNewFiles = lines.slice(2).filter((line) => /^신설:\s*/.test(line));
+  const rawNewFiles = lines.slice(1, 2).filter((line) => /^신설:\s*/.test(line))
+    .flatMap((line) => line.slice('신설:'.length).split(' · ').map((path) => path.trim()));
+  const newFiles = new Set(rawNewFiles.filter(validPath));
   const warnings: string[] = [];
   if ((input.dispatchKind ?? 'code') === 'code') {
-    if (!first || !first[1]!.trim() || targets.length === 0) warnings.push('첫 줄 대상 경로가 없다');
-    for (const path of targets) if (!deps.existsAtMain(path) && !newFileDeclared) warnings.push(`${path}: origin/main에 없는 파일 · 신설: 둘째 줄 선언 필요`);
+    if (!first || !first[1]!.trim()) warnings.push('첫 줄 대상 경로가 없다');
+    else if (targets.length !== rawTargets.length || targets.length === 0) warnings.push('첫 줄은 실제 파일 경로만 « · »로 구분한다');
+    if (misplacedNewFiles.length) warnings.push('신설: 선언은 제목 둘째 줄에만 둔다');
+    for (const path of rawNewFiles) if (!validPath(path)) warnings.push(`신설: ${path || '(빈 항목)'}: 정확한 새 파일 경로가 아니다`);
+    for (const path of targets) {
+      const objectType = deps.objectTypeAtMain?.(path);
+      const exists = objectType ? objectType === 'blob' : deps.existsAtMain(path);
+      if (objectType === 'unavailable') warnings.push(`${path}: origin/main Git 조회 실패 · 대상 검증 불가`);
+      if (objectType === 'tree' || objectType === 'commit') warnings.push(`${path}: origin/main의 ${objectType === 'tree' ? '디렉터리' : 'gitlink'}는 파일 대상이 아니다`);
+      if (objectType === 'blocked-blob' || objectType === 'blocked-gitlink')
+        warnings.push(`${path}: origin/main의 상위 ${objectType === 'blocked-blob' ? '파일' : 'gitlink'} 아래에는 신설할 수 없다`);
+      if (!exists && !newFiles.has(path)) warnings.push(`${path}: origin/main에 없는 파일 · 신설: 줄에 해당 경로 선언 필요`);
+      if (exists && newFiles.has(path)) warnings.push(`${path}: 이미 있는 파일은 신설:에서 뺀다`);
+    }
+    for (const path of newFiles) if (!targets.includes(path)) warnings.push(`${path}: 신설: 경로가 첫 줄 대상에 없다`);
+    for (const path of newFiles) {
+      const objectType = deps.objectTypeAtMain?.(path);
+      if (objectType === 'unavailable' && !targets.includes(path))
+        warnings.push(`${path}: origin/main Git 조회 실패 · 신설 검증 불가`);
+      if ((objectType === 'tree' || objectType === 'commit') && !targets.includes(path))
+        warnings.push(`${path}: origin/main의 ${objectType === 'tree' ? '디렉터리' : 'gitlink'}는 신설 파일이 아니다`);
+      if ((objectType === 'blocked-blob' || objectType === 'blocked-gitlink') && !targets.includes(path))
+        warnings.push(`${path}: origin/main의 상위 ${objectType === 'blocked-blob' ? '파일' : 'gitlink'} 아래에는 신설할 수 없다`);
+    }
+    for (const label of ['코드', '실물', '증거 명령']) {
+      if (!lines.some((line) => line.startsWith(`- 완료 경계 ${label}:`) && line.slice(`- 완료 경계 ${label}:`.length).trim()))
+        warnings.push(`- 완료 경계 ${label}: 줄이 없다`);
+    }
+    const real = lines.find((line) => line.startsWith('- 완료 경계 실물:'))?.slice('- 완료 경계 실물:'.length).trim();
+    if (real && isMergeOrTypecheckOnlyEvidence(real)) warnings.push(MERGE_OR_TYPECHECK_ONLY_REAL_WARNING);
   }
   if (!warnings.length) return { targets, warnings, candidates: [] };
   const sources = [input.title, input.evidence ?? '', ...(input.refs ?? [])].join('\n');
@@ -302,6 +360,46 @@ export function setItem(v: string, id: string, patch: { status?: ChecklistStatus
   return setItemGuarded(v, id, patch, by);
 }
 
+/** Remove only the exact machine-authored line; preserve all other evidence bytes and blank lines. */
+export function withoutDispatchSkipLine(evidence: string, line: string | null): string {
+  if (!line) return evidence;
+  if (evidence === line) return '';
+  if (evidence.endsWith(`\n${line}`)) return evidence.slice(0, -line.length - 1);
+  if (evidence.startsWith(`${line}\n`)) return evidence.slice(line.length + 1);
+  return evidence.replace(`\n${line}\n`, '\n');
+}
+
+/** Record one dispatcher refusal on the same title snapshot, without overwriting a person's evidence. */
+export function noteDispatchSkip(v: string, id: string, reason: string, expectedTitle: string, by: string): Checklist {
+  if (!by.trim()) throw new CliUserError('건너뜀 기록 주체가 비었다');
+  const detail = reason.replace(/[\r\n\t]+/g, ' ').trim().slice(0, 300);
+  if (!detail) throw new CliUserError('건너뜀 사유가 비었다');
+  return mutate(v, (data) => {
+    const item = data.items.find((entry) => entry.id === id);
+    if (!item) throw new CliUserError(`없는 칸: ${id}`);
+    if (item.title !== expectedTitle) throw new CliUserError(`칸 제목이 바뀌어 건너뜀 근거를 기록하지 않았다: ${id}`);
+    const marker = createHash('sha256').update(`${v}\0${id}\0${expectedTitle}`).digest('hex').slice(0, 16);
+    const line = `디스패처 건너뜀 [${marker}]: ${detail}`;
+    const prior = item.evidence ?? '';
+    const previous = data.history.filter((entry) => entry.id === id && entry.field === 'dispatch-skip').at(-1)?.to;
+    const oldLine = typeof previous === 'string' ? previous : null;
+    if (oldLine === line && prior.split(/\r?\n/).includes(line)) return false;
+    const priorLines = prior.split('\n');
+    const oldIndex = oldLine ? priorLines.findIndex((entry) => entry.replace(/\r$/, '') === oldLine) : -1;
+    const next = oldIndex >= 0
+      ? priorLines.map((entry, index) => index === oldIndex ? entry.replace(oldLine!, line) : entry).join('\n')
+      : prior ? `${prior}\n${line}` : line;
+    if (next === prior) return false;
+    const at = new Date().toISOString();
+    item.evidence = next;
+    item.updatedAt = at;
+    item.updatedBy = by;
+    change(data, id, 'evidence', prior, next, by, at);
+    change(data, id, 'dispatch-skip', oldLine, line, by, at);
+    return true;
+  });
+}
+
 /** Apply a measured verdict only while the release cell is still the snapshot that was judged. */
 export function setItemIfSnapshot(v: string, id: string, patch: Parameters<typeof setItem>[2], by: string, expected: Pick<ChecklistItem, 'title' | 'status' | 'evidence'>): Checklist {
   return setItemGuarded(v, id, patch, by, expected);

package/src/release-loop/feature-store.ts

@@ -8,7 +8,7 @@ import { CliUserError } from '../cli/cli-user-error.js';
 import { debug } from '../debug/log.js';
 import { getUserConfig } from '../user-config.js';
 import { hqSeenGenerationPath, readHqLease, readSeenGeneration } from '../hq/hq.js';
-import { devVersion, type Checklist, type ChecklistHistory, type ChecklistItem } from './checklist.js';
+import { devVersion, withoutDispatchSkipLine, type Checklist, type ChecklistHistory, type ChecklistItem } from './checklist.js';
 
 export function validateVersion(version: string): void {
   if (!/^\d+\.\d+\.\d+(?:-(?:rc|alpha|beta)\.\d+)?$/.test(version)) throw new CliUserError(`체크리스트 판이 아니다: ${version}`);
@@ -487,7 +487,7 @@ export function move(id: string, from: string, to: string, by: string, released
     return result;
   } finally { db.close(); }
 }
-export function retitle(id: string, title: string, by: string, released = releasedVersion(), dev = devVersion()): void {
+export function retitle(id: string, title: string, by: string, released = releasedVersion(), dev = devVersion(), validate?: (item: ChecklistItem, version: string) => void): void {
   if (!title.trim()) throw new CliUserError('칸 제목이 비었다');
   importLegacyAll();
   const db = open();
@@ -500,10 +500,27 @@ export function retitle(id: string, title: string, by: string, released = releas
       if (!versions.length) throw new CliUserError(`없는 칸: ${id}`);
       const changed = versions.filter((row) => row.title !== title);
       if (!changed.length && old.title === title) return false;
+      // Retitle changes every assignment for this id. Validate every affected
+      // version under the same transaction before the first title write.
+      for (const { version } of changed) {
+        const item = snapshot(db, version, released, dev).items.find((entry) => entry.id === id);
+        if (item) validate?.(item, version);
+      }
       const at = new Date().toISOString();
       db.query('UPDATE features SET title = ? WHERE id = ?').run(title, id);
       db.query('UPDATE assignments SET title_override = NULL WHERE feature_id = ?').run(id);
       for (const { version, title: previousTitle } of changed) {
+        const raw = db.query('SELECT evidence FROM assignments WHERE feature_id = ? AND version = ?').get(id, version) as { evidence: string | null };
+        const last = db.query('SELECT "to" AS value FROM events WHERE feature_id = ? AND version = ? AND field = ? ORDER BY seq DESC LIMIT 1')
+          .get(id, version, 'dispatch-skip') as { value: string | null } | null;
+        const managedLine = last?.value ? JSON.parse(last.value) as string | null : null;
+        const priorEvidence = raw.evidence ?? '';
+        const nextEvidence = withoutDispatchSkipLine(priorEvidence, managedLine);
+        if (nextEvidence !== priorEvidence) {
+          db.query('UPDATE assignments SET evidence = ? WHERE feature_id = ? AND version = ?').run(nextEvidence || null, id, version);
+          record(db, version, { at, by, id, field: 'evidence', from: priorEvidence, to: nextEvidence, released, dev });
+          record(db, version, { at, by, id, field: 'dispatch-skip', from: managedLine, to: null, released, dev });
+        }
         db.query('UPDATE assignments SET updated_at = ?, updated_by = ? WHERE feature_id = ? AND version = ?').run(at, by, id, version);
         record(db, version, { at, by, id, field: 'title', from: previousTitle, to: title, released, dev });
       }

package/src/release-loop/landed-but-yellow.ts

@@ -23,9 +23,64 @@ export function evidencePlan(rows: readonly LandedButYellowRow[]): Array<{ id: s
   }));
 }
 
+interface PrIndex {
+  /** Shape of the list when indexed — a mismatch means the caller changed the array in place. */
+  length: number;
+  firstNumber: number | undefined;
+  lastNumber: number | undefined;
+  /** PR positions per body `칸:` line id — the whole-line label the matcher accepts. */
+  cellIds: Map<string, number[]>;
+  /** PR positions per maximal ASCII-alphanumeric run in the title or body. */
+  runs: Map<string, number[]>;
+}
+
+const ALNUM_RUN = /[A-Za-z0-9]+/g;
+const CELL_LINE = /^[ \t]*칸(?:[ \t]*:[ \t]*|[ \t]+)([A-Za-z0-9_-]+(?:[ \t]*,[ \t]*[A-Za-z0-9_-]+)*)[ \t]*$/;
+const prIndexes = new WeakMap<readonly MergedChecklistPr[], PrIndex>();
+
+function push(map: Map<string, number[]>, key: string, position: number): void {
+  const list = map.get(key);
+  if (!list) map.set(key, [position]);
+  else if (list[list.length - 1] !== position) list.push(position);
+}
+
+/**
+ * Built once per PR list (the open audit reuses one list across every version). Contract: callers treat the list as
+ * read-only after passing it. A cheap guard still re-indexes when the length or the first/last PR number changed;
+ * an in-place edit that keeps all three is not detected.
+ */
+function prIndex(prs: readonly MergedChecklistPr[]): PrIndex {
+  const cached = prIndexes.get(prs);
+  if (cached && cached.length === prs.length && cached.firstNumber === prs[0]?.number && cached.lastNumber === prs[prs.length - 1]?.number) return cached;
+  const index: PrIndex = { length: prs.length, firstNumber: prs[0]?.number, lastNumber: prs[prs.length - 1]?.number, cellIds: new Map(), runs: new Map() };
+  prs.forEach((pr, position) => {
+    const body = pr.body ?? '';
+    for (const line of body.split('\n')) {
+      const match = CELL_LINE.exec(line.endsWith('\r') ? line.slice(0, -1) : line);
+      for (const candidate of match?.[1]?.split(',') ?? []) push(index.cellIds, candidate.trim(), position);
+    }
+    for (const text of [pr.title, body]) for (const [run] of text.matchAll(ALNUM_RUN)) push(index.runs, run, position);
+  });
+  prIndexes.set(prs, index);
+  return index;
+}
+
+/**
+ * PRs that can match `id` at all — a necessary condition, never a verdict. Every non-cell-line basis needs `id`
+ * in the title or body with no ASCII letter/digit on either side, so its leading alphanumeric run appears there
+ * as a maximal run. Ids that do not start with a letter or digit fall back to every PR.
+ */
+function candidatePositions(index: PrIndex, id: string, total: number): number[] {
+  const lead = /^[A-Za-z0-9]+/.exec(id)?.[0];
+  if (!lead) return Array.from({ length: total }, (_, position) => position);
+  const merged = new Set([...(index.cellIds.get(id) ?? []), ...(index.runs.get(lead) ?? [])]);
+  return [...merged].sort((a, b) => a - b);
+}
+
 /** Prefer a dedicated body cell line over title evidence; incidental mentions only qualify for long ids. */
 export function landedButYellow(items: readonly ChecklistItem[], prs: readonly MergedChecklistPr[], { owner }: { owner?: string } = {}): LandedButYellowRow[] {
   const rows: LandedButYellowRow[] = [];
+  const index = prIndex(prs);
   for (const item of items) {
     if (item.status !== 'yellow' && item.status !== 'red') continue;
     if (owner !== undefined && !ownerMatches(item.owner, owner)) continue;
@@ -37,11 +92,10 @@ export function landedButYellow(items: readonly ChecklistItem[], prs: readonly M
       : new RegExp(`^${id}(?:\\s|$)`);
     const explicitTitle = new RegExp(`(?<![A-Za-z0-9])${id}\\s+(?:수확|(?:첫|둘째|셋째)\\s*조각)(?![A-Za-z0-9가-힣])|\\(${id}\\)`);
     const rank: Record<PrMatchBasis, number> = { 'cell-line': 0, 'title-strong': 1, mention: 2 };
-    const matched = prs.flatMap((pr) => {
-      const cellLine = (pr.body ?? '').split('\n').some((line) => {
-        const match = /^[ \t]*칸(?:[ \t]*:[ \t]*|[ \t]+)([A-Za-z0-9_-]+(?:[ \t]*,[ \t]*[A-Za-z0-9_-]+)*)[ \t]*$/.exec(line.endsWith('\r') ? line.slice(0, -1) : line);
-        return match?.[1]?.split(',').some((candidate) => candidate.trim() === item.id) ?? false;
-      });
+    const cellLines = new Set(index.cellIds.get(item.id) ?? []);
+    const matched = candidatePositions(index, item.id, prs.length).flatMap((position) => {
+      const pr = prs[position]!;
+      const cellLine = cellLines.has(position);
       const basis: PrMatchBasis | undefined = cellLine ? 'cell-line'
         : titleStart.test(pr.title) || explicitTitle.test(pr.title) ? 'title-strong'
           : !shortId && (word.test(pr.title) || word.test(pr.body ?? '')) ? 'mention' : undefined;
@@ -58,3 +112,73 @@ export function landedButYellow(items: readonly ChecklistItem[], prs: readonly M
   }
   return rows.sort((a, b) => Number(b.newer) - Number(a.newer));
 }
+
+export interface MergedPrRunResult { status: number | null; stdout: string; stderr: string }
+/** One `gh` invocation; resolves when the process exits. */
+export type MergedPrRunner = (command: string, args: readonly string[], cwd: string) => Promise<MergedPrRunResult>;
+
+export const MERGED_PR_LIMIT = 400;
+/** Concurrent `gh pr list` calls once the first page is full (LANDED-YELLOW-FAST · 10-21 prod: 24 sequential calls ≈ 145s). */
+export const MERGED_PR_CONCURRENCY = 6;
+const DAY_MS = 86_400_000;
+
+/**
+ * Merged PRs since `since` (UTC date). One call answers when it returns fewer than the cap. Otherwise the range
+ * splits into UTC-day windows fetched with a concurrency cap; a full window is halved down to one second as before,
+ * and a full one-second window probes one extra row to tell exactly 400 from truncation.
+ * The returned set and the truncation flag match the former sequential bisection; only call shape and time differ.
+ */
+export async function fetchMergedChecklistPrs(since: string, now: Date, run: MergedPrRunner, cwd: string,
+  { concurrency = MERGED_PR_CONCURRENCY }: { concurrency?: number } = {}): Promise<{ prs: MergedChecklistPr[]; truncated: boolean; calls: number }> {
+  let calls = 0;
+  const fetch = async (lower: string, upper?: string, limit = MERGED_PR_LIMIT): Promise<MergedChecklistPr[]> => {
+    const search = `merged:>=${lower}${upper ? ` merged:<${upper}` : ''}`;
+    calls++;
+    const r = await run('gh', ['pr', 'list', '--state', 'merged', '--search', search, '--limit', String(limit), '--json', 'number,title,body,mergedAt'], cwd);
+    if (r.status !== 0) throw new Error(`병합 PR 조회(gh) 실패 rc=${r.status}: ${(r.stderr || r.stdout).trim().slice(0, 400)}`);
+    const page = JSON.parse(r.stdout.trim()) as MergedChecklistPr[];
+    if (!Array.isArray(page)) throw new Error('병합 PR 조회(gh): 배열이 아니다');
+    return page;
+  };
+  const first = await fetch(since);
+  if (first.length < MERGED_PR_LIMIT) return { prs: first, truncated: false, calls };
+  // Bounded pool: at most `concurrency` gh processes at once; a failure stops new calls and rejects.
+  let active = 0;
+  let failed: unknown;
+  const waiting: Array<() => void> = [];
+  const limited = async <T>(task: () => Promise<T>): Promise<T> => {
+    while (active >= Math.max(1, concurrency) && failed === undefined) await new Promise<void>((resolve) => waiting.push(resolve));
+    if (failed !== undefined) throw failed;
+    active++;
+    try { return await task(); }
+    catch (error) { failed ??= error; throw error; }
+    finally { active--; if (failed !== undefined) for (const wake of waiting.splice(0)) wake(); else waiting.shift()?.(); }
+  };
+  let truncated = false;
+  const visit = async (start: number, end: number): Promise<MergedChecklistPr[]> => {
+    const from = new Date(start).toISOString();
+    const to = new Date(end).toISOString();
+    const page = await limited(() => fetch(from, to));
+    if (page.length < MERGED_PR_LIMIT) return page;
+    if (end - start <= 1000) {
+      // The second-precision search cannot be subdivided; probe one extra row to distinguish exactly 400 from a real truncation.
+      const probe = await limited(() => fetch(from, to, MERGED_PR_LIMIT + 1));
+      if (probe.length > MERGED_PR_LIMIT) truncated = true;
+      return probe.slice(0, MERGED_PR_LIMIT);
+    }
+    const middle = start + Math.floor((end - start) / 2000) * 1000;
+    const [left, right] = await Promise.all([visit(start, middle), visit(middle, end)]);
+    return [...left, ...right];
+  };
+  const lower = Date.parse(`${since}T00:00:00Z`);
+  const upper = Math.max(lower + 1000, Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + 1));
+  const windows: Array<[number, number]> = [];
+  for (let start = lower; start < upper; start += DAY_MS) windows.push([start, Math.min(start + DAY_MS, upper)]);
+  const settled = await Promise.allSettled(windows.map(([start, end]) => visit(start, end)));
+  const rejected = settled.find((result): result is PromiseRejectedResult => result.status === 'rejected');
+  if (rejected) throw failed ?? rejected.reason;
+  // Chronological window order, first occurrence wins — the same de-duplication as before.
+  const unique = new Map<number, MergedChecklistPr>();
+  for (const result of settled) for (const pr of (result as PromiseFulfilledResult<MergedChecklistPr[]>).value) if (!unique.has(pr.number)) unique.set(pr.number, pr);
+  return { prs: [...unique.values()], truncated, calls };
+}

package/src/release-loop/light-rc.ts

@@ -209,6 +209,7 @@ export async function runLightRc(version: string, opts: LightRcOptions = {}, dep
   };
   const captured: Buffer[] = [];
   const rc = await (deps.dispatch ?? dispatchHeavyCheck)({
+    // Keep the self-gate contract: an unavailable remote leaves this release check unmeasured; do not start a heavy gate locally.
     tool: 'self-gate', repo: cwd, installPwa: true, refs: [base], json: true, commit: measuredCommit,
     // The host re-runs this command with --local (and ELANOUS_GATE_REMOTE_CHILD=1), so it never recurses.
     remoteArgv: (sha) => ['bun', 'bin/elanous.mjs', 'release', 'light-rc', '--version', version, '--base', sha(base), '--head', measuredCommit, '--shards', String(shards), ...(opts.fixedShardDistribution ? ['--fixed-shard-distribution'] : []), '--local', '--json', ...(opts.rehearsalTui ? ['--rehearsal-tui'] : [])],

package/src/release-loop/placement.ts

@@ -6,7 +6,7 @@ import { resolveRepositoryName } from '../harness/repository-name.js';
 import { getElanousConfigDirOverride } from '../elanous-config-dir.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { userConfigPath } from '../user-config.js';
-import { addItem, checklistHistory, inspectChecklistTargetPaths, listChecklist, ownerMatches, parseOwner, setItem, validateCeoLoad, type ChecklistItem } from './checklist.js';
+import { addItem, checklistHistory, listChecklist, ownerMatches, parseOwner, setItem, validateCeoLoad, type ChecklistItem } from './checklist.js';
 import { assignedVersions, move, releasedVersion } from './feature-store.js';
 import { debug } from '../debug/log.js';
 import { kstDay, listSchedules, type ReleaseSchedule } from './release-schedule.js';
@@ -455,8 +455,15 @@ export function planPullForward(deps: PullForwardDeps): RebalanceResult {
     else incomplete.add(item.id);
   }
   const targetPathsReady = (title: string): boolean => {
-    const check = inspectChecklistTargetPaths({ title }, { existsAtMain: deps.targetPathExists });
-    return check.targets.length > 0 && check.warnings.length === 0;
+    const lines = title.split(/\r?\n/);
+    const first = /^대상 경로:\s*(.*)$/.exec(lines[0] ?? '');
+    if (!first) return false;
+    // Pull-forward reads existing cells. Preserve its original path token and
+    // second-line 신설: rules; strict authoring has a separate, richer contract.
+    const paths = [...first[1]!.matchAll(/(?:^|[^A-Za-z0-9_.\/-])((?:(?:[A-Za-z0-9_.-]+\/)+)?[A-Za-z0-9_.-]+\.(?:ts|tsx|js|jsx|mjs|cjs|json|md|yaml|yml|sh|py|css|html|toml|sql|rs|swift))(?![A-Za-z0-9_.\/-])/g)]
+      .map((match) => match[1]!).filter((path) => !path.split('/').includes('..'));
+    const legacyNewFile = /^신설:\s*/.test(lines[1] ?? '');
+    return paths.length > 0 && paths.every((path) => deps.targetPathExists(path) || legacyNewFile);
   };
   const candidates = snapshots.get(source.version)!.filter((item) =>
     (item.priority === 'P0' || item.priority === 'P1') && item.status !== 'green' && item.status !== 'done'