elanous 0.2.38 → 0.2.41

package/src/ux-sim/classic-tui-seat-scenarios.ts

@@ -480,19 +480,13 @@ export async function runClassicTuiScenario(spec: ClassicTuiScenarioSpec): Promi
     env[TEST_FAKE_LLM_RESPONSE_ENV] = reply;
     const banner = '↻ 자동 재개(goal-continue)';
     const replies = (s: string) => s.split(reply).length - 1;
-    let settledAt = 0;
     const steps: SeatPtyStep[] = [
       { label: 'human turn', text: '영상 만들어줘', until: (s) => replies(s) >= 1 },
       {
         label: 'continued',
-        until: (s) => {
-          const ok = s.includes(banner) && replies(s) === 2 && turnDone(s.slice(s.lastIndexOf(banner)));
-          if (ok && settledAt === 0) settledAt = Date.now();
-          return ok;
-        },
+        until: (s) => s.includes(banner) && replies(s) === 2 && turnDone(s.slice(s.lastIndexOf(banner))),
         timeoutMs: 60_000,
       },
-      { label: 'no loop', until: (s) => settledAt > 0 && Date.now() >= settledAt + 25_000 && replies(s) === 2, timeoutMs: 40_000 },
     ];
     const run = await mockSeatPtySequence({ ...base, env, steps });
     const last = run.frames.at(-1)?.screen ?? '';

package/src/ux-sim/fake-land-queue.ts

@@ -0,0 +1,88 @@
+/** In-process LAND-QUEUE simulator. Scheduling and verdict logic use the production train functions;
+ * only git's merge-tree/commit-tree and the remote gate are replaced. */
+import { integrateTrain, runTrain, type TrainCandidate, type TrainGit, type TrainVerdict } from '../self-implement/merge-train.js';
+
+export type FakeLandQueueItem = TrainCandidate & { files: string[] };
+export type FakeLandQueueInput = {
+  readonly queue: readonly FakeLandQueueItem[];
+  readonly load: number;
+  readonly previousSlots?: 2 | 3;
+  readonly cutWindowOpen?: boolean;
+  readonly expedite?: number;
+  readonly eject?: readonly number[];
+  readonly conflicting?: readonly number[];
+  readonly gates?: readonly ('pass' | 'fail' | 'unmeasured')[];
+};
+export type FakeLandQueueResult = {
+  readonly slots: 2 | 3;
+  readonly departed: readonly (readonly number[])[];
+  readonly waiting: readonly number[];
+  readonly ejected: readonly number[];
+  readonly stoppedAtCut: boolean;
+  readonly verdicts: readonly TrainVerdict[];
+};
+
+/** Hysteresis prevents slot oscillation: below 60% expand; at/above 80% contract. */
+export function fakeLandSlots(load: number, previous: 2 | 3 = 2): 2 | 3 {
+  if (!Number.isFinite(load) || load < 0 || load > 100) throw new Error('load must be between 0 and 100');
+  if (load < 60) return 3;
+  if (load >= 80) return 2;
+  return previous;
+}
+
+function syntheticGit(conflicting: ReadonlySet<number>, prByHead: ReadonlyMap<string, number>): TrainGit {
+  let commit = 0;
+  const sha = (n: number) => n.toString(16).padStart(40, '0');
+  return (args) => {
+    const command = args.find((arg) => arg === 'merge-tree' || arg === 'commit-tree');
+    if (command === 'merge-tree') {
+      const pr = prByHead.get(args.at(-1) ?? '');
+      return pr !== undefined && conflicting.has(pr)
+        ? { status: 1, stdout: `${sha(900 + (pr ?? 0))}\0src/conflict.ts\0\0`, stderr: '' }
+        : { status: 0, stdout: `${sha(900 + (pr ?? 0))}\0`, stderr: '' };
+    }
+    if (command === 'commit-tree') return { status: 0, stdout: sha(++commit), stderr: '' };
+    return { status: 2, stdout: '', stderr: `unsupported fake git command: ${args[0]}` };
+  };
+}
+
+/** One dry-run tick. Cut-window closure and ejection never call the train; no ref is updated. */
+export async function simulateFakeLandQueue(input: FakeLandQueueInput): Promise<FakeLandQueueResult> {
+  const ejected = new Set(input.eject ?? []);
+  const queue = input.queue.filter((item) => !ejected.has(item.number)).map((item) => ({ ...item, files: [...item.files] }));
+  if (input.expedite !== undefined) {
+    const at = queue.findIndex((item) => item.number === input.expedite);
+    if (at >= 0) queue.unshift(...queue.splice(at, 1));
+  }
+  const slots = fakeLandSlots(input.load, input.previousSlots);
+  if (input.cutWindowOpen === false) return {
+    slots, departed: [], waiting: queue.map((item) => item.number), ejected: [...ejected], stoppedAtCut: true, verdicts: [],
+  };
+
+  const departed: number[][] = [];
+  const waiting: number[] = [];
+  const verdicts: TrainVerdict[] = [];
+  const gates = [...(input.gates ?? [])];
+  const git = syntheticGit(new Set(input.conflicting ?? []), new Map(queue.map((item) => [item.head, item.number])));
+  while (queue.length) {
+    const batch: FakeLandQueueItem[] = [];
+    const occupied = new Set<string>();
+    for (let i = 0; i < queue.length && batch.length < slots;) {
+      const candidate = queue[i]!;
+      if (candidate.files.some((file) => occupied.has(file))) { waiting.push(candidate.number); queue.splice(i, 1); continue; }
+      batch.push(candidate); queue.splice(i, 1); candidate.files.forEach((file) => occupied.add(file));
+    }
+    if (!batch.length) break;
+    departed.push(batch.map((item) => item.number));
+    const train = await runTrain(batch, {
+      integrate: (candidates) => {
+        const integrated = integrateTrain('/fake-land-queue', '1'.repeat(40), candidates, git);
+        return integrated;
+      },
+      gate: async () => gates.shift() ?? 'pass',
+      observe: () => {},
+    });
+    verdicts.push(...train.verdicts);
+  }
+  return { slots, departed, waiting: [...waiting, ...queue.map((item) => item.number)], ejected: [...ejected], stoppedAtCut: false, verdicts };
+}

package/src/ux-sim/fault-needs-human-reason-repair.ts

@@ -0,0 +1,107 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { debug } from '../debug/log.js';
+import { superviseRun, type SupervisorJobResult, type SupervisorStopReason } from '../self-dev/run-supervisor.js';
+
+const CASES = [
+  { reason: 'missing-path', runId: 'run-a4117f90-20261028-0000-4000-8000-000000000001',
+    piece: { taskId: 'missing-path-piece', feature: 'missing path piece', status: 'failed', stage: 'error',
+      targetPaths: ['src/gone.ts'],
+      error: { code: 'ENOENT', message: "ENOENT: no such file or directory, open 'src/gone.ts'" } }, goalText: '없는 경로를 다시 접지한다' },
+  { reason: 'scope-expansion', runId: 'run-b2aa6c1e-20261028-0000-4000-8000-000000000002',
+    piece: { taskId: 'scope-expansion-piece', feature: 'scope expansion piece', status: 'failed', stage: 'error',
+      error: { code: 'SCOPE_OUTSIDE', message: 'changed files outside the goal target paths' },
+      changedFiles: ['src/other/expanded.ts'], targetPaths: ['src/self-dev/run-supervisor.ts'] }, goalText: '범위 확장을 좁힌다' },
+  { reason: 'step-timeout', runId: 'run-c928719f-20261028-0000-4000-8000-000000000003',
+    piece: { taskId: 'step-timeout-piece', feature: 'step timeout piece', status: 'failed', stage: 'timed-out',
+      targetPaths: ['src/self-dev/run-supervisor.ts'],
+      error: { code: 'ETIMEDOUT', message: 'review step exceeded its budget' } }, goalText: '좁은 시험' },
+  { reason: 'no-piece', runId: 'run-d31870a2-20261028-0000-4000-8000-000000000004',
+    piece: { taskId: 'no-piece-piece', feature: 'no piece piece', status: 'failed', stage: 'error',
+      targetPaths: ['src/self-dev/run-supervisor.ts'],
+      error: { code: 'BOOM', message: 'TypeError: undefined is not a function' } }, goalText: '조각 없이 실패했다' },
+] as const;
+
+export interface NeedsHumanReasonRepairSimulationCase {
+  reason: typeof CASES[number]['reason'];
+  runId: string;
+  taskId: string;
+  goalText: string;
+  reruns: number;
+  repairGoal?: string;
+  stopReason?: SupervisorStopReason;
+  why?: string;
+  events: Array<{ event: string; data: Record<string, unknown> }>;
+}
+
+/** Runs the production supervisor with one injected failure per repair reason. */
+export async function simulateNeedsHumanReasonRepair(): Promise<NeedsHumanReasonRepairSimulationCase[]> {
+  const outcomes: NeedsHumanReasonRepairSimulationCase[] = [];
+  const previousStateDir = process.env.ELANOUS_STATE_DIR;
+  process.env.ELANOUS_STATE_DIR = join(process.cwd(), '.elanous-test');
+  let logStore: import('../mss/logging/log-store.js').LogStore | null = null;
+  let logSink: import('../mss/logging/log-store.js').StoreSink | null = null;
+  let unregisterLogSink: (() => void) | null = null;
+  if (process.env.NODE_ENV === 'test') {
+    const storeModule = await import('../mss/logging/log-store.js');
+    logStore = new storeModule.LogStore();
+    logSink = new storeModule.StoreSink(logStore, 'self-dev.supervisor', { installExitHandlers: false });
+    unregisterLogSink = debug.registerSink(logSink);
+  } else {
+    const { registerStandaloneLogSink } = await import('../domains/standalone-log-sink.js');
+    await registerStandaloneLogSink('self-dev.supervisor');
+  }
+  try {
+    for (const fixture of CASES) {
+      const operatorDir = mkdtempSync(join(tmpdir(), 'needs-human-reason-repair-sim-'));
+      const events: NeedsHumanReasonRepairSimulationCase['events'] = [];
+      const decisions: Array<{ action: string; stopReason?: SupervisorStopReason; why: string }> = [];
+      let repairGoal: string | undefined;
+      let reruns = 0;
+      try {
+        await superviseRun({
+          initial: [fixture.piece as unknown as SupervisorJobResult],
+          repairGoalExecution: true,
+          needsHumanReasonRepairExecution: true,
+          runStore: { runId: fixture.runId, operatorDir },
+          rerun: async (_previous, invocation) => {
+            reruns++;
+            repairGoal = invocation.repairGoals?.[fixture.piece.taskId];
+            return [fixture.piece as unknown as SupervisorJobResult];
+          },
+          onDecision: (decision) => decisions.push(decision),
+          observe: (event, data) => {
+            events.push({ event, data });
+            // Mirror the production single-run observer in self-implement-cli.ts.
+            try { debug.log('self-dev.supervisor', event, { ...data, surface: 'single' }); } catch { /* fail-open */ }
+          },
+          sweepPendingMerges: async () => ({ pending: 0, merged: 0 }),
+          taskAgentShadow: false,
+          taskAgentRejudge: false,
+        });
+        const terminal = decisions.at(-1);
+        outcomes.push({
+          reason: fixture.reason,
+          runId: fixture.runId,
+          taskId: fixture.piece.taskId,
+          goalText: fixture.goalText,
+          reruns,
+          ...(repairGoal === undefined ? {} : { repairGoal }),
+          ...(terminal?.stopReason === undefined ? {} : { stopReason: terminal.stopReason }),
+          ...(terminal === undefined ? {} : { why: terminal.why }),
+          events,
+        });
+      } finally {
+        rmSync(operatorDir, { recursive: true, force: true });
+      }
+    }
+  } finally {
+    logSink?.close();
+    unregisterLogSink?.();
+    logStore?.close();
+    if (previousStateDir === undefined) delete process.env.ELANOUS_STATE_DIR;
+    else process.env.ELANOUS_STATE_DIR = previousStateDir;
+  }
+  return outcomes;
+}

package/src/ux-sim/fault-pod-child-result.ts

@@ -0,0 +1,42 @@
+import { classifyPodTerminal } from '../self-dev/draft-residue.js';
+import { podChildEvidenceLedgerRow, type PodTermination } from '../task-orchestrator/surfaces/pod-failure-reason.js';
+
+export interface PodChildResultScenario {
+  firstAttempt: Record<string, unknown>;
+  harvestAttempt: Record<string, unknown>;
+}
+
+/** Replays a successful Kubernetes Job carrying a failed/partial child result. */
+export function podChildResultScenario(): PodChildResultScenario {
+  const podTermination: PodTermination = {
+    job: 'si-task-report-deficit', path: 'result-marker', observedAt: '2026-10-28T09:35:13Z',
+    jobLookup: 'ok', jobUid: 'job-uid-1', jobConditionReason: 'CompletionsReached',
+    activeDeadlineSeconds: 14400, deadlineExceeded: false, podLookup: 'terminated',
+    containerReason: 'Completed', exitCode: 0, finishedAt: '2026-10-28T09:35:13Z', oomKilled: false,
+  };
+  const firstAttempt = podChildEvidenceLedgerRow({
+    job: podTermination.job, childRunId: 'run-first-report-deficit', state: 'complete',
+    result: {
+      stage: 'aborted', ok: false, failureClassification: 'report-deficit',
+      completionDisposition: 'partial', childEvidence: { error: 'report-deficit: missing child result summary' },
+    },
+    noResultDiagnostic: null, noResultLogEvidence: null, podTermination,
+  });
+  const harvestAttempt = classifyPodTerminal({
+    childRunId: 'run-second-harvest', state: 'complete', env: { ELANOUS_HARNESS_SEAT: 'UX' },
+    disposition: { stage: 'pr-opened', ok: true, prNumber: 32614,
+      prUrl: 'https://github.com/ElanvitalAI/elanous/pull/32614', branch: 'self-impl/coord-entrance-fold' },
+    at: '2026-10-28T09:35:29Z',
+  });
+  return { firstAttempt: firstAttempt ?? {}, harvestAttempt };
+}
+
+export function renderPodChildResult(scenario: PodChildResultScenario): string[] {
+  const first = scenario.firstAttempt as { childResult?: Record<string, unknown>; podTermination?: PodTermination };
+  return [
+    `pod-child-result · child completion=${String(first.childResult?.completionDisposition ?? 'unknown')}`,
+    `  first: child=${String(first.childResult?.ok)} · stage=${String(first.childResult?.stage)} · failure=${String(first.childResult?.failureClassification)}`,
+    `  pod: ${String(first.podTermination?.containerReason)} · exit=${String(first.podTermination?.exitCode)} · childRunId=${String(scenario.firstAttempt.childRunId)}`,
+    `  harvest: PR #${String(scenario.harvestAttempt.prNumber)} · ${String(scenario.harvestAttempt.terminalClass)}`,
+  ];
+}

package/src/ux-sim/gate-shard-host-reroute.ts

@@ -0,0 +1,82 @@
+/** S1 device for a release gate's shard dispatch. It replaces host execution, not planning or reduction. */
+import { createHash } from 'node:crypto';
+import {
+  planGateShardDispatch,
+  reduceGateShardReceipts,
+  type GateShardAction,
+  type GateShardDispatchInput,
+  type GateShardReceipt,
+  type GateShardReduction,
+} from '../../scripts/release-loop/gate-shard-dispatch.js';
+
+export interface FakeGateShardHostResult {
+  shardId: string;
+  host: string;
+  status: 'complete' | 'unmeasured';
+  failureIds: string[];
+  errorIds: string[];
+  envKey?: string;
+}
+
+export interface GateShardRerouteScenario {
+  input: GateShardDispatchInput;
+  /** A result is supplied only for an expected host call. An omitted result remains unmeasured. */
+  hostResults: readonly FakeGateShardHostResult[];
+}
+
+export interface FakeGateShardHostCall {
+  shardId: string;
+  host: string;
+  files: string[];
+  head40: string;
+  base40: string;
+}
+
+export interface GateShardRerouteObservation {
+  actions: GateShardAction[];
+  hostCalls: FakeGateShardHostCall[];
+  /** One selected receipt per reused or executed shard; no predecessor fills a failed remeasurement. */
+  receipts: GateShardReceipt[];
+  reduction: GateShardReduction;
+}
+
+/** Stage inputs without making dispatch decisions; the production planner receives them unchanged. */
+export function gateShardRerouteScenario(
+  input: GateShardDispatchInput,
+  hostResults: readonly FakeGateShardHostResult[],
+): GateShardRerouteScenario {
+  return { input, hostResults };
+}
+
+/**
+ * Inject deterministic fake host results into the production planner and reducer. This never starts a gate,
+ * Pod, SSH command, or host sweep. The fake evidence digest is a scenario marker, not an artifact verification;
+ * the caller of the production planner still owns verification before reuse.
+ */
+export function simGateShardHostReroute(scenario: GateShardRerouteScenario): GateShardRerouteObservation {
+  const actions = planGateShardDispatch(scenario.input);
+  const hostCalls: FakeGateShardHostCall[] = [];
+  const receipts: GateShardReceipt[] = [];
+  for (const action of actions) {
+    if (action.kind === 'reuse') {
+      receipts.push(action.receipt);
+      continue;
+    }
+    if (action.kind === 'unmeasured') continue;
+    hostCalls.push({ shardId: action.shardId, host: action.host, files: [...action.files],
+      head40: scenario.input.head40, base40: scenario.input.base40 });
+    const result = scenario.hostResults.find((row) => row.shardId === action.shardId && row.host === action.host);
+    if (!result) continue;
+    const evidence = JSON.stringify({ head40: scenario.input.head40, base40: scenario.input.base40,
+      shardId: action.shardId, host: action.host, files: action.files, result });
+    receipts.push({ id: action.shardId, files: [...action.files], head40: scenario.input.head40, base40: scenario.input.base40,
+      host: action.host, envKey: result.envKey ?? `sim:${action.host}`, status: result.status,
+      failureIds: [...result.failureIds], errorIds: [...result.errorIds],
+      evidencePath: `sim/${action.shardId}-${action.host}.json`,
+      evidenceSha256: createHash('sha256').update(evidence).digest('hex'),
+      measuredAt: '2026-10-27T00:00:00.000Z', attempt: (action.replacing?.attempt ?? 0) + 1 });
+  }
+  const reduction = reduceGateShardReceipts({ head40: scenario.input.head40, base40: scenario.input.base40,
+    shards: scenario.input.shards, receipts });
+  return { actions, hostCalls, receipts, reduction };
+}

package/src/ux-sim/goal-interim-trace.ts

@@ -0,0 +1,24 @@
+/** One injected input trace shared by classic and next goal-interim renderer evidence. */
+export const GOAL_INTERIM_USER_INPUT = '영상 만들어줘';
+export const GOAL_INTERIM_NOT_DONE_REPLY = '[fake-llm] {step}단계 렌더를 진행했습니다.\n남은 작업 {step}단계: 완료 영상 경로는 아직 보고할 수 없습니다 — 아직 못 했습니다.';
+export const GOAL_INTERIM_TOOL_CALL = JSON.stringify({ when: GOAL_INTERIM_USER_INPUT, name: 'ScheduleWakeup', args: { delaySeconds: 3600, reason: '렌더 점검' } });
+
+export const GOAL_INTERIM_RENDER_TRACE = {
+  userInput: GOAL_INTERIM_USER_INPUT,
+  interimReplies: [1, 2].map((step) => GOAL_INTERIM_NOT_DONE_REPLY.replaceAll('{step}', String(step))),
+  finalReply: '완료 영상: /tmp/final.mp4',
+  toolCalls: ['ScheduleWakeup', 'ScheduleWakeup progress', 'ScheduleWakeup progress'],
+} as const;
+
+export function goalInterimRenderMessages(ts: string) {
+  const trace = GOAL_INTERIM_RENDER_TRACE;
+  return [
+    { role: 'user' as const, content: trace.userInput, ts },
+    { role: 'tool' as const, content: '', toolName: trace.toolCalls[0], toolResult: '예약됨', ts },
+    { role: 'tool' as const, content: '', toolName: trace.toolCalls[1], toolResult: '진행', ts },
+    { role: 'assistant' as const, goalInterim: true, content: trace.interimReplies[0], ts },
+    { role: 'tool' as const, content: '', toolName: trace.toolCalls[2], toolResult: '진행', ts },
+    { role: 'assistant' as const, goalInterim: true, content: trace.interimReplies[1], ts },
+    { role: 'assistant' as const, content: trace.finalReply, ts },
+  ];
+}

package/src/ux-sim/next-tui-seat-scenarios.ts

@@ -7,6 +7,8 @@ import { chmodSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from '
 import { join, resolve } from 'node:path';
 import { appendMessage, createSession, getActiveSessionId, loadSession, setActiveSessionId } from '../session/index.js';
 import { mockSeatPtySequence, type SeatPtySequenceEvidence, type SeatPtyStep } from './mock-seat-pty-sequence.js';
+import { GOAL_INTERIM_NOT_DONE_REPLY, GOAL_INTERIM_TOOL_CALL } from './goal-interim-trace.js';
+export { GOAL_INTERIM_NOT_DONE_REPLY, GOAL_INTERIM_TOOL_CALL } from './goal-interim-trace.js';
 import { pasteFoldToken } from '../chat/paste-fold.js';
 import { DEFAULT_GOAL_CONTINUE_CAP } from '../dashboard/input/goal-continue.js';
 import {
@@ -471,29 +473,24 @@ async function runNextProactiveContinueScenario(spec: NextTuiScenarioSpec, root:
 /** TUI-NEXT-QUEUE-AND-WAKE ② — a turn calls ScheduleWakeup(60s); a slow human turn covers the due time
  *  (NotIdle → deferred a minute), then the wakeup opens one internal turn on its own. */
 async function runNextWakeupScenario(spec: NextTuiScenarioSpec, root: string, base: ScenarioBase, reply: string, done: Done): Promise<NextTuiScenarioResult> {
-  let scheduledAt = 0;
   const banner = '↻ 자동 재개(scheduled): 점검';
   const steps: SeatPtyStep[] = [
     {
       label: 'scheduled',
       text: '60초 뒤 예약해줘',
-      until: (s) => {
-        const ok = done(1)(s) && s.includes('⏰ 예약 깨움');
-        if (ok && scheduledAt === 0) scheduledAt = Date.now();
-        return ok;
-      },
+      until: (s) => done(1)(s) && s.includes('⏰ 예약 깨움'),
     },
-    { label: 'before due', until: () => scheduledAt > 0 && Date.now() >= scheduledAt + 45_000, timeoutMs: 60_000 },
-    { label: 'busy over the due time', text: '긴 작업 하나', until: (s) => s.includes('응답 중') },
-    { label: 'long turn done', until: done(2, '긴 작업 하나'), timeoutMs: 60_000 },
-    { label: 'woke', until: (s) => s.includes(banner) && done(3)(s), timeoutMs: 150_000 },
+    { label: 'busy over the due time', text: '긴 작업 하나', until: (s) => s.includes('응답 중'), timeoutMs: 30_000 },
+    { label: 'long turn done', until: done(2, '긴 작업 하나'), timeoutMs: 30_000 },
+    { label: 'woke after one deferral', until: (s) => s.includes(banner) && done(3)(s), timeoutMs: 30_000 },
   ];
   const run = await mockSeatPtySequence({
     ...base,
     env: {
       ...base.env,
+      ELANOUS_TEST_FAST_WAKEUP_CLOCK: '1',
       [TEST_FAKE_LLM_TOOL_CALL_ENV]: JSON.stringify({ when: '예약해줘', name: 'ScheduleWakeup', args: { delaySeconds: 60, reason: '점검' } }),
-      [TEST_FAKE_LLM_DELAY_MS_ENV]: '25000',
+      [TEST_FAKE_LLM_DELAY_MS_ENV]: '5000',
       [TEST_FAKE_LLM_DELAY_WHEN_ENV]: '긴 작업',
     },
     steps,
@@ -737,13 +734,11 @@ async function runNextGoalContinueScenario(spec: NextTuiScenarioSpec, root: stri
 
 /** TUI-GOAL-INTERIM-QUIET — every step ends with «아직 못 했다» (a different reply per turn via `{step}`, so the
  *  same-reply stop does not end it early). The fake reply's honesty sentence, counted on screen. */
-export const GOAL_INTERIM_NOT_DONE_REPLY = '[fake-llm] {step}단계 렌더를 진행했습니다.\n남은 작업 {step}단계: 완료 영상 경로는 아직 보고할 수 없습니다 — 아직 못 했습니다.';
 const GOAL_INTERIM_STEP_MARK = '단계 렌더를 진행했습니다';
 const GOAL_INTERIM_NOT_DONE_MARK = '아직 못 했습니다';
 /** An internal turn drawn as if a person typed it (classic «❯ …» · next «나: …»). */
 /** The first (human) turn also calls one tool, so a folded reply must leave that turn's tool lines on screen.
  *  ScheduleWakeup an hour out: a real registered tool with no approval prompt that never fires inside the run. */
-export const GOAL_INTERIM_TOOL_CALL = JSON.stringify({ when: '영상 만들어줘', name: 'ScheduleWakeup', args: { delaySeconds: 3600, reason: '렌더 점검' } });
 export const INTERNAL_TURN_USER_HEADER = /(?:나:|❯)\s*\[(?:골 이어가기|자동 재개)\]/u;
 
 export interface GoalInterimScreenCounts { steps: number; notDone: number; folded: number; userHeader: boolean }