elanous 0.2.37 → 0.2.40

package/src/self-implement/self-implement-cli.ts

@@ -19,9 +19,12 @@ import type { DocumentReferenceStatus } from './self-implement-runtime.js';
 import { resolveObserveOnlyDecision } from './observe-only.js';
 import { getUserConfig } from '../user-config.js';
 import { resolveAutoReview } from './context-capsule.js';
+import { readDecomposeProposals } from '../self-dev/decompose-proposal.js';
 
 /** self implement CLI 옵션(commander) — `--no-draft` 는 draft:false 로, `--max-wait` 는 문자열로 도착. */
 export interface SelfImplementCliOpts {
+  /** Managed tool dispatch cancellation signal, forwarded through the pipeline to the active implementation child. */
+  signal?: AbortSignal;
   base?: string;
   draft?: boolean;
   openPr?: boolean;
@@ -71,6 +74,28 @@ export interface SelfImplementCliDeps {
   }>;
   /** runDevPipeline 내부 배선 주입(runSelfImplement/seams 등·테스트). */
   pipelineDeps?: DevPipelineDeps;
+  /** Parent-side run-ledger observation, injected to verify terminal JSON evidence. */
+  readGoalPlanRevision?: typeof readDecomposeProposals;
+}
+
+function attachGoalPlanRevisionObservation(
+  result: SelfImplementResult,
+  deps: SelfImplementCliDeps,
+): SelfImplementResult {
+  if (result.goalPlanRevision !== undefined || typeof result.runId !== 'string' || !result.runId.trim()) return result;
+  try {
+    // The ledger reader joins by shardId when present and otherwise by runId; a single-run
+    // child uses its runId as either key depending on the writer, so query both explicitly.
+    const scan = (deps.readGoalPlanRevision ?? readDecomposeProposals)({
+      shardIds: [result.runId],
+      runIds: [result.runId],
+    });
+    const observation = scan.goalPlanRevisions.get(result.runId) ?? scan.readFailure;
+    return observation ? { ...result, goalPlanRevision: observation } : result;
+  } catch {
+    // An unavailable observation stays absent; the supervisor treats that as a hold.
+    return result;
+  }
 }
 
 /**
@@ -205,11 +230,12 @@ export async function runSelfImplementCliCommand(
       entry: opts.entry ?? 'external-verbatim', // CLI = 외부 창구(외부가 프롬프트 엔지니어 → verbatim 존중)
     });
     spec.entrance = opts.naturalLanguageDispatch ? 'nl-self-implement' : 'cli-self-implement';
-    const pipelineDeps = opts.approver || opts.progress
-      ? { ...deps.pipelineDeps, ...(opts.approver ? { approver: opts.approver } : {}), ...(opts.progress ? { progress: opts.progress } : {}) }
+    const pipelineDeps = opts.approver || opts.progress || opts.signal
+      ? { ...deps.pipelineDeps, ...(opts.approver ? { approver: opts.approver } : {}), ...(opts.progress ? { progress: opts.progress } : {}), ...(opts.signal ? { signal: opts.signal } : {}) }
       : deps.pipelineDeps;
     const exec = deps.executeReroute ?? executeSelfImplementReroute;
     let { result, exitCode } = await exec(spec, pipelineDeps ? { pipelineDeps } : undefined);
+    result = attachGoalPlanRevisionObservation(result, deps);
 
     // ⭐⭐⭐ 단일 실행도 «루프»를 지난다 (E2) — 판정자는 연합과 «같은 자»다.
     //   ⛔ 종전엔 단일이 실패하면 그냥 끝났다. 아무도 「다시 걸까」를 묻지 않았다.
@@ -257,9 +283,9 @@ export async function runSelfImplementCliCommand(
         rerun: async (_, invocation) => {
           const repairGoal = invocation.repairGoals?.[initialJob.taskId];
           const next = await exec(repairGoal ? { ...spec, input: { ...spec.input, text: repairGoal } } : spec, pipelineDeps ? { pipelineDeps } : undefined);
-          result = next.result;
+          result = attachGoalPlanRevisionObservation(next.result, deps);
           exitCode = next.exitCode;
-          return [{ ...singleRunAsJobResult(feature, next.result), taskId: initialJob.taskId }];
+          return [{ ...singleRunAsJobResult(feature, result), taskId: initialJob.taskId }];
         },
       });
     }

package/src/session/channel-ask-op-envelope.ts

@@ -0,0 +1,36 @@
+export interface AskOpQuestionEnvelope {
+  surface: 'telegram';
+  botId: string;
+  chatId: number | string;
+  threadId?: number | string;
+  messageId: number | string;
+  updateId: number | string;
+  question: string;
+}
+
+export const ASK_OP_COMMAND = 'askop';
+
+export function formatAskOpQuestionEnvelope(input: AskOpQuestionEnvelope): string {
+  return [
+    `Telegram /${ASK_OP_COMMAND}`,
+    `botId=${input.botId}`,
+    `chatId=${input.chatId}`,
+    `threadId=${input.threadId ?? 'none'}`,
+    `messageId=${input.messageId}`,
+    `updateId=${input.updateId}`,
+    `question: ${input.question.trim()}`,
+  ].join('\n');
+}
+
+export function parseAskOpQuestionEnvelope(body: string): AskOpQuestionEnvelope | null {
+  const telegram = /^Telegram \/(?:askop|ask-op)\nbotId=([A-Za-z0-9_-]+)\nchatId=(-?\d+)\nthreadId=(none|\d+)\nmessageId=(\d+)\nupdateId=(\d+)\nquestion: ([\s\S]+)$/.exec(body);
+  if (telegram) {
+    const [, botId, chatId, threadId, messageId, updateId, question] = telegram;
+    return {
+      surface: 'telegram', botId: botId!, chatId: chatId!,
+      ...(threadId === 'none' ? {} : { threadId: threadId! }),
+      messageId: messageId!, updateId: updateId!, question: question!,
+    };
+  }
+  return null;
+}

package/src/session/channel-op-reply-route.ts

@@ -0,0 +1,200 @@
+import { openMsgStore, openMsgStoreReadOnly, type Message, type MsgStore } from '../msg/msg-store.js';
+import { subscribeMsgStream, type MsgStreamHandle } from '../msg/msg-sse-client.js';
+import { join } from 'node:path';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { debug } from '../debug/log.js';
+import { isOwnInstanceEndpoint, parseTelegramEndpoint, telegramEndpointKey } from './session-endpoint-key.js';
+import type { TelegramBot } from '../telegram.js';
+import { parseAskOpQuestionEnvelope } from './channel-ask-op-envelope.js';
+
+export type ChannelOpEndpoint = { surface: 'telegram'; key: string } & NonNullable<ReturnType<typeof parseTelegramEndpoint>>;
+
+export interface ChannelOpReplyTransport {
+  /** Must reject endpoint keys whose instance or bot is not served by this transport. */
+  canSend(endpoint: ChannelOpEndpoint): boolean;
+  /** The stable idempotency key lets a transport suppress retries if it supports them. */
+  send(endpoint: ChannelOpEndpoint, body: string, idempotencyKey: string): Promise<{ receiptId: string }>;
+}
+
+export function createTelegramChannelOpReplyTransport(input: {
+  bot: Pick<TelegramBot, 'sendMessage'>;
+  botId: string;
+  instance: string;
+}): ChannelOpReplyTransport {
+  return {
+    canSend(endpoint) {
+      return endpoint.surface === 'telegram'
+        && isOwnInstanceEndpoint(endpoint.instance, input.instance)
+        && endpoint.botId === input.botId;
+    },
+    async send(endpoint, body, idempotencyKey) {
+      if (endpoint.surface !== 'telegram') throw new Error('Telegram transport cannot send to Discord');
+      const sent = await input.bot.sendMessage(Number(endpoint.chatId), body, {
+        ...(endpoint.threadId !== '0' ? { threadId: Number(endpoint.threadId) } : {}),
+      });
+      return { receiptId: sent && 'messageId' in sent ? `telegram:${sent.messageId}` : `telegram:${idempotencyKey}` };
+    },
+  };
+}
+
+export type ChannelOpReplyResult =
+  | { status: 'delivered'; receiptId: string }
+  | { status: 'already-delivered'; receiptId: string }
+  | { status: 'held' }
+  | { status: 'unknown' }
+  | { status: 'failed-permanent'; errorCode: number }
+  | { status: 'rejected'; reason: 'not-op-reply' | 'missing-question' | 'invalid-question' | 'invalid-endpoint' | 'unknown-endpoint' | 'already-answered' };
+
+const CREATE_RECEIPTS = `CREATE TABLE IF NOT EXISTS channel_op_reply_receipts (
+  question_id INTEGER PRIMARY KEY REFERENCES msg_messages(id),
+  answer_id INTEGER NOT NULL UNIQUE REFERENCES msg_messages(id),
+  endpoint_key TEXT NOT NULL,
+  status TEXT NOT NULL CHECK(status IN ('sending', 'delivered', 'unknown', 'retry', 'failed-permanent')),
+  transport_receipt TEXT,
+  transport_error_code INTEGER,
+  updated_at TEXT NOT NULL
+)`;
+
+function telegramEndpoint(questionBody: string, instance: string): ChannelOpEndpoint | null {
+  const source = parseAskOpQuestionEnvelope(questionBody);
+  if (!source) return null;
+  const threadId = source.threadId ?? '0';
+  if (!Number.isSafeInteger(Number(source.chatId)) || !Number.isSafeInteger(Number(threadId))) return null;
+  const key = telegramEndpointKey({ instance, botId: source.botId, chatId: source.chatId, threadId });
+  const parsed = parseTelegramEndpoint(key);
+  return parsed ? { surface: 'telegram', key, ...parsed } : null;
+}
+
+function parseQuestionEndpoint(questionBody: string, instance: string): ChannelOpEndpoint | null {
+  return telegramEndpoint(questionBody, instance);
+}
+
+/**
+ * Resolve an OP reply through its durable replyTo link, claim one channel receipt,
+ * and send only to the endpoint captured in that question's stored envelope.
+ * An interrupted/ambiguous attempt is held rather than resent. Telegram 4xx
+ * responses other than rate limiting are terminal because the request cannot succeed unchanged.
+ */
+export async function deliverChannelOpReply(
+  store: MsgStore,
+  answerId: number,
+  transport: ChannelOpReplyTransport,
+  options: { instance: string },
+): Promise<ChannelOpReplyResult> {
+  store.db.exec(CREATE_RECEIPTS);
+  const answer = store.getMessage(answerId);
+  if (!answer || answer.from !== 'OP' || answer.replyTo === undefined) return { status: 'rejected', reason: 'not-op-reply' };
+  const question = store.getMessage(answer.replyTo);
+  if (!question) return { status: 'rejected', reason: 'missing-question' };
+  if (question.to !== 'COORDINATOR' || question.kind !== 'question' || question.from !== 'TELEGRAM') {
+    return { status: 'rejected', reason: 'invalid-question' };
+  }
+  const source = parseAskOpQuestionEnvelope(question.body);
+  if (!source) return { status: 'rejected', reason: 'invalid-endpoint' };
+  const provenanceKey = `coord:tg-${source.botId}-${source.updateId}:COORDINATOR`;
+  const provenance = store.db.query(`SELECT 1 FROM msg_provenance WHERE provenance_key = ? AND message_id = ?`)
+    .get(provenanceKey, question.id);
+  if (!provenance) return { status: 'rejected', reason: 'invalid-question' };
+  const endpoint = parseQuestionEndpoint(question.body, options.instance);
+  if (!endpoint) return { status: 'rejected', reason: 'invalid-endpoint' };
+  if (!transport.canSend(endpoint)) return { status: 'rejected', reason: 'unknown-endpoint' };
+
+  const claim = store.db.transaction(() => {
+    const existing = store.db.query(`SELECT answer_id, endpoint_key, status, transport_receipt, transport_error_code
+      FROM channel_op_reply_receipts WHERE question_id = ?`).get(question.id) as {
+        answer_id: number; endpoint_key: string; status: 'sending' | 'delivered' | 'unknown' | 'retry' | 'failed-permanent'; transport_receipt: string | null; transport_error_code: number | null;
+      } | null;
+    if (existing) {
+      if (existing.answer_id !== answer.id || existing.endpoint_key !== endpoint.key) return { kind: 'already-answered' as const };
+      if (existing.status === 'delivered') return { kind: 'delivered' as const, receiptId: existing.transport_receipt ?? '' };
+      if (existing.status === 'failed-permanent') return { kind: 'failed-permanent' as const, errorCode: existing.transport_error_code ?? 400 };
+      if (existing.status !== 'retry') return { kind: 'held' as const };
+      store.db.query(`UPDATE channel_op_reply_receipts SET status = 'sending', updated_at = ?
+        WHERE question_id = ? AND answer_id = ? AND status = 'retry'`)
+        .run(new Date().toISOString(), question.id, answer.id);
+      return { kind: 'claimed' as const };
+    }
+    store.db.query(`INSERT INTO channel_op_reply_receipts(question_id, answer_id, endpoint_key, status, updated_at)
+      VALUES (?, ?, ?, 'sending', ?)`).run(question.id, answer.id, endpoint.key, new Date().toISOString());
+    return { kind: 'claimed' as const };
+  }).immediate();
+  if (claim.kind === 'already-answered') return { status: 'rejected', reason: 'already-answered' };
+  if (claim.kind === 'delivered') return { status: 'already-delivered', receiptId: claim.receiptId };
+  if (claim.kind === 'failed-permanent') return { status: 'failed-permanent', errorCode: claim.errorCode };
+  if (claim.kind === 'held') return { status: 'held' };
+
+  try {
+    const receipt = await transport.send(endpoint, answer.body, `ask-op-reply:${question.id}`);
+    store.db.transaction(() => {
+      store.db.query(`UPDATE channel_op_reply_receipts SET status = 'delivered', transport_receipt = ?, updated_at = ?
+        WHERE question_id = ? AND answer_id = ? AND status = 'sending'`)
+        .run(receipt.receiptId, new Date().toISOString(), question.id, answer.id);
+    }).immediate();
+    return { status: 'delivered', receiptId: receipt.receiptId };
+  } catch (error) {
+    const errorCode = error && typeof error === 'object' && 'errorCode' in error
+      ? (error as { errorCode?: unknown }).errorCode
+      : undefined;
+    const permanent4xx = typeof errorCode === 'number' && Number.isInteger(errorCode)
+      && errorCode >= 400 && errorCode < 500 && errorCode !== 429;
+    const permanentErrorCode = permanent4xx ? errorCode as number : null;
+    store.db.transaction(() => {
+      store.db.query(`UPDATE channel_op_reply_receipts SET status = ?, transport_error_code = ?, updated_at = ?
+        WHERE question_id = ? AND answer_id = ? AND status = 'sending'`)
+        .run(permanent4xx ? 'failed-permanent' : 'unknown', permanentErrorCode, new Date().toISOString(), question.id, answer.id);
+    }).immediate();
+    if (permanentErrorCode !== null) return { status: 'failed-permanent', errorCode: permanentErrorCode };
+    return { status: 'unknown' };
+  }
+}
+
+/** Explicit operator reconciliation for an ambiguous Telegram send. */
+export function reconcileChannelOpReply(
+  store: MsgStore,
+  questionId: number,
+  decision: { status: 'delivered'; receiptId: string } | { status: 'not-delivered' },
+): boolean {
+  store.db.exec(CREATE_RECEIPTS);
+  if (decision.status === 'delivered' && !decision.receiptId.trim()) throw new Error('receiptId is required for delivered reconciliation');
+  const status = decision.status === 'delivered' ? 'delivered' : 'retry';
+  const receiptId = decision.status === 'delivered' ? decision.receiptId : null;
+  return store.db.transaction(() => store.db.query(`UPDATE channel_op_reply_receipts
+    SET status = ?, transport_receipt = ?, updated_at = ? WHERE question_id = ? AND status IN ('sending', 'unknown')`)
+    .run(status, receiptId, new Date().toISOString(), questionId).changes === 1).immediate();
+}
+
+export interface StartChannelOpReplyRouteOptions {
+  transport: ChannelOpReplyTransport;
+  instance: string;
+  botId: string;
+  cursorPath?: string;
+  openReadStore?: () => MsgStore;
+  openWriteStore?: () => MsgStore;
+}
+
+/** Listen to the Telegram seat mailbox and route only linked OP replies. */
+export function startChannelOpReplyRoute(options: StartChannelOpReplyRouteOptions): MsgStreamHandle {
+  const cursorPath = options.cursorPath ?? join(
+    elanousStateRoot(), 'msg', 'sse-cursor', `TELEGRAM-channel-op-replies-${options.botId}.json`,
+  );
+  return subscribeMsgStream({
+    address: 'TELEGRAM',
+    cursorPath,
+    pollMs: 500,
+    openStore: options.openReadStore ?? (() => openMsgStoreReadOnly()),
+    onMessage: async (message: Message) => {
+      if (message.to !== 'TELEGRAM' || message.from !== 'OP' || message.replyTo === undefined) return;
+      const store = (options.openWriteStore ?? (() => openMsgStore()))();
+      try {
+        const result = await deliverChannelOpReply(store, message.id, options.transport, { instance: options.instance });
+        if (result.status === 'unknown' || result.status === 'rejected' || result.status === 'held' || result.status === 'failed-permanent') {
+          debug.log('channel-op-reply-route', result.status, {
+            answerId: message.id,
+            reason: result.status === 'rejected' ? result.reason : undefined,
+            errorCode: result.status === 'failed-permanent' ? result.errorCode : undefined,
+          });
+        }
+      } finally { store.close(); }
+    },
+  });
+}

package/src/session/chat.ts

@@ -58,6 +58,8 @@ export interface RunTurnOpts {
   /** Optional callback for each streamed text delta — telegram uses this to
    *  accumulate; CLI uses it to render live. */
   onDelta?: (delta: string) => void;
+  /** Optional transient stream recovery status for the originating UI. */
+  onStatusLine?: (line: string) => void;
   /** Optional provider override — for tests. */
   provider?: LLMProvider;
   /** Originating utterance surface. Omit only when the caller cannot
@@ -283,7 +285,8 @@ const childContextComposedSessions = new Set<string>();
 export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
   const loaded = loadSession(opts.sessionId);
   if (!loaded) throw new Error(`session not found: ${opts.sessionId}`);
-  const { meta, messages } = loaded;
+  const { meta } = loaded;
+  let messages = loaded.messages;
 
   // Memory injection: build the block once per turn, folded into the
   // system prompt. Never fails loud — if the store isn't set up, we
@@ -366,6 +369,19 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
   };
   appendMessage(opts.sessionId, userMsg);
 
+  const explicitTier = opts.llmOpts?.model ? undefined : explicitTurnTier(opts.userConfig, opts.sessionId);
+  const llmOpts = explicitTier ? {
+    ...(opts.llmOpts ?? {}), model: explicitTier.model,
+    ...(explicitTier.reasoningEffort && !opts.llmOpts?.reasoningEffort ? { reasoningEffort: explicitTier.reasoningEffort } : {}),
+  } : opts.llmOpts;
+  if (explicitTier) {
+    debug.log('llm.tier', 'turn-tier-applied', {
+      sessionId: opts.sessionId, tier: explicitTier.tier, source: explicitTier.source, model: explicitTier.model,
+      reasoningEffort: llmOpts?.reasoningEffort ?? null,
+    });
+  }
+  const provider = opts.provider ?? getProviderForConfig(opts.userConfig, llmOpts?.model);
+
   // 2) Assemble, trim, call. When images are attached for THIS turn,
   //    swap the string content of the latest user message for
   //    ContentBlock[] so the provider adapter sends them multimodally.
@@ -384,18 +400,67 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
     return trimToBudget(wire, opts.maxTokens ?? DEFAULT_TOKEN_BUDGET);
   };
 
-  const explicitTier = opts.llmOpts?.model ? undefined : explicitTurnTier(opts.userConfig, opts.sessionId);
-  const llmOpts = explicitTier ? {
-    ...(opts.llmOpts ?? {}), model: explicitTier.model,
-    ...(explicitTier.reasoningEffort && !opts.llmOpts?.reasoningEffort ? { reasoningEffort: explicitTier.reasoningEffort } : {}),
-  } : opts.llmOpts;
-  if (explicitTier) {
-    debug.log('llm.tier', 'turn-tier-applied', {
-      sessionId: opts.sessionId, tier: explicitTier.tier, source: explicitTier.source, model: explicitTier.model,
-      reasoningEffort: llmOpts?.reasoningEffort ?? null,
-    });
-  }
-  const provider = opts.provider ?? getProviderForConfig(opts.userConfig, llmOpts?.model);
+  let measuredProviderRequests = 0;
+  const requestSizeGuard: NonNullable<LLMOpts['requestSizeGuard']> | undefined =
+    meta.source === 'tui' && provider.name === 'openai-codex'
+      ? {
+          maxChars: 400_000,
+          compactMessages: async (currentMessages) => {
+            // The first request has only the persisted transcript plus this
+            // user turn, so use the shared session compactor and rebuild from
+            // the rewritten history. Later tool rounds compact their live
+            // message list so no just-produced tool context is lost.
+            if (measuredProviderRequests === 0) {
+              const { compactSessionHistory } = await import('./compact-session.js');
+              const result = await compactSessionHistory(opts.sessionId, {
+                config: opts.userConfig.chat.autoCompact,
+                force: true,
+                modelId: llmOpts?.model ?? provider.defaultModel,
+              });
+              if (result.fired) {
+                const refreshed = loadSession(opts.sessionId);
+                if (refreshed) {
+                  // The persisted compacted session includes this turn's
+                  // user message. Drop that final persisted row here, then
+                  // assembleTurnMessages re-adds the canonical userMsg and
+                  // any image blocks from opts.userImages exactly once.
+                  messages = refreshed.messages.slice(0, -1);
+                  const rebuilt = assembleTurnMessages(effectiveSystemPrompt).kept;
+                  return { messages: rebuilt, reason: `session-${result.reason}` };
+                }
+              }
+            }
+
+            const { runCompactPipeline } = await import('../compact/pipeline.js');
+            const { getDefaultCompactProvider } = await import('../compact/provider.js');
+            const compacted = await runCompactPipeline(currentMessages, {
+              sessionId: opts.sessionId,
+              provider: getDefaultCompactProvider(),
+              activeModelId: llmOpts?.model ?? provider.defaultModel,
+              policy: {
+                preserveLastN: opts.userConfig.chat.autoCompact.preserveLastN,
+                archiveEnabled: opts.userConfig.chat.compact.archiveEnabled,
+              },
+            });
+            const diagnostics = compacted.diagnostics;
+            const changed = diagnostics.layer1ResponsesTrimmed > 0
+              || diagnostics.layer2MicrocompactCleared > 0
+              || diagnostics.layer3SummaryApplied === 1
+              || diagnostics.layer5FallbackTruncated === 1;
+            return changed
+              ? { messages: compacted.messages, reason: 'live-request-compact' }
+              : null;
+          },
+          onMeasured: (measurement) => {
+            measuredProviderRequests += 1;
+            opts.onStatusLine?.(
+              `ctx ${measurement.requestChars.toLocaleString()} chars / ${measurement.maxChars.toLocaleString()}`
+              + (measurement.compacted ? ` · compact ${measurement.reason}` : ''),
+            );
+          },
+        }
+      : undefined;
+
   let kept: LLMMessage[] = [];
   let dropped = 0;
   let used = 0;
@@ -430,6 +495,9 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
       effectiveSystemPrompt = terminal.systemPromptParts.join('\n\n');
     }
     const turnLlmOpts = terminal ? terminal.llmOpts : llmOpts;
+    const guardedTurnLlmOpts = requestSizeGuard
+      ? { ...(turnLlmOpts ?? {}), requestSizeGuard: turnLlmOpts?.requestSizeGuard ?? requestSizeGuard }
+      : turnLlmOpts;
     ({ kept, dropped, used } = assembleTurnMessages(effectiveSystemPrompt));
     // Durable tool telemetry (추적성) — pair each call's args (onToolCall) with its
     // result (onToolResult) and persist a role:'tool' message so later "어떤 도구
@@ -469,6 +537,8 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
         userText: opts.userText,
         messages: kept,
         tools: turnTools,
+        ...(guardedTurnLlmOpts?.requestSizeGuard
+          ? { requestSizeGuard: guardedTurnLlmOpts.requestSizeGuard } : {}),
         dispatchTool: async (name, args, ctx) => dispatchTool(name, args, ctx),
         signal: opts.signal ?? new AbortController().signal,
         callbacks: {
@@ -489,6 +559,8 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
         },
         ...(turnLlmOpts?.model ? { modelOverride: turnLlmOpts.model } : {}),
         ...(turnLlmOpts?.budgetGrant ? { budgetGrant: turnLlmOpts.budgetGrant } : {}),
+        ...(guardedTurnLlmOpts?.requestSizeGuard
+          ? { requestSizeGuard: guardedTurnLlmOpts.requestSizeGuard } : {}),
       };
       const maxIterations = opts.goalLoopMaxIterations ?? goalLoopCfg?.maxIterations;
       const gl = await runGoalLoop(coreCtx, maxIterations !== undefined ? { maxIterations } : {});
@@ -500,6 +572,7 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
         onText: (delta /*, full */) => {
           opts.onDelta?.(delta);
         },
+        onStatus: (line) => { opts.onStatusLine?.(line); },
         dispatchTool: async (name, args, ctx) => dispatchTool(name, args, ctx),
         onToolCall: (call) => { toolCallArgs.set(call.id, call.args); opts.onToolCall?.(call); },
         onToolResult: (call) => {
@@ -510,7 +583,7 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
         },
       },
       {
-        ...(turnLlmOpts ?? {}),
+        ...(guardedTurnLlmOpts ?? {}),
         tools: turnTools,
         provider,
         // ★ /cancel 범용화(대표 2026-07-12) — per-turn abort signal 을 tool 루프·llm 호출에 전파.
@@ -524,7 +597,11 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
     }
   } else {
     ({ kept, dropped, used } = assembleTurnMessages(effectiveSystemPrompt));
-    const plainOpts = opts.signal ? { ...(llmOpts ?? {}), signal: opts.signal } : (llmOpts ?? {});
+    const plainOpts = {
+      ...(llmOpts ?? {}),
+      ...(requestSizeGuard ? { requestSizeGuard: llmOpts?.requestSizeGuard ?? requestSizeGuard } : {}),
+      ...(opts.signal ? { signal: opts.signal } : {}),
+    };
     const stream = provider.streamChat
       ? provider.streamChat(kept, plainOpts)
       : wrapTextOnly(provider.chat(kept, plainOpts));

package/src/session/index.ts

@@ -243,6 +243,8 @@ export interface SessionMeta {
    *  **no runtime effect today** — placeholder for schema stability so
    *  future coordinator does not require a migration pass. */
   retiredAt?: string | null;
+  /** Per-session Next TUI presentation preferences. */
+  uiState?: { sidetabOpen?: boolean };
 }
 
 /** Runtime channel attachments. Each key is optional; presence means

package/src/session-runtime/index.ts

@@ -1,5 +1,6 @@
 import { buildGitSnapshot } from '../git-fs/index.js';
 import { debug } from '../debug/log.js';
+import { isResearchAgentIntent } from '../tool-hints/signals.js';
 import { resolve } from 'node:path';
 import type { ModelFamily } from '../models/prompts.js';
 import type { InputSourceKind, InputSourceRef } from '../input/input-source-kind.js';
@@ -127,6 +128,13 @@ export interface SessionTurnProfile {
   inputSourceKind: InputSourceKind | null;
 }
 
+/** A date anchor for research answers. Keep this local to the turn so a
+ *  long-lived session never presents yesterday as today's date. */
+export function buildResearchDateSystemMessage(now = new Date()): LLMMessage {
+  const localDate = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`;
+  return { role: 'system', content: `Current local date: ${localDate}. Verify dates in sources; do not infer freshness from an undated result.` };
+}
+
 export interface SessionModeSnapshot {
   rawMode: ChatModeState['mode'];
   activeIntent: string | null;
@@ -2412,27 +2420,6 @@ const WEB_SEARCH_PROVIDER_TERMS = [
   'claude',
 ] as const;
 
-const DEEP_RESEARCH_INTENT_TERMS = [
-  'research',
-  'deep research',
-  'triangulate',
-  'compare sources',
-  'multiple sources',
-  'community reaction',
-  'reddit reaction',
-  'x reaction',
-  'trend',
-  'sentiment',
-  '여러 소스',
-  '깊게 조사',
-  '리서치',
-  '반응',
-  '트렌드',
-  '여론',
-  '비교 조사',
-  '교차검증',
-] as const;
-
 const WEB_FETCH_INTENT_TERMS = [
   'http://',
   'https://',
@@ -2647,7 +2634,7 @@ function hasWebSearchExposureIntent(text: string): boolean {
 }
 
 function hasResearchSearchIntent(text: string): boolean {
-  return matchesIntentLexicon(text, DEEP_RESEARCH_INTENT_TERMS);
+  return isResearchAgentIntent(text);
 }
 
 function hasWebFetchIntent(text: string): boolean {