elanous 0.2.35 → 0.2.36

package/src/ux-sim/fake-llm.ts

@@ -2,17 +2,114 @@
  * Deterministic, network-free LLM for gate tests without provider credentials.
  * The opt-in is deliberately explicit; production never selects this provider.
  */
+import { appendFileSync } from 'node:fs';
 import type { LLMMessage, LLMOpts, LLMProvider, LLMStreamEvent } from '../llm.js';
 
 export const TEST_FAKE_LLM_ENV = 'ELANOUS_TEST_FAKE_LLM';
 export const TEST_FAKE_LLM_RESPONSE_ENV = 'ELANOUS_TEST_FAKE_LLM_RESPONSE';
+/** TUI-400-AUTOHEAL-FALLBACK — 호출별 결함 스크립트(쉼표 목록 · `400` | `400codex` | `ok`). 예: `400,ok,ok`.
+ *  `400` 칸은 실측 «대화 기록 어긋남» 꼴(`LLM API 400: … No tool call found for function call output …`)을 던진다.
+ *  스크립트가 끝나면 `ok`. 칸 소비는 이 프로세스 안 호출 순서다(라이브 TUI 격리 무대용 — 생산은 이 env 를 안 본다). */
+export const TEST_FAKE_LLM_SCRIPT_ENV = 'ELANOUS_TEST_FAKE_LLM_SCRIPT';
+export const TEST_FAKE_LLM_400_MESSAGE = 'LLM API 400: {"error":{"message":"No tool call found for function call output with call_id call_fake_llm.","type":"invalid_request_error"}}';
+/** TUI-ORPHAN-AUTO-RESUME-STOP — `400codex` 칸: 같은 «고아 도구 출력» 400 을 Codex 공급자 머리(`Codex API 400`)로 던진다.
+ *  seat-autowake 의 종결 판정은 생산 Codex 문면을 문다 — `400` 칸(`LLM API 400`)으로는 그 길이 안 열린다. */
+export const TEST_FAKE_LLM_CODEX_400_MESSAGE = 'Codex API 400: {"error":{"message":"No tool call found for function call output with call_id call_fake_llm.","type":"invalid_request_error"}}';
 
 export function testFakeLlmEnabled(): boolean {
   return process.env[TEST_FAKE_LLM_ENV] === '1';
 }
 
-export function testFakeLlmResponse(): string {
-  return process.env[TEST_FAKE_LLM_RESPONSE_ENV] ?? '[test-fake-llm] OK';
+/** `{step}` in the response becomes the number of user messages (tool results excluded) the model received — a different reply per
+ *  turn of one conversation (TUI-GOAL-INTERIM-QUIET: «every step ends with 아직 못 했다» without same-reply stops). */
+const TEST_FAKE_LLM_STEP_TOKEN = '{step}';
+
+export function testFakeLlmResponse(messages?: readonly LLMMessage[]): string {
+  const text = process.env[TEST_FAKE_LLM_RESPONSE_ENV] ?? '[test-fake-llm] OK';
+  if (!text.includes(TEST_FAKE_LLM_STEP_TOKEN)) return text;
+  // Person/internal-turn text only — a tool result travels as a user-role message and must not count as a step.
+  const step = (messages ?? []).filter((m) => m.role === 'user'
+    && !(Array.isArray(m.content) && m.content.some((block) => block.type === 'tool_result'))).length;
+  return text.split(TEST_FAKE_LLM_STEP_TOKEN).join(String(step));
+}
+
+let scriptCursor = 0;
+/** 커서가 센 스크립트 문자열 — env 가 바뀌면 처음부터 다시 센다(앞 시험의 진행이 뒤 시험으로 새지 않게). */
+let scriptCursorFor: string | undefined;
+
+/** 시험 seam — 스크립트 칸 위치를 처음으로. */
+export function resetTestFakeLlmScript(): void {
+  scriptCursor = 0;
+  scriptCursorFor = undefined;
+}
+
+/** TUI-ORPHAN-AUTO-RESUME-STOP — 마지막 사람 발화가 이 표지를 담으면 스크립트 칸을 안 쓰고 답한다
+ *  («결함이 계속되는 세션에서도 사람 턴은 답을 받는다» 무대 · 칸 수를 호출 수에 맞춰 세지 않게). */
+export const TEST_FAKE_LLM_SCRIPT_SKIP_WHEN_ENV = 'ELANOUS_TEST_FAKE_LLM_SCRIPT_SKIP_WHEN';
+
+/** 다음 호출의 스크립트 칸을 소비한다. 400 칸이면 던진다. */
+function consumeScriptStep(messages: LLMMessage[]): void {
+  const raw = process.env[TEST_FAKE_LLM_SCRIPT_ENV];
+  if (!raw) return;
+  const skipWhen = process.env[TEST_FAKE_LLM_SCRIPT_SKIP_WHEN_ENV];
+  if (skipWhen && (lastHumanText(messages) ?? '').includes(skipWhen)) return;
+  if (raw !== scriptCursorFor) { scriptCursorFor = raw; scriptCursor = 0; }
+  const steps = raw.split(',').map((step) => step.trim()).filter(Boolean);
+  const step = steps[scriptCursor];
+  scriptCursor += 1;
+  if (step === '400') throw new Error(TEST_FAKE_LLM_400_MESSAGE);
+  if (step === '400codex') throw new Error(TEST_FAKE_LLM_CODEX_400_MESSAGE);
+}
+
+/** TUI-SEAT-MEMORY-RECALL — 요청 기록(격리 무대 전용). 경로를 주면 호출마다 받은 메시지(role·문자열 content)를
+ *  JSONL 한 줄로 덧붙인다 — «모델이 실제로 받은 preamble» 을 무대 밖에서 단언하기 위함. 생산은 이 env 를 안 본다. */
+export const TEST_FAKE_LLM_CAPTURE_ENV = 'ELANOUS_TEST_FAKE_LLM_CAPTURE';
+
+function captureRequest(messages: LLMMessage[]): void {
+  const path = process.env[TEST_FAKE_LLM_CAPTURE_ENV];
+  if (!path) return;
+  const rows = messages.map((message) => ({ role: message.role, content: typeof message.content === 'string' ? message.content : null }));
+  appendFileSync(path, `${JSON.stringify({ messages: rows })}\n`);
+}
+
+/** TUI-NEXT-QUEUE-AND-WAKE — `{"when":"<표지>","name":"<도구>","args":{…}}`. 마지막 메시지가 표지를 담은 사람 발화
+ *  (도구 결과 아님)면 텍스트 대신 그 도구 호출 하나를 낸다 — 도구가 실제 턴 루프에서 «불리는» 무대(예: ScheduleWakeup).
+ *  도구 결과 뒤 호출·표지 없는 발화는 고정 응답. JSON 이 틀리면 없는 것과 같다. */
+export const TEST_FAKE_LLM_TOOL_CALL_ENV = 'ELANOUS_TEST_FAKE_LLM_TOOL_CALL';
+/** 응답 전 지연(ms) — «도는 턴»을 사람 손으로 잡을 만큼 길게 만든다(busy 중 입력 무대). */
+export const TEST_FAKE_LLM_DELAY_MS_ENV = 'ELANOUS_TEST_FAKE_LLM_DELAY_MS';
+/** 주면 마지막 사람 발화가 이 표지를 담을 때만 지연한다. */
+export const TEST_FAKE_LLM_DELAY_WHEN_ENV = 'ELANOUS_TEST_FAKE_LLM_DELAY_WHEN';
+
+let toolCallSeq = 0;
+
+/** 마지막 메시지가 사람 발화면 그 글, 도구 결과(또는 사람 아님)면 null. */
+function lastHumanText(messages: LLMMessage[]): string | null {
+  const last = messages.at(-1);
+  if (!last || last.role !== 'user') return null;
+  if (typeof last.content === 'string') return last.content;
+  if (last.content.some((block) => block.type === 'tool_result')) return null;
+  return last.content.map((block) => (block.type === 'text' ? block.text : '')).join('');
+}
+
+function scriptedToolCall(messages: LLMMessage[]): LLMStreamEvent | null {
+  const raw = process.env[TEST_FAKE_LLM_TOOL_CALL_ENV];
+  if (!raw) return null;
+  let spec: { when?: unknown; name?: unknown; args?: unknown };
+  try { spec = JSON.parse(raw) as typeof spec; } catch { return null; }
+  if (typeof spec.when !== 'string' || typeof spec.name !== 'string') return null;
+  const text = lastHumanText(messages);
+  if (text === null || !text.includes(spec.when)) return null;
+  const args = spec.args && typeof spec.args === 'object' ? spec.args as Record<string, unknown> : {};
+  return { type: 'tool_call', id: `call_fake_llm_tool_${++toolCallSeq}`, name: spec.name, args };
+}
+
+async function scriptedDelay(messages: LLMMessage[]): Promise<void> {
+  const ms = Number(process.env[TEST_FAKE_LLM_DELAY_MS_ENV] ?? 0);
+  if (!Number.isFinite(ms) || ms <= 0) return;
+  const when = process.env[TEST_FAKE_LLM_DELAY_WHEN_ENV];
+  if (when && !(lastHumanText(messages) ?? '').includes(when)) return;
+  await new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 /** Shares the real LLMProvider contract; only the external model call is replaced. */
@@ -20,10 +117,18 @@ export const testFakeLlmProvider: LLMProvider = {
   name: 'test-fake-llm',
   defaultModel: 'test-fake-llm',
   available: testFakeLlmEnabled,
-  async *chat(_messages: LLMMessage[], _opts?: LLMOpts): AsyncGenerator<string, void, unknown> {
-    yield testFakeLlmResponse();
+  async *chat(messages: LLMMessage[], _opts?: LLMOpts): AsyncGenerator<string, void, unknown> {
+    captureRequest(messages);
+    consumeScriptStep(messages);
+    await scriptedDelay(messages);
+    yield testFakeLlmResponse(messages);
   },
-  async *streamChat(_messages: LLMMessage[], _opts?: LLMOpts): AsyncGenerator<LLMStreamEvent, void, unknown> {
-    yield { type: 'text', delta: testFakeLlmResponse() };
+  async *streamChat(messages: LLMMessage[], _opts?: LLMOpts): AsyncGenerator<LLMStreamEvent, void, unknown> {
+    captureRequest(messages);
+    consumeScriptStep(messages);
+    await scriptedDelay(messages);
+    const call = scriptedToolCall(messages);
+    if (call) { yield call; return; }
+    yield { type: 'text', delta: testFakeLlmResponse(messages) };
   },
 };

package/src/ux-sim/fault-glm-no-credential.ts

@@ -0,0 +1,116 @@
+// 결함 주입 심 «glm 자식 자격 없음» ── 하니스 자식 공급자를 glm(Z.ai GLM Coding Plan)으로 쐈는데 이 프로세스에
+// Z.ai 자격이 없을 때, 발사 직전 해석(생산 `toSelfImplementOptions`)이 무엇을 내는지 프로세스 안(S1)에서 잰다.
+//
+// 🚨 왜 이것이 있나 (GLM-NO-CREDENTIAL-FALLBACK · OP #28375 · 2026-10-22)
+// run-6c85c69f 부검이 «provider: glm / glm-5.3 · no provider configured» 한 줄로 «자격 결손 → 구현 0» 을 추정했다.
+// 실측(Pod 로그)은 자격이 살아 있었고(Z.ai 200 OK) 그 줄은 배너가 glm 칸을 몰라 찍은 «거짓 표시»였다.
+// 이 심은 두 축을 상주 시험으로 만든다 —
+//   ① 자격이 정말 없을 때: OpenRouter 키 있음 → openrouter/z-ai/glm-5.3 로 바꿔 발사 · 둘 다 없음 → 발사 전 거부
+//   ② 자격이 있을 때: 배너가 «no provider configured» 라고 거짓말하지 않는다
+//
+// ⛔ 흉내 내지 않는다 — 진짜 `toSelfImplementOptions`(dev-pipeline 이 runSelfImplement 직전에 부르는 그 함수) ⊕
+// 진짜 `zaiCodingPlanAvailable`·`getOpenRouterApiKey`(키 캐시 → env) ⊕ 진짜 `oneLineProvider` 를 부른다.
+// 주입은 «자격 env» 하나뿐이다(키 캐시 파일은 ELANOUS_KEEP_ENV_KEYS 로 끄고 기억된 값도 비운다 — 호스트의 진짜 키가 섞이지 않게).
+// 관측 = 결과 선택 · 거부 문면 · self-dev.child-llm 관측 원본 · 배너 한 줄 · 영수증(명령 ⊕ injectionId ⊕ 결과) · 층 L1.
+
+import { randomUUID } from 'node:crypto';
+import { _resetKeyCacheForTests } from '../config.js';
+import { debug } from '../debug/log.js';
+import type { ChildLlmSelection } from '../agent/run-context.js';
+import { planDevPipeline, toSelfImplementOptions } from '../self-dev/dev-pipeline.js';
+import type { SelfImplementSeams } from '../self-implement/orchestrator.js';
+import { inspectActiveProvider, oneLineProvider } from '../provider-summary.js';
+import { getUserConfig, setUserConfigOverlay } from '../user-config.js';
+
+export const GLM_NO_CREDENTIAL_LEVEL = 'L1' as const;
+export const GLM_NO_CREDENTIAL_EVIDENCE_COMMAND = 'bun test src/ux-sim/fault-glm-no-credential.test.ts';
+
+const ISOLATED_KEYS = ['ZAI_API_KEY', 'OPENROUTER_API_KEY'] as const;
+
+export interface GlmNoCredentialScenario {
+  /** Z.ai 자격(env ZAI_API_KEY)을 둔다. */
+  readonly zaiKey: boolean;
+  /** OpenRouter 자격(env OPENROUTER_API_KEY)을 둔다. */
+  readonly openrouterKey: boolean;
+  /** 발사 인자 모델(기본 glm-5.3). */
+  readonly model?: string;
+  readonly injectionId?: string;
+}
+
+export interface GlmNoCredentialObservedRow {
+  readonly category: string;
+  readonly event: string;
+  readonly data: Record<string, unknown>;
+}
+
+export interface GlmNoCredentialObservation {
+  readonly level: typeof GLM_NO_CREDENTIAL_LEVEL;
+  readonly injectionId: string;
+  readonly scenario: { zaiKey: boolean; openrouterKey: boolean; model: string };
+  /** keep = glm 그대로 · fallback = openrouter 로 바꿈 · refused = 발사 전 거부. */
+  readonly result: 'keep' | 'fallback' | 'refused';
+  readonly childLlm: ChildLlmSelection | null;
+  readonly error: string | null;
+  readonly rows: readonly GlmNoCredentialObservedRow[];
+  /** 같은 자격 상태에서 llm.provider=glm 일 때 배너가 찍는 한 줄(자식 PTY 첫 줄과 같은 함수). */
+  readonly banner: string;
+}
+
+export function glmNoCredentialReceipt(observation: Pick<GlmNoCredentialObservation, 'injectionId' | 'result'>): string {
+  return `영수증: ${GLM_NO_CREDENTIAL_EVIDENCE_COMMAND} ⊕ ${observation.injectionId} ⊕ ${observation.result}`;
+}
+
+export function renderGlmNoCredential(observation: GlmNoCredentialObservation): string[] {
+  const { scenario } = observation;
+  return [
+    `glm-no-credential · 층 ${observation.level} · 주입 ${observation.injectionId} · zai=${scenario.zaiKey ? '있음' : '없음'} · openrouter=${scenario.openrouterKey ? '있음' : '없음'} · 결과 ${observation.result}`,
+    observation.childLlm ? `  자식 선택: ${observation.childLlm.provider}/${observation.childLlm.model}` : `  거부: ${observation.error ?? '-'}`,
+    ...observation.rows.map((row) => `  ${row.category} ${row.event} ${JSON.stringify(row.data)}`),
+    `  배너: ${observation.banner}`,
+    glmNoCredentialReceipt(observation),
+  ];
+}
+
+/** 결함 주입 본체 — 생산 `toSelfImplementOptions` 를 그대로 부른다(runSelfImplement 는 부르지 않는다 · 발사 0). */
+export function simGlmNoCredential(scenario: GlmNoCredentialScenario): GlmNoCredentialObservation {
+  const injectionId = scenario.injectionId ?? `inj-${randomUUID()}`;
+  const model = scenario.model ?? 'glm-5.3';
+  const savedEnv: Record<string, string | undefined> = {};
+  for (const key of [...ISOLATED_KEYS, 'ELANOUS_KEEP_ENV_KEYS']) savedEnv[key] = process.env[key];
+  const savedLog = debug.log;
+  const rows: GlmNoCredentialObservedRow[] = [];
+  try {
+    for (const key of ISOLATED_KEYS) delete process.env[key];
+    process.env.ELANOUS_KEEP_ENV_KEYS = '1';
+    _resetKeyCacheForTests();
+    if (scenario.zaiKey) process.env.ZAI_API_KEY = 'fake-zai-test-only';
+    if (scenario.openrouterKey) process.env.OPENROUTER_API_KEY = 'fake-openrouter-test-only';
+    debug.log = ((category: string, event: string, data: Record<string, unknown>): void => {
+      if (category === 'self-dev.child-llm') rows.push({ category, event, data });
+    }) as typeof debug.log;
+    const requested: ChildLlmSelection = { provider: 'glm', model, source: 'flag' };
+    const plan = planDevPipeline({ input: { text: `glm-no-credential ${injectionId}` }, executor: { kind: 'self' }, completion: 'worktree-only', self: { childLlm: requested } });
+    let childLlm: ChildLlmSelection | null = null;
+    let error: string | null = null;
+    try {
+      childLlm = toSelfImplementOptions(plan.input && 'text' in plan.input ? plan.input.text : '', plan, {} as SelfImplementSeams).childLlm ?? null;
+    } catch (caught) {
+      error = caught instanceof Error ? caught.message : String(caught);
+    }
+    setUserConfigOverlay((config) => ({ ...config, llm: { ...config.llm, provider: 'glm', model } }));
+    let banner: string;
+    // 자격이 없으면 생산 해석기가 glm 을 «배선 안 됨» 오류로 던진다 — 그 문면을 그대로 배너 칸에 싣는다(삼키지 않는다).
+    try { banner = oneLineProvider(inspectActiveProvider(getUserConfig())); }
+    catch (caught) { banner = `throw: ${caught instanceof Error ? caught.message : String(caught)}`; }
+    finally { setUserConfigOverlay(null); }
+    const result = error !== null ? 'refused' as const : childLlm?.provider === 'glm' ? 'keep' as const : 'fallback' as const;
+    return { level: GLM_NO_CREDENTIAL_LEVEL, injectionId, scenario: { zaiKey: scenario.zaiKey, openrouterKey: scenario.openrouterKey, model }, result, childLlm, error, rows, banner };
+  } finally {
+    debug.log = savedLog;
+    for (const [key, value] of Object.entries(savedEnv)) {
+      if (value === undefined) delete process.env[key];
+      else process.env[key] = value;
+    }
+    _resetKeyCacheForTests();
+  }
+}

package/src/ux-sim/fault-nextmove-dispatch.ts

@@ -29,6 +29,10 @@ import { createTempGitRemote, type TempGitRemote } from './temp-git-remote.js';
 import { runRepairCycle, type RepairCycleInput, type RepairLaunchRequest } from '../task-agent/repair-cycle.js';
 import { applyRepairBundle, REPAIR_BUNDLE_REF, type RepairCasDeps } from '../task-agent/repair-branch-cas.js';
 import { readTaskCard, writeTaskCards, type TaskCard } from '../task-agent/task-hand.js';
+import { recordTaskAgentShadowMove, RELAUNCH_LAUNCHED_EVENT } from '../task-agent/shadow.js';
+import { installHarnessCliCommand } from '../harness/harness-cli-command.js';
+import type { SupervisorJobResult } from '../self-dev/run-supervisor.js';
+import { Command } from 'commander';
 
 /** 이 심을 재는 증거 명령 — 매뉴얼 §3 과 영수증의 «명령» 칸이 같은 문자열이다. */
 export const FAULT_NEXTMOVE_DISPATCH_COMMAND = 'bun test src/ux-sim/fault-nextmove-dispatch.test.ts';
@@ -166,6 +170,10 @@ export interface FaultNextmoveDispatchObservation {
   readonly ghCalls: number;
   /** 생산 확인 루프가 요청한 지연(ms) — 확인 지연이 «생산 루프를 다 돈 뒤» unconfirmed 가 됐다는 증거. */
   readonly confirmSleeps: readonly number[];
+  /** HARNESS-FULL-GRAPH-NEXTMOVE — 한 수의 id 를 세 원문에서 읽은 값(결정 = next-move 노드 출구 · 간선 · 실제 발사 요청). */
+  readonly moveId: { readonly decision: string | undefined; readonly edge: string | undefined; readonly dispatch: string | undefined;
+    /** NEXTMOVE-GENERAL-RELAUNCH-MOVEID — 회수 틱이 결과 파일과 짝지어 카드 `repair-result` 줄에 실은 값. */
+    readonly consumed: string | undefined };
   /** 두 틱이 낸 알림(심이 받아 적음 · 운영 우편함 0). */
   readonly notified: readonly { seat: string; body: string }[];
   /** 영수증 = 명령 ⊕ injectionId ⊕ 결과. */
@@ -179,10 +187,13 @@ export async function simFaultNextmoveDispatch(): Promise<FaultNextmoveDispatchO
   const firstTick = new Date('2026-10-21T08:00:00.000Z');
   const secondTick = new Date('2026-10-21T08:01:00.000Z');
   const edges: Record<string, unknown>[] = [];
+  const decisions: Record<string, unknown>[] = [];
   const off = debug.registerSink({
     name: `ux-sim-fault-nextmove-dispatch-${injectionId}`,
     emit: (record) => {
       if (record.category === 'self-implement' && record.event === 'graph-edge-taken') edges.push(record.data as Record<string, unknown>);
+      if (record.category === 'self-implement' && record.event === 'pipeline-node-exit'
+        && (record.data as Record<string, unknown> | undefined)?.node === 'next-move') decisions.push(record.data as Record<string, unknown>);
     },
   });
   // ⛔ 생산 기본 notify(`msg post`)·request(detached elanous spawn)에 «절대» 닿지 않게 두 틱 모두 기록용 심을 준다.
@@ -208,9 +219,10 @@ export async function simFaultNextmoveDispatch(): Promise<FaultNextmoveDispatchO
     // 수리 worker 가 끝 JSON ⊕ artifact 를 남겼다(생산 회수 경로가 읽는 꼴 그대로).
     const result = { pr: PR, baseHead: fixture.head, runId: launch.runId, commit: fixture.commit, bundleSha256: fixture.bundleSha256 };
     writeFileSync(join(fixture.artifactDir, 'result.json'), JSON.stringify(result));
+    // 생산 runRepairWorker 는 받은 --move-id 를 결과 파일에 그대로 싣는다(RepairWorkerResult.moveId).
     writeFileSync(launch.resultPath, JSON.stringify({
       pr: PR, head: fixture.head, runId: launch.runId, ok: true, job: JOB,
-      artifactDir: fixture.artifactDir, result,
+      artifactDir: fixture.artifactDir, result, moveId: launch.moveId,
     }));
     // 틱 ② — 결과 회수. 생산 applyRepairBundle 이 exact-head CAS push 에 성공하고
     // PR 머리 확인이 늙은 가짜 gh 머리를 못 따라잡아 unconfirmed 로 돌아온다.
@@ -228,6 +240,14 @@ export async function simFaultNextmoveDispatch(): Promise<FaultNextmoveDispatchO
       reason: second.reason,
     };
     const edgeCount = edges.filter((edge) => edge.from === 'next-move' && edge.to === 'dispatch').length;
+    const asId = (value: unknown): string | undefined => (typeof value === 'string' ? value : undefined);
+    const moveId = {
+      // 발사 요청과 같은 runId 의 결정만 짝짓는다(결정이 여럿이어도 남의 결정과 대조하지 않게).
+      decision: asId(decisions.find((row) => row.runId === launch.runId)?.moveId),
+      edge: asId(edges.find((edge) => edge.from === 'next-move' && edge.to === 'dispatch')?.moveId),
+      dispatch: launch.moveId,
+      consumed: asId(stored?.history.find((entry) => entry.event === 'repair-result' && entry.runId === launch.runId)?.moveId),
+    };
     const remoteHead = fixture.remote.git(fixture.remote.checkout, ['ls-remote', 'origin', `refs/heads/${BRANCH}`]).split('\t')[0] ?? '';
     const ghCalls = fixture.fakeBins.calls().filter((call) => call.name === 'gh').length;
     const receipt = {
@@ -240,6 +260,7 @@ export async function simFaultNextmoveDispatch(): Promise<FaultNextmoveDispatchO
       edge: { count: edgeCount, record: edges.find((edge) => edge.from === 'next-move' && edge.to === 'dispatch'), decision: first.decision },
       unconfirmed,
       remoteHead,
+      moveId,
       repairCommit: fixture.commit,
       ghCalls,
       confirmSleeps: [...fixture.confirmSleeps],
@@ -258,9 +279,89 @@ export function renderFaultNextmoveDispatch(observation: FaultNextmoveDispatchOb
     'fault-nextmove-dispatch · 층 L2 · 생산 runRepairCycle/repairNextMove/applyRepairBundle 직접 호출(GitHub API·네트워크 0)',
     `  receipt: command=${observation.receipt.command} ⊕ injectionId=${observation.receipt.injectionId} ⊕ result=${observation.receipt.result}`,
     `  ① graph-edge-taken: ${JSON.stringify(observation.edge.record ?? {})}`,
+    `  ⓜ moveId: ${renderMoveIds(observation.moveId)}`,
     `  ② unconfirmed: decision=${observation.unconfirmed.decision} · status=${observation.unconfirmed.status ?? '-'} · reason=${observation.unconfirmed.reason}`,
     `  원격 PR 가지 머리: ${observation.remoteHead.slice(0, 12)} · 수리 commit ${observation.repairCommit.slice(0, 12)} · push ${observation.remoteHead === observation.repairCommit ? '됨' : '안 됨'}`,
     `  확인 지연 루프 요청(ms): ${observation.confirmSleeps.join(',') || '-'} · 알림 ${observation.notified.length}건(심이 받음)`,
     `  가짜 gh 심 호출: ${observation.ghCalls}회 · 발사 틱 판정: ${observation.edge.decision}`,
   ];
 }
+
+/** 수 id 네 원문 한 줄 — 넷이 다 같아야 «일치». */
+function renderMoveIds(ids: { decision: string | undefined; edge: string | undefined; dispatch: string | undefined; consumed: string | undefined }): string {
+  const same = ids.decision !== undefined && [ids.edge, ids.dispatch, ids.consumed].every((id) => id === ids.decision);
+  return `decision=${ids.decision ?? '-'} · graph-edge-taken=${ids.edge ?? '-'} · dispatch=${ids.dispatch ?? '-'} · consumed=${ids.consumed ?? '-'} · ${same ? '일치' : '불일치'}`;
+}
+
+// ── NEXTMOVE-GENERAL-RELAUNCH-MOVEID — 일반 재발사(TA terminal → `harness say` 문자열 경로) 한 건 ─────────
+//   생산 recordTaskAgentShadowMove(shadow.ts) → executeNextAction(actions.ts) 를 그대로 돌리고, 실행부가 낸 argv 를
+//   생산 `harness say` CLI 파서(installHarnessCliCommand)에 그대로 먹인다. ⛔ 실제 발사·spawn 0 — command 는 argv 를 적기만 하고,
+//   say 처리기는 문장만 받아 적는다. 카드 상태는 임시 디렉터리 하나에만 쓰고 끝에 지운다.
+
+export const FAULT_NEXTMOVE_GENERAL_COMMAND = 'bun test src/self-dev/graph-nextmove-moveid.test.ts -t "general relaunch device"';
+
+export interface FaultNextmoveGeneralObservation {
+  readonly injectionId: string;
+  readonly executorResult: string | null;
+  /** 실행부가 낸 발사 argv(하나). */
+  readonly argv: readonly string[];
+  /** 결정(next-move 노드 출구) · graph-edge-taken · 발사(harness say 가 받은 값) · 카드 history(relaunch-launched). */
+  readonly moveId: { readonly decision: string | undefined; readonly edge: string | undefined; readonly dispatch: string | undefined; readonly consumed: string | undefined };
+  readonly receipt: { readonly command: string; readonly injectionId: string; readonly result: string };
+}
+
+export async function simFaultNextmoveGeneralRelaunch(): Promise<FaultNextmoveGeneralObservation> {
+  const injectionId = `fng-${randomBytes(6).toString('hex')}`;
+  const root = mkdtempSync(join(tmpdir(), 'ux-sim-nextmove-general-'));
+  const runId = `run-sim-general-${injectionId.slice(4)}`;
+  const statePath = join(root, 'task-agent-actions.json');
+  const card: TaskCard = { id: 'ta-sim-general', text: 'feature ask', seat: 'TC', createdAt: '2026-10-22T08:00:00.000Z',
+    status: 'launched', history: [], runId };
+  writeTaskCards(statePath, [card]);
+  const rows: { category: string; event: string; data: Record<string, unknown> }[] = [];
+  const off = debug.registerSink({ name: `ux-sim-fault-nextmove-general-${injectionId}`, emit: (record) => {
+    if (record.category === 'self-implement' || record.category === 'harness') rows.push({ category: record.category, event: record.event, data: record.data as Record<string, unknown> });
+  } });
+  try {
+    const argvs: string[][] = [];
+    const job = { taskId: 't', feature: 'feature ask', status: 'done' } as SupervisorJobResult;
+    const move = await recordTaskAgentShadowMove({ runId, stopReason: 'no-progress', results: [job] }, {
+      // 빈 env — Pod·카드 힌트 없이 HQ 로컬 런으로 판단한다(운영 env 를 읽지 않는다).
+      env: {} as NodeJS.ProcessEnv, statePath, log: () => {}, liveMoves: new Set(['narrow-relaunch']),
+      loadGate: { loadMax: 2, load1: () => 0.5 },
+      command: async (args) => { argvs.push(args); return { status: 0, stdout: '' }; },
+    });
+    if (argvs.length !== 1) throw new Error(`fault-nextmove-general: 발사 argv ${argvs.length}건(기대 1) · executorResult=${move.executorResult}`);
+    // 발사 받는 쪽 — 생산 harness say 파서에 그 argv 를 그대로(처리기는 문장만 적는다 · 발사 0).
+    const program = new Command().exitOverride();
+    const said: string[][] = [];
+    installHarnessCliCommand(program, { registerSink: async () => {}, resolveSurface: async () => 'harness',
+      say: async (words: string[]) => { said.push(words); } } as never);
+    await program.parseAsync(['node', 'elanous', ...argvs[0]!]);
+    if (said.length !== 1) throw new Error(`fault-nextmove-general: harness say 처리기 호출 ${said.length}건(기대 1)`);
+    const asId = (value: unknown): string | undefined => (typeof value === 'string' ? value : undefined);
+    const stored = readTaskCard(card.id, statePath);
+    const moveId = {
+      decision: asId(rows.find((row) => row.event === 'pipeline-node-exit' && row.data.node === 'next-move' && row.data.runId === runId)?.data.moveId),
+      edge: asId(rows.find((row) => row.event === 'graph-edge-taken' && row.data.from === 'next-move' && row.data.to === 'dispatch')?.data.moveId),
+      dispatch: asId(rows.find((row) => row.category === 'harness' && row.event === 'move-id-received')?.data.moveId),
+      consumed: asId(stored?.history.find((entry) => entry.event === RELAUNCH_LAUNCHED_EVENT && entry.runId === runId)?.moveId),
+    };
+    return {
+      injectionId, executorResult: move.executorResult, argv: argvs[0]!, moveId,
+      receipt: { command: FAULT_NEXTMOVE_GENERAL_COMMAND, injectionId, result: renderMoveIds(moveId) },
+    };
+  } finally {
+    off();
+    rmSync(root, { recursive: true, force: true });
+  }
+}
+
+export function renderFaultNextmoveGeneralRelaunch(observation: FaultNextmoveGeneralObservation): string[] {
+  return [
+    'fault-nextmove-dispatch · 일반 재발사 · 층 L2 · 생산 recordTaskAgentShadowMove/executeNextAction/harness say 파서 직접 호출(발사·spawn 0)',
+    `  receipt: command=${observation.receipt.command} ⊕ injectionId=${observation.receipt.injectionId} ⊕ result=${observation.receipt.result}`,
+    `  실행부 결과: ${observation.executorResult ?? '-'} · argv 꼬리: ${JSON.stringify(observation.argv.slice(-2))}`,
+    `  ⓜ moveId: ${renderMoveIds(observation.moveId)}`,
+  ];
+}

package/src/ux-sim/fault-scope-escape-lift.ts

@@ -10,6 +10,11 @@
 //    ② 원장 줄 pod-child-run ⊕ pod-child-evidence — self-implement-pod.ts 가 쓰는 꼴 그대로 appendRunLedgerEntry
 //    ③ classifyHarnessPodExit → recordHarnessPodStop(부모 stop) → recordClassifiedHarnessPodExit(incident) · harness-cli-command.ts
 //    부모 출력 줄은 formatOrchestrateResultLine(운영 요약 줄) ⊕ extractPodFailureReason(운영 Pod 사유)로 만든다.
+//    ④ 처방 = AUTOHEAL_ACTION_BY_CLASS[stop.class](stop-autoheal.ts 표) — «런 계속(resume-from-salvage)» vs «정지(needs-owner)».
+//
+// 🔀 SCOPE-ESCAPE-AS-REFINE (2026-10-22 · 대표 «범위 밖 허용도 로직으로») — 정지 사유(삭제·보호 경로·상한) 없는 held 편집은
+//    scope-escape 가 아니라 newScope(«구현이 알려준 새 범위»)로 기록된다. 사례 셋:
+//    'scope-escape' = 사유 없는 held(옛 정지 → 이제 계속) · 'scope-stop' = 삭제 사유 held(여전히 정지) · 'implementation-deficit' = held 없음.
 //    kubectl·Pod·네트워크는 없다. 쓰기는 임시 ELANOUS_STATE_DIR 하나에만 가고 끝에 지운다.
 
 import { mkdtempSync, rmSync } from 'node:fs';
@@ -23,8 +28,9 @@ import { classifyHarnessPodExit, recordClassifiedHarnessPodExit, recordHarnessPo
 import { readRunExits } from '../harness/harness-incidents.js';
 import { appendRunLedgerEntry, loadRunLedger, runLedgerDir } from '../self-implement/run-ledger.js';
 import { readRunStopRecord, type RunStopRecord } from '../self-implement/run-stop.js';
+import { AUTOHEAL_ACTION_BY_CLASS, type AutohealAction } from '../self-implement/stop-autoheal.js';
 
-export type ScopeEscapeLiftCase = 'scope-escape' | 'implementation-deficit';
+export type ScopeEscapeLiftCase = 'scope-escape' | 'scope-stop' | 'implementation-deficit';
 
 /** 두 입력이 공유하는 자식 끝 JSON 몸통 — `attachAbandonedClassification` 이 붙이는 분류 꼴 그대로. */
 function childBase(): Record<string, unknown> {
@@ -55,6 +61,11 @@ export function scopeEscapeChildResult(): Record<string, unknown> {
   return { ...childBase(), ...held };
 }
 
+/** 정지 사유가 있는 범위 이탈 — orchestrator decideScopeExpansion 이 삭제를 보고 held 한 끝 JSON(scopeStopReasons 한 칸 더). */
+export function scopeStopChildResult(): Record<string, unknown> {
+  return { ...scopeEscapeChildResult(), scopeStopReasons: ['deletion'] };
+}
+
 /** 구현 결손 — held 편집 없이 같은 분류(implementation-deficit)로 멈춘 끝 JSON. */
 export function implementationDeficitChildResult(): Record<string, unknown> {
   return childBase();
@@ -74,6 +85,10 @@ export interface ScopeEscapeLiftObservation {
   readonly stop: RunStopRecord | undefined;
   /** recordClassifiedHarnessPodExit 가 incidents 에 쓴 한 줄. */
   readonly incident: { reason: string; childEvidence?: PodChildEvidence } | undefined;
+  /** stop class 의 기본 처방(AUTOHEAL_ACTION_BY_CLASS) — needs-owner 면 정지, 아니면 런이 이어진다. */
+  readonly autohealAction: AutohealAction | undefined;
+  /** childEvidence.newScope — «구현이 알려준 새 범위»(정지 사유 없는 범위 밖 편집). */
+  readonly newScope: readonly string[] | undefined;
 }
 
 function withTempState<T>(fn: (root: string) => T): T {
@@ -91,7 +106,8 @@ function withTempState<T>(fn: (root: string) => T): T {
 /** 한 자식 실패를 부모 기록 경로 전체에 흘리고 각 층의 필드를 돌려준다. */
 export function simScopeEscapeLift(
   which: ScopeEscapeLiftCase,
-  childResult: Record<string, unknown> = which === 'scope-escape' ? scopeEscapeChildResult() : implementationDeficitChildResult(),
+  childResult: Record<string, unknown> = which === 'scope-escape' ? scopeEscapeChildResult()
+    : which === 'scope-stop' ? scopeStopChildResult() : implementationDeficitChildResult(),
 ): ScopeEscapeLiftObservation {
   const suffix = randomBytes(4).toString('hex');
   const runId = `run-sim-scope-lift-${suffix}`;
@@ -121,6 +137,7 @@ export function simScopeEscapeLift(
     const ledger = loadRunLedger(runId, dir) ?? [];
     const stopEntry = ledger.find((entry) => entry.event === 'stop');
     const incidentRow = readRunExits(root).find((row) => row.runId === runId);
+    const stop = stopEntry ? readRunStopRecord(stopEntry) : undefined;
     return {
       case: which,
       disposition: {
@@ -130,9 +147,11 @@ export function simScopeEscapeLift(
       childEvidence,
       ledgerChildEvidence: ledger.find((entry) => entry.event === 'pod-child-evidence')?.data.childEvidence,
       parentExitReason: classified.reason,
-      stop: stopEntry ? readRunStopRecord(stopEntry) : undefined,
+      stop,
       incident: incidentRow ? { reason: incidentRow.reason,
         ...(incidentRow.childEvidence ? { childEvidence: incidentRow.childEvidence } : {}) } : undefined,
+      autohealAction: stop ? AUTOHEAL_ACTION_BY_CLASS[stop.class] : undefined,
+      newScope: childEvidence?.newScope,
     };
   });
 }
@@ -140,6 +159,8 @@ export function simScopeEscapeLift(
 export interface ScopeEscapeLiftPair {
   readonly scopeEscape: ScopeEscapeLiftObservation;
   readonly implementationDeficit: ScopeEscapeLiftObservation;
+  /** 정지 사유(삭제) 있는 범위 이탈 — 비교 밖 · 정지가 남아 있음을 같은 화면에 보인다. */
+  readonly scopeStop: ScopeEscapeLiftObservation;
   /** 두 결과가 갈린 칸(고정 순서). */
   readonly differingFields: readonly string[];
   /** 두 결과가 같은 칸(고정 순서). */
@@ -152,23 +173,27 @@ const COMPARED: ReadonlyArray<readonly [string, (o: ScopeEscapeLiftObservation)
   ['childEvidence.classification', (o) => o.childEvidence?.classification],
   ['childEvidence.scopeEscape', (o) => o.childEvidence?.scopeEscape],
   ['childEvidence.outOfScopeEdits', (o) => o.childEvidence?.outOfScopeEdits],
+  ['childEvidence.newScope', (o) => o.childEvidence?.newScope],
   ['childEvidence.detail', (o) => o.childEvidence?.detail],
   ['parentExitReason', (o) => o.parentExitReason],
   ['stop.class', (o) => o.stop?.class],
-  ['stop.cause', (o) => o.stop?.cause],
+  // 무작위 Job 이름 접미는 비교에서 뺀다 — 같은 사유가 Job 이름 때문에 «갈렸다» 고 읽히지 않게.
+  ['stop.cause', (o) => o.stop?.cause.replace(/si-sim-scope-lift-[0-9a-f]+/g, 'si-sim-scope-lift-*')],
   ['incident.reason', (o) => o.incident?.reason],
+  ['autohealAction', (o) => o.autohealAction],
 ];
 
 /** 두 입력을 나란히 흘리고 갈린 칸을 센다. */
 export function simScopeEscapeLiftPair(): ScopeEscapeLiftPair {
   const scopeEscape = simScopeEscapeLift('scope-escape');
   const implementationDeficit = simScopeEscapeLift('implementation-deficit');
+  const scopeStop = simScopeEscapeLift('scope-stop');
   const differingFields: string[] = [];
   const sameFields: string[] = [];
   for (const [name, read] of COMPARED) {
     (JSON.stringify(read(scopeEscape)) === JSON.stringify(read(implementationDeficit)) ? sameFields : differingFields).push(name);
   }
-  return { scopeEscape, implementationDeficit, differingFields, sameFields };
+  return { scopeEscape, implementationDeficit, scopeStop, differingFields, sameFields };
 }
 
 /** CLI·시험 출력 한 화면 — 두 분류 원문을 나란히. */
@@ -176,10 +201,12 @@ export function renderScopeEscapeLift(pair: ScopeEscapeLiftPair): string[] {
   const row = (o: ScopeEscapeLiftObservation): string =>
     `  ${o.case} · classification=${o.childEvidence?.classification ?? '-'} · scopeEscape=${String(o.childEvidence?.scopeEscape ?? '-')}`
     + ` · exit=${o.parentExitReason} · stop=${o.stop?.class ?? '-'} · incident=${o.incident?.reason ?? '-'}`
-    + ` · failureClassification=${o.disposition.failureClassification ?? '-'}`;
+    + ` · failureClassification=${o.disposition.failureClassification ?? '-'}`
+    + ` · newScope=${o.newScope ? JSON.stringify(o.newScope) : '-'} · autoheal=${o.autohealAction ?? '-'}`;
   return [
     'scope-escape-lift · 층 L1 · 운영 함수 직접 호출(kubectl·네트워크 0)',
     row(pair.scopeEscape),
+    row(pair.scopeStop),
     row(pair.implementationDeficit),
     `  다른 칸: ${pair.differingFields.join(', ') || '없음'}`,
     `  같은 칸: ${pair.sameFields.join(', ') || '없음'}`,