elanous 0.2.34 → 0.2.36

package/scripts/ux-sim.ts

@@ -17,6 +17,7 @@
 //   bun scripts/ux-sim.ts --fault pod-death   # 결함 주입: PARTIAL 줄을 남긴 Pod 가 SIGTERM 으로 지워짐 → 호스트 재방출 판정
 //   bun scripts/ux-sim.ts --fault pool-cap    # 결함 주입: --pod-pool 에 :N 이 빠진 풀 → 승인 판정(limitedBy)
 //   bun scripts/ux-sim.ts --fault sqlite-busy # 결함 주입: 실제 SQLite 잠금 → 로그 배치 버퍼·복구
+//   bun scripts/ux-sim.ts emit child-error-long --json # 사건 주입(L0): 격리 우주 원장에 주입 줄 → 소비자 목록
 //
 // ⛔ 이 CLI 는 «실제 위젯 render()» 를 부른다 — 흉내 렌더러가 아니다.
 import { simRenderLogFrame } from '../src/ux-sim/render-frame.js';
@@ -29,6 +30,97 @@ const PHASES: TurnPhase[] = [
 
 const argv = process.argv.slice(2);
 
+// ── 사건 주입 «이벤트 몽키» (SIM-EVENT-MONKEY · L0) — 자기 플래그를 가진 하위 명령 ──
+//   bun scripts/ux-sim.ts emit <kind> [--run <id>] [--variant allowed|refused] [--state-dir <dir>] [--json]
+//   bun scripts/ux-sim.ts emit --list
+//   ⛔ 운영 우주(~/.elanous)면 쓰기 전에 거부(rc 3). 격리 우주는 ELANOUS_STATE_DIR 또는 --state-dir.
+if (argv[0] === 'emit') {
+  // 얇은 별칭 — 해석은 `eln sim emit` 과 «같은» runEventMonkeyCli 하나가 한다.
+  const rest = argv.slice(1);
+  const EMIT_FLAGS = new Set(['--run', '--variant', '--state-dir', '--json', '--list']);
+  const VALUED = new Set(['--run', '--variant', '--state-dir']);
+  const unknown = rest.filter((a) => a.startsWith('--') && !EMIT_FLAGS.has(a));
+  if (unknown.length > 0) {
+    console.error(`⛔ 모르는 인자다: ${unknown.join(' ')} — 아는 것: ${[...EMIT_FLAGS].join(' · ')}`);
+    process.exit(2);
+  }
+  const value = (flag: string): string | undefined => {
+    const i = rest.indexOf(flag);
+    if (i < 0) return undefined;
+    const v = rest[i + 1];
+    if (!v || v.startsWith('--')) { console.error(`⛔ ${flag} 에 값이 필요하다`); process.exit(2); }
+    return v;
+  };
+  const { renderEventMonkeyKinds, runEventMonkeyCli } = await import('../src/ux-sim/event-monkey.js');
+  if (rest.includes('--list')) { console.log(renderEventMonkeyKinds(rest.includes('--json')).join('\n')); process.exit(0); }
+  const positional = rest.filter((a, i) => !a.startsWith('--') && !VALUED.has(rest[i - 1] ?? ''));
+  if (positional.length > 1) {
+    console.error(`⛔ 사건은 하나만 받는다 — 남는 인자: ${positional.slice(1).join(' ')}`);
+    process.exit(2);
+  }
+  const runId = value('--run');
+  const variant = value('--variant');
+  const stateDir = value('--state-dir');
+  const out = runEventMonkeyCli({ kindName: positional[0], json: rest.includes('--json'),
+    ...(runId ? { runId } : {}), ...(variant ? { variant } : {}), ...(stateDir ? { stateDir } : {}) });
+  for (const line of out.stdout) console.log(line);
+  for (const line of out.stderr) console.error(line);
+  process.exit(out.code);
+}
+
+// ── N03 키 순서열 (TUI-NEXT E4) — 진짜 PTY 에 next TUI 를 fake LLM 으로 띄워 단계별 화면 ⊕ 격리 우주 logs ──
+//   bun scripts/ux-sim.ts seat-seq <next-new-session|next-compact|next-queue|next-wakeup|next-paste|next-goal-continue|next-goal-interim|next-proactive-continue|classic-400-heal|classic-400-exhausted|classic-seat-boot|classic-typing-lag|classic-wakeup|classic-paste|classic-goal-continue|classic-goal-interim|classic-orphan-autostop> --root <빈 폴더> [--installed | --executable <bun> --entry <elanous.mjs>] [--expect-sha <sha256>] [--json]
+//   기본 실행 = 이 트리 bin/elanous.mjs ⊕ 이 bun. --installed = ~/.local/share/elanous/current 의 elanous.mjs.
+//   rc: 0 = 모든 checks 참 · 1 = 거짓이 있다 · 2 = 인자 오류
+if (argv[0] === 'seat-seq') {
+  const rest = argv.slice(1);
+  const SEQ_FLAGS = new Set(['--root', '--installed', '--executable', '--entry', '--expect-sha', '--json']);
+  const SEQ_VALUED = new Set(['--root', '--executable', '--entry', '--expect-sha']);
+  const unknown = rest.filter((a) => a.startsWith('--') && !SEQ_FLAGS.has(a));
+  if (unknown.length > 0) { console.error(`⛔ 모르는 인자다: ${unknown.join(' ')} — 아는 것: ${[...SEQ_FLAGS].join(' · ')}`); process.exit(2); }
+  const value = (flag: string): string | undefined => {
+    const i = rest.indexOf(flag);
+    if (i < 0) return undefined;
+    const v = rest[i + 1];
+    if (!v || v.startsWith('--')) { console.error(`⛔ ${flag} 에 값이 필요하다`); process.exit(2); }
+    return v;
+  };
+  const { NEXT_TUI_SCENARIOS, runNextTuiScenario } = await import('../src/ux-sim/next-tui-seat-scenarios.js');
+  const { CLASSIC_TUI_SCENARIOS, runClassicTuiScenario } = await import('../src/ux-sim/classic-tui-seat-scenarios.js');
+  const ALL_SEQ: readonly string[] = [...NEXT_TUI_SCENARIOS, ...CLASSIC_TUI_SCENARIOS];
+  const scenario = rest.find((a, i) => !a.startsWith('--') && !SEQ_VALUED.has(rest[i - 1] ?? ''));
+  if (!scenario || !ALL_SEQ.includes(scenario)) { console.error(`⛔ 시나리오: ${ALL_SEQ.join(' | ')}`); process.exit(2); }
+  const root = value('--root');
+  if (!root) { console.error('⛔ --root <빈 폴더> 가 필요하다(격리 우주 · 남긴다)'); process.exit(2); }
+  const { homedir } = await import('node:os');
+  const { join: pjoin, resolve: presolve } = await import('node:path');
+  const { realpathSync } = await import('node:fs');
+  const installedEntry = pjoin(homedir(), '.local', 'share', 'elanous', 'current', 'node_modules', 'elanous', 'bin', 'elanous.mjs');
+  if (rest.includes('--installed') && rest.includes('--entry')) { console.error('⛔ --installed 와 --entry 는 함께 못 준다 — 어느 elanous.mjs 로 낸 원문인지 갈라야 한다'); process.exit(2); }
+  let entry: string;
+  if (rest.includes('--installed')) {
+    try { entry = realpathSync(installedEntry); } catch { console.error(`⛔ 설치본 없음: ${installedEntry}`); process.exit(2); }
+  } else entry = presolve(value('--entry') ?? pjoin(import.meta.dir, '..', 'bin', 'elanous.mjs'));
+  const executable = value('--executable') ?? process.execPath;
+  const expected = value('--expect-sha');
+  const pin = expected ? { expectedBinarySha256: expected } : {};
+  // classic-* = bare `elanous`(대시보드) · next-* = `--tui next`. 결과 모양은 같다(run · store · logs · checks).
+  const result = (CLASSIC_TUI_SCENARIOS as readonly string[]).includes(scenario)
+    ? await runClassicTuiScenario({ scenario: scenario as (typeof CLASSIC_TUI_SCENARIOS)[number], root, executable, entry, ...pin })
+    : await runNextTuiScenario({ scenario: scenario as (typeof NEXT_TUI_SCENARIOS)[number], root, executable, entry, ...pin });
+  if (rest.includes('--json')) console.log(JSON.stringify(result, null, 2));
+  else {
+    console.log(`scenario=${result.scenario} universe=${result.universe}`);
+    console.log(`binary=${result.run.executable} sha256=${result.run.binarySha256} entry=${result.run.args[0]} entrySha256=${result.run.entrySha256}`);
+    for (const f of result.run.frames) console.log(`===== ${f.label} =====\n${f.screen}\n`);
+    console.log(`store=${JSON.stringify(result.store)}`);
+    console.log(`logs: ${result.logs.command} (rc=${result.logs.rc})`);
+    for (const l of result.logs.lines) console.log(l);
+    for (const [k, v] of Object.entries(result.checks)) console.log(`check ${k}=${v}`);
+  }
+  process.exit(Object.values(result.checks).every(Boolean) ? 0 : 1);
+}
+
 // ⛔⭐ 모르는 인자를 «조용히 삼키지» 않는다 — 이름을 대고 거부한다.
 //
 //  🚨 2026-08-27 실측: `--trajectory-list`(오타 · 실제는 `--list-trajectories`)를 쳤더니

package/skills/README.md

@@ -66,6 +66,7 @@ bun -e '
 |---|---|---|
 | [`grill-me`](grill-me/SKILL.md) | 계획·설계를 공감대에 이를 때까지 인터뷰 | ⛔ 아니다(`disable-model-invocation`) — 사람이 부른다 |
 | [`video-builder`](video-builder/SKILL.md) | 영상 파이프라인을 «능력·구현·구간»으로 조립 — 추천 스택·크레딧·구멍 | ⛔ 아니다(`autoTrigger` 미선언) — 슬래시로 «먼저» 연다 |
+| [`floorplan-to-film`](floorplan-to-film/SKILL.md) | 평면도(PDF·이미지·치수) → 2D 수정 도면 → Blender 3D 투시도(Higgsfield Bridge MCP · 미연결 대안 cli-anything-blender) → 워크스루 영상 — 조립·자막·BGM 은 video-builder | O — `autoTrigger` 선언(«평면도로 3D»·«인테리어 영상» 명시 트리거 · 점수 2.0↑ 일 때 자동, 그 전엔 제안) |
 
 ---
 

package/src/acp/core-turn-bridge.ts

@@ -34,7 +34,8 @@
 // headless-core guard test asserts the bridge stays TUI-free so
 // Core really can run headless.
 
-import type { LLMMessage, LLMToolSpec, ContentBlock } from '../llm.js';
+import { nextTurnFallbackProvider, resolveDefaultProvider, type LLMMessage, type LLMProvider, type LLMToolSpec, type ContentBlock } from '../llm.js';
+import { readAutohealProviderFallback } from '../self-health/autoheal.js';
 import { debug, redactSecretText } from '../debug/log.js';
 import { CoreTurnAuthRejectedError } from '../core-turn/auth-rejected-notice.js';
 import {
@@ -208,6 +209,9 @@ export function bridgeCoreTurnToAcp(
   deps: CoreTurnBridgeDeps,
 ): NonNullable<AcpServerOptions['runTurn']> {
   const pollMs = deps.abortPollMs ?? DEFAULT_BRIDGE_ABORT_POLL_MS;
+  // TUI-400-AUTOHEAL-FALLBACK ② — 앞 턴이 «실제로» 마지막에 부른 공급자(턴 안 폴백이 넘겼으면 넘어간 쪽).
+  //   ② 의 제외 목록에 기본 공급자와 함께 넣는다 — 방금 400 을 낸 쪽을 다시 고르지 않게(r2 리뷰).
+  let lastResolvedProvider: string | null = null;
   return async (turnCtx: AcpTurnContext): Promise<void> => {
     const ctrl = new AbortController();
     const poll = setInterval(() => {
@@ -262,6 +266,25 @@ export function bridgeCoreTurnToAcp(
         }
       }
       const modelOverride = deps.resolveModel?.({ sessionId: turnCtx.sessionId, userText: turnCtx.userText });
+      // TUI-400-AUTOHEAL-FALLBACK ② — TUI 가 «이 턴은 다음 공급자로» 를 실어 보냈다(같은 턴이 400 을 두 번 받은 뒤).
+      //   ⛔ 고르는 것은 서버다 — 클라이언트는 표지만 싣고, 공급자는 이 프로세스의 `llm.fallbackChain` 해석으로 정한다.
+      //   ⛔ in-process TUI(tuiRouting) 만 — 데몬 ACP 는 종전 그대로.
+      let autohealProvider: { initialProvider: LLMProvider; skipProviders: readonly string[] } | null = null;
+      const autohealStep2 = deps.tuiRouting === true && readAutohealProviderFallback(turnCtx.promptMeta);
+      // ② 표지가 없는 프롬프트(새 턴 · ① 재시도)는 «그 턴» 의 시도다 — 앞 턴이 폴백으로 넘긴 공급자를 들고 오지 않는다(r3 리뷰).
+      if (!autohealStep2) lastResolvedProvider = null;
+      if (autohealStep2) {
+        try {
+          const failed = [...new Set([resolveDefaultProvider(modelOverride).name, ...(lastResolvedProvider ? [lastResolvedProvider] : [])])];
+          const next = nextTurnFallbackProvider(failed);
+          debug.log('self-health.autoheal', next ? 'provider-fallback-applied' : 'provider-fallback-none', {
+            sessionId: turnCtx.sessionId, from: failed[0], skipped: failed, to: next?.name ?? null,
+          }, { level: 'warn' });
+          if (next) autohealProvider = { initialProvider: next, skipProviders: failed };
+        } catch (error) {
+          debug.log('self-health.autoheal', 'provider-fallback-none', { sessionId: turnCtx.sessionId, error: String(error) }, { level: 'warn' });
+        }
+      }
       // Tier 2 arming(config-gated·2026-07-19 goal-exec → 아크4 전-family) — llm.goalLoop.enabled
       // 면 across-turn goal loop(runGoalLoop)로 감싸 목표 완료(update_goal 증거게이트)까지 지속·
       // continuation 재주입. **family 무관**(runGoalLoop 프롬프트·update_goal 툴 전부 provider-generic·
@@ -393,7 +416,7 @@ export function bridgeCoreTurnToAcp(
           { reasoning: true },
         );
       });
-      const dispatchResult = await runTurnDispatch({
+      const buildCoreTurnContext = (): CoreTurnContext => ({
         sessionId: turnCtx.sessionId,
         ...(originSessionId ? { originSessionId } : {}),
         ...(turnCtx.userText ? { userText: turnCtx.userText } : {}),
@@ -402,6 +425,7 @@ export function bridgeCoreTurnToAcp(
         dispatchTool,
         signal: ctrl.signal,
         ...(modelOverride !== undefined ? { modelOverride } : {}),
+        ...(autohealProvider ?? {}),
         ...(maxToolTurns !== undefined ? { maxToolTurns } : {}),
         ...((!factQuestion || explicitMaxToolTurns !== undefined) && deps.budgetGrant !== undefined ? { budgetGrant: deps.budgetGrant } : {}),
         callbacks: {
@@ -438,7 +462,7 @@ export function bridgeCoreTurnToAcp(
           onToolResult: (call) => { void turnCtx.pushToolResult(call); },
           // 실제로 응답한 공급자·모델을 기억한다 — 폴백 체인이 넘기면(예 codex → grok) 턴 모델(turnModel)과 달라진다.
           //   streamLLMWithTools 가 스트림을 (다시) 열 때마다 부른다 → 사용량 직전 값 = 그 사용량을 낸 쪽.
-          onResolvedProvider: (provider, model) => { resolvedRoute = { provider, model }; },
+          onResolvedProvider: (provider, model) => { resolvedRoute = { provider, model }; lastResolvedProvider = provider; },
           // 턴 모델(라우팅 결과)을 실어 보낸다 — 대시보드 턴 지표가 설정 모델로 ctx·단가를 잡지 않게.
           //   ⭐ 폴백이면 «넘어간» 모델·공급자를 싣는다(TUI-MODEL-BADGE-ACTUAL · 완료 배지가 읽는다 · 상태줄·/model 은 후속 TUI-MODEL-BADGE-SOURCE).
           onUsage: (usage) => {
@@ -606,11 +630,29 @@ export function bridgeCoreTurnToAcp(
             }
           },
         },
-      // 오류·취소로 끝나 onTurnComplete 가 안 불려도 마지막 추론 문단을 내보낸다(#28964 리뷰 FU-1 · 빈 버퍼면 무동작).
-      }).finally(() => reasoningThoughts.flush());
+      });
+      // TUI-SPEECH-STYLE-DAEMON — 자동 수복 1회: 하위 단계가 aborted(수렴 실패)로 끝나면 실패 범위만
+      // 좁혀 같은 시드로 «정확히 1회» 다시 돈다. 사용자 중단(isAborted)은 수복 대상이 아니며, 원래
+      // 완료 경계(onTurnComplete 1회 지속 · 최종 답 표면화)는 복구된 시도가 그대로 이어받는다.
+      let attempt = 0;
+      let dispatchResult: unknown;
+      let stopReason: unknown;
+      for (;;) {
+        attempt += 1;
+        // 오류·취소로 끝나 onTurnComplete 가 안 불려도 마지막 추론 문단을 내보낸다(#28964 리뷰 FU-1 · 빈 버퍼면 무동작).
+        dispatchResult = await runTurnDispatch(buildCoreTurnContext()).finally(() => reasoningThoughts.flush());
+        stopReason = (dispatchResult as { stopReason?: unknown } | null | undefined)?.stopReason;
+        const userCancelled = ctrl.signal.aborted || turnCtx.isAborted();
+        if (stopReason !== 'aborted' || userCancelled || attempt >= 2) break;
+        // 첫 시도의 잔류 스트림·보충은 폐기한다 — 복구 시도의 완료 경계가 폐기물로 오염되지 않게.
+        streamedTextSum = '';
+        finalSupplement = null;
+        try {
+          debug.log('acp.turn', 'autoheal-retry', { sessionId: turnCtx.sessionId, attempt: attempt + 1 });
+        } catch { /* observation cannot interrupt a turn */ }
+      }
       // ⭐ 인증 거절은 코어 턴이 «던지지 않고» 돌려준다 — 여기서 안 읽으면 서버는 end_turn 을 내고
       //   TUI 엔 «✔ 완료»만 남는다(TUI 결함 #22). 던져서 실패 경로(prompt-failed · 오류 줄)로 보낸다.
-      const stopReason = (dispatchResult as { stopReason?: unknown } | null | undefined)?.stopReason;
       if (stopReason === 'auth_rejected') {
         const rawError = (dispatchResult as { errorMessage?: unknown }).errorMessage;
         const error = new CoreTurnAuthRejectedError(typeof rawError === 'string' ? rawError : undefined);

package/src/agent/delegate-hint.ts

@@ -0,0 +1,16 @@
+export const DELEGATE_HINT = '[delegate] 남은 일 중 서로 독립인 단위나 긴 조사는 Agent 도구로 서브에이전트에 넘겨라(가능하면 동시에 · 긴 일은 run_in_background) — 결과는 자동으로 회수된다. 너는 조율과 마무리를 맡는다.';
+
+export function shouldHintDelegate({
+  iteration, maxIterations, toolCallsThisIteration, toolBudget, alreadyHinted,
+}: {
+  iteration: number;
+  maxIterations: number;
+  toolCallsThisIteration: number;
+  toolBudget: number;
+  alreadyHinted: boolean;
+}): boolean {
+  return !alreadyHinted && (
+    (iteration >= 2 && iteration <= maxIterations)
+    || (toolBudget > 0 && toolCallsThisIteration >= toolBudget * 0.8)
+  );
+}

package/src/agent/runner.ts

@@ -330,6 +330,66 @@ export function filterAgentTools(
   return filtered.length > 0 ? filtered : undefined;
 }
 
+// ── SUBAGENT-ENCAPSULATION (0.2.36 · 대표 10-22 «서브에이전트 안의 행위는 안에서 해결 · 밖으로는 이상 상황에서만») ──
+//
+// 🚨 실물(n8n wS:p1 · 22:4x): 서브에이전트가 1~2분 만에 «…하지 못했습니다» 로 끝나 메인 대화에 끼어들었다.
+// ⭐ 자식 답이 «못 했다»형이고 이상 사유(막힘·권한·사람 필요·예산)가 없으면 «안에서» 잇는다 — 상한 SUBAGENT_CONTINUE_INSIDE_CAP.
+//   같은 답이 다시 나오면(같은 원인 반복) 그때 밖으로 낸다 = 이상 상황.
+// 세 얼굴: 관측 = agent.encapsulation continue-inside / surfaced{reason} · 인지 = 미완형 ∧ 이상 사유 없음 ·
+//   힐링 = 이어가기 지시 한 턴 · 상한·반복이면 그대로 반환(실패를 숨기지 않는다).
+
+export const SUBAGENT_CONTINUE_INSIDE_CAP = 2;
+
+export const SUBAGENT_CONTINUE_INSIDE_PROMPT = [
+  '[continue inside]',
+  '아직 맡은 일이 끝나지 않았다. 부모에게 «못 했다»를 돌려주지 말고 지금 이어서 끝까지 하라 — 막힌 도구는 다른 방법(다른 도구·인자·순서)으로 다시 시도하라.',
+  '정말 더 갈 수 없을 때(권한 없음 · 사람이 정해야 함 · 같은 장애 반복)만 «BLOCKED: <사유> · <시도한 것>» 한 줄로 끝내라. 끝났으면 결과와 증거만 짧게.',
+].join('\n');
+
+const INCOMPLETE_EXIT = /(?:하지 못했|못했습니다|못 했습니다|완료하지 못|완료되지 않|끝내지 못|보고할 수 없|could not (?:complete|finish)|unable to (?:complete|finish)|not (?:yet )?(?:complete|completed|done|finished))/i;
+const ABNORMAL_EXIT = /(?:BLOCKED:|needs-human|사람이 (?:정해|결정)|권한(?:이)? (?:없|부족)|permission denied|예산(?:을)? (?:소진|초과)|budget exhausted|quota)/i;
+
+/** 자식 답을 가른다 — 'done'(밖으로) · 'abnormal'(이상 상황 · 밖으로) · 'incomplete'(안에서 잇는다). 순수. */
+export function classifySubagentExit(text: string): 'done' | 'abnormal' | 'incomplete' {
+  if (ABNORMAL_EXIT.test(text)) return 'abnormal';
+  return INCOMPLETE_EXIT.test(text) ? 'incomplete' : 'done';
+}
+
+/** 걸음의 «답» 텍스트(마지막 도구 라운드 뒤)를 붙들어 두는 칸 — 걸음이 끝나 «밖으로 낼 답»으로 판정된 뒤에만
+ *  부모에게 흘린다(r1 must-fix). 안에서 이어간 걸음의 답(«…하지 못했습니다»)은 부모 소비자에게 닿지 않는다.
+ *  도구 호출 앞 진행 서술은 순서대로 바로 흘린다(이벤트 순서 계약 유지). */
+export interface SubagentStepBuffer {
+  /** 새 걸음을 시작한다 — 앞 걸음에 남은 텍스트는 버리고 그 글자 수를 돌려준다. */
+  reset(): number;
+}
+
+async function runEncapsulated(task: AgentTask, runOnce: () => Promise<string>, step: SubagentStepBuffer): Promise<string> {
+  step.reset();
+  let text = await runOnce();
+  const seen = new Set<string>([text.trim()]);
+  for (let attempt = 1; attempt <= SUBAGENT_CONTINUE_INSIDE_CAP; attempt++) {
+    const kind = classifySubagentExit(text);
+    if (kind !== 'incomplete' || task.controller.signal.aborted) {
+      // 첫 걸음에서 바로 끝나도 남긴다(should-fix) — 종료 건수를 이 이벤트 하나로 셀 수 있게.
+      debug.log('agent.encapsulation', 'surfaced', { taskId: task.id, agent: task.definition.name, reason: kind, attempts: attempt - 1 }, attempt === 1 && kind === 'done' ? { level: 'debug' } : undefined);
+      return text;
+    }
+    const droppedStreamChars = step.reset();
+    debug.log('agent.encapsulation', 'continue-inside', { taskId: task.id, agent: task.definition.name, attempt, chars: text.length, droppedStreamChars });
+    task.messages.push({ role: 'user', content: SUBAGENT_CONTINUE_INSIDE_PROMPT });
+    text = await runOnce();
+    const key = text.trim();
+    if (seen.has(key)) {
+      debug.log('agent.encapsulation', 'surfaced', { taskId: task.id, agent: task.definition.name, reason: 'same-reply', attempts: attempt }, { level: 'warn' });
+      return text;
+    }
+    seen.add(key);
+  }
+  const final = classifySubagentExit(text);
+  debug.log('agent.encapsulation', 'surfaced', { taskId: task.id, agent: task.definition.name, reason: final === 'incomplete' ? 'cap' : final, attempts: SUBAGENT_CONTINUE_INSIDE_CAP }, final === 'incomplete' ? { level: 'warn' } : undefined);
+  return text;
+}
+
 // ── runAgent ──
 
 /** Stream an agent's execution as a sequence of AgentEvent frames.
@@ -390,7 +450,17 @@ export async function* runAgent(
 
   // Kick off the LLM call. Callbacks push events to the queue; the
   // promise's resolution/rejection closes the queue.
-  const runPromise = streamLLMWithTools(
+  // SUBAGENT-ENCAPSULATION — 한 번의 tool loop 를 «한 걸음»으로 두고, 그 답이 «못 했다»형이면 안에서 잇는다(아래 runEncapsulated).
+  // 걸음별 스트림 버퍼 — 판정 전 텍스트는 부모에게 흘리지 않는다(runEncapsulated 가 밖으로 낼 걸음만 flush).
+  let stepDeltas: string[] = [];
+  const stepBuffer: SubagentStepBuffer = {
+    reset: () => { const dropped = stepDeltas.join('').length; stepDeltas = []; return dropped; },
+  };
+  const flushStep = (): void => {
+    for (const delta of stepDeltas) queue.push({ type: 'text', delta });
+    stepDeltas = [];
+  };
+  const runOnce = (): Promise<string> => streamLLMWithTools(
     task.messages,
     {
       // ⛔⭐⭐ 빈 델타는 «에이전트 이벤트»가 아니다 — LLM 층의 «표식»이다.
@@ -406,8 +476,12 @@ export async function* runAgent(
       //     📌 그래서 라이브 소비자는 여전히 «툴 라운드 «전»» 텍스트를 화면에 들고 있고,
       //        최종 `done.text` 는 그것을 «뺀» 값이다(실측: 델타 누적 "checking done" ↔ done.text " done").
       //        ⇒ 그건 «별개 결손»이고 이 줄이 고치지 않는다. AgentEvent 에 지움 의미가 생겨야 닫힌다.
-      onText: (delta) => { if (delta !== '') queue.push({ type: 'text', delta }); },
+      onText: (delta) => { if (delta !== '') stepDeltas.push(delta); },
       onToolCall: (call) => {
+        // 도구 호출 앞 텍스트는 걸음의 «답»이 아니라 진행 서술이다 — 순서를 지켜 바로 흘린다.
+        //   붙들어 두는 것은 마지막 도구 라운드 뒤의 텍스트(= 이 걸음의 답)뿐이다.
+        flushStep();
+        task.toolCallCount = (task.toolCallCount ?? 0) + 1;
         queue.push({ type: 'status', stage: 'tool' });
         queue.push({ type: 'tool_call', id: call.id, name: call.name, args: call.args });
       },
@@ -416,6 +490,8 @@ export async function* runAgent(
         queue.push({ type: 'status', stage: 'thinking' });
       },
       dispatchTool,
+      // 이 걸음의 새 메시지(도구 호출·결과·답)를 이력에 이어 둔다 — 안에서 이어갈 때 앞 걸음을 잊지 않게.
+      onTurnComplete: (newMessages) => { task.messages.push(...newMessages); },
     },
     {
       model: modelResolution.model,
@@ -425,9 +501,11 @@ export async function* runAgent(
       maxTurns: opts.maxTurns,
     },
   );
+  const runPromise = runEncapsulated(task, runOnce, stepBuffer);
 
   runPromise.then(
     (text) => {
+      flushStep();
       task.result = text;
       task.state = 'done';
       task.finishedAt = Date.now();
@@ -440,6 +518,8 @@ export async function* runAgent(
       try { opts.onTerminal?.(task); } catch { /* registry isolates */ }
     },
     (err) => {
+      // 중단·오류 걸음의 부분 텍스트는 예전처럼 흘린다(취소 결과의 output 이 이 누적에 기댄다).
+      flushStep();
       task.finishedAt = Date.now();
       if (task.controller.signal.aborted) {
         task.state = 'aborted';

package/src/agent/self-ambient-cache.ts

@@ -18,8 +18,16 @@ import { elanousSelfAmbientBaseParts } from './self-ambient.js';
 
 export const SELF_AMBIENT_FRESH_MS = 30_000;
 export const SELF_AMBIENT_STALE_MAX_MS = 10 * 60_000;
+export const SELF_AMBIENT_KEEP_WARM_ACTIVE_MS = 25_000;
+export const SELF_AMBIENT_KEEP_WARM_IDLE_MS = 8 * 60_000;
+const SELF_AMBIENT_IDLE_AFTER_MS = 2 * 60_000;
 const WORKER_TIMEOUT_MS = 60_000;
 
+/** Keep turn context warm while active; avoid periodic ambient scans during a long idle. */
+export function selfAmbientKeepWarmIntervalMs(idleMs: number): number {
+  return idleMs >= SELF_AMBIENT_IDLE_AFTER_MS ? SELF_AMBIENT_KEEP_WARM_IDLE_MS : SELF_AMBIENT_KEEP_WARM_ACTIVE_MS;
+}
+
 interface CacheEntry { at: number; version: number; parts: string[] }
 
 export interface SelfAmbientCacheDeps {

package/src/agent/task-notification.ts

@@ -30,6 +30,10 @@ import {
 import type { AgentTask } from './types.js';
 import { globalAgentFlash } from '../display/agent-flash.js';
 import { debug } from '../debug/log.js';
+import { DATA_DIR } from '../config.js';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
 
 /** Max chars of the child's final result we echo in the notification.
  *  The parent can still fetch the full text via the registry if it
@@ -49,6 +53,10 @@ export interface PendingTaskNotification {
   output: string;
   /** Whether output was truncated (for XML `truncated` attribute). */
   truncated: boolean;
+  /** Openable full result when the completion exceeds the inline cap. */
+  resultPath?: string;
+  /** Why preservation failed; never present on a successful full-result notification. */
+  preservationError?: string;
   /** When state === 'error', the error message from runner. */
   errorMessage?: string;
   /** Wall-clock ms from task.startedAt to task.finishedAt. */
@@ -57,6 +65,11 @@ export interface PendingTaskNotification {
 }
 
 export class TaskNotificationQueue {
+  constructor(
+    private readonly resultDir = join(DATA_DIR, 'agent-results'),
+    private readonly maxResultChars = 10_000_000,
+  ) {}
+
   private queue: PendingTaskNotification[] = [];
   /** De-dup guard — same task.finishedAt can fire twice if a caller
    *  listens to both runner events and a separate `onTaskDone` hook.
@@ -67,6 +80,13 @@ export class TaskNotificationQueue {
    *  signal so an idle parent can open the next turn. Opening the turn
    *  itself is deliberately NOT wired here (next shard). */
   private wakeListeners = new Set<(n: PendingTaskNotification) => void>();
+  private drainListeners = new Set<(items: readonly PendingTaskNotification[]) => void>();
+
+  /** Register a drain listener for notifications actually delivered to a turn. */
+  onDrain(listener: (items: readonly PendingTaskNotification[]) => void): () => void {
+    this.drainListeners.add(listener);
+    return () => { this.drainListeners.delete(listener); };
+  }
 
   /** Register a wake listener; returns an unsubscribe function.
    *  Listeners survive `clear()` — they belong to the wiring, not the
@@ -78,12 +98,31 @@ export class TaskNotificationQueue {
 
   enqueue(n: PendingTaskNotification): void {
     if (this.seen.has(n.taskId)) return;
+    let pending = n;
+    if (n.output.length > TASK_NOTIFICATION_OUTPUT_CAP) {
+      const summary = n.output.slice(0, TASK_NOTIFICATION_OUTPUT_CAP);
+      try {
+        if (n.output.length > this.maxResultChars) {
+          throw new Error(`result length ${n.output.length} exceeds limit ${this.maxResultChars}`);
+        }
+        mkdirSync(this.resultDir, { recursive: true });
+        const resultPath = join(this.resultDir, `${randomUUID()}.txt`);
+        writeFileSync(resultPath, n.output, { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+        pending = { ...n, output: summary, truncated: true, resultPath };
+        debug.log('agent.task-notification', 'result-preserved', { taskId: n.taskId, resultPath, length: n.output.length });
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        pending = { ...n, state: 'error', output: summary, truncated: true,
+          preservationError: `full result unavailable: ${reason}`, resultPath: undefined };
+        debug.log('agent.task-notification', 'result-preservation-failed', { taskId: n.taskId, reason }, { level: 'warn' });
+      }
+    }
     this.seen.add(n.taskId);
-    this.queue.push(n);
+    this.queue.push(pending);
     debug.log('agent.task-notification', 'wake', { taskId: n.taskId, size: this.queue.length });
     for (const listener of this.wakeListeners) {
       try {
-        listener(n);
+        listener(pending);
       } catch (error) {
         // fail-soft — a throwing wake listener must not lose the
         // queued notification or break sibling listeners.
@@ -106,6 +145,16 @@ export class TaskNotificationQueue {
     // time for the same task (rare but possible under races) still
     // can't double-inject. `seen` grows unbounded across a session;
     // acceptable — a session produces O(100) tasks at most.
+    if (out.length > 0) {
+      for (const listener of this.drainListeners) {
+        try { listener(out); }
+        catch (error) {
+          debug.log('agent.task-notification', 'drain-listener-failed', {
+            reason: error instanceof Error ? error.message : String(error),
+          }, { level: 'warn' });
+        }
+      }
+    }
     return out;
   }
 
@@ -139,11 +188,7 @@ export const globalTaskNotificationQueue = new TaskNotificationQueue();
 function buildPendingFromTask(task: AgentTask): PendingTaskNotification | null {
   const state = task.state;
   if (state !== 'done' && state !== 'error' && state !== 'aborted') return null;
-  const raw = task.result ?? '';
-  const truncated = raw.length > TASK_NOTIFICATION_OUTPUT_CAP;
-  const output = truncated
-    ? raw.slice(0, TASK_NOTIFICATION_OUTPUT_CAP) + '…(truncated)'
-    : raw;
+  const output = task.result ?? '';
   return {
     taskId: task.id,
     agentName: task.definition.name,
@@ -151,7 +196,7 @@ function buildPendingFromTask(task: AgentTask): PendingTaskNotification | null {
     ...(task.teamName ? { teamName: task.teamName } : {}),
     state,
     output,
-    truncated,
+    truncated: false,
     ...(task.error ? { errorMessage: task.error } : {}),
     durationMs: (task.finishedAt ?? Date.now()) - (task.startedAt ?? Date.now()),
     finishedAt: task.finishedAt ?? Date.now(),
@@ -256,12 +301,13 @@ export function renderTaskNotificationsXml(
       p.truncated ? `truncated="true"` : null,
     ].filter(Boolean).join(' ');
     lines.push(`  <task ${attrs}>`);
-    if (p.state === 'error' && p.errorMessage) {
-      lines.push(`    <error>${escapeXml(p.errorMessage)}</error>`);
+    if (p.state === 'error' && (p.preservationError || p.errorMessage)) {
+      lines.push(`    <error>${escapeXml(p.preservationError ?? p.errorMessage!)}</error>`);
     }
     if (p.output) {
       lines.push(`    <output>${escapeXml(p.output)}</output>`);
     }
+    if (p.resultPath) lines.push(`    <result-path>${escapeXml(p.resultPath)}</result-path>`);
     lines.push(`  </task>`);
   }
   lines.push('</task-notification>');

package/src/agent/types.ts

@@ -91,6 +91,10 @@ export interface AgentTask {
   /** Full message history as the runner built it — starts with a
    *  system message + user prompt and grows with tool rounds. */
   messages: LLMMessage[];
+  /** Tool calls the child has made so far, counted live as each call starts.
+   *  `messages` only grows when a tool loop completes (and never on abort/error),
+   *  so a roster that counted messages alone showed «0 tools» for a working child. */
+  toolCallCount?: number;
   /** Final assistant text once the run completes. */
   result?: string;
   /** Error message when state === 'error'. */

package/src/agent-substrate/acp-reviewer.ts

@@ -35,6 +35,22 @@ export interface AcpReviewerOpts {
   timeoutMs?: number;
   /** One deadline for spawn → initialize → session/new → model select (ms). A child that never answers ACP must not hang the review. Default min(timeoutMs, 60000). */
   handshakeTimeoutMs?: number;
+  /**
+   * ACP-REVIEW-VIA-TEAMCLAUDE: how a `claude` review without an explicit `backendSpec` finds the teamclaude
+   * (cct) route. Default (production, non-injected) = `resolveTeamclaudeReviewRoute()`; an injected agent
+   * without this seam does not probe the host.
+   */
+  resolveClaudeRoute?: () => import('../self-dev/review-provider-fallback.js').TeamclaudeReviewRoute
+    | Promise<import('../self-dev/review-provider-fallback.js').TeamclaudeReviewRoute>;
+}
+
+/** ACP claude reviews read the repo with tools and ran 228–345s in practice (OPC #25934); 300s cut them. */
+const ACP_CLAUDE_REVIEW_TIMEOUT_SEC = 600;
+const ACP_REVIEW_TIMEOUT_SEC = 300;
+
+/** Default per-review deadline (seconds) when the caller gives none. */
+export function defaultAcpReviewTimeoutSec(backend: string): number {
+  return canonicalizeBackendId(backend) === 'claude' ? ACP_CLAUDE_REVIEW_TIMEOUT_SEC : ACP_REVIEW_TIMEOUT_SEC;
 }
 
 /**
@@ -96,6 +112,26 @@ export function makeAcpReviewLLM(opts: AcpReviewerOpts): (prompt: string, images
     // The injected seam deliberately accepts arbitrary test backends. The
     // production path alone resolves aliases and transport through the factory.
     const backend = canonicalizeBackendId(requestedBackend);
+    const timeoutMs = opts.timeoutMs ?? defaultAcpReviewTimeoutSec(backend) * 1000;
+    // ACP-REVIEW-VIA-TEAMCLAUDE (대표 10-21): a claude review goes through teamclaude (multi-account proxy) when it
+    //   answers with a base URL — same cct spawn as the subscription lane. No answer = the prior path, recorded.
+    let backendSpec = opts.backendSpec;
+    let childEnv = opts.env;
+    const resolveClaudeRoute = backend === 'claude' && !opts.backendSpec
+      ? opts.resolveClaudeRoute ?? (injected ? undefined
+        : async () => (await import('../self-dev/review-provider-fallback.js')).resolveTeamclaudeReviewRoute())
+      : undefined;
+    if (resolveClaudeRoute) {
+      let route: import('../self-dev/review-provider-fallback.js').TeamclaudeReviewRoute;
+      try { route = await resolveClaudeRoute(); } catch { route = { reason: 'teamclaude-unavailable' }; }
+      if (route.spawn) { backendSpec = route.spawn.backendSpec; childEnv = route.spawn.env; }
+      debug.log('review.acp', 'claude-route', {
+        viaTeamclaude: Boolean(route.spawn),
+        baseUrlSet: Boolean(childEnv?.ANTHROPIC_BASE_URL),
+        timeoutSec: Math.round(timeoutMs / 1000),
+        reason: route.reason,
+      });
+    }
     // ⛔⭐⭐⭐ 백엔드 해석은 «`try` 밖»이라 여기서 던지면 아래 `catch` 의 `acp-review/error` 가
     //   «안 걸린다**. 그래서 `--acp-backend claude-code`(미등록) 같은 오타를 주면 레지스트리가
     //   ***`Unknown ACP backend "claude-code". Known: …"`*** 라는 «완벽한» 오류를 던지는데도
@@ -105,14 +141,13 @@ export function makeAcpReviewLLM(opts: AcpReviewerOpts): (prompt: string, images
     //   ⇒ 이 한 줄만 자기 catch 로 감싼다(전체 try 를 앞당기면 `start` 관측이 그 안으로 들어간다).
     let transport: string | null;
     try {
-      transport = injected ? null : opts.backendSpec?.transport ?? getAcpBackend(backend).transport ?? 'acp';
+      transport = injected ? null : backendSpec?.transport ?? getAcpBackend(backend).transport ?? 'acp';
     } catch (e) {
       debug.log('acp-review', 'error', {
         requestedBackend, backend, stage: 'resolve-backend', message: (e as Error).message,
       }, { level: 'error' });
       throw e;
     }
-    const timeoutMs = opts.timeoutMs ?? 300_000;
     debug.log('acp-review', 'start', {
       requestedBackend,
       backend,
@@ -130,7 +165,7 @@ export function makeAcpReviewLLM(opts: AcpReviewerOpts): (prompt: string, images
     let capabilitiesObserved = false;
     const agentOpts: Omit<AcpAgentOpts, 'backendId'> = {
       cwd: opts.cwd,
-      ...(opts.backendSpec ? { backendSpec: opts.backendSpec, env: opts.env } : {}),
+      ...(backendSpec ? { backendSpec, env: childEnv } : {}),
       log: (message) => debug.log('acp-review', 'agent-log', { backend, message }),
       onCapabilities: (capabilities) => {
         capabilitiesObserved = true;
@@ -159,7 +194,7 @@ export function makeAcpReviewLLM(opts: AcpReviewerOpts): (prompt: string, images
     // chat agents, whose callbacks and lifecycle must not be mutated here.
     // Grok's start can hang before the manager registers the subprocess;
     // own it directly so the handshake timeout can stop that child.
-    const directAgent = injected || Boolean(opts.backendSpec) || backend === 'grok';
+    const directAgent = injected || Boolean(backendSpec) || backend === 'grok';
     const reviewManager = directAgent ? undefined : new AcpAgentManager();
     let agent: AcpAgent | undefined;
     let text = '';