elanous 0.2.19 → 0.2.21

package/src/self-dev/graph-journey-nodes.ts

@@ -0,0 +1,157 @@
+import { randomUUID } from 'node:crypto';
+import { debug } from '../debug/log.js';
+import { GRAPH_SPECS, GRAPH_TEMPLATES, GRAPH_TEMPLATES_SOURCE, pipelineNodeEntryPayload, templateForGoalType, type GraphTemplate } from '../self-implement/graph-templates.js';
+import type { GoalType } from '../self-implement/goal-author.js';
+
+/** ⭐ HARNESS-FULL-GRAPH (0.2.21 · 대표 10-08) — 하니스 «여정» 전 단계를 그래프 노드로 선언·관측한다.
+ *
+ *  🩸 계기: `내부 문서 `TECH-harness-map-2026-10-06`` 차트의 단계 중 «입구·대기열·발사 관문·배치·Pod 입장·
+ *    이미지 동기화·자격 선갱신·동결 검사·보류·회수·실패 쪽(결과 해석·수확·heal·다음 한 수)»이
+ *    그래프 밖의 «맨 코드»였다. 공개 문서는 「그래프 선언이 모든 걸음을 대조한다」고 말한다 — 거짓이 되지 않게.
+ *
+ *  ⛔ 이 모듈은 «관측»이다(1단계) — 흐름을 바꾸지 않는다. 진입은 기존 노드와 «같은 사건»
+ *    (`self-implement` / `pipeline-node-entry` · 같은 `pipelineNodeEntryPayload`)으로 남겨
+ *    그래프 권위의 declared/undeclared 판정과 원장 질의가 이 노드들을 «같은 자»로 본다.
+ *    출구는 `pipeline-node-exit`(결과 `outcome` 포함)로 남긴다.
+ *  ⛔ fail-soft — 관측이 발사·착지를 죽이지 않는다.
+ *
+ *  🔗 조인(런 id 가 없는 앞단): 입구에서 `ELANOUS_JOURNEY_KEY` 를 한 번 만들어 환경에 싣는다.
+ *    자식 프로세스는 그 값을 물려받고, 오케스트레이터의 모든 파이프라인 관측에도 `journeyKey` 가 실린다.
+ *    ⇒ `journeyKey` 로 「runId 없이 남은 앞단 걸음」과 「runId 가 있는 후반 걸음」을 한 질의로 묶는다.
+ *    대기열을 거친 발사는 부모·자식 프로세스가 다르다 — 그 자리는 `queueLaunchId`(=`ELANOUS_HARNESS_QUEUE_LAUNCH`)가 잇는다.
+ *    설계 = 내부 문서 `RFC-harness-full-journey-as-graph-2026-10-08` §4. */
+
+/** 여정 노드 — ⛔ id 는 원장의 조인 키이자 라이브 그래프 화면(HARNESS-RUN-LIVE-GRAPH)의 키다. 바꾸지 마라. */
+export const JOURNEY_NODE_IDS = [
+  'intake',
+  'queue',
+  'launch-gate',
+  'dispatch',
+  'pool-admit',
+  'image-sync',
+  'credential-refresh',
+  'freeze-check',
+  'hold',
+  'cleanup',
+  'result-parse',
+  'salvage',
+  'heal',
+  'next-move',
+  'stopped',
+] as const;
+export type JourneyNodeId = typeof JOURNEY_NODE_IDS[number];
+
+export const JOURNEY_KEY_ENV = 'ELANOUS_JOURNEY_KEY';
+const QUEUE_LAUNCH_ENV = 'ELANOUS_HARNESS_QUEUE_LAUNCH';
+const RUN_ID_ENV = 'ELANOUS_RUN_ID';
+
+/** 이 여정의 조인 키 — 없으면 만들어 환경에 싣는다(자식이 물려받는다). */
+export function ensureJourneyKey(env: NodeJS.ProcessEnv = process.env): string {
+  const existing = env[JOURNEY_KEY_ENV]?.trim();
+  if (existing) return existing;
+  const key = `jrn-${randomUUID()}`;
+  env[JOURNEY_KEY_ENV] = key;
+  return key;
+}
+
+/** 관측 자리마다 펼치는 조인 칸(있는 것만). */
+export function journeyJoinFields(env: NodeJS.ProcessEnv = process.env): { journeyKey?: string; queueLaunchId?: string } {
+  const journeyKey = env[JOURNEY_KEY_ENV]?.trim();
+  const queueLaunchId = env[QUEUE_LAUNCH_ENV]?.trim();
+  return {
+    ...(journeyKey ? { journeyKey } : {}),
+    ...(queueLaunchId ? { queueLaunchId } : {}),
+  };
+}
+
+/** 여정 노드를 선언한 템플릿 — 골 종류의 템플릿이 그 노드를 선언하면 그것, 아니면 구현 루프. */
+export function journeyTemplate(node: string, goalType?: GoalType | null): GraphTemplate {
+  const own = goalType ? templateForGoalType(goalType) : null;
+  if (own && own.nodes.some((n) => n.nodeId === node)) return own;
+  return GRAPH_TEMPLATES['self-implement'] as GraphTemplate;
+}
+
+export interface JourneyObservation {
+  readonly provenance: string;
+  readonly outcome?: string;
+  readonly runId?: string;
+  readonly goalType?: GoalType | null;
+  readonly data?: Readonly<Record<string, unknown>>;
+}
+
+function emit(entry: boolean, node: JourneyNodeId, o: JourneyObservation): void {
+  try {
+    const template = journeyTemplate(node, o.goalType);
+    const runId = o.runId ?? process.env[RUN_ID_ENV]?.trim();
+    const fields = {
+      node,
+      round: 0,
+      phase: 'journey',
+      provenance: o.provenance,
+      ...(o.outcome === undefined ? {} : { outcome: o.outcome }),
+      ...(runId ? { runId } : {}),
+      ...(o.goalType ? { goalType: o.goalType } : {}),
+      ...journeyJoinFields(),
+      ...o.data,
+      graphTemplatesSource: GRAPH_TEMPLATES_SOURCE,
+    };
+    // ⛔ 진입은 «공용 payload» 를 그 호출 안에서 펼친다 — 우회 가드(graph-templates.ts)가 행 단위로 문다.
+    if (entry) debug.log('self-implement', 'pipeline-node-entry', { ...pipelineNodeEntryPayload(template, node), ...fields });
+    else debug.log('self-implement', 'pipeline-node-exit', { ...pipelineNodeEntryPayload(template, node), ...fields });
+  } catch { /* 관측은 fail-soft */ }
+}
+
+/** 노드 진입. */
+export function enterJourneyNode(node: JourneyNodeId, o: JourneyObservation): void {
+  emit(true, node, o);
+}
+
+/** 노드 출구 — `outcome` 이 그 노드에서 나간 간선의 라벨(YAML `map` 키)이다.
+ *  ⭐ 그 라벨이 선언에서 종결 노드 `stopped` 로 가면 `stopped` 진입도 남긴다 — 거절·포기 런이 «선언된 종결점»에서 끝난다.
+ *  `outcome: 'error'` = 노드 안 작업이 예외를 던졌다(예외는 호출자에게 그대로 간다). */
+export function exitJourneyNode(node: JourneyNodeId, o: JourneyObservation & { readonly outcome: string }): void {
+  emit(false, node, o);
+  if (node !== 'stopped' && journeyEdgeTarget(node, o.outcome) === 'stopped') {
+    const { outcome: _outcome, ...rest } = o;
+    emit(true, 'stopped', { ...rest, provenance: `${node}:${o.outcome}` });
+  }
+}
+
+/** 선언(기준 YAML)에서 `from` 의 `label` 간선이 가는 노드. 없으면 undefined. */
+export function journeyEdgeTarget(from: string, label: string): string | undefined {
+  try {
+    for (const edge of GRAPH_SPECS['self-implement']?.edges ?? []) {
+      if (edge.from === from && edge.map !== undefined && Object.hasOwn(edge.map, label)) return edge.map[label];
+    }
+  } catch { /* 관측 보조 — 실패해도 출구는 이미 남았다 */ }
+  return undefined;
+}
+
+/** 노드 안 작업을 감싼다 — 예외면 출구 `error` 를 남기고 다시 던진다(진입 뒤 출구가 빠지지 않게). */
+export function withJourneyNode<T>(node: JourneyNodeId, o: JourneyObservation, work: () => Promise<T>): Promise<T> {
+  const onError = (error: unknown): void => {
+    exitJourneyNode(node, { ...o, outcome: 'error', data: { ...o.data, error: error instanceof Error ? error.message : String(error) } });
+  };
+  let pending: Promise<T>;
+  try { pending = work(); }
+  catch (error) { onError(error); throw error; }
+  // ⛔ 같은 약속을 «그대로» 돌려준다 — async/await 로 감싸면 마이크로태스크가 늘어 호출자의 순서가 밀린다
+  //   (2판에서 self-implement-pod 시험이 그 차이를 잡았다). 관측은 곁가지(.then)로만 붙인다.
+  pending.then(undefined, onError);
+  return pending;
+}
+
+/** 동기 판. */
+export function withJourneyNodeSync<T>(node: JourneyNodeId, o: JourneyObservation, work: () => T): T {
+  try { return work(); }
+  catch (error) {
+    exitJourneyNode(node, { ...o, outcome: 'error', data: { ...o.data, error: error instanceof Error ? error.message : String(error) } });
+    throw error;
+  }
+}
+
+/** 진입·출구를 한 번에 — 판정만 하는 노드(대기 없는 관문)용. */
+export function passJourneyNode(node: JourneyNodeId, o: JourneyObservation & { readonly outcome: string }): void {
+  enterJourneyNode(node, o);
+  exitJourneyNode(node, o);
+}

package/src/self-dev/graph-journey-route.ts

@@ -0,0 +1,105 @@
+import { debug } from '../debug/log.js';
+import { GRAPH_SPECS } from '../self-implement/graph-templates.js';
+import { applyGraphOverlays, defaultOverlaysDir, loadGraphOverlays, selectOverlays, type GraphOverlaySpec } from '../self-implement/graph-overlay-yaml.js';
+import type { GraphTemplateSpec } from '../self-implement/graph-yaml.js';
+import { journeyJoinFields } from './graph-journey-nodes.js';
+
+/** ⭐ HARNESS-FULL-GRAPH 2판 — 「다음 노드」를 코드가 아니라 «그래프»가 정한다.
+ *
+ *  대표 10-08: *«그래프에 따라 실제 경로가 바뀌어야 한다. 기본은 풀세트, 환경 셋업·운영 방법에 따라 일부만 걷거나 생략.»*
+ *  ⇒ 코드는 «상태 값»(queue=queued|direct · substrate=local|pod · freeze=open|frozen …)만 낸다.
+ *    그 값으로 «어느 간선을 타나»는 YAML 의 `on:`/`map:`(⊕ `stage: launch` 오버레이)이 정한다.
+ *  ⛔ 기본 YAML 은 오늘 코드와 «같은 길»을 낸다 — 시험이 그 동치를 문다(graph-journey-route.test.ts).
+ *  ⛔ 그래프가 답을 못 내면(간선 없음·로드 실패) 코드 기본으로 간다 — 그 사실을 `source: 'code-default'` 로 남긴다.
+ *  🔎 관측: `self-implement` / `graph-edge-taken` { from, on, label, to, source, overlays } */
+
+export interface JourneyRoute {
+  readonly from: string;
+  readonly on: string | null;
+  readonly label: string;
+  /** 그래프가 고른 다음 노드. 못 고르면 null. */
+  readonly to: string | null;
+  readonly source: 'graph' | 'code-default';
+  readonly overlays: readonly string[];
+}
+
+/** ⛔ 캐시하지 않는다 — 여러 런을 처리하는 프로세스(데몬·대기열 tick)가 다음 발사에서 오버레이 변경을 봐야 한다.
+ *  여정 판정은 발사당 몇 번뿐이라 디렉터리 한 번 읽기가 싸다. */
+let overlaysForTesting: readonly GraphOverlaySpec[] | undefined;
+function launchOverlays(): readonly GraphOverlaySpec[] {
+  if (overlaysForTesting !== undefined) return overlaysForTesting;
+  try { return loadGraphOverlays(defaultOverlaysDir()).overlays; }
+  catch { return []; }
+}
+
+/** 시험 전용 — 오버레이 묶음을 고정한다(undefined 면 디스크에서 읽는다). */
+export function setJourneyOverlaysForTesting(overlays: readonly GraphOverlaySpec[] | undefined): void {
+  overlaysForTesting = overlays;
+}
+
+/** 상태 값으로 고른 «이 런의 여정 선언» — 기준 YAML ⊕ 조건이 맞는 launch 오버레이. */
+export function journeySpec(
+  state: Readonly<Record<string, unknown>>,
+  base: GraphTemplateSpec | undefined = GRAPH_SPECS['self-implement'],
+  overlays: readonly GraphOverlaySpec[] = launchOverlays(),
+): { readonly spec: GraphTemplateSpec | undefined; readonly applied: readonly string[] } {
+  if (base === undefined) return { spec: undefined, applied: [] };
+  try {
+    const { applied } = selectOverlays(overlays, { graphId: base.graphId, stage: 'launch', state });
+    if (applied.length === 0) return { spec: base, applied: [] };
+    const result = applyGraphOverlays(base, applied);
+    // ⛔ 거절된 오버레이는 길을 바꾸지 않는다 — 기준 선언으로 간다.
+    return result.ok ? { spec: result.template, applied: result.overlayIds } : { spec: base, applied: [] };
+  } catch {
+    return { spec: base, applied: [] };
+  }
+}
+
+/** `from` 노드에서 `label` 로 나가는 다음 노드를 그래프에서 «읽는다»(기록하지 않는다).
+ *  ⛔ 판독과 기록을 가른다 — 실제로 탄 간선은 전제 검사·실제 단계 경계 «뒤»에 `recordJourneyEdge` 로 남긴다. */
+export function readJourneyEdge(
+  from: string,
+  label: string,
+  state: Readonly<Record<string, unknown>> = {},
+  deps: { readonly base?: GraphTemplateSpec; readonly overlays?: readonly GraphOverlaySpec[] } = {},
+): JourneyRoute {
+  const { spec, applied } = journeySpec(state, deps.base ?? GRAPH_SPECS['self-implement'], deps.overlays ?? launchOverlays());
+  let route: JourneyRoute = { from, on: null, label, to: null, source: 'code-default', overlays: applied };
+  for (const edge of spec?.edges ?? []) {
+    if (edge.from !== from) continue;
+    if (edge.map !== undefined && Object.hasOwn(edge.map, label)) {
+      route = { from, on: edge.on ?? null, label, to: edge.map[label]!, source: 'graph', overlays: applied };
+      break;
+    }
+  }
+  return route;
+}
+
+/** 실제로 탄 간선을 남긴다 — `taken` 은 실제 다음 노드(그래프 답과 다르면 `honored: false` · 그 이유를 `reason` 에). */
+export function recordJourneyEdge(route: JourneyRoute, taken: string, reason?: string): void {
+  try {
+    debug.log('self-implement', 'graph-edge-taken', {
+      graphId: 'self-implement', ...route, taken, honored: route.to === null || route.to === taken,
+      ...(reason === undefined ? {} : { reason }), ...journeyJoinFields(),
+    });
+  } catch { /* 관측은 fail-soft */ }
+}
+
+/** 판독 ⊕ 그 자리에서 기록 — 판독 자리가 곧 실제 단계 경계일 때만 쓴다. */
+export function routeJourneyEdge(
+  from: string,
+  label: string,
+  state: Readonly<Record<string, unknown>> = {},
+  deps: { readonly base?: GraphTemplateSpec; readonly overlays?: readonly GraphOverlaySpec[] } = {},
+): JourneyRoute {
+  const route = readJourneyEdge(from, label, state, deps);
+  recordJourneyEdge(route, route.to ?? label);
+  return route;
+}
+
+/** 입구의 대기열 갈래 — 그래프가 고른 다음 노드로 정한다. 그래프가 답을 못 내면 코드 라벨을 따른다.
+ *  ⛔ `eligible`(자리 있음 · 대기열 자식 아님 · --no-queue 아님)은 그래프가 못 넘는 전제다. */
+export function intakeTakesQueue(label: 'queued' | 'direct', route: Pick<JourneyRoute, 'source' | 'to'>, eligible: boolean): boolean {
+  const graphQueues = route.source === 'graph' ? route.to === 'queue' : label === 'queued';
+  return graphQueues && eligible;
+}

package/src/self-dev/launch-preflight.ts

@@ -538,6 +538,9 @@ export interface LaunchPreflightInput {
   readonly askTargetPaths?: readonly string[];
   /** 대상 경로 라벨이 «있는데» 거부된 조각. 0건 막음 문면이 그 이유를 말하게 한다(판정은 안 바꾼다). */
   readonly askTargetPathRejections?: readonly AskTargetPathHintRejection[];
+  /** AUTO-TARGET: machine-suggested target paths dropped because the goal is NOT-GROUNDED (no persistent evidence).
+   *  Non-empty = the goal is a scope card and must not launch an implementation. */
+  readonly notGroundedDroppedTargetPaths?: readonly string[];
   /** ask 원문 경로. 있으면 ask-outside-path 경고만 이 목록과 최종 대상을 비교한다. */
   readonly askOutsidePathHints?: readonly string[];
   /** 이번에 쏠 골의 브랜치 이름. 없으면 형제 PR 축의 경고를 내지 않는다. */
@@ -559,19 +562,31 @@ function emitAskMarkerObservation(result: LaunchPreflightResult): void {
   emittedAskMarkerObservations.add(result);
 }
 
+/** AUTO-TARGET: blocker name for a NOT-GROUNDED goal whose only target paths were machine-suggested (a scope card). */
+export const NOT_GROUNDED_SCOPE_CARD_BLOCKER = '(NOT-GROUNDED 범위 카드)';
+
 export function evaluateLaunchPreflight(input: LaunchPreflightInput): LaunchPreflightResult {
   const paths = [...new Set(input.paths.filter((path) => path.trim().length > 0))];
   const blockers: LaunchPreflightBlocker[] = [];
   const warnings: LaunchPreflightBlocker[] = [];
 
+  // AUTO-TARGET (10-08 canary · TSC-HEAP): a NOT-GROUNDED goal whose only target paths came from the
+  //   harness candidate search is a scope card — refuse it with that reason, not the generic «no label» text.
+  const notGroundedDropped = input.notGroundedDroppedTargetPaths ?? [];
+  const notGroundedDetail = notGroundedDropped.length > 0
+    ? `골이 NOT-GROUNDED(영속 근거 0)라 하니스 후보 검색이 넣은 대상 경로 ${notGroundedDropped.length}개(${notGroundedDropped.slice(0, 3).join(' · ')}${notGroundedDropped.length > 3 ? ' …' : ''})를 대상으로 쓰지 않는다 — 범위 카드: 구현 발사 대상이 아니다 · ask 첫 줄에 사람이 「대상 경로: <파일>」을 적거나 접지 근거를 복구한 뒤 다시 저작`
+    : undefined;
+  if (notGroundedDetail !== undefined && paths.length > 0) {
+    blockers.push({ kind: 'no-target-paths', name: NOT_GROUNDED_SCOPE_CARD_BLOCKER, detail: notGroundedDetail });
+  }
   // ① 모집단이 0이면 «통과»가 아니라 «막는 사유»다(METHOD v32 를 이 코드에도 적용).
   if (paths.length === 0) {
     blockers.push({
       kind: 'no-target-paths',
-      name: '(대상 경로 0)',
+      name: notGroundedDetail !== undefined ? NOT_GROUNDED_SCOPE_CARD_BLOCKER : '(대상 경로 0)',
       // ⛔ 2026-09-23 — 라벨이 «있는데» 조각이 거부된 경우를 「라벨을 넣어라」로 뭉개면 「거부됐다」를 「없다」로 읽게 된다
       //   (실측: `대상 경로: README.md — 설명…` 한 줄 → has-whitespace 로 통째 거부 · 문면은 「넣어라」뿐이었다).
-      detail: (input.askTargetPathRejections?.length
+      detail: notGroundedDetail !== undefined ? notGroundedDetail : (input.askTargetPathRejections?.length
         ? `대상 경로 라벨은 있는데 조각 ${input.askTargetPathRejections.length}개가 거부됐다: ${input.askTargetPathRejections.slice(0, 3).map((r) => `「${r.fragment.length > 40 ? `${r.fragment.slice(0, 40)}…` : r.fragment}」(${r.reason})`).join(' · ')} — 그 줄에는 «경로만» 둔다(설명은 다음 줄)`
         : '골에서 대상 경로를 하나도 못 뽑았다 — ask 첫 줄에 「대상 경로: <파일> · <파일>」을 넣어라')
         + ' — 이 상태의 「위반 0」은 「검사했다」가 아니다 — elanous self author --inspect-target-paths "<문면>"',
@@ -1192,6 +1207,9 @@ export interface AskPreflightDeps {
   readonly askTargetPaths?: (document: string) => readonly string[];
   /** 대상 경로 라벨 «안»에서 거부된 조각(이유 포함). 0건 막음 문면이 「라벨이 없다」와 「있는데 거부됐다」를 가르게 한다. */
   readonly askTargetPathRejections?: (document: string) => readonly AskTargetPathHintRejection[];
+  /** AUTO-TARGET: true when the authored goal is NOT-GROUNDED with no persistent evidence (a scope card).
+   *  Omitted = this distinction is not made (existing behavior). Production wires `isNotGroundedWithoutPersistentEvidence`. */
+  readonly notGroundedWithoutPersistentEvidence?: (document: string) => boolean;
 }
 
 export interface AskPreflightOptions {
@@ -1212,6 +1230,10 @@ export interface AskPreflightOptions {
   readonly plannedBranch?: string;
   /** 저작 전 ask 원문. 주면 기존 ask-marker-check로 형식을 관측하되 발사를 막지 않는다. */
   readonly askText?: string;
+  /** AUTO-TARGET: target paths the harness put into the ask (candidate search), not the human.
+   *  If the authored goal is NOT-GROUNDED without persistent evidence, these paths are dropped and the
+   *  goal stops before launch (`no-target-paths` blocker naming the reason). */
+  readonly machineSuggestedTargetPaths?: readonly string[];
 }
 
 export type PlannedBranchResolution =
@@ -1539,7 +1561,24 @@ export function decideAskPreflight(
     }
   }
   // ⛔ 저작 전에는 pathsOverride 자체가 ask 대상 힌트다. 저작 뒤에는 골에서 뽑은 대상만 역할로 쓴다.
-  const askTargetPaths = opts.pathsOverride ?? (goalDocument && deps.askTargetPaths ? deps.askTargetPaths(goalDocument) : []);
+  const declaredAskTargetPaths = opts.pathsOverride ?? (goalDocument && deps.askTargetPaths ? deps.askTargetPaths(goalDocument) : []);
+  // AUTO-TARGET: a NOT-GROUNDED goal (no persistent evidence) carries no machine-suggested target path.
+  const machineSuggested = new Set((opts.machineSuggestedTargetPaths ?? []).map((path) => path.trim()).filter(Boolean));
+  let notGroundedGoal = false;
+  if (!opts.pathsOverride && goalDocument !== null && machineSuggested.size > 0 && deps.notGroundedWithoutPersistentEvidence) {
+    try { notGroundedGoal = deps.notGroundedWithoutPersistentEvidence(goalDocument); } catch { notGroundedGoal = false; }
+  }
+  const notGroundedDroppedTargetPaths = notGroundedGoal ? declaredAskTargetPaths.filter((path) => machineSuggested.has(path)) : [];
+  const askTargetPaths = notGroundedDroppedTargetPaths.length > 0
+    ? declaredAskTargetPaths.filter((path) => !machineSuggested.has(path))
+    : declaredAskTargetPaths;
+  if (notGroundedDroppedTargetPaths.length > 0) {
+    try {
+      debug.log('harness.preflight', 'not-grounded-target-paths-dropped', { goalFile: opts.goalFile, dropped: notGroundedDroppedTargetPaths });
+    } catch {
+      // Observation never changes the launch decision.
+    }
+  }
   // 저작 뒤에는 접지가 읽은 경로와 선언 대상 경로를 함께 검사한다. 저작 전 pathsOverride는 그대로 쓴다.
   const paths = opts.pathsOverride ?? [...new Set([...tracedPaths, ...askTargetPaths])];
   const askMarkerInspection = opts.askText === undefined
@@ -1677,6 +1716,7 @@ export function decideAskPreflight(
     ...(goalRulersUnknownReason ? { goalRulersUnknownReason } : {}),
     preexistingFailures,
     ...(askTargetPaths.length > 0 ? { askTargetPaths } : {}),
+    ...(notGroundedDroppedTargetPaths.length > 0 ? { notGroundedDroppedTargetPaths } : {}),
     ...(askTargetPaths.length === 0 && goalDocument && deps.askTargetPathRejections
       ? { askTargetPathRejections: deps.askTargetPathRejections(goalDocument) }
       : {}),

package/src/self-dev/pr-preview.ts

@@ -8,6 +8,8 @@ export interface PreviewOptions {
   scenario?: string;
   /** Main-based combined preview: only existing config paths may be enabled. */
   flags?: readonly string[];
+  /** PR heads to preview together on main when no feature flags exist. */
+  bundlePrs?: readonly number[];
   commentPr?: number;
 }
 export interface PreviewResult {
@@ -35,14 +37,50 @@ export interface PreviewDeps {
   probePwa?: (url: string) => Promise<boolean>;
 }
 
-const SCENARIOS: Record<string, string> = {
-  S2: '/help', S3: '/status', S6: '/now', S7: '/term list', S8: '/model', S9: '/harness',
+const SCENARIOS: Record<string, { input: string; expected: string; matches: (snapshot: string) => boolean }> = {
+  // GOODHART (#24844 review): a group head (`▸ 시작`) or the echoed `/help` is not the list. The /help modal
+  // (help-from-registry.ts) prints one `/name  description` row per command; the «시작» group alone has six.
+  // Pass only when at least three other start-group commands are listed as rows.
+  S2: { input: '/help', expected: 'help command list (/status, /model, /clear ... rows)', matches: (s) =>
+    ['status', 'model', 'clear', 'new', 'resume'].filter((name) => new RegExp(`(?:^|\\s)/${name}(?: \\([^)]*\\))?\\s{2,}\\S`, 'mu').test(s)).length >= 3 },
+  S3: { input: '/status', expected: 'model and connection', matches: (s) => /모델|model/iu.test(s) && /연결|connection/iu.test(s) },
+  S6: { input: '/now', expected: 'current runs or schedules', matches: (s) => /지금|도는 런|스케줄|running|schedule/iu.test(s) },
+  S7: { input: '/term list', expected: 'terminal/PTY list', matches: (s) => /terminal|pty|터미널/iu.test(s) },
+  S8: { input: '/model', expected: 'model choices', matches: (s) => /빠름|보통|깊음|terra|sol|luna|선택/iu.test(s) },
+  S9: { input: '/harness', expected: 'harness usage or stages', matches: (s) => /usage:.*harness|저작|구현|리뷰|착지/iu.test(s) },
 };
 
+/**
+ * Lines of `after` that were not already on `before`'s screen (multiset by line, trailing spaces ignored).
+ * A prefix check is not enough: the PTY re-renders and scrolls, so the previous scenario's answer can
+ * reappear anywhere on the next screen (#24844 review). A repeated line is conservatively treated as old.
+ */
+export function previewFreshLines(before: string, after: string): string {
+  const seen = new Map<string, number>();
+  for (const line of before.split('\n')) {
+    const key = line.trimEnd();
+    if (key) seen.set(key, (seen.get(key) ?? 0) + 1);
+  }
+  return after.split('\n').filter((line) => {
+    const key = line.trimEnd();
+    if (!key) return false;
+    const left = seen.get(key) ?? 0;
+    if (left > 0) { seen.set(key, left - 1); return false; }
+    return true;
+  }).join('\n');
+}
+
+/** Whether a fresh screen region shows the scenario's expected answer (exported for the preview tests). */
+export function previewScenarioMatches(scenario: string, fresh: string): boolean {
+  const entry = Object.hasOwn(SCENARIOS, scenario) ? SCENARIOS[scenario] : undefined;
+  if (!entry) throw new Error(`TUI-COMFORT §4: unsupported scenario ${scenario}`);
+  return entry.matches(fresh);
+}
+
 export function previewScenarioInput(scenario: string): string {
   const text = Object.hasOwn(SCENARIOS, scenario) ? SCENARIOS[scenario] : undefined;
   if (!text) throw new Error(`TUI-COMFORT §4: unsupported scenario ${scenario}; available: ${Object.keys(SCENARIOS).join(', ')}`);
-  return text;
+  return text.input;
 }
 
 const defaultRun: NonNullable<PreviewDeps['run']> = (command, args, cwd, timeoutMs = 120_000) => {
@@ -60,13 +98,18 @@ export async function runPrPreview(options: PreviewOptions, deps: PreviewDeps =
   if (isPr && !Number.isSafeInteger(Number(target))) throw new Error('preview: invalid PR number');
   if (/^\d+$/u.test(target) && !isPr) throw new Error('preview: invalid PR number');
   if (options.commentPr !== undefined && (!Number.isSafeInteger(options.commentPr) || options.commentPr <= 0)) throw new Error('preview: invalid --comment-pr');
+  const bundlePrs = options.bundlePrs ?? [];
+  if (bundlePrs.length && (target !== 'main' || (options.flags?.length ?? 0) > 0)) throw new Error('preview: --bundle-pr requires main without feature flags');
+  if (bundlePrs.length && (new Set(bundlePrs).size !== bundlePrs.length || bundlePrs.some((pr) => !Number.isSafeInteger(pr) || pr <= 0))) throw new Error('preview: invalid or duplicate --bundle-pr');
   if (target === 'main' && options.commentPr === undefined) throw new Error('preview: main ⊕ flags requires --comment-pr <PR number> to publish the result');
   if (isPr && options.commentPr !== undefined && options.commentPr !== Number(target)) throw new Error('preview: --comment-pr must match the target PR');
   const flags = options.flags ?? [];
   if (flags.length && target !== 'main') throw new Error('preview: --flag requires main (main ⊕ feature flags)');
   if (flags.some((flag) => !/^[a-zA-Z][\w-]*(?:\.[a-zA-Z][\w-]*)+$/u.test(flag))) throw new Error('preview: --flag expects an existing dotted config path');
-  const scenario = options.scenario ?? 'S2';
-  const input = previewScenarioInput(scenario);
+  const scenarios = (options.scenario ?? 'S2').split(',').map((id) => id.trim());
+  if (scenarios.length === 0 || new Set(scenarios).size !== scenarios.length) throw new Error('preview: duplicate or empty scenario');
+  for (const id of scenarios) previewScenarioInput(id);
+  const scenario = scenarios.join(',');
   const check = (command: string, args: readonly string[], cwd: string, timeout?: number): string => {
     const r = run(command, args, cwd, timeout);
     if (r.status !== 0) throw new Error(`preview: ${command} ${args.join(' ')} failed: ${(r.stdout + '\n' + r.stderr).slice(-600)}`);
@@ -99,6 +142,16 @@ export async function runPrPreview(options: PreviewOptions, deps: PreviewDeps =
     const pr = JSON.parse(check('gh', ['pr', 'view', String(prNumber), '--json', 'headRefOid,headRefName'], root)) as { headRefOid?: string; headRefName?: string };
     if (pr.headRefName !== target || pr.headRefOid !== head || (branchPrHead !== undefined && branchPrHead !== head)) throw new Error('preview: branch does not match the target PR head; use the PR number');
   }
+  const bundleHeads = bundlePrs.map((number) => {
+    const pr = JSON.parse(check('gh', ['pr', 'view', String(number), '--json', 'number,headRefOid'], root)) as { number?: number; headRefOid?: string };
+    if (pr.number !== number || !/^[0-9a-f]{40}$/iu.test(pr.headRefOid ?? '')) throw new Error(`preview: PR #${number} head is unavailable`);
+    const oid = pr.headRefOid!;
+    if (run('git', ['cat-file', '-e', `${oid}^{commit}`], root).status !== 0) {
+      check('git', ['fetch', '--no-tags', 'origin', `pull/${number}/head`], root, 120_000);
+      if (check('git', ['rev-parse', '--verify', 'FETCH_HEAD^{commit}'], root) !== oid) throw new Error(`preview: PR #${number} head changed while fetching; retry`);
+    }
+    return { number, oid };
+  });
   const directory = (deps.makeDir ?? (() => {
     const previews = join(root, '.elanous-test', 'previews');
     mkdirSync(previews, { recursive: true });
@@ -112,6 +165,11 @@ export async function runPrPreview(options: PreviewOptions, deps: PreviewDeps =
   try {
     check('git', ['worktree', 'add', '--detach', worktree, head], root);
     added = true;
+    for (const { number, oid } of bundleHeads) {
+      const current = JSON.parse(check('gh', ['pr', 'view', String(number), '--json', 'number,headRefOid'], root)) as { number?: number; headRefOid?: string };
+      if (current.number !== number || current.headRefOid !== oid) throw new Error(`preview: PR #${number} head changed while preparing bundle; retry`);
+      check('git', ['-c', 'user.name=elanous-preview', '-c', 'user.email=preview@localhost', 'merge', '--no-ff', '--no-edit', oid], worktree, 120_000);
+    }
     check('bun', ['install', '--frozen-lockfile'], worktree, 300_000);
     check('bun', ['install', '--frozen-lockfile'], join(worktree, 'apps/pwa'), 300_000);
     for (const flag of flags) {
@@ -145,17 +203,27 @@ export async function runPrPreview(options: PreviewOptions, deps: PreviewDeps =
     if (pty.held !== true || !/^pty_[\w-]+$/u.test(pty.ptyId ?? '')) throw new Error('preview: B-1 held TUI did not return a PTY reference');
     heldPty = pty.ptyId;
     const snapshotArgs = ['bin/elanous.mjs', '--test', 'pty', 'snapshot', pty.ptyId!] as const;
-    const before = check('bun', snapshotArgs, worktree);
-    check('bun', ['bin/elanous.mjs', '--test', 'pty', 'text', pty.ptyId!, input, '--enter'], worktree);
-    // A constant sleep misses slow frames under load — poll until the screen answers (≤ 20s).
-    let snapshot = '';
-    for (let attempt = 0; attempt < 20; attempt++) {
-      await wait(1000);
-      snapshot = check('bun', snapshotArgs, worktree);
-      if (snapshot && snapshot !== 'ok' && snapshot !== before) break;
+    const rows: string[] = [];
+    const snapshots: string[] = [];
+    for (const id of scenarios) {
+      const { input, expected, matches } = SCENARIOS[id]!;
+      const before = check('bun', snapshotArgs, worktree);
+      check('bun', ['bin/elanous.mjs', '--test', 'pty', 'text', pty.ptyId!, input, '--enter'], worktree);
+      // A constant sleep misses slow frames under load — poll until this scenario's expected response (≤ 20s).
+      let snapshot = '';
+      let matched = false;
+      for (let attempt = 0; attempt < 20; attempt++) {
+        await wait(1000);
+        snapshot = check('bun', snapshotArgs, worktree);
+        const fresh = previewFreshLines(before, snapshot);
+        matched = snapshot !== 'ok' && snapshot !== before && matches(fresh);
+        if (matched) break;
+      }
+      const observed = snapshot && snapshot !== 'ok' && snapshot !== before;
+      rows.push(`| TUI-COMFORT §4 ${id} | \`${input}\` → ${matched ? `expected ${expected} matched` : `friction: expected ${expected} not found${observed ? '' : ' (no response within 20s)'}`} |`);
+      snapshots.push(`<details><summary>Inner PTY snapshot ${id}</summary>\n\n\`\`\`text\n${snapshot.slice(-3000).replaceAll('```', "'''")}\n\`\`\`\n</details>`);
     }
-    if (!snapshot || snapshot === 'ok' || snapshot === before) throw new Error('preview: inner PTY did not show a response to the scenario input within 20s');
-    report = `| Check | Observation |\n|---|---|\n| head | \`${head}\` |\n| B-1 version | ${version.slice(0, 120)} |\n| P-1 PWA | \`${endpoint}/app/\` served the built PWA |\n| TUI-COMFORT §4 ${scenario} | \`${input}\` → snapshot captured |\n\n<details><summary>Inner PTY snapshot</summary>\n\n\`\`\`text\n${snapshot.slice(-3000).replaceAll('```', "'''")}\n\`\`\`\n</details>`;
+    report = `| Check | Observation |\n|---|---|\n| head | \`${head}\` |${bundleHeads.length ? `\n| bundled PR heads | ${bundleHeads.map(({ number, oid }) => `#${number} \`${oid}\``).join(' ⊕ ')} |` : ''}\n| B-1 version | ${version.slice(0, 120)} |\n| P-1 PWA | \`${endpoint}/app/\` served the built PWA |\n${rows.join('\n')}\n\n${snapshots.join('\n\n')}`;
   } catch (error) {
     report = `| Check | Friction |\n|---|---|\n| head | \`${head}\` |\n| TUI-COMFORT §4 ${scenario} | ${String(error).replaceAll('|', '\\|').slice(0, 700)} |`;
   } finally {
@@ -167,7 +235,7 @@ export async function runPrPreview(options: PreviewOptions, deps: PreviewDeps =
     }
     (deps.dispose ?? ((dir) => rmSync(dir, { recursive: true, force: true })))(directory);
   }
-  const status = report.includes('| Friction |') ? 'friction' : 'passed';
+  const status = report.includes('| Friction |') || report.includes('→ friction:') ? 'friction' : 'passed';
   const body = `## PR preview — ${target} (${status})\n\n${report}`;
   if (prNumber === undefined) throw new Error('preview: cannot comment without a PR number');
   check('gh', ['pr', 'comment', String(prNumber), '--body', body], root);

package/src/self-dev/release-path-guard.ts

@@ -1,6 +1,9 @@
-// Release path = what publishing reads directly: the release scripts and graph, plus the manifest, release notes and cut schedule
-// in `src/release-loop/`. The checklist store (`checklist.ts`, `feature-store.ts`) is shared ops ledger code — the gate catches its regressions (OP 10-03).
-export const RELEASE_PATH_PREFIXES = ['scripts/release-loop/', 'graphs/release/', 'src/release-loop/manifest', 'src/release-loop/release-note', 'src/release-loop/release-schedule'] as const;
+// Release path = release scripts and graph, manifest, notes and cut schedule, plus gate execution modules
+// imported by scripts/release-loop/gate-node.ts (pod-command-job → pod-pool → pod-lease; pod-bun-cache; pod-install-slots; gate-shards).
+// The checklist store (`checklist.ts`, `feature-store.ts`) remains shared ops ledger code (OP 10-03).
+export const RELEASE_PATH_PREFIXES = ['scripts/release-loop/', 'graphs/release/', 'src/release-loop/manifest', 'src/release-loop/release-note', 'src/release-loop/release-schedule',
+  'src/task-orchestrator/surfaces/pod-command-job.ts', 'src/task-orchestrator/surfaces/pod-pool.ts', 'src/task-orchestrator/surfaces/pod-lease.ts',
+  'src/task-orchestrator/surfaces/pod-bun-cache.ts', 'src/task-orchestrator/surfaces/pod-install-slots.ts', 'src/release-loop/gate-shards.ts'] as const;
 export const RELEASE_PATH_LABEL = 'elanous:release-path';
 
 /** Flatten every GitHub PR file page, including the source of a rename. */
@@ -35,7 +38,7 @@ export function releaseGitDiffPaths(output: string): string[] {
 
 /** Evaluate the paths from the opened PR, not the requested goal or local working tree. */
 export function releasePathHold(paths: readonly string[]): string | undefined {
-  return paths.find((path) => RELEASE_PATH_PREFIXES.some((prefix) => path.startsWith(prefix)));
+  return paths.find((path) => RELEASE_PATH_PREFIXES.some((prefix) => prefix.endsWith('.ts') ? path === prefix : path.startsWith(prefix)));
 }
 
 /** Fixed opening of the hold comment — also how a PR held by several merge surfaces (or polls) is recognised, so it is posted once. */