elanous 0.2.37 → 0.2.38

package/src/nexus/api/telegram-trigger-bot.ts

@@ -37,6 +37,12 @@ import { createTelegramStreamSink } from '../../session/streaming/telegram-strea
 import { splitMarkdownForTelegram } from '../../telegram-format.js';
 import { formatTablesAndRules } from '../../discord-markdown.js';
 import { receiveChannelEvent } from '../outbound/router.js';
+import { openMsgStore } from '../../msg/msg-store.js';
+import { createAskOpTelegramSlashCommand } from './channel-ask-op.js';
+import { createTelegramChannelOpReplyTransport, startChannelOpReplyRoute } from '../../session/channel-op-reply-route.js';
+import { resolveInstanceName } from '../../instance-identity.js';
+import { elanousStateRoot } from '../../autopilot/state-paths.js';
+import { join } from 'node:path';
 
 export interface NexusTelegramTriggerBotOpts {
   /** Bot token (without `Bot ` prefix). Production reads
@@ -167,6 +173,14 @@ export function createNexusTelegramTriggerBot(
   const onTriggerTap = buildTelegramTriggerTap(opts.dispatch, log);
 
   const botWasInjected = opts.bot !== undefined;
+  const askOpCommand = createAskOpTelegramSlashCommand({
+    allowedUserIds: opts.allowedUsers,
+    append: (message, provenanceKey) => {
+      const store = openMsgStore();
+      try { return store.appendWithProvenance(message, provenanceKey); }
+      finally { store.close(); }
+    },
+  });
   const bot = opts.bot ?? (opts.userConfig
     // Unified inbound: botFromConfig gives the full Q&A handler
     // (onMessage → runTurn, sessions, attachments, slash) and we graft
@@ -174,6 +188,7 @@ export function createNexusTelegramTriggerBot(
     ? botFromConfig({
         userConfig: opts.userConfig,
         log,
+        extraSlashCommands: [askOpCommand],
         ...(opts.runTurnImpl ? { runTurnImpl: opts.runTurnImpl } : {}),
         telegramBotOpts: {
           token: opts.token,
@@ -286,6 +301,14 @@ export function createNexusTelegramTriggerBot(
     });
   }
 
+  const opReplyInstance = resolveInstanceName();
+  const opReplyRoute = !botWasInjected ? startChannelOpReplyRoute({
+    transport: createTelegramChannelOpReplyTransport({ bot, botId: thisBotId, instance: opReplyInstance }),
+    botId: thisBotId,
+    instance: opReplyInstance,
+    cursorPath: join(elanousStateRoot(), 'msg', 'sse-cursor', `TELEGRAM-channel-op-replies-${thisBotId}.json`),
+  }) : undefined;
+
   // One drain promise for every caller. A second stop (SIGINT then
   // SIGTERM, or a duplicate SIGTERM) must wait for the same bound —
   // returning immediately would let the process exit before the turn
@@ -297,6 +320,7 @@ export function createNexusTelegramTriggerBot(
       if (drainPromise) return drainPromise;
       const timeoutMs = stopOpts?.timeoutMs ?? TELEGRAM_TRIGGER_DRAIN_TIMEOUT_MS;
       drainPromise = (async (): Promise<void> => {
+        try { await opReplyRoute?.stop(); } catch { /* swallow */ }
         try { offTelegramSink?.(); } catch { /* swallow */ }
         try { offTelegramStream?.(); } catch { /* swallow */ }
         try { bot.stop(); } catch { /* swallow */ }

package/src/nexus/api/terminals.ts

@@ -102,6 +102,11 @@ export interface TerminalSummary {
   startedAt: number;
   /** Total bytes currently held in the head/tail buffer (after trim). */
   outputBytes: number;
+  /** Seat copied from the joined lifecycle row for this PTY id; omitted when unknown. */
+  seat?: string;
+  /** Cumulative output from the joined lifecycle row; omitted when unknown (NULL/missing/0 legacy row).
+   *  Only a recorded positive total is a fact — same rule as the lineage endpoint. Distinct from outputBytes (buffer length). */
+  outputBytesTotal?: number;
   /** The owner-process access mode, or null when this row is manifest-only. */
   accessMode: 'read' | 'write' | 'auto' | null;
   /** Why accessMode is unavailable; null when an access mode is present. */
@@ -266,6 +271,18 @@ function terminalOriginFields(row: Pick<PtyManifestRow, 'terminalOriginCategory'
   return { terminalOriginCategory: 'unknown', terminalOriginReason: 'legacy-or-malformed-origin-decision' };
 }
 
+/** `> 0` 만 사실이다 — legacy 행의 NULL/누락(그리고 매니페스트가 0을 «기록값»으로 구분 못 하는 한 0 전부)은
+ *  미상으로 칸을 비운다. 계보 쪽 `lineageRowFromManifest`(`src/cli/pty-takeover-cli.ts`)와 같은 규칙이라
+ *  두 엔드포인트가 같은 행을 같게 판정한다. */
+function lifecycleFieldsFromJoinedRow(row: { seat?: string; outputBytesTotal?: number } | undefined): Pick<TerminalSummary, 'seat' | 'outputBytesTotal'> {
+  return {
+    ...(row?.seat ? { seat: row.seat } : {}),
+    ...(typeof row?.outputBytesTotal === 'number' && Number.isFinite(row.outputBytesTotal) && row.outputBytesTotal > 0
+      ? { outputBytesTotal: row.outputBytesTotal }
+      : {}),
+  };
+}
+
 function summarize(
   handle: PtyHandle,
   manifest: PtyManifestRow | null,
@@ -300,6 +317,7 @@ function summarize(
     exitCode: handle.exitCode,
     startedAt: handle.startedAt,
     outputBytes: snapshot.length,
+    ...lifecycleFieldsFromJoinedRow(manifest ? { seat: manifest.seat, outputBytesTotal: manifest.outputBytesTotal } : undefined),
     accessMode: handle.accessMode,
     accessModeUnavailableReason: accessModeUnavailableReason('process', handle.accessMode),
     ownerRunUsage: ownerRunUsage(manifest?.ownerPid !== undefined ? isOwnerProcessAlive(manifest.ownerPid) : undefined, manifest?.runId ?? '', resolveRunTerminationForRow),
@@ -337,6 +355,7 @@ function summarizeManifest(
     producer: 'process',
     alive: row.alive, exitCode: row.exitCode, startedAt: row.startedAt,
     outputBytes: Buffer.byteLength(row.snapshot, 'utf8'),
+    ...lifecycleFieldsFromJoinedRow({ seat: row.seat, outputBytesTotal: row.outputBytesTotal }),
     // Access mode lives in the owner process, so manifest-only rows cannot know it without IPC.
     accessMode: null,
     accessModeUnavailableReason: accessModeUnavailableReason('process', null),
@@ -1102,12 +1121,15 @@ export function handleTerminalsList(req: Request, opts: MetaApiOpts, deps: Termi
   try { cleanupStale(Date.now()); } catch { /* fail-soft */ }
   const manifestAfterInitialCleanup = readLocalManifest();
   const manifestById = new Map(manifestAfterInitialCleanup.map((row) => [row.id, row]));
-  const local = (deps.listPty ?? listPty)().map((handle) => summarize(
-    handle,
-    manifestById.get(handle.id) ?? null,
-    resolveRunTerminationForRow,
-    deps.isProcessAlive,
-  ));
+  const local = (deps.listPty ?? listPty)().map((handle) => {
+    const manifest = manifestById.get(handle.id) ?? null;
+    return summarize(
+      handle,
+      manifest,
+      resolveRunTerminationForRow,
+      deps.isProcessAlive,
+    );
+  });
   const localIds = new Set(local.map((t) => t.id));
   try { cleanupOrphans(localIds); } catch { /* fail-soft */ }
   const isVisible = (row: PtyManifestRow): boolean => isVisibleManifestRow(row, deps.isProcessAlive);

package/src/patents/ledger.ts

@@ -1,5 +1,5 @@
 import { Database } from 'bun:sqlite';
-import { chmodSync, mkdirSync } from 'node:fs';
+import { chmodSync, existsSync, mkdirSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
 import { debug } from '../debug/log.js';
@@ -80,6 +80,12 @@ export class PatentLedger {
     try { return work(db); } finally { db.close(); }
   }
 
+  private usingExisting<T>(work: (db: Database) => T): T {
+    if (!existsSync(this.path)) throw new Error('patent ledger unavailable');
+    const db = new Database(this.path, { readonly: true, create: false, strict: true });
+    try { return work(db); } finally { db.close(); }
+  }
+
   private transaction<T>(db: Database, work: () => T): T {
     db.exec('BEGIN IMMEDIATE');
     try { const result = work(); db.exec('COMMIT'); return result; }
@@ -125,4 +131,15 @@ export class PatentLedger {
     return this.using(db =>
       db.query(`SELECT id, title, track, status, deadline, created_at, updated_at FROM patent_candidates WHERE status = '공개 허용' ORDER BY created_at, id`).all() as PatentCandidate[]);
   }
+
+  /** Return only line numbers; candidate identifiers and titles remain private. */
+  unapprovedCandidateLineNumbers(text: string): number[] {
+    return this.usingExisting(db => {
+      if (!text.trim()) return [];
+      const rows = db.query(`SELECT title FROM patent_candidates WHERE status != '공개 허용'`).all() as Array<{ title: string }>;
+      const titles = rows.map(({ title }) => title.toLocaleLowerCase()).filter((title) => title.length >= 3);
+      return text.split(/\r?\n/).flatMap((line, index) =>
+        titles.some((title) => line.toLocaleLowerCase().includes(title)) ? [index + 1] : []);
+    });
+  }
 }

package/src/preview/terminal.ts

@@ -67,6 +67,8 @@ export interface PreviewTerminalOpts {
    *  splitting honest). */
   shellArgs?: readonly string[];
   env?: Record<string, string>;
+  /** Remove captured environment keys after env composition (for subscription-only child auth). */
+  unsetEnv?: readonly string[];
   /** Defaults to `xterm-256color` (universal). Override with
    *  `xterm-ghostty` to match a ghostty host, or another terminfo
    *  name for testing. The chosen name lands in $TERM of the child
@@ -343,7 +345,7 @@ export class PreviewTerminal {
       //   PreviewTerminal 자체 에뮬레이터가 렌더 담당이라 무관). 출력 구독/exit 배선은 아래 pump 분기에서.
       this.registryHandle = this.registryDeps.startPty({
         // 합성자 = registry(resolveSpawnShape) — 여기서는 overlay 만 넘긴다.
-        cmd: shell, args, workdir: this.opts.cwd, env: childEnv,
+        cmd: shell, args, workdir: this.opts.cwd, env: childEnv, unsetEnv: this.opts.unsetEnv,
         cols: this.term.cols, rows: this.term.rows,
         kind: this.opts.registryKind ?? 'preview',
         nickname: this.opts.registryNickname,
@@ -360,7 +362,7 @@ export class PreviewTerminal {
         cols: this.term.cols,
         rows: this.term.rows,
         cwd: this.opts.cwd,
-        env: buildPtyEnv(childEnv),
+        env: buildPtyEnv(childEnv, process.env, { unset: this.opts.unsetEnv }),
       });
       const masterFd = this.resolveMasterFd(this.pty);
       if (masterFd === null) throw new Error('PreviewTerminal: could not resolve PTY master fd');

package/src/prompt-cache/anthropic.ts

@@ -20,6 +20,7 @@
 // caching went GA without a version bump.
 
 import type { LLMMessage, LLMToolSpec } from '../llm.js';
+import { assertNoTopLevelToolSchemaCombinators } from '../llm-tool-schema.js';
 import {
   cacheControlFor,
   type CacheControl,
@@ -98,6 +99,7 @@ export function toAnthropicToolsCached(
   opts: CacheOpts,
 ): AnthropicToolBlock[] | undefined {
   if (!tools || tools.length === 0) return undefined;
+  assertNoTopLevelToolSchemaCombinators(tools);
   // ⭐ Anthropic 은 tool name UNIQUE 를 강제(400 "Tool names must be unique.")한다.
   //   OpenAI/codex 는 중복을 조용히 관대 처리 → 하니스가 codex 위주로 개발되며 중복 tool spec
   //   (예: goal-loop 이 카탈로그에 이미 있는 spec 을 append)이 claude 에서만 400 으로 터졌다.

package/src/prompt-enhance/enhance.ts

@@ -118,6 +118,8 @@ export interface EnhanceOpts {
    * ⭐ 새 LLM 경로를 만들지 않는다 — 이 모듈이 이미 그 자리의 유일한 LLM 단계다.
    */
   groundedFacts?: readonly string[];
+  /** Relevant prior-failure lessons for goal-authoring prompts only; never part of the original ask. */
+  authoringLessons?: string;
   /** Clock seam for the first-token observation (ms epoch); defaults to `Date.now`. */
   now?: () => number;
 }
@@ -434,6 +436,9 @@ export async function enhancePrompt(raw: string, opts: EnhanceOpts = {}): Promis
               '위 사실을 «옮겨 적지 말고», 그것이 보여 주는 상태(situation)와 문제(complication)를 써라.',
             ]
             : []),
+          ...(opts.authoringLessons?.trim()
+            ? ['', '## 지난 실패에서 배운 것', opts.authoringLessons.trim(), '위 교훈은 현재 ask의 대상 경로와 범위에 맞을 때만 적용하고, 맞지 않으면 무시하라.']
+            : []),
         ].join('\n'),
       },
     ];

package/src/pty-shell/pty-manifest.ts

@@ -75,7 +75,10 @@ export interface PtyManifestRow {
   exitCode: number | null;
   snapshot: string;
   snapshotAt: number;
-  outputBytesTotal: number;
+  /** Cumulative output bytes recorded for this PTY. `undefined` = the row never recorded a total
+   *  (legacy schema before `output_bytes_total`, or NULL) — that is *unknown*, not 0. A genuinely
+   *  recorded zero from a fresh spawn stays 0. */
+  outputBytesTotal?: number;
   lastControlAt?: number;
   updatedAt: number;
   frame: string;
@@ -420,6 +423,17 @@ export function updatePtyManifestNickname(id: string, nickname: string | undefin
   } catch { /* fail-soft */ }
 }
 
+/** Update the conversation currently shown by a TUI surface without replacing its manifest row. */
+export function updatePtyManifestSession(id: string, sessionId: string, now: number = Date.now()): boolean {
+  try {
+    const d = db(); if (!d) return false;
+    const result = d.run('UPDATE pty_manifest SET session_id=?, updated_at=? WHERE id=? AND kind=\'tui\' AND session_id<>?', [sessionId, now, id, sessionId]);
+    return (result.changes ?? 0) > 0;
+  } catch {
+    return false;
+  }
+}
+
 /** 턴 상태 기록 — 행이 없거나 db 를 못 열면 false(호출자가 관측을 남긴다). */
 export function updatePtyManifestTurn(id: string, turn: PtyTurnState, at: number): boolean {
   try {
@@ -866,7 +880,7 @@ function mapRow(r: Record<string, unknown>): PtyManifestRow {
     exitCode: r.exit_code === null || r.exit_code === undefined ? null : Number(r.exit_code),
     snapshot: String(r.snapshot ?? ''),
     snapshotAt: Number(r.snapshot_at ?? 0),
-    outputBytesTotal: Number(r.output_bytes_total ?? 0),
+    ...(r.output_bytes_total === null || r.output_bytes_total === undefined ? {} : { outputBytesTotal: Number(r.output_bytes_total) }),
     ...(r.last_control_at === null || r.last_control_at === undefined ? {} : { lastControlAt: Number(r.last_control_at) }),
     frame: String(r.frame ?? ''),
     frameAt: Number(r.frame_at ?? 0),

package/src/release-loop/gate-shards.ts

@@ -12,6 +12,12 @@ export type ShardState = typeof SHARD_STATES[number];
 export interface GateShard {
   id: string;
   state: ShardState;
+  /** Kubernetes Job for the current attempt; lets the gate watchdog reconcile a lost completion callback. */
+  job?: string;
+  /** Attempt identity associated with the currently recorded Job/result marker. */
+  attemptId?: string;
+  /** Result JSON for the current attempt; retries replace this so an older marker cannot close a new Job. */
+  resultFile?: string;
   startedAt?: string;
   endedAt?: string;
   /** 설치(install) 단계에 쓴 초. */
@@ -61,8 +67,14 @@ function shardOf(value: unknown): GateShard | null {
   const waitReason = str(raw.waitReason);
   const plannedMin = num(raw.plannedMin);
   const host = str(raw.host, 120);
+  const job = str(raw.job, 120);
+  const attemptId = str(raw.attemptId, 120);
+  const resultFile = str(raw.resultFile, 200);
   return {
     id, state,
+    ...(job ? { job } : {}),
+    ...(attemptId ? { attemptId } : {}),
+    ...(resultFile ? { resultFile } : {}),
     ...(startedAt ? { startedAt } : {}), ...(endedAt ? { endedAt } : {}),
     ...(installSec !== undefined ? { installSec } : {}), ...(rc !== undefined ? { rc } : {}),
     ...(waitReason ? { waitReason } : {}), ...(plannedMin !== undefined ? { plannedMin } : {}),
@@ -70,6 +82,55 @@ function shardOf(value: unknown): GateShard | null {
   };
 }
 
+export type GateJobTerminal = 'complete' | 'failed';
+
+/** Forget the prior child Job before a shard descends into a retry/split attempt. */
+export function beginGateShardAttempt(shard: GateShard, now = new Date()): GateShard {
+  const next: GateShard = { ...shard, state: 'retry', startedAt: now.toISOString() };
+  delete next.endedAt;
+  delete next.waitReason;
+  delete next.host;
+  delete next.job;
+  delete next.resultFile;
+  delete next.attemptId;
+  return next;
+}
+
+/**
+ * Close each stale running row when its result marker or Kubernetes Job has terminal evidence.
+ * A result marker can close a row even when the Kubernetes status read is unavailable.
+ */
+export function finalizeTerminalGateShards(
+  file: GateShardsFile,
+  terminalJobs: ReadonlyMap<string, GateJobTerminal>,
+  results: ReadonlyMap<string, { completed?: boolean; jobName?: string; attemptId?: string; jobFailed?: boolean; rc?: number | null; reason?: 'timeout' | 'stall' }>,
+  now: Date = new Date(),
+  staleAfterMs = 120_000,
+): GateShardsFile {
+  const active = file.shards.filter((shard) => shard.state === 'running' || shard.state === 'retry');
+  if (!active.length) return file;
+  const at = now.getTime();
+  const ready = active.map((shard) => {
+    const result = results.get(shard.id);
+    const resultTerminal = result?.completed === true && result.jobName === shard.job && result.attemptId === shard.attemptId;
+    const k8sTerminal = shard.job ? terminalJobs.get(shard.job) : undefined;
+    const startedAt = shard.startedAt ? Date.parse(shard.startedAt) : Number.NaN;
+    if (!resultTerminal && !k8sTerminal) return undefined;
+    if (!Number.isFinite(startedAt) || at - startedAt < staleAfterMs) return undefined;
+    return { shard, result, state: resultTerminal
+      ? (result!.reason === 'timeout' ? 'timeout' as const : result!.reason === 'stall' || result!.jobFailed === true ? 'failed' as const : 'done' as const)
+      : k8sTerminal === 'failed' ? 'failed' as const : 'done' as const };
+  });
+  const finalized = ready.filter((entry): entry is NonNullable<typeof entry> => entry !== undefined);
+  if (!finalized.length) return file;
+  const byId = new Map(finalized.map(({ shard, result, state }) => {
+    const current = { ...shard };
+    delete current.waitReason;
+    return [shard.id, { ...current, state, endedAt: now.toISOString(), ...(result && typeof result.rc === 'number' ? { rc: result.rc } : {}) } satisfies GateShard];
+  }));
+  return { ...file, updatedAt: now.toISOString(), shards: file.shards.map((shard) => byId.get(shard.id) ?? shard) };
+}
+
 function verdictOf(value: unknown): GateShardsVerdict | undefined {
   if (!value || typeof value !== 'object') return undefined;
   const raw = value as Record<string, unknown>;

package/src/release-loop/light-rc.ts

@@ -7,7 +7,7 @@ import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { debug } from '../debug/log.js';
-import { runSelfGateCli, type SelfGateCliOptions, type SelfGateCliResult } from '../self-implement/gate-cli.js';
+import { runSelfGateCliAsync, type SelfGateCliOptions, type SelfGateCliResult } from '../self-implement/gate-cli.js';
 import { dispatchHeavyCheck, isValidGateHost, type DispatchDeps, type DispatchOptions } from '../self-implement/gate-remote.js';
 import { latestPublishedPreviousVersion } from '../../scripts/release-loop/unattended-release.js';
 import { baseVersion, isReleaseVersion } from '../../scripts/release-loop/release-version.js';
@@ -29,6 +29,8 @@ export interface LightRcOptions {
   /** Run on this machine (the remote child is re-invoked with it). */
   local?: boolean;
   shards?: number;
+  /** Maximum simultaneously active gate bundles, including per-file RSS samples (default three). */
+  shardConcurrency?: number;
   /** OP FU — pass `--fixed-shard-distribution` to self gate (sorted round-robin into `shards`, no RSS pre-measurement).
    *  Opt-in; absent = the measured planner, unchanged. Also carried to the remote child. */
   fixedShardDistribution?: boolean;
@@ -71,7 +73,7 @@ export interface LightRcDeps {
   git?: (args: string[], cwd: string) => { rc: number | null; stdout: string };
   previousVersion?: (version: string, ledgerRoot?: string) => string;
   readFile?: (path: string) => string | undefined;
-  runGate?: (cwd: string, options: SelfGateCliOptions) => SelfGateCliResult;
+  runGate?: (cwd: string, options: SelfGateCliOptions) => SelfGateCliResult | Promise<SelfGateCliResult>;
   dispatch?: (opts: DispatchOptions, deps?: DispatchDeps) => Promise<number>;
   /** Extra dispatch deps (runner · settings) — tests drive the real dispatch with a fake host. */
   dispatchDeps?: Omit<DispatchDeps, 'write'>;
@@ -175,6 +177,7 @@ export async function runLightRc(version: string, opts: LightRcOptions = {}, dep
   if (!isReleaseVersion(version)) throw new Error(`release version must be x.y.z: ${version}`);
   const shards = opts.shards ?? LIGHT_RC_DEFAULT_SHARDS;
   if (!Number.isSafeInteger(shards) || shards < 1) throw new Error(`invalid --shards count: ${opts.shards}`);
+  if (opts.shardConcurrency !== undefined && (!Number.isSafeInteger(opts.shardConcurrency) || opts.shardConcurrency < 1 || opts.shardConcurrency > 4)) throw new Error(`invalid --shard-concurrency: ${opts.shardConcurrency}`);
   if (opts.remote !== undefined && !isValidGateHost(opts.remote)) throw new Error(`invalid --remote host: ${opts.remote}`);
   const log = opts.log ?? ((line: string) => process.stderr.write(`${line}\n`));
   const cwd = repoRoot(deps);
@@ -195,7 +198,7 @@ export async function runLightRc(version: string, opts: LightRcOptions = {}, dep
     try {
       const dir = checkout?.dir ?? cwd;
       if (checkout) alwaysInclude = readList(dir);
-      local = (deps.runGate ?? runSelfGateCli)(dir, { base, shards, ...(opts.fixedShardDistribution ? { fixedShardDistribution: true } : {}), alwaysInclude, includeImporterTests: true });
+      local = await (deps.runGate ?? runSelfGateCliAsync)(dir, { base, shards, ...(opts.shardConcurrency !== undefined ? { shardConcurrency: opts.shardConcurrency } : {}), ...(opts.fixedShardDistribution ? { fixedShardDistribution: true } : {}), alwaysInclude, includeImporterTests: true });
       if (opts.rehearsalTui) {
         const command = async (cmd: string, args: string[], tree: string, limitMs?: number) => {
           const run = spawnSync(cmd, args, { cwd: tree, encoding: 'utf8', timeout: limitMs });
@@ -212,7 +215,7 @@ export async function runLightRc(version: string, opts: LightRcOptions = {}, dep
     // Keep the self-gate contract: an unavailable remote leaves this release check unmeasured; do not start a heavy gate locally.
     tool: 'self-gate', repo: cwd, installPwa: true, refs: [base], json: true, commit: measuredCommit,
     // The host re-runs this command with --local (and ELANOUS_GATE_REMOTE_CHILD=1), so it never recurses.
-    remoteArgv: (sha) => ['bun', 'bin/elanous.mjs', 'release', 'light-rc', '--version', version, '--base', sha(base), '--head', measuredCommit, '--shards', String(shards), ...(opts.fixedShardDistribution ? ['--fixed-shard-distribution'] : []), '--local', '--json', ...(opts.rehearsalTui ? ['--rehearsal-tui'] : [])],
+    remoteArgv: (sha) => ['bun', 'bin/elanous.mjs', 'release', 'light-rc', '--version', version, '--base', sha(base), '--head', measuredCommit, '--shards', String(shards), ...(opts.shardConcurrency !== undefined ? ['--shard-concurrency', String(opts.shardConcurrency)] : []), ...(opts.fixedShardDistribution ? ['--fixed-shard-distribution'] : []), '--local', '--json', ...(opts.rehearsalTui ? ['--rehearsal-tui'] : [])],
     flags: { remote: opts.local ? undefined : opts.remote ?? true, local: !!opts.local },
     runLocal,
   }, {

package/src/release-loop/rehearsal.ts

@@ -495,7 +495,7 @@ export async function runRehearsalTick(opts: RehearsalOptions = {}, deps: Rehear
               const introducedCount: number | null = stamp.outcome === 'unmeasured' || stamp.outcome === 'error' ? null : hard.introduced.length;
               const preexistingCount: number | null = introducedCount === null ? null : hard.preexisting;
               const totalFailures: number | null = introducedCount === null || preexistingCount === null ? null : introducedCount + preexistingCount;
-              stamp.summary = oneLine(`hard gate ${hard.outcome} · introduced ${introducedCount ?? 'UNKNOWN'} · preexisting ${preexistingCount ?? 'UNKNOWN'} · total failures ${totalFailures ?? 'UNKNOWN'} · node-b Pod · 12 shards · runId ${hardGateRunId} · evidence ${hardGateLog}${cause ? ` · ${cause}` : ''}`);
+              stamp.summary = oneLine(`hard gate ${hard.outcome} · introduced ${introducedCount ?? 'UNKNOWN'} · preexisting ${preexistingCount ?? 'UNKNOWN'} · total failures ${totalFailures ?? 'UNKNOWN'} · 원격 Pod · 12 shards · runId ${hardGateRunId} · evidence ${hardGateLog}${cause ? ` · ${cause}` : ''}`);
             } else {
             const shardPlan = opts.shards === undefined ? (deps.shardPlan ?? planRehearsalShards)(plan.version, root, checkout, { ...deps.shardPlanDeps, remoteGate: true }) : undefined;
             if (shardPlan) stamp.shardPlan = shardPlan;

package/src/repl/index.ts

@@ -198,6 +198,7 @@ function buildReplTools(): {
     specs.push(wakeup.spec);
     dispatchByName.set(wakeup.spec.name, wakeup.dispatch);
   }
+  (require('../tui/sidetab/nl-tool.js') as typeof import('../tui/sidetab/nl-tool.js')).registerNextSidetabReplTool(specs, dispatchByName, process as unknown as import('../tui/sidetab/nl-tool.js').NextSidetabIpcProcess);
   const planner = sr.createSearchPlannerState({ maxAutoNarrowCandidates: 2 });
   const dispatch = async (name: string, args: Record<string, unknown>): Promise<unknown> => {
     try {
@@ -342,6 +343,7 @@ async function runOneTurn(
   jsonOutput: boolean,
   nextTuiDelivery?: { pending: PendingTaskNotification[] },
   onJsonDelta?: (delta: string) => void,
+  onJsonStatus?: (line: string) => void,
 ): Promise<{ reply: string; provider: string; model: string | null; durationMs: number; logPath: string | null }> {
   const startedAt = Date.now();
   const replyChunks: string[] = [];
@@ -374,6 +376,10 @@ async function runOneTurn(
     userText,
     systemPrompt,
     userImages: userImages.length > 0 ? userImages : undefined,
+    ...(process.env.ELANOUS_TEST_FAKE_LLM === '1' && Number.isFinite(Number(process.env.ELANOUS_TEST_FAKE_LLM_IDLE_TIMEOUT_MS))
+      && Number(process.env.ELANOUS_TEST_FAKE_LLM_IDLE_TIMEOUT_MS) > 0
+      ? { llmOpts: { streamIdleTimeoutMs: Number(process.env.ELANOUS_TEST_FAKE_LLM_IDLE_TIMEOUT_MS) } }
+      : {}),
     onDelta: (d) => {
       if (jsonOutput) {
         replyChunks.push(d);
@@ -381,6 +387,7 @@ async function runOneTurn(
       }
       else process.stdout.write(d);
     },
+    onStatusLine: (line) => { onJsonStatus?.(line); },
     tools: replToolSpecs,
     dispatchTool: tools?.dispatch,
     onToolCall: (call) => {
@@ -785,6 +792,9 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
           process.env.ELANOUS_NEXT_TUI_STREAM === '1' && typeof turn.id === 'string'
             ? (delta) => { process.stdout.write(`${JSON.stringify({ event: 'delta', turnId: turn.id, text: delta })}\n`); }
             : undefined,
+          process.env.ELANOUS_NEXT_TUI_STREAM === '1' && typeof turn.id === 'string'
+            ? (text) => { process.stdout.write(`${JSON.stringify({ event: 'status', turnId: turn.id, text })}\n`); }
+            : undefined,
         );
       } catch (error) {
         if (!backgroundBridge) throw error;

package/src/research/axis-fanout.ts

@@ -0,0 +1,133 @@
+// Research-only native fanout. The caller supplies Bloom's question ladder;
+// each axis gets its own direct tool call and evidence stays attributed to it.
+import type { BloomResearchQuestion, ResearchEvidenceEnvelope } from '../auto-research/question-ladder-contract.js';
+import type { WebSearchHit } from '../web-search/provider.js';
+
+export interface AxisToolCallPlan {
+  questionId: string;
+  tool: 'OmniSearch';
+  query: string;
+}
+
+export interface AxisEvidenceGroup {
+  questionId: string;
+  evidence: ResearchEvidenceEnvelope[];
+  error?: string;
+}
+
+export interface AxisFanoutResult {
+  plan: AxisToolCallPlan[];
+  axes: AxisEvidenceGroup[];
+}
+
+export type AxisSearchHit = WebSearchHit & { engine?: string };
+export interface AxisSearchResult {
+  hits: AxisSearchHit[];
+  errors: string[];
+}
+export type AxisSearch = (query: string) => Promise<AxisSearchHit[] | AxisSearchResult>;
+
+export interface AxisFanoutDeps {
+  search?: AxisSearch;
+}
+
+/** Keep every query attached to the Bloom question that produced it. */
+export function planAxisToolCalls(questions: readonly BloomResearchQuestion[]): AxisToolCallPlan[] {
+  return questions.flatMap(question => question.searchTerms
+    .map(query => query.trim())
+    .filter(Boolean)
+    .map(query => ({ questionId: question.id, tool: 'OmniSearch' as const, query })));
+}
+
+async function directOmniSearch(query: string): Promise<AxisSearchResult> {
+  const { dispatchOmniSearch } = await import('../skills/tools/omni-search.js');
+  const hits: AxisSearchHit[] = [];
+  const result = await dispatchOmniSearch({ query }, { onSource: hit => { hits.push(hit); } });
+  if (Object.keys(result.metadata.perEngine).length === 0) {
+    throw new Error('no available web-search providers');
+  }
+  const errors = Object.entries(result.metadata.perEngine)
+    .flatMap(([engine, info]) => info.error ? [`${engine}: ${info.error}`] : []);
+  return { hits, errors };
+}
+
+function evidenceFromHit(question: BloomResearchQuestion, hit: AxisSearchHit): ResearchEvidenceEnvelope {
+  const published = hit.publishedAt;
+  const date = published !== undefined && Number.isFinite(published) && published > 0
+    ? new Date(published) : undefined;
+  const observedAt = date && Number.isFinite(date.getTime()) ? date.toISOString() : undefined;
+  return {
+    questionId: question.id,
+    sourceKind: hit.engine ? `web-search:${hit.engine}` : 'web-search',
+    source: hit.url,
+    ...(question.requestedWindow ? { requestedWindow: question.requestedWindow } : {}),
+    ...(observedAt ? { observedAt } : {}),
+    content: [hit.title, hit.snippet].filter(Boolean).join(' — '),
+    outcome: hit.snippet ? 'complete' : 'partial',
+    truncated: true, // Search snippets are excerpts, not the complete source page.
+  };
+}
+
+function failedEvidence(question: BloomResearchQuestion, query: string, message: string): ResearchEvidenceEnvelope {
+  return {
+    questionId: question.id,
+    sourceKind: 'search-query',
+    source: query,
+    ...(question.requestedWindow ? { requestedWindow: question.requestedWindow } : {}),
+    content: message,
+    outcome: 'failed',
+    truncated: false,
+  };
+}
+
+/** Invoke all axis queries concurrently, preserving ladder order and partial failures. */
+export async function fanOutAxisEvidence(
+  questions: readonly BloomResearchQuestion[],
+  deps: AxisFanoutDeps = {},
+): Promise<AxisFanoutResult> {
+  const plan = planAxisToolCalls(questions);
+  if (new Set(questions.map(question => question.id)).size !== questions.length) {
+    throw new Error('research axis question IDs must be unique');
+  }
+  const search = deps.search ?? directOmniSearch;
+  const settled = await Promise.allSettled(plan.map(call => search(call.query)));
+  const axes: AxisEvidenceGroup[] = questions.map(question => ({ questionId: question.id, evidence: [] }));
+  const groups = new Map(axes.map(axis => [axis.questionId, axis]));
+  const byQuestion = new Map(questions.map(question => [question.id, question]));
+  for (const question of questions) {
+    if (!plan.some(call => call.questionId === question.id)) {
+      const group = groups.get(question.id)!;
+      group.error = 'no search terms';
+      group.evidence.push(failedEvidence(question, question.prompt, group.error));
+    }
+  }
+  settled.forEach((outcome, index) => {
+    const call = plan[index]!;
+    const group = groups.get(call.questionId)!;
+    const question = byQuestion.get(call.questionId)!;
+    if (outcome.status === 'fulfilled') {
+      const response = Array.isArray(outcome.value) ? { hits: outcome.value, errors: [] } : outcome.value;
+      if (response.hits.length === 0 && response.errors.length === 0) {
+        group.evidence.push({ ...failedEvidence(question, call.query, 'no hits returned'), outcome: 'partial' });
+      }
+      for (const hit of response.hits) {
+        try {
+          group.evidence.push(evidenceFromHit(question, hit));
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          group.error = group.error ? `${group.error}; ${message}` : message;
+          group.evidence.push(failedEvidence(question, call.query, message));
+        }
+      }
+      for (const message of response.errors) {
+        group.error = group.error ? `${group.error}; ${message}` : message;
+        group.evidence.push(failedEvidence(question, call.query, message));
+      }
+    } else {
+      const message = outcome.reason instanceof Error ? outcome.reason.message : String(outcome.reason);
+      group.error = group.error ? `${group.error}; ${message}` : message;
+      group.evidence.push(failedEvidence(question, call.query, message));
+    }
+  });
+  return { plan, axes };
+}