elanous 0.2.34 → 0.2.36

package/src/task-orchestrator/surfaces/self-implement.ts

@@ -30,6 +30,7 @@ import { isAbandonedClassification, type AbandonedClassificationResult } from '.
 import { createExecution, type Task, type TaskExecution } from '../types.js';
 import type { DispatchContext, DispatchResult } from '../surface-registry.js';
 import { nestedPodResult } from './pod-failure-reason.js';
+import { SCOPE_EXPANSION_CAP, SCOPE_STOP_REASONS, isProtectedScopePath, type ScopeStopReason } from '../../self-implement/scope-adjacency.js';
 
 /** Result of one self-implement subprocess. */
 export interface SelfImplementJobDone {
@@ -107,11 +108,52 @@ export interface PodChildEvidence {
   classification?: string;
   scopeEscape?: true;
   outOfScopeEdits?: unknown;
+  /** SCOPE-ESCAPE-AS-REFINE — why held out-of-scope edits stop the run (deletion · protected path · cap). Present only with scopeEscape. */
+  scopeStopReasons?: ScopeStopReason[];
+  /** SCOPE-ESCAPE-AS-REFINE — «구현이 알려준 새 범위», not a failure: held names with no stop reason, or (no held names)
+   *  the accepted `scopeExpansion` paths of a child that failed later (e.g. gate). Evidence is built only for failed results. */
+  newScope?: string[];
   abandonedClassification?: Record<string, unknown>;
   supervisorVerdict?: unknown;
   goalCauseObserved?: true;
   terminationReason?: unknown;
   accountAvailability?: Record<string, unknown>;
+  prFailure?: {
+    stage: 'pr-open-failed';
+    source?: 'child-ledger' | 'terminal-result';
+    errorTail: string;
+    blockingPrNumber?: number;
+    candidateCardId?: string;
+    blockingCardId?: string;
+  };
+}
+
+const SCOPE_STOP_REASON_ORDER: readonly ScopeStopReason[] = SCOPE_STOP_REASONS;
+
+/** Stop reasons for held out-of-scope edits: the child's own `scopeStopReasons` (orchestrator decideScopeExpansion) plus
+ *  what the names alone prove (protected path · count over SCOPE_EXPANSION_CAP · incomplete name list). A deletion is
+ *  only known from the child. Deterministic, fixed order. */
+export function scopeStopReasonsFromResult(o: Record<string, unknown>, outOfScopeEdits: unknown = o.outOfScopeEdits): ScopeStopReason[] {
+  const reasons = new Set<ScopeStopReason>();
+  if (Array.isArray(o.scopeStopReasons)) {
+    for (const reason of o.scopeStopReasons) if ((SCOPE_STOP_REASON_ORDER as readonly unknown[]).includes(reason)) reasons.add(reason as ScopeStopReason);
+  }
+  const names = Array.isArray(outOfScopeEdits) ? outOfScopeEdits.filter((name): name is string => typeof name === 'string') : [];
+  if (names.some(isProtectedScopePath)) reasons.add('protected-path');
+  const count = typeof o.outsideCount === 'number' ? Math.max(o.outsideCount, names.length) : names.length;
+  if (count > SCOPE_EXPANSION_CAP) reasons.add('over-cap');
+  if (o.nameCapReached === true) reasons.add('name-cap');
+  return SCOPE_STOP_REASON_ORDER.filter((reason) => reasons.has(reason));
+}
+
+/** «구현이 알려준 새 범위» — held names with no stop reason, else the accepted expansion's paths. */
+function newScopeFromResult(outOfScopeEdits: unknown, scopeExpansion: unknown): string[] | undefined {
+  const names = Array.isArray(outOfScopeEdits) ? outOfScopeEdits.filter((name): name is string => typeof name === 'string' && name.length > 0) : [];
+  if (names.length) return names.slice(0, 40);
+  const files = scopeExpansion && typeof scopeExpansion === 'object' ? (scopeExpansion as { files?: unknown }).files : undefined;
+  const paths = Array.isArray(files) ? files.map((file) => (file && typeof file === 'object' ? (file as { path?: unknown }).path : undefined))
+    .filter((path): path is string => typeof path === 'string' && path.length > 0) : [];
+  return paths.length ? paths.slice(0, 40).map((path) => redactSecretText(path)) : undefined;
 }
 
 /** Preserve only named terminal facts; the full child detail may contain logs or credentials. */
@@ -138,8 +180,13 @@ export function podChildEvidenceFromResult(o: Record<string, unknown>): PodChild
   const failureExitCode = o.ok === false && typeof o.exitCode === 'number'
     && Number.isInteger(o.exitCode) && o.exitCode >= 0 && o.exitCode <= 255 ? o.exitCode : undefined;
   const outOfScopeEdits = scrubValue(o.outOfScopeEdits);
-  const scopeEscape = (Array.isArray(outOfScopeEdits) && outOfScopeEdits.length > 0)
+  const held = (Array.isArray(outOfScopeEdits) && outOfScopeEdits.length > 0)
     || (typeof o.detail === 'string' && /^Out-of-scope edits held in the worktree(?:[.;]|$)/i.test(o.detail.trim()));
+  // SCOPE-ESCAPE-AS-REFINE (대표 10-22 «범위 밖 허용도 로직으로») — held edits stop the run only for a deletion, a protected
+  //   path, or a cap; otherwise they are the new scope the implementation found and the exit is classified as if unheld.
+  const scopeStopReasons = held ? scopeStopReasonsFromResult(o, outOfScopeEdits) : [];
+  const scopeEscape = held && scopeStopReasons.length > 0;
+  const newScope = scopeEscape ? undefined : newScopeFromResult(outOfScopeEdits, o.scopeExpansion);
   const classification = scopeEscape ? 'scope-escape'
     : typeof abandoned?.classification === 'string' ? redactSecretText(abandoned.classification)
       : typeof o.failureClassification === 'string' ? redactSecretText(o.failureClassification) : undefined;
@@ -149,14 +196,30 @@ export function podChildEvidenceFromResult(o: Record<string, unknown>): PodChild
     ...(failedText(o.stderr) ? { stderr: failedText(o.stderr) } : {}),
     ...(failureExitCode !== undefined ? { exitCode: failureExitCode } : {}),
     ...(classification ? { classification } : {}),
-    ...(scopeEscape ? { scopeEscape: true } : {}),
+    ...(scopeEscape ? { scopeEscape: true, scopeStopReasons } : {}),
     ...(outOfScopeEdits !== undefined ? { outOfScopeEdits } : {}),
+    ...(newScope ? { newScope } : {}),
     ...(abandoned ? { abandonedClassification: abandoned } : {}),
     ...(o.supervisorVerdict !== undefined ? { supervisorVerdict: scrubValue(o.supervisorVerdict) } : {}),
     ...(o.goalCauseObserved === true ? { goalCauseObserved: true } : {}),
     ...(o.terminationReason !== undefined ? { terminationReason: scrubValue(o.terminationReason) } : {}),
     ...(accountAvailability ? { accountAvailability } : {}),
   };
+  if (o.ok === false && typeof o.error === 'string'
+    && /draft PR 생성 실패|PR (?:gh|guard) 실패|same-cell reuse:/u.test(o.error)) {
+    const safe = redactSecretText(o.error).replace(/\/home\/[^/\s]+\//gu, '~/');
+    const blocker = /(?:blockers=|blockingPr=)\s*#?(\d+)(?::([A-Za-z0-9_-]{1,128}))?/u.exec(safe);
+    const number = blocker ? Number(blocker[1]) : null;
+    const candidate = /candidateCardId=([A-Za-z0-9_-]{1,128})/u.exec(safe)?.[1];
+    const card = blocker?.[2];
+    evidence.prFailure = {
+      stage: 'pr-open-failed',
+      errorTail: (safe.split(/\r\n|\n|\r/u).filter(Boolean).at(-1) ?? safe).slice(-240),
+      ...(number && Number.isSafeInteger(number) ? { blockingPrNumber: number } : {}),
+      ...(candidate && candidate !== 'unknown' ? { candidateCardId: candidate } : {}),
+      ...(card && card !== 'unknown' ? { blockingCardId: card } : {}),
+    };
+  }
   return Object.keys(evidence).length ? evidence : undefined;
 }
 

package/src/tool-runtime/index.ts

@@ -73,11 +73,18 @@ import { bootstrapMcpProxyRuntimes } from './mcp-proxy-bootstrap.js';
 import { SELF_COGNITION_RUNTIMES } from './self-cognition-runtimes.js';
 import { ELANOUS_CONTROL_RUNTIMES } from './elanous-control-runtimes.js';
 
+export interface RegisterAllDefaultToolRuntimesOpts {
+  /** CLASSIC-IDLE-MCP-LAZY — classic TUI 만 켠다. 외부 MCP 프록시를 «첫 도구
+   *  호출» 때 띄우고, 그 전엔 지난 부팅의 툴 인덱스로 목록만 알린다.
+   *  데몬·`mcp serve` 는 기본값(즉시 기동) 그대로다. */
+  mcpLazyBoot?: boolean;
+}
+
 /** Register every built-in runtime. Idempotent — safe to call more
  *  than once (registry dedupe). Call from the dashboard boot path;
  *  skills pick up registrations via side-effect when this module
  *  gets imported. */
-export function registerAllDefaultToolRuntimes(): void {
+export function registerAllDefaultToolRuntimes(opts: RegisterAllDefaultToolRuntimesOpts = {}): void {
   for (const rt of PTY_RUNTIMES) registerToolRuntime(rt);
   registerToolRuntime(terminalInjectRuntime);
   registerToolRuntime(bashRuntime);
@@ -170,7 +177,13 @@ export function registerAllDefaultToolRuntimes(): void {
   // External MCP proxies already declare surfaces `['mcp','tui']`, but the
   // TUI process never registered them. Fire-and-forget: handshake must not
   // block TUI startup; failures stay queryable via diagnostics.
-  bootstrapMcpProxyRuntimes();
+  // CLASSIC-IDLE-MCP-LAZY: classic TUI 는 지연 기동 — 자식 둘(약 267MB)을
+  // 기동 때 상주시키지 않고, 첫 도구 호출 때 한 번 띄운다.
+  if (opts.mcpLazyBoot === true) {
+    bootstrapMcpProxyRuntimes({ lazy: true });
+  } else {
+    bootstrapMcpProxyRuntimes();
+  }
 }
 
 export { setTerminalInjectApprover } from './terminal-inject-runtime.js';

package/src/tool-runtime/mcp-proxy-bootstrap.ts

@@ -51,6 +51,10 @@ export interface BootstrapMcpProxyRuntimesOpts {
   registerRuntime?: typeof registerToolRuntime;
   logger?: McpBootLogger;
   handshakeTimeoutMs?: number;
+  /** CLASSIC-IDLE-MCP-LAZY — classic TUI 만 켠다. MCP 자식을 «첫 도구 호출»
+   *  때 띄우고, 그 전엔 지난 부팅의 툴 인덱스로 목록만 알린다. */
+  lazy?: boolean;
+  toolIndexStore?: RegisterMcpClientsOpts['toolIndexStore'];
 }
 
 const IDLE: McpProxyBootstrapSnapshot = {
@@ -62,6 +66,8 @@ const IDLE: McpProxyBootstrapSnapshot = {
 
 let testOpts: BootstrapMcpProxyRuntimesOpts | null = null;
 let activeHandle: McpProxyBootstrapHandle | undefined;
+let activeClients: McpClientsHandle | undefined;
+let exitHookInstalled = false;
 let lastSnapshot: McpProxyBootstrapSnapshot = IDLE;
 let bootGeneration = 0;
 
@@ -75,6 +81,7 @@ export function setMcpProxyBootstrapOptsForTest(opts: BootstrapMcpProxyRuntimesO
 export function _resetMcpProxyBootstrapForTest(): void {
   bootGeneration += 1;
   activeHandle = undefined;
+  activeClients = undefined;
   lastSnapshot = IDLE;
 }
 
@@ -86,6 +93,24 @@ export function getMcpProxyBootstrapHandle(): McpProxyBootstrapHandle | undefine
   return activeHandle;
 }
 
+/** 프로세스가 «그냥» 죽는 경로(exit 훅)에서도 MCP 자식이 고아로 남지 않게 마지막
+ *  SIGTERM 을 건다. `process.on('exit')` 은 await 할 수 없으므로 동기 kill 만 쓴다. */
+function installMcpExitHook(): void {
+  if (exitHookInstalled) return;
+  exitHookInstalled = true;
+  process.once('exit', () => {
+    const clients = activeClients;
+    activeClients = undefined;
+    if (!clients) return;
+    try {
+      const terminated = clients.terminateChildrenSync?.() ?? 0;
+      if (terminated > 0) log('exit-terminate', { terminated });
+    } catch {
+      /* dying process — never throw from an exit hook */
+    }
+  });
+}
+
 function observabilityBootLogger(): McpBootLogger {
   return {
     info: (line) => {
@@ -183,11 +208,15 @@ export function bootstrapMcpProxyRuntimes(
         ...(resolved.handshakeTimeoutMs !== undefined
           ? { handshakeTimeoutMs: resolved.handshakeTimeoutMs }
           : {}),
+        ...(resolved.lazy === true ? { lazy: true } : {}),
+        ...(resolved.toolIndexStore ? { toolIndexStore: resolved.toolIndexStore } : {}),
       });
       if (generation !== bootGeneration) {
         try { await result.shutdown(); } catch { /* abandoned boot */ }
         return current;
       }
+      activeClients = result;
+      installMcpExitHook();
       const snap = freezeSnapshot({
         status: 'ready',
         registered: result.registered,

package/src/tool-runtime/ops-ledger-runtimes.ts

@@ -1,8 +1,8 @@
 // ── Ops-ledger tool runtimes (우편 msg · 판 release checklist) ──
 //
-// Registers the eight in-process ledger tools with the tool-runtime
+// Registers the nine in-process ledger tools with the tool-runtime
 // layer so every surface (skill-runner, TUI) can call them by name:
-// MsgList / MsgPost / MsgAck and ChecklistList / ChecklistAdd /
+// MsgList / MsgPost / MsgAsk / MsgAck and ChecklistList / ChecklistAdd /
 // ChecklistSet / ChecklistEdit / ChecklistMove. Dispatchers live in
 // src/skills/tools/ops-ledger.ts; this file is a thin adapter — the
 // same pattern as team-tool-runtimes.ts. Every call goes through
@@ -23,6 +23,7 @@ import {
   observeLedgerCall,
 } from '../skills/tools/ops-ledger.js';
 import type { ToolRuntime } from './types.js';
+import { buildMsgAskTool, dispatchMsgAsk, type MsgAskResult } from '../skills/tools/msg-ask.js';
 
 export const msgListRuntime: ToolRuntime<Record<string, unknown>, MsgListResult> = {
   id: 'msg_list',
@@ -36,6 +37,12 @@ export const msgPostRuntime: ToolRuntime<Record<string, unknown>, MsgPostResult>
   async run(req) { return observeLedgerCall('MsgPost', req, () => dispatchMsgPost(req), (a, r) => ({ from: a.from, to: a.to, ...(r ? { id: r.message.id } : {}) })); },
 };
 
+export const msgAskRuntime: ToolRuntime<Record<string, unknown>, MsgAskResult> = {
+  id: 'msg_ask',
+  spec: buildMsgAskTool(),
+  async run(req, ctx) { return observeLedgerCall('MsgAsk', req, () => dispatchMsgAsk(req, { signal: ctx.signal }), (a, r) => ({ from: a.from, to: a.to, ...(r ? { id: r.question.id, replied: r.reply !== null } : {}) })); },
+};
+
 export const msgAckRuntime: ToolRuntime<Record<string, unknown>, MsgAckResult> = {
   id: 'msg_ack',
   spec: buildMsgAckTool(),
@@ -75,6 +82,7 @@ export const checklistMoveRuntime: ToolRuntime<Record<string, unknown>, Checklis
 export const ALL_OPS_LEDGER_RUNTIMES: ToolRuntime<any, any>[] = [
   msgListRuntime,
   msgPostRuntime,
+  msgAskRuntime,
   msgAckRuntime,
   checklistListRuntime,
   checklistAddRuntime,

package/src/tty-foreground.ts

@@ -0,0 +1,155 @@
+// TUI-SIGTTIN-SUSPEND (0.2.36 · 10-23 n8n) — the TUI must not be stopped because a child stole its terminal.
+//
+// Observed: the TUI's process group was no longer the foreground group of its own tty, its next stdin
+// read raised SIGTTIN and zsh printed «suspended (tty input)» (state T). The trigger was an interactive
+// login shell (`$SHELL -l -i -c printenv`, shell-env-bootstrap.ts) that opened /dev/tty for job control,
+// moved the terminal to its own group and never gave it back. The root fix runs that capture with no
+// controlling tty (`detached`). This module is the defence for any other child that does the same:
+//
+//   ① every tick, compare tcgetpgrp(stdin) with our own group;
+//   ② if the foreground group is gone, or it is led by one of our own descendants (or its leader is
+//      dead), it was taken by a child of ours → take it back (SIGTTOU ignored for that one call);
+//   ③ if a live process that is NOT ours holds it (the user's shell after a real job-control action),
+//      do not fight it — log `tui.lifecycle background-tty` once.
+//
+// Shared by both TUIs: `initTui()` (src/tui.ts) starts it for the classic dashboard and `--tui next`.
+
+import { spawnSync } from 'node:child_process';
+import { debug } from './debug/log.js';
+
+export interface ForegroundFacts {
+  /** Our process group id (getpgrp()). */
+  ownPgid: number;
+  /** tcgetpgrp(stdin) — -1 when it could not be read (stdin is not our controlling tty). */
+  ttyPgid: number;
+  /** Some process still exists in ttyPgid (kill(-ttyPgid, 0)). */
+  groupAlive: boolean;
+  /** The group leader (pid === ttyPgid) still exists. */
+  leaderAlive: boolean;
+  /** The group leader is one of our descendants. */
+  leaderIsDescendant: boolean;
+}
+
+export type ForegroundVerdict =
+  | { action: 'ok' }
+  | { action: 'unknown' }
+  | { action: 'reclaim'; reason: 'fg-group-gone' | 'fg-leader-gone' | 'fg-held-by-our-child'; ttyPgid: number }
+  | { action: 'yield'; ttyPgid: number };
+
+/** Pure decision — see the header for the rule. */
+export function decideForeground(f: ForegroundFacts): ForegroundVerdict {
+  if (f.ttyPgid < 0 || f.ownPgid < 0) return { action: 'unknown' };
+  if (f.ttyPgid === f.ownPgid) return { action: 'ok' };
+  if (!f.groupAlive) return { action: 'reclaim', reason: 'fg-group-gone', ttyPgid: f.ttyPgid };
+  if (!f.leaderAlive) return { action: 'reclaim', reason: 'fg-leader-gone', ttyPgid: f.ttyPgid };
+  if (f.leaderIsDescendant) return { action: 'reclaim', reason: 'fg-held-by-our-child', ttyPgid: f.ttyPgid };
+  return { action: 'yield', ttyPgid: f.ttyPgid };
+}
+
+export interface ForegroundDeps {
+  tcgetpgrp(): number;
+  getpgrp(): number;
+  /** tcsetpgrp(stdin, pgid) with SIGTTOU ignored for the call. Returns true on success. */
+  reclaim(pgid: number): boolean;
+  alive(pid: number): boolean;
+  isDescendant(pid: number): boolean;
+  log(event: string, data: Record<string, unknown>): void;
+}
+
+function exists(pid: number): boolean {
+  try { process.kill(pid, 0); return true; } catch (e) { return (e as { code?: string }).code === 'EPERM'; }
+}
+
+/** Walks ppid from `pid` up to 1 and reports whether it passes through us. Only runs on an anomaly. */
+function isOurDescendant(pid: number): boolean {
+  let cur = pid;
+  for (let i = 0; i < 64 && cur > 1; i++) {
+    const r = spawnSync('ps', ['-o', 'ppid=', '-p', String(cur)], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 1000 });
+    const ppid = Number.parseInt(String(r.stdout ?? '').trim(), 10);
+    if (!Number.isFinite(ppid) || ppid <= 0) return false;
+    if (ppid === process.pid) return true;
+    cur = ppid;
+  }
+  return false;
+}
+
+type Libc = { tcgetpgrp(fd: number): number; tcsetpgrp(fd: number, pgid: number): number; getpgrp(): number; signal(sig: number, handler: number | bigint): number | bigint };
+
+let libcCache: Libc | null | undefined;
+function libc(): Libc | null {
+  if (libcCache !== undefined) return libcCache;
+  libcCache = null;
+  const path = process.platform === 'darwin' ? '/usr/lib/libSystem.B.dylib' : process.platform === 'linux' ? 'libc.so.6' : null;
+  if (!path || typeof (globalThis as { Bun?: unknown }).Bun === 'undefined') return null;
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { dlopen, FFIType } = require('bun:ffi') as typeof import('bun:ffi');
+    const lib = dlopen(path, {
+      tcgetpgrp: { args: [FFIType.i32], returns: FFIType.i32 },
+      tcsetpgrp: { args: [FFIType.i32, FFIType.i32], returns: FFIType.i32 },
+      getpgrp: { args: [], returns: FFIType.i32 },
+      // sig_t signal(int, sig_t) — the handler is a pointer; i64 carries it in the same register.
+      signal: { args: [FFIType.i32, FFIType.i64], returns: FFIType.i64 },
+    });
+    libcCache = lib.symbols as unknown as Libc;
+  } catch {
+    libcCache = null;
+  }
+  return libcCache;
+}
+
+const SIGTTOU = 22; // darwin and linux
+const SIG_IGN = 1;
+
+export function defaultForegroundDeps(): ForegroundDeps | null {
+  const c = libc();
+  if (!c) return null;
+  return {
+    tcgetpgrp: () => c.tcgetpgrp(0),
+    getpgrp: () => c.getpgrp(),
+    reclaim: (pgid) => {
+      // A background tcsetpgrp raises SIGTTOU unless it is ignored — ignore it for this one call only.
+      const prev = c.signal(SIGTTOU, SIG_IGN);
+      try { return c.tcsetpgrp(0, pgid) === 0; } finally { c.signal(SIGTTOU, prev); }
+    },
+    alive: exists,
+    isDescendant: isOurDescendant,
+    log: (event, data) => debug.log('tui.lifecycle', event, data),
+  };
+}
+
+/** One check. Exported for tests; the guard calls it on a timer. `state.yieldedTo` keeps the yield log to once per holder. */
+export function checkForeground(deps: ForegroundDeps, state: { yieldedTo: number | null } = { yieldedTo: null }): ForegroundVerdict {
+  const ownPgid = deps.getpgrp();
+  const ttyPgid = deps.tcgetpgrp();
+  if (ttyPgid < 0 || ttyPgid === ownPgid) {
+    state.yieldedTo = null;
+    return decideForeground({ ownPgid, ttyPgid, groupAlive: true, leaderAlive: true, leaderIsDescendant: false });
+  }
+  if (state.yieldedTo === ttyPgid) return { action: 'yield', ttyPgid };
+  const groupAlive = deps.alive(-ttyPgid);
+  const leaderAlive = groupAlive && deps.alive(ttyPgid);
+  const leaderIsDescendant = leaderAlive && deps.isDescendant(ttyPgid);
+  const verdict = decideForeground({ ownPgid, ttyPgid, groupAlive, leaderAlive, leaderIsDescendant });
+  if (verdict.action === 'reclaim') {
+    const ok = deps.reclaim(ownPgid);
+    deps.log(ok ? 'foreground-reclaimed' : 'foreground-reclaim-failed', { reason: verdict.reason, ttyPgid, ownPgid });
+  } else if (verdict.action === 'yield') {
+    state.yieldedTo = ttyPgid;
+    deps.log('background-tty', { ttyPgid, ownPgid, groupAlive, leaderAlive });
+  }
+  return verdict;
+}
+
+/** Starts the guard; returns stop(). No-op (returns a no-op) when libc/FFI is unavailable. */
+export function startForegroundGuard(opts: { intervalMs?: number; deps?: ForegroundDeps | null } = {}): () => void {
+  if (process.env.ELANOUS_TTY_FOREGROUND_GUARD === '0') return () => {};
+  const deps = opts.deps === undefined ? defaultForegroundDeps() : opts.deps;
+  if (!deps) return () => {};
+  const state = { yieldedTo: null as number | null };
+  const tick = (): void => { try { checkForeground(deps, state); } catch { /* fail-soft */ } };
+  tick();
+  const timer = setInterval(tick, opts.intervalMs ?? 250);
+  (timer as { unref?: () => void }).unref?.();
+  return () => clearInterval(timer);
+}

package/src/tui/README.md

@@ -33,4 +33,6 @@ src/tui/
 
 ## 현황 (M2 착수)
 - ✅ `tui/chat/execution-badge.ts` — 실행모델 뱃지 리졸버 (dashboard/ 에서 이전, shim 유지)
+- ✅ `tui/entry.ts` · `tui/chat/log-view.ts` · `tui/input/composer.ts` — `elanous --tui next` 로 여는 로컬 대화 화면. 공용 inline editor 로 입력·전송하고 공용 REPL 턴 경로를 JSONL stdin 자식으로 호출한다. `--tui classic` 과 기본 진입은 기존 dashboard 를 사용한다.
+- ✅ `tui/size-contract.test.ts` — 이 디렉토리 TypeScript 파일의 4,000줄 상한을 검사한다.
 - ⬜ render · input · rich/* — 후속 슬라이스

package/src/tui/chat/background-job-status.ts

@@ -0,0 +1,54 @@
+/** Session-scoped, immutable projection of the REPL child's task state. */
+export interface BackgroundJobSnapshot {
+  readonly sessionId: string;
+  readonly promised: boolean;
+  readonly running: number;
+  readonly pending: number;
+}
+
+function nonnegativeCount(value: unknown): value is number {
+  return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+}
+
+export class BackgroundJobStatus {
+  private sessionId: string | null;
+  private current: BackgroundJobSnapshot | null = null;
+
+  constructor(sessionId: string | null) { this.sessionId = sessionId; }
+
+  setSessionId(sessionId: string): void {
+    if (this.sessionId === sessionId) return;
+    this.sessionId = sessionId;
+    this.current = null;
+  }
+
+  accept(json: string): boolean {
+    let value: unknown;
+    try { value = JSON.parse(json); } catch { return false; }
+    if (!value || typeof value !== 'object') return false;
+    const frame = value as Record<string, unknown>;
+    if (frame.sessionId !== this.sessionId || typeof frame.promised !== 'boolean'
+      || !nonnegativeCount(frame.running) || !nonnegativeCount(frame.pending)) return false;
+    this.current = Object.freeze({
+      sessionId: frame.sessionId,
+      promised: frame.promised,
+      running: frame.running,
+      pending: frame.pending,
+    }) as BackgroundJobSnapshot;
+    return true;
+  }
+
+  snapshot(): BackgroundJobSnapshot | null { return this.current; }
+
+  clear(): void { this.current = null; }
+
+  line(): string {
+    const state = this.current;
+    if (!state) return '';
+    const parts: string[] = [];
+    if (state.running > 0) parts.push(`⧗ 백그라운드 ${state.running}`);
+    if (state.pending > 0) parts.push(`✓ 백그라운드 끝 ${state.pending} · 결과 대기`);
+    if (parts.length === 0 && state.promised) parts.push('⚠ 약속한 백그라운드 없음');
+    return parts.join(' · ');
+  }
+}

package/src/tui/chat/goal-interim.ts

@@ -0,0 +1,173 @@
+// ── 골 중간 답 접기 `goal-interim` (TUI-GOAL-INTERIM-QUIET 조각 2 · 2026-10-22 · 대표 «대화 연결이 이상하다») ──────
+//
+// 🚨 무엇을 푸는가: 골 하나를 도는 동안 작은 단계마다 턴이 끝나고(«…아직 못 했습니다»·«…하겠습니다»),
+//   goal-continue / child-complete 내부 턴이 다시 열린다. 그 사이 «못 했다» 문단이 대화에 단계 수만큼 쌓이고
+//   (n8n 세션 10-22 22:4x), next TUI 는 내부 턴 입력을 «나: [골 이어가기] …» 로 사람 발화처럼 그렸다.
+// ⭐ 이 모듈은 «그리는 층»의 판정만 한다(순수):
+//   ① 내부 턴 입력 글(우리 포매터가 만든 접두)을 알아본다 → 사람 머리(«나:»·«❯») 대신 «↻ 자동 재개(<origin>)».
+//   ② 내부 이어가기 턴 «바로 앞» 답이 중간 보고(못 했다·약속)면 한 줄 «· 진행 — <첫 줄> (접힘)» 로 접는다.
+//      마지막 답(골 끝·막힘)은 접지 않는다 → 미완 목록 문단은 한 번만 남는다.
+// ⛔ 세션 기록·모델 입력은 그대로다(화면만 접는다). 판정이 애매하면 접지 않는다(정보를 숨기지 않는 쪽).
+//
+// 세 얼굴:
+//   관측 = debug.log('tui.goal-interim', 'folded' | 'kept', { surface:'classic', origin, reason, lines }) ·
+//          next 는 턴 끝마다 접힘 수가 바뀌면 'folded' { surface:'next', folded, internal } (src/tui/entry.ts)
+//   인지 = 다음 턴이 내부 이어가기인가 ∧ 앞 답이 중간 보고 꼴인가 ∧ (classic) 그 줄들이 아직 제자리인가
+//   힐링 = 앞 문단을 한 줄로 접는다 · 줄이 움직였으면(버퍼 잘림·끼워 넣은 에코) 접지 않고 'kept' 사유를 남긴다
+
+import { debug } from '../../debug/log.js';
+import { classifyReplyTail, replyTailFromLines } from '../../chat/goal-continue-verdict.js';
+import type { InternalTurnOrigin } from '../../chat/internal-turn-origin.js';
+
+/** 내부 턴 입력 접두 — goal-continue.ts `formatGoalContinuePrompt` · agent-wake.ts `formatAgentWakePrompt` ·
+ *  seat-autowake.ts `formatSeatAutowakePrompt` 와 같아야 한다(goal-interim.test.ts 가 세 포매터를 문다). */
+const INTERNAL_TURN_TEXT_PREFIXES: ReadonlyArray<{ prefix: string; origin: InternalTurnOrigin }> = [
+  { prefix: '[골 이어가기] ', origin: 'goal-continue' },
+  { prefix: '[자동 재개] 위임 끝: ', origin: 'child-complete' },
+  { prefix: '[자동 재개] 남은 일: ', origin: 'autowake' },
+];
+
+/** 이 글이 우리가 연 내부 턴의 입력이면 그 출처, 아니면 null(사람 글). */
+export function internalTurnOriginOfText(text: string): InternalTurnOrigin | null {
+  const head = text.trimStart();
+  for (const { prefix, origin } of INTERNAL_TURN_TEXT_PREFIXES) if (head.startsWith(prefix)) return origin;
+  return null;
+}
+
+/** 앞 답을 접는 이어가기 출처 — 같은 골을 «이어서» 도는 턴만(goal-continue · child-complete).
+ *  autowake(«남은 일: 우편·큐»)·예약·우편 깨움은 새 일이라 앞 답을 건드리지 않는다(입력 줄 머리만 바꾼다). */
+const FOLDING_ORIGINS: ReadonlySet<InternalTurnOrigin> = new Set(['goal-continue', 'child-complete']);
+function isFoldingOrigin(origin: InternalTurnOrigin | null | undefined): boolean {
+  return origin != null && FOLDING_ORIGINS.has(origin);
+}
+
+// eslint-disable-next-line no-control-regex
+const ANSI = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+/** 답이 아닌 줄(턴 상태·도구·배너) — goal-continue 의 NON_REPLY 와 같은 뜻. */
+const NON_REPLY_LINE = /^\s*(?:✔ 완료|✘ 실패|응답 완료|응답 중|라우팅:|󰧑|⚙️|도구:|나:|↻ 자동 재개|⏰|⏸|⏹|❯|[─━]{3,})/u;
+
+/** 미완 고백 — «못 했다 / 보고할 수 없다 / 아직 안 됐다» ⊕ 영어. */
+const INCOMPLETE_RE = new RegExp([
+  '못\\s?했',
+  '하지\\s?못(?:했|함|하였)',
+  '(?:완료|끝내|마치|만들|보고하)지\\s?못',
+  '보고할\\s?수\\s?없',
+  '아직\\s?(?:안\\s?(?:됐|되었|끝)|없습니다|미완)',
+  "couldn['’]t",
+  'could not',
+  "was(?:n['’]t| not) able",
+  'unable to',
+  'not (?:yet )?(?:done|finished|completed?)\\b',
+].join('|'), 'iu');
+
+export type InterimVerdict =
+  | { interim: true; reason: 'incomplete' | 'pledge'; summary: string }
+  | { interim: false; reason: 'no-reply' | 'final' };
+
+/** 답 줄(색 코드 포함 가능)이 «중간 보고»인가 — 미완 고백 또는 약속으로 끝난 답. */
+export function classifyInterimReply(lines: readonly string[]): InterimVerdict {
+  const plain = lines.map((l) => l.replace(ANSI, '').trim()).filter((l) => l && !NON_REPLY_LINE.test(l));
+  if (plain.length === 0) return { interim: false, reason: 'no-reply' };
+  const summary = plain[0]!.replace(/^엘라누스:\s*/u, '');
+  // 끝 문장만 본다 — 중간의 «X 는 못 했지만 Y 는 끝냈다» 한 구절로 결과 답을 접지 않는다(goal-continue 와 같은 규칙).
+  const tail = replyTailFromLines(lines);
+  const last = tail ? (tail.split(/(?<=[.!?。？])\s+/u).filter(Boolean).at(-1) ?? tail) : '';
+  if (INCOMPLETE_RE.test(last)) return { interim: true, reason: 'incomplete', summary };
+  if (classifyReplyTail(tail).pledge) return { interim: true, reason: 'pledge', summary };
+  return { interim: false, reason: 'final' };
+}
+
+const SUMMARY_CHARS = 60;
+/** 접힌 한 줄 — «· 진행 — <첫 줄> (접힘)». */
+export function formatInterimFoldLine(summary: string): string {
+  const flat = summary.replace(/\s+/g, ' ').trim();
+  const cut = [...flat].length > SUMMARY_CHARS ? `${[...flat].slice(0, SUMMARY_CHARS).join('')}…` : flat;
+  return `· 진행 — ${cut} (접힘)`;
+}
+
+// ── next: 세션 메시지 위의 그리기 계획(순수) ─────────────────────────────────────────────
+
+export type InterimDisplay =
+  | { kind: 'internal-input'; origin: InternalTurnOrigin }
+  | { kind: 'folded'; line: string };
+
+/** 메시지 인덱스 → 그리기 바꿈. 내부 턴 입력은 출처 한 줄, 그 «바로 앞» 중간 보고 답은 한 줄로 접는다. */
+export function planInterimDisplay(messages: ReadonlyArray<{ role: string; content?: unknown }>): Map<number, InterimDisplay> {
+  const plan = new Map<number, InterimDisplay>();
+  for (let i = 0; i < messages.length; i++) {
+    const m = messages[i]!;
+    if (m.role !== 'user' || typeof m.content !== 'string') continue;
+    const origin = internalTurnOriginOfText(m.content);
+    if (!origin) continue;
+    plan.set(i, { kind: 'internal-input', origin });
+    if (!isFoldingOrigin(origin)) continue;
+    // 앞 사람/내부 입력 뒤의 마지막 답 하나만 — 도구 블록은 그대로 둔다.
+    for (let j = i - 1; j >= 0; j--) {
+      const prev = messages[j]!;
+      if (prev.role === 'user') break;
+      if (prev.role !== 'assistant' || typeof prev.content !== 'string') continue;
+      const verdict = classifyInterimReply(prev.content.split('\n'));
+      if (verdict.interim) plan.set(j, { kind: 'folded', line: formatInterimFoldLine(verdict.summary) });
+      break;
+    }
+  }
+  return plan;
+}
+
+/** 계획의 접힌 답 수 ⊕ 내부 입력 줄 수 — next 관측용. */
+export function countInterimDisplay(plan: ReadonlyMap<number, InterimDisplay>): { folded: number; internal: number } {
+  let folded = 0;
+  let internal = 0;
+  for (const d of plan.values()) { if (d.kind === 'folded') folded += 1; else internal += 1; }
+  return { folded, internal };
+}
+
+// ── classic: 화면 줄(chatLines) 위의 접기 상태 ──────────────────────────────────────────
+
+export interface ClassicInterimFoldDeps {
+  /** 접어도 되는 때인가 — 대시보드는 «끼워 넣은 사람 에코가 없다»를 넘긴다(줄 위치가 확실할 때만). */
+  canFold?: () => boolean;
+  log?: (category: string, event: string, data: Record<string, unknown>) => void;
+}
+
+export interface ClassicInterimFold {
+  /** 턴이 끝났다 — 이번 턴의 «마지막 답 블록» 시작(스트림 applier 의 assistantStart)부터 끝까지를 사본으로 잡는다.
+   *  도구·라우팅 줄은 그 앞이라 접히지 않는다(next 가 답 메시지만 접는 것과 같다). */
+  noteTurnEnded(chatLines: readonly string[], start: number): void;
+  /** 사람이 턴을 열었다 — 잡아 둔 답을 놓는다(사람 턴 앞 답은 접지 않는다). */
+  noteHumanTurn(): void;
+  /** 내부 이어가기 턴이 막 열린다 — 잡아 둔 앞 답이 중간 보고면 그 자리를 한 줄로 바꾼다. */
+  foldBeforeInternalTurn(chatLines: string[], origin: InternalTurnOrigin, style?: (line: string) => string): { folded: boolean; reason: string };
+}
+
+export function createClassicInterimFold(deps: ClassicInterimFoldDeps = {}): ClassicInterimFold {
+  const log = deps.log ?? ((c, e, d) => debug.log(c, e, d));
+  let last: { start: number; lines: string[] } | null = null;
+  const kept = (origin: InternalTurnOrigin, reason: string, extra: Record<string, unknown> = {}) => {
+    log('tui.goal-interim', 'kept', { surface: 'classic', origin, reason, ...extra });
+    return { folded: false, reason };
+  };
+  return {
+    noteTurnEnded(chatLines, start) {
+      const from = Math.max(0, Math.min(start, chatLines.length));
+      last = { start: from, lines: chatLines.slice(from) };
+    },
+    noteHumanTurn() { last = null; },
+    foldBeforeInternalTurn(chatLines, origin, style = (l) => l) {
+      const snap = last;
+      last = null;
+      if (!isFoldingOrigin(origin)) return kept(origin, 'not-continuation');
+      if (!snap || snap.lines.length === 0) return kept(origin, 'no-previous-reply');
+      if (deps.canFold && !deps.canFold()) return kept(origin, 'lines-unstable');
+      // 그 줄들이 아직 제자리인가 — 버퍼 앞이 잘렸거나 무엇이 끼어들었으면 위치를 믿지 않는다.
+      const here = chatLines.slice(snap.start, snap.start + snap.lines.length);
+      if (here.length !== snap.lines.length || here.some((line, k) => line !== snap.lines[k])) return kept(origin, 'lines-moved');
+      const verdict = classifyInterimReply(snap.lines);
+      if (!verdict.interim) return kept(origin, verdict.reason);
+      const line = formatInterimFoldLine(verdict.summary);
+      chatLines.splice(snap.start, snap.lines.length, style(`  ${line}`));
+      log('tui.goal-interim', 'folded', { surface: 'classic', origin, reason: verdict.reason, lines: snap.lines.length });
+      return { folded: true, reason: verdict.reason };
+    },
+  };
+}