elanous 0.2.35 → 0.2.36

package/scripts/ux-sim.ts

@@ -68,6 +68,59 @@ if (argv[0] === 'emit') {
   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/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/pr-reviewer.ts

@@ -36,10 +36,25 @@ export function isScopeRevertMustFix(mustFix: string): boolean {
   return scopeSignal && revertSignal;
 }
 
+/**
+ * SCOPE-ESCAPE-AS-REFINE (대표 10-22 «범위 밖 허용도 로직으로») — 범위-되돌림 must-fix 중 강등하지 «않는» 것:
+ * 삭제·보호 경로(규칙·자격증명·운영 config)를 되돌리라는 지적. 오케스트레이터 자동 정지 사유(scope-adjacency
+ * `ScopeStopReason`)와 같은 선이다 — 상한은 리뷰 문면으로 잴 수 없으니 여기서 다루지 않는다.
+ */
+// ⚠️ 영어 `remove` 는 «되돌려라» 동사로도 흔하다(«unrelated change, remove it») — 삭제 신호는 `delet` 만 본다.
+const SCOPE_REVERT_KEEP_BLOCKER = /삭제|지웠|지운|delet|\.rules\b|credential|secret|auth\.json|\.env\b|config\.json|보호\s*경로|protected/i;
+
+/** 범위-되돌림 must-fix 를 shouldFix 로 강등할 대상인가(결정론 · 문자열만). */
+export function isDemotableScopeRevertMustFix(mustFix: string): boolean {
+  return isScopeRevertMustFix(mustFix) && !SCOPE_REVERT_KEEP_BLOCKER.test(mustFix);
+}
+
 export interface ReviewResult {
   verdict: ReviewVerdict;
   mustFix: string[];
   shouldFix: string[];
+  /** SCOPE-ESCAPE-AS-REFINE — 리뷰어가 must-fix 로 냈지만 «범위 밖이니 되돌려라» 라서 shouldFix 로 내린 원문(관측용). */
+  scopeRevertDemoted?: string[];
   /** 리뷰어가 판정에 앞서 더 보아야 한다고 관측한 저장소 맥락. 소비·판정에는 아직 쓰지 않는다. */
   requirements?: string[];
   /** 실제 리뷰가 돌았나(LLM 응답 파싱 성공). 미주입/예외로 verdict='pass' 된 경우와 진짜 PASS 구분. */
@@ -302,7 +317,7 @@ export function planReviewChunks(
  */
 export function foldReviewResults(
   results: readonly ReviewResult[],
-): Pick<ReviewResult, 'verdict' | 'mustFix' | 'shouldFix' | 'requirements' | 'reviewed' | 'failureReason' | 'reviewerFallback'> {
+): Pick<ReviewResult, 'verdict' | 'mustFix' | 'shouldFix' | 'scopeRevertDemoted' | 'requirements' | 'reviewed' | 'failureReason' | 'reviewerFallback'> {
   const dedupe = (values: readonly string[]): string[] => [...new Set(values)];
   const collect = (pick: (r: ReviewResult) => readonly string[] | undefined): string[] =>
     dedupe(results.flatMap((r) => [...(pick(r) ?? [])]));
@@ -312,12 +327,14 @@ export function foldReviewResults(
   const mustFix = collect((r) => r.mustFix).slice(0, 6);
   const shouldFix = collect((r) => r.shouldFix).slice(0, 6);
   const requirements = collect((r) => r.requirements);
+  const scopeRevertDemoted = collect((r) => r.scopeRevertDemoted);
   const failed = results.find((r) => r.reviewed !== true);
   const reviewerFallback = results.find((r) => r.reviewerFallback)?.reviewerFallback;
   return {
     verdict,
     mustFix,
     shouldFix,
+    ...(scopeRevertDemoted.length ? { scopeRevertDemoted } : {}),
     ...(requirements.length ? { requirements } : {}),
     reviewed: results.length > 0 && failed === undefined,
     ...(failed?.failureReason ? { failureReason: failed.failureReason } : {}),
@@ -678,6 +695,8 @@ const NO_FINDING_REMARK = new RegExp([
   String.raw`^수용\s*기준(?:을|이)?\s*(?:(?:모두|전부)\s*)?충족(?:함|됨|했다|합니다)?[.。]?$`,
   String.raw`^(?:all\s+)?acceptance\s+criteria\s+(?:are\s+)?(?:all\s+)?met\.?$`,
 ].join('|'), 'i');
+// Unbracketed free text is more ambiguous; fold only explicit blocker-absence statements.
+const UNBRACKETED_NO_FINDING_REMARK = /^(?:(?:블로커|차단)\s*)?(?:수준의?\s*)?(?:결함|문제|이슈|지적|블로커)(?:은|는|이|가)?\s*(?:발견되지\s*않(?:음|았(?:다|습니다)?)|없(?:음|다|습니다))[.。]?$/i;
 // OP #3173 — 설명은 의미 추정하지 않는다. 실측으로 무소견임을 확인한 문장만 등록한다.
 // 문법 밖 `없음 — 설명`은 실제 결함일 수 있으므로 mustFix에 남긴다.
 const LONG_BRACKETED_SENTINEL = new RegExp(String.raw`^[([（【]\s*(?:[-—–]+\s*)?${NONE_WORD}\s*[—–\-:·]\s*([\s\S]+?)\s*[)\]）】]$`, 'i');
@@ -695,6 +714,20 @@ const KNOWN_POSITIVE_FINDINGS = new Set([
   'retro 사실과 tasks cover 집계는 분모 줄이 있든 없든 같다. 시험(`retro-cli.test.ts`)이 이를 고정하고, 임시 폴더는 `finally` 의 `rmSync` 로 지운다.',
   // 이 후속 PR 자체의 ACP r2: 닫힌 무소견 문장.
   '없음 — 막는 결함은 찾지 못했다.',
+  // REVIEW-MUSTFIX-NONE-NORMALIZE · 2026-10-22 ACP 저장 결과 #30199/#30188/#30183.
+  // 설명을 의미 추정으로 삭제하지 않는다. 원문 전체 일치만 무결함으로 접는다.
+  '(없음) #30188(UX)과 #30189(MK)는 서로 다른 파일만 고쳐서 글자 단위로 겹치는 곳이 없습니다. 합친 뒤에 새로 생긴 회귀도 찾지 못했습니다.',
+  '없음. 네 고침 모두 지금 저장소 계약과 맞는다. 하나씩 대조했다.',
+  '`catalog.yaml:24` kinds 끝에 `classify`가 있다.',
+  '`research-loop.yaml`은 노드 26개이고 `entry_node: intake`다.',
+  '`self-implement.ts:247`이 `cwd-repository`를 돌려준다.',
+  '기본 확장 판정(`scope-adjacency.ts:121`)은 삭제를 `deletion` 정지 사유로 본다.',
+  "`tier-split.ts`의 `planTierSplit`은 두 경우를 `kind:'blocked'`로 돌려보냅니다.",
+  'device-test 조각 없이 feature 조각만 있는 경우: `device-first-stage-missing`',
+  'device-test 조각이 2개 이상이거나, 첫 조각이 아니거나, 그 뒤에 feature가 아닌 조각이 섞인 경우: `device-first-order-invalid`',
+  '이 반환은 `tier-split.ts:114`에서 `handTask({ ...hand, tierSplitBlocked: plan.reason })` 한 곳으로만 이어집니다. decomposer의 timeout이나 throw도 같은 blocked 경로를 탑니다.',
+  '`task-hand.ts`는 다음 세 줄에서 이 경우를 처리합니다.',
+  "`:1066`: 카드 status를 `'failed'`로 정하고, history에 `tier-split-failed: <reason>`을 남깁니다.",
 ]);
 function isPositiveNoFinding(text: string): boolean {
   return KNOWN_POSITIVE_FINDINGS.has(text);
@@ -712,10 +745,13 @@ function isLongNoFindingBracket(text: string): boolean {
  *  ⭐ export — `parseReviewResultOutput` 가 «같은» 판정으로 저장된 결과의 표지 줄을 다시 접는다(PR-LAND-MUSTFIX-NONE · 복제 금지). */
 export function isNoneSentinelFinding(finding: string): boolean {
   const text = finding.trim();
-  if (!text || isBracketedPlaceholder(text)) return true;
+  if (!text || text === '[]' || isBracketedPlaceholder(text)) return true;
   if (isPositiveNoFinding(text)) return true;
+  if (text === '(없음 — 막는 결함은 찾지 못했다.)') return true;
   if (/^[-—–]+$/.test(text)) return true;
   const markerText = text.replace(/^[—–-]+\s*|\s*[—–-]+$/g, '').trim();
+  const unbracketedNone = new RegExp(String.raw`^${NONE_WORD}\s*[—–\-:·]\s*(.+)$`, 'i').exec(markerText);
+  if (unbracketedNone && UNBRACKETED_NO_FINDING_REMARK.test(unbracketedNone[1]!.trim())) return true;
   const leadingNone = /^[（(]\s*(?:없음|none)\s*[）)]\s+(.+)$/i.exec(markerText);
   if (leadingNone && KNOWN_NO_FINDING_REMARKS.has(leadingNone[1]!.trim())) return true;
   if (markerText && (BARE_SENTINEL.test(markerText) || DASH_ONLY_SENTINEL.test(markerText) || DASH_WRAPPED_BRACKETED_SENTINEL.test(markerText))) return true;
@@ -767,11 +803,27 @@ export function parseReviewResult(text: string): ReviewResult {
     const first = shouldFix.shift() ?? fallbackFinding;
     mustFix.push(first ?? 'PR 리뷰 FAIL — 재작업 필요(구체 지적 미파싱).');
   }
+  // SCOPE-ESCAPE-AS-REFINE — 골의 대상 경로는 출발점이다: «범위 밖이니 되돌려라/분리하라» 는 블로커가 아니라 비블로커.
+  //   삭제·보호 경로 지적은 블로커로 남긴다. 남은 블로커가 없으면 FAIL → WARN(위 «FAIL 인데 must-fix 없음» 승격을 다시 타지 않는다).
+  const scopeRevertDemoted = mustFix.filter(isDemotableScopeRevertMustFix);
+  let finalVerdict = verdict;
+  if (scopeRevertDemoted.length > 0) {
+    const kept = mustFix.filter((finding) => !isDemotableScopeRevertMustFix(finding));
+    mustFix.splice(0, mustFix.length, ...kept);
+    // 리뷰어가 원래 낸 should-fix 를 앞에 둔다 — 아래 상한(6)이 원래 지적을 밀어내지 않게(강등 원문은 scopeRevertDemoted 에 전부 남는다).
+    shouldFix.push(...scopeRevertDemoted);
+    if (verdict === 'fail' && kept.length === 0) finalVerdict = 'warn';
+    try {
+      debug.log('review.parse', 'scope-revert-demoted', { count: scopeRevertDemoted.length, verdictBefore: verdict, verdictAfter: finalVerdict,
+        remainingMustFix: kept.length, heads: scopeRevertDemoted.map((finding) => safeLogText(finding, 120)) });
+    } catch { /* observation must not change parsed review data */ }
+  }
   const fallback = text.match(/\n\[reviewer fallback: ([^\r\n]+)\]$/);
   return {
-    verdict,
+    verdict: finalVerdict,
     mustFix: mustFix.slice(0, 6),
     shouldFix: shouldFix.slice(0, 6),
+    ...(scopeRevertDemoted.length ? { scopeRevertDemoted } : {}),
     ...(fallback ? { reviewerFallback: fallback[1] } : {}),
     ...(requirements.length ? { requirements } : {}),
   };