elanous 0.2.40 → 0.2.42

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

@@ -38,6 +38,7 @@ import { nextTurnFallbackProvider, resolveDefaultProvider, type LLMMessage, type
 import { readAutohealProviderFallback } from '../self-health/autoheal.js';
 import { debug, redactSecretText } from '../debug/log.js';
 import { CoreTurnAuthRejectedError } from '../core-turn/auth-rejected-notice.js';
+import { globalTaskNotificationQueue, renderTaskNotificationsXml } from '../agent/task-notification.js';
 import {
   runCoreTurn,
   runGoalLoop,
@@ -57,6 +58,13 @@ import { resolveSessionSurfaceProfile } from '../session-runtime/index.js';
 import { classifyTuiChatIntent, formatTuiRouteLine, isSeatOpsDirective, type TuiChatRoute } from '../core-turn/short-question.js';
 import { HARNESS_ROLE_ENV } from '../harness/harness-space.js';
 import { createReasoningThoughtBuffer } from './reasoning-thought-buffer.js';
+import {
+  REQUEST_SIZE_MAX_CHARS,
+  createRequestSizeGuard,
+  estimateRequestChars,
+  formatRequestSizeStatus,
+  type RequestSizeGuard,
+} from '../session/request-size-guard.js';
 
 const FACT_QUESTION_INSTRUCTION = '사실·최신 정보 질문이다. WebSearch 를 1~2회 쓰고 검색 결과(제목·스니펫·URL)로 답하라. 출처 링크를 붙여라. 셸·브라우저·파일 도구는 검색 결과로 부족할 때만. 도구 예산에 닿으면 지금까지 근거로 답하고 끝에 «더 찾아볼까요?»를 붙여라.';
 
@@ -143,6 +151,18 @@ export interface CoreTurnBridgeDeps {
   /** TUI-H1-SEAT-GOALLOOP — the seat this TUI works for (`detectSeatTui`), read per turn. null/absent = a human
    *  conversation TUI (routing unchanged). A seat TUI sends operational directives to the goal loop. */
   resolveSeat?: () => string | null;
+  /** TUI-TOKEN-GUARD-WIRE — host write-back for the #32254 request-size cap.
+   *  Compacts the host's own history store (the one `getMessages` reads) in place
+   *  so the next prompt does not reload the original. The bridge re-reads
+   *  `getMessages` after `fired:true`. Only consulted on `tuiRouting` turns. */
+  compactPersistedHistory?: (ctx: {
+    sessionId: string;
+    userText: string;
+    requestChars: number;
+    maxChars: number;
+  }) => Promise<{ fired: boolean; reason: string }>;
+  /** Override the request-size cap (tests). Defaults to `REQUEST_SIZE_MAX_CHARS`. */
+  requestSizeMaxChars?: number;
 }
 
 /** Default abort-poll cadence. 50ms = 20 Hz: responsive without
@@ -224,7 +244,7 @@ export function bridgeCoreTurnToAcp(
     (poll as unknown as { unref?: () => void }).unref?.();
 
     try {
-      const messages = await Promise.resolve(
+      let messages = await Promise.resolve(
         deps.getMessages({
           sessionId: turnCtx.sessionId,
           userText: turnCtx.userText,
@@ -318,9 +338,71 @@ export function bridgeCoreTurnToAcp(
       }
       const explicitMaxToolTurns = deps.resolveMaxToolTurns?.({ sessionId: turnCtx.sessionId });
       const maxToolTurns = explicitMaxToolTurns ?? (factQuestion ? getUserConfig().chat.factQuestion.maxToolTurns : undefined);
-      const turnMessages: LLMMessage[] = factQuestion
-        ? [{ role: 'system', content: FACT_QUESTION_INSTRUCTION }, ...messages]
-        : messages;
+      const withFactInstruction = (seed: LLMMessage[]): LLMMessage[] => factQuestion
+        ? [{ role: 'system', content: FACT_QUESTION_INSTRUCTION }, ...seed]
+        : seed;
+      let turnMessages: LLMMessage[] = withFactInstruction(messages);
+      // TUI-TOKEN-GUARD-WIRE — exact serialized provider measurement owns
+      // first-request compaction; the seed estimate is telemetry only. This
+      // keeps turn-0 history untouched until compactFirstRequest writes back.
+      let requestSizeGuard: RequestSizeGuard | undefined;
+      if (deps.tuiRouting === true) {
+        const maxChars = deps.requestSizeMaxChars ?? REQUEST_SIZE_MAX_CHARS;
+        let historyCompacted = false;
+        const compactHistory = async (requestChars: number, stage: 'first-request') => {
+          if (!deps.compactPersistedHistory || historyCompacted) return false;
+          let fired = false;
+          let reason = 'no-op';
+          try {
+            const result = await deps.compactPersistedHistory({
+              sessionId: turnCtx.sessionId, userText: turnCtx.userText, requestChars, maxChars,
+            });
+            fired = result.fired;
+            reason = result.reason;
+            historyCompacted = fired;
+          } catch (error) {
+            reason = 'compaction-error';
+            debug.log('llm.request', 'request-size-compact-error', {
+              stage, requestChars, maxChars, message: error instanceof Error ? error.message : String(error),
+            }, { level: 'warn' });
+          }
+          return { fired, reason };
+        };
+        const estimatedSeedChars = estimateRequestChars(turnMessages, tools);
+        debug.log('llm.request', 'request-size-compact', {
+          stage: 'estimate', sessionId: turnCtx.sessionId,
+          beforeChars: estimatedSeedChars, maxChars,
+          compacted: false, reason: 'awaiting-exact-wire-measurement',
+        });
+        requestSizeGuard = createRequestSizeGuard({
+          maxChars,
+          compactOptions: () => {
+            const guardModel = modelOverride ?? getUserConfig().llm?.model;
+            const guardConfig = getUserConfig().chat;
+            const preserveLastN = guardConfig?.autoCompact?.preserveLastN;
+            const archiveEnabled = guardConfig?.compact?.archiveEnabled;
+            return {
+              sessionId: turnCtx.sessionId,
+              ...(guardModel ? { activeModelId: guardModel } : {}),
+              ...(preserveLastN !== undefined ? { preserveLastN } : {}),
+              ...(archiveEnabled !== undefined ? { archiveEnabled } : {}),
+            };
+          },
+          // The preflight estimate missed (wire over cap, seed under): still write the
+          // compaction back so the next prompt starts small, then compact this request live.
+          compactFirstRequest: async (_current, info) => {
+            await compactHistory(info.requestChars, 'first-request');
+            return null;
+          },
+          onMeasured: (measurement) => {
+            if (!measurement.compacted) return;
+            void turnCtx.pushSessionUpdate(
+              { sessionUpdate: 'agent_thought_chunk', content: { type: 'text', text: formatRequestSizeStatus(measurement) } },
+              { status: true },
+            );
+          },
+        });
+      }
       let toolCallCount = 0;
       const toolKinds = new Set<string>();
       const observeToolBudget = () => {
@@ -371,6 +453,11 @@ export function bridgeCoreTurnToAcp(
           ? runGoalLoop(c, {
               // ACP owns an interactive provider loop: keep its post-completion response contract.
               terminalCompletionShortcut: false,
+              drainIterationMessages: () => {
+                const pending = globalTaskNotificationQueue.drainForParentSessionOrUnscoped(c.sessionId);
+                const xml = renderTaskNotificationsXml(pending);
+                return xml ? [{ role: 'user', content: xml }] : [];
+              },
               ...(goalLoopCfg?.maxIterations !== undefined ? { maxIterations: goalLoopCfg.maxIterations } : {}),
               // #29 처방 — 자리 판정으로 goal loop 에 «되돌아온» 턴만 빈 evidence 완료를 답으로 받는다.
               ...(route.reason.startsWith('seat-') ? { lenientCompletionEvidence: true } : {}),
@@ -434,6 +521,7 @@ export function bridgeCoreTurnToAcp(
         ...(modelOverride !== undefined ? { modelOverride } : {}),
         ...(autohealProvider ?? {}),
         ...(maxToolTurns !== undefined ? { maxToolTurns } : {}),
+        ...(requestSizeGuard ? { requestSizeGuard } : {}),
         ...((!factQuestion || explicitMaxToolTurns !== undefined) && deps.budgetGrant !== undefined ? { budgetGrant: deps.budgetGrant } : {}),
         callbacks: {
           onStatus: (line) => {
@@ -461,6 +549,13 @@ export function bridgeCoreTurnToAcp(
             streamedTextSum += delta;
             void turnCtx.push(delta);
           },
+          onReplaceText: (full) => {
+            reasoningThoughts.flush();
+            streamedTextSum = full;
+            // Match the existing ACP clear/replace convention used for final synthesis.
+            void turnCtx.push('');
+            void turnCtx.push(full);
+          },
           // P2-bridge-ext — forward tool + usage events as ACP
           // sessionUpdate notifications so extension-aware clients
           // (dashboard as ACP client / future web / iphone) can

package/src/agent/registry.ts

@@ -123,6 +123,7 @@ export class AgentRegistry {
       id: randomUUID(),
       definition: opts.definition,
       prompt: opts.prompt,
+      ...(opts.parentSessionId ? { parentSessionId: opts.parentSessionId } : {}),
       depth,
       ...(opts.label ? { label: opts.label } : {}),
       ...(opts.correlationId ? { correlationId: opts.correlationId } : {}),
@@ -136,6 +137,7 @@ export class AgentRegistry {
       ...(opts.teamName ? { teamName: opts.teamName } : {}),
       ...(opts.cwd ? { cwd: opts.cwd } : {}),
       ...(opts.background ? { background: true } : {}),
+      ...(opts.completionDelivery ? { completionDelivery: opts.completionDelivery } : {}),
       // MSS M1.2: brand the spawn with an AgentUri (caller may pre-mint
       // for cross-task tracing; default = fresh mint). The legacy UUID
       // `id` stays the registry key — agentUri rides alongside.

package/src/agent/task-notification.ts

@@ -5,7 +5,7 @@
 // "(running in background)" message on the same turn. To surface the
 // eventual result, we collect a `PendingTaskNotification` per completed
 // background task and inject a `<task-notification>` XML user message
-// at the start of the parent's NEXT turn.
+// at the start of the parent's next turn or at a live goal-loop boundary.
 //
 // Why XML injection instead of a tool ──
 //  • Tool-loop parents would need to remember to poll; the reliability
@@ -43,11 +43,14 @@ export const TASK_NOTIFICATION_OUTPUT_CAP = 500;
 
 export interface PendingTaskNotification {
   taskId: string;
+  parentSessionId?: string;
   agentName: string;
   /** Caller-supplied short label (Agent tool's `name` arg). */
   label?: string;
   /** Team context this task belonged to (Agent tool's `team_name`). */
   teamName?: string;
+  /** Parent-selected route; supplemental results never reopen a TUI turn. */
+  completionDelivery?: 'follow-up' | 'supplement';
   /** Final state of the task — parent LLM sees this to choose follow-up. */
   state: 'done' | 'error' | 'aborted';
   /** Child's final text (capped at TASK_NOTIFICATION_OUTPUT_CAP). */
@@ -150,11 +153,26 @@ export class TaskNotificationQueue {
     }
   }
 
-  /** Return all pending notifications AND clear the queue. Parents
-   *  call this exactly once per turn-start. */
+  /** Return all pending notifications and remove them from the queue. */
   drain(): PendingTaskNotification[] {
-    const out = this.queue;
-    this.queue = [];
+    return this.drainMatching(() => true);
+  }
+
+  /** Drain only results owned by one parent session; leave sibling sessions queued. */
+  drainForParentSession(parentSessionId: string): PendingTaskNotification[] {
+    return this.drainMatching((item) => item.parentSessionId === parentSessionId);
+  }
+
+  /** Drain one session's receipts plus legacy sessionless receipts; keep sibling sessions queued. */
+  drainForParentSessionOrUnscoped(parentSessionId: string): PendingTaskNotification[] {
+    return this.drainMatching((item) => item.parentSessionId === undefined || item.parentSessionId === parentSessionId);
+  }
+
+  private drainMatching(matches: (item: PendingTaskNotification) => boolean): PendingTaskNotification[] {
+    const out = this.queue.filter(matches);
+    if (out.length === 0) return out;
+    const drained = new Set(out);
+    this.queue = this.queue.filter((item) => !drained.has(item));
     this.persist();
     // NOTE: we keep `seen` populated so a listener firing a second
     // time for the same task (rare but possible under races) still
@@ -260,9 +278,11 @@ function buildPendingFromTask(task: AgentTask): PendingTaskNotification | null {
   const output = task.result ?? '';
   return {
     taskId: task.id,
+    ...(task.parentSessionId ? { parentSessionId: task.parentSessionId } : {}),
     agentName: task.definition.name,
     ...(task.label ? { label: task.label } : {}),
     ...(task.teamName ? { teamName: task.teamName } : {}),
+    ...(task.completionDelivery ? { completionDelivery: task.completionDelivery } : {}),
     state,
     output,
     truncated: false,

package/src/agent/types.ts

@@ -154,6 +154,8 @@ export interface AgentTask {
    *  the runner drains events in the background; completion emits
    *  a task-notification (PFC-S1 P2). */
   background?: boolean;
+  /** How a background completion reaches an idle parent TUI. */
+  completionDelivery?: 'follow-up' | 'supplement';
   /** MSS M1.2: branded URI form of this spawn's identity. The
    *  registry mints one alongside the UUID-keyed `id`. Downstream
    *  MSS bridges (M3 signal sender · M4 memory participant) reference
@@ -183,6 +185,8 @@ export interface AgentSpawnOpts {
   definition: AgentDefinition;
   /** User message / query the agent should answer. */
   prompt: string;
+  /** Session that owns this spawn; scopes background completion delivery. */
+  parentSessionId?: string;
   /** Short task label — used by UI panes (e.g. agent-roster in
    *  wd-scratch) to distinguish spawns that share a definition.
    *  Stored verbatim on AgentTask.label. Optional; when omitted,
@@ -225,6 +229,8 @@ export interface AgentSpawnOpts {
    *  immediately and drains events off-thread. Completion emits a
    *  task-notification (see src/agent/task-notification.ts, P2). */
   background?: boolean;
+  /** Parent-selected routing for background completions. */
+  completionDelivery?: 'follow-up' | 'supplement';
   /** MSS M1.2: when the caller has already minted an AgentUri (e.g. a
    *  parent spawn pre-allocating ids for tracing), pass it here.
    *  Otherwise registry.spawn mints one. */

package/src/agent-mission/mission-cli.ts

@@ -6,6 +6,7 @@
 
 import { readFileSync } from 'node:fs';
 import type { AgentBackend, AgentMissionResult, EvidenceMode } from './driver.js';
+import type { AgentCliDetection } from './tool-install.js';
 import { buildAgentMissionDevSpec, executeAgentMissionReroute, type runDevPipeline } from '../self-dev/dev-pipeline.js';
 import { parsePositiveInt } from '../self-dev/dev-cli.js';
 import { parsePluginRef } from './in-agent-plugin.js';
@@ -33,6 +34,8 @@ export interface MissionCliOpts {
 
 export interface MissionCliDeps {
   resolveBackend: (name?: string) => AgentBackend;
+  detectAgentCli?: (agent: 'claude' | 'codex') => AgentCliDetection;
+  onStatus?: (line: string) => void;
   signal?: AbortSignal;
   readFile?: (path: string) => string;
   runDevPipeline?: typeof runDevPipeline;
@@ -114,6 +117,27 @@ export async function runAgentMissionCliCommand(
     ...(opts.deliverable ? { deliverableHint: opts.deliverable } : {}),
     ...(opts.screens ? { screensDir: opts.screens } : {}),
   });
+  // The production CLI injects the host probe; injected tests can assert this preflight
+  // without spawning an agent CLI. For a chain, inspect each external CLI before any launch.
+  const externalAgents = [...new Set((chain ?? [agentBackend.name]).filter(
+    (name): name is 'claude' | 'codex' => name === 'claude' || name === 'codex',
+  ))];
+  const detections = deps.detectAgentCli ? externalAgents.map((agent) => deps.detectAgentCli!(agent)) : [];
+  const statusLine = detections.map(({ message }) => message).join(' · ');
+  if (statusLine) deps.onStatus?.(statusLine);
+  const notReady = detections.find(({ installed, login }) => installed !== true || login !== 'ready');
+  if (notReady) {
+    const message = notReady.installed === false
+      ? `${notReady.message}; 공식 설치 후 다시 실행`
+      : notReady.installed === null
+        ? `${notReady.message}; 설치 상태를 확인한 뒤 다시 실행`
+        : notReady.login === 'api-key'
+          ? `${notReady.message}; API 키 요금 고지와 동의 화면이 아직 없어 미션을 시작하지 않습니다 — Codex 구독 로그인(codex login) 후 다시 실행`
+        : notReady.login === 'needed'
+          ? `${notReady.message}; ${notReady.agent} login 후 다시 실행`
+          : `${notReady.message}; 로그인 상태를 확인한 뒤 다시 실행`;
+    return { ok: false, message, exitCode: 1 };
+  }
   const { result, exitCode } = await executeAgentMissionReroute(
     spec, agentBackend,
     { ...(deps.runDevPipeline ? { runDevPipeline: deps.runDevPipeline } : {}), ...(deps.signal ? { signal: deps.signal } : {}) },