elanous 0.2.35 → 0.2.37

package/src/acp/client.ts

@@ -43,6 +43,7 @@ import { grokApiKeyEnvName } from './grok-auth-probe.js';
 import { grokAuthHint, isGrokAuthError } from './grok-auth.js';
 import { providerEnvKey } from '../llm/provider-credentials.js';
 import { getUserConfig } from '../user-config.js';
+import { createAcpStderrSummarizer } from './stderr-summary.js';
 import {
   AcpForkSessionUnsupportedError,
   AcpListSessionsUnsupportedError,
@@ -548,16 +549,41 @@ export class AcpAgent {
     });
     await spawned;
 
-    // Stderr from the agent is opaque text — log it so the operator
-    // sees errors from the subprocess (auth, network, etc.) without
-    // having to attach a debugger.
+    // Keep raw diagnostics in the debug log and coalesce the UI warning.
+    const stderrSummary = createAcpStderrSummarizer(({ kind, count }) => {
+      this.log(`stderr: ${kind} (${count}건)`);
+    });
+    const maxPendingStderrChars = 8 * 1024;
+    let pendingStderr = '';
+    const recordStderrLine = (line: string): void => {
+      const clean = line.trim();
+      if (!clean) return;
+      const redacted = redactSecretText(clean);
+      debug.log('acp.stderr', 'line', { backendId: this.spec.id, line: redacted });
+      stderrSummary.push(redacted);
+    };
     child.stderr.setEncoding('utf-8');
     child.stderr.on('data', (chunk: string) => {
-      for (const line of chunk.split('\n')) {
-        if (line.trim()) this.log(`stderr: ${line}`);
+      const lines = `${pendingStderr}${chunk}`.split('\n');
+      pendingStderr = lines.pop() ?? '';
+      for (const line of lines) recordStderrLine(line);
+      while (pendingStderr.length > maxPendingStderrChars) {
+        recordStderrLine(`${pendingStderr.slice(0, maxPendingStderrChars)} [continued]`);
+        pendingStderr = pendingStderr.slice(maxPendingStderrChars);
       }
     });
+    child.stderr.once('end', () => {
+      recordStderrLine(pendingStderr);
+      pendingStderr = '';
+      stderrSummary.flush();
+    });
+    child.stderr.once('error', () => {
+      recordStderrLine(pendingStderr);
+      pendingStderr = '';
+      stderrSummary.flush();
+    });
     child.on('exit', (code, signal) => {
+      stderrSummary.flush();
       this.log(`subprocess exited (code=${code}, signal=${signal})`);
       this.proc = null;
       this.connection = null;

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,9 +425,16 @@ export function bridgeCoreTurnToAcp(
         dispatchTool,
         signal: ctrl.signal,
         ...(modelOverride !== undefined ? { modelOverride } : {}),
+        ...(autohealProvider ?? {}),
         ...(maxToolTurns !== undefined ? { maxToolTurns } : {}),
         ...((!factQuestion || explicitMaxToolTurns !== undefined) && deps.budgetGrant !== undefined ? { budgetGrant: deps.budgetGrant } : {}),
         callbacks: {
+          onGoalInterim: (text) => {
+            void turnCtx.pushSessionUpdate(
+              { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: '' } },
+              { goalInterim: text },
+            );
+          },
           onText: (delta, full) => {
             // ⛔ 검증 보충이 붙은 최종 답의 재방출(`onText('', 답+보충)`)은 흘리지 않는다 — 빈 청크를 TUI 는
             //   «확정(commit)»으로 읽어 이미 그린 답을 굳히고, 아래 onTurnComplete 재표면화가 같은 답을
@@ -438,7 +468,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 +636,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/acp/stderr-summary.ts

@@ -0,0 +1,49 @@
+export interface AcpStderrSummary {
+  kind: string;
+  count: number;
+}
+
+const MAX_KINDS_PER_WINDOW = 8;
+const OTHER_KIND = 'other stderr messages';
+
+function classify(line: string): string {
+  const clean = line.replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, '').trim();
+  if (/Skipping MCP tool\b/i.test(clean)) {
+    return clean
+      .replace(/\bserver=\S+/gi, 'server=*')
+      .replace(/\btool=\S+/gi, 'tool=*')
+      .replace(/tool name .+? is invalid/i, 'tool name <name> is invalid')
+      .slice(0, 240);
+  }
+  return clean.slice(0, 240);
+}
+
+/** Collect stderr into bounded, one-second UI summaries while callers retain raw lines in debug logs. */
+export function createAcpStderrSummarizer(
+  report: (summary: AcpStderrSummary) => void,
+  intervalMs = 1_000,
+): { push(line: string): void; flush(): void } {
+  const pending = new Map<string, number>();
+  let timer: ReturnType<typeof setTimeout> | undefined;
+
+  const flush = (): void => {
+    if (timer) clearTimeout(timer);
+    timer = undefined;
+    for (const [kind, count] of pending) report({ kind, count });
+    pending.clear();
+  };
+
+  return {
+    push(line): void {
+      const kind = classify(line);
+      if (!kind) return;
+      const key = pending.has(kind) || pending.size < MAX_KINDS_PER_WINDOW ? kind : OTHER_KIND;
+      pending.set(key, (pending.get(key) ?? 0) + 1);
+      if (!timer) {
+        timer = setTimeout(flush, intervalMs);
+        timer.unref?.();
+      }
+    },
+    flush,
+  };
+}

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/monad-agent-turn.ts

@@ -172,6 +172,7 @@ export function makeElanousAgentRunTurn(cfg: UserConfig, surface: SessionSource,
           provider: cfg.llm.provider,
           configuredModel: cfg.llm.model,
           text: opts.userText,
+          surface,
           explicitModel: llmOpts?.model,
           routePolicy: cfg.llm.routePolicy,
         });

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>');