elanous 0.2.0 → 0.2.5

package/src/skills/tools/control.ts

@@ -1,88 +1,15 @@
-// ── Control mutation tools — Phase D of PLAN-llm-active-context-and-control ──
-//
-// Fills the gaps that the existing virtual-window/PTY tools don't
-// cover: window + pane resize, preset pane layouts (2x2 / 1x3 / …),
-// LLM self-modification (tool toggle, prompt hint append).
-//
-// Addressing:
-//   • window addr → "win:<int>" or bare "<int>"
-//   • pane   addr → "pane:<hex>" or bare "<hex>"
-// Resolution routes through the global ElementRegistry so PTY /
-// session / widget addrs can be added later without reshaping tools.
+// ── Control tools: tool exposure and prompt hints ──
 
 import type { LLMToolSpec } from '../../llm.js';
 import { nativeToolCatalog } from '../../native-tool-catalog.js';
 import { appendPromptHint, clearPromptHints, listPromptHints, type HintScope } from '../../prompt/hint-store.js';
 import { publishElementEvent } from '../../element-registry/index.js';
 import { recordControlAudit } from '../../control-audit-log.js';
-import type { WindowRegistry } from '../../virtual-windows/window-registry.js';
-import type { PaneContentSpec, PaneFactoryDeps } from '../../virtual-windows/pane-content.js';
-
-interface ControlDeps {
-  getWindowRegistry?: () => WindowRegistry | null;
-  /** Pane content used when layout preset fills empty slots. Defaults
-   *  to blank terminals (kind='terminal'). Caller can override to
-   *  seed panes with specific cmds. */
-  defaultPaneSpec?: (slot: number) => PaneContentSpec;
-  paneDeps?: PaneFactoryDeps;
-}
-
-let deps: ControlDeps = {};
-
-export function setControlRuntimeDeps(next: ControlDeps): void {
-  deps = { ...next };
-}
 
 // ── Tool specs ─────────────────────────────────────────────────────
 
 export function buildControlTools(): LLMToolSpec[] {
   return [
-    {
-      name: 'ControlWindowResize',
-      description:
-        'Resize a virtual window. Pass width/height cells; row/col default to current position. Addr "win:3" or "3".',
-      parameters: {
-        type: 'object',
-        properties: {
-          addr: { type: 'string' },
-          width: { type: 'number' },
-          height: { type: 'number' },
-          row: { type: 'number' },
-          col: { type: 'number' },
-        },
-        required: ['addr'],
-        additionalProperties: false,
-      },
-    },
-    {
-      name: 'ControlPaneResize',
-      description:
-        'Grow or shrink the split enclosing a pane. axis="h" slides the vertical divider, axis="v" slides the horizontal one. delta in cells (positive grows the pane).',
-      parameters: {
-        type: 'object',
-        properties: {
-          addr: { type: 'string' },
-          axis: { type: 'string', enum: ['h', 'v'] },
-          delta: { type: 'number' },
-        },
-        required: ['addr', 'axis', 'delta'],
-        additionalProperties: false,
-      },
-    },
-    {
-      name: 'ControlPaneLayout',
-      description:
-        'Apply a preset layout to the target window: "2x2" (4 panes), "1x3" (3 side-by-side), "3x1" (3 stacked), "2x1", "1x2". Uses the focused pane as the root and splits outward. NOTE: this is destructive — existing splits below it get rebuilt.',
-      parameters: {
-        type: 'object',
-        properties: {
-          windowAddr: { type: 'string' },
-          layout: { type: 'string', enum: ['2x2', '1x3', '3x1', '2x1', '1x2'] },
-        },
-        required: ['windowAddr', 'layout'],
-        additionalProperties: false,
-      },
-    },
     {
       name: 'ControlToolToggle',
       description:
@@ -128,31 +55,20 @@ export function buildControlTools(): LLMToolSpec[] {
 
 // ── Helpers ────────────────────────────────────────────────────────
 
-function parseWinAddr(raw: string): number | null {
-  const m = /^(?:win:)?(\d+)$/.exec(String(raw).trim());
-  return m ? parseInt(m[1]!, 10) : null;
-}
-function parsePaneAddr(raw: string): string | null {
-  const s = String(raw).trim();
-  const m = /^(?:pane:)?([A-Za-z0-9_-]+)$/.exec(s);
-  return m ? m[1]! : null;
-}
-
 /** Emit an update event on the ElementEventBus so ContextEventsTail
  *  can replay control actions, AND append to the persistent control
  *  audit log (Phase F). Both calls are best-effort: a control action
  *  must never fail because observability is broken. */
 function publishControlEvent(
-  kind: 'window' | 'pane' | 'tool',
   id: string,
   payload: Record<string, unknown>,
 ): void {
-  try { publishElementEvent(kind, id, 'update', payload); } catch { /* swallow */ }
+  try { publishElementEvent('tool', id, 'update', payload); } catch { /* swallow */ }
   try {
     recordControlAudit({
       ts: new Date().toISOString(),
       action: String(payload.action ?? 'unknown'),
-      subject: `${kind}:${id}`,
+      subject: `tool:${id}`,
       ok: payload.ok !== false,
       detail: payload,
     });
@@ -169,106 +85,6 @@ function auditAction(action: string, ok: boolean, detail?: Record<string, unknow
 
 // ── Dispatchers ───────────────────────────────────────────────────
 
-export async function dispatchControlWindowResize(
-  args: Record<string, unknown>,
-): Promise<{ output: string; ok?: boolean; bounds?: unknown }> {
-  const addr = String(args.addr ?? '');
-  const id = parseWinAddr(addr);
-  if (id === null) return { output: `invalid window addr: ${addr}`, ok: false };
-  const reg = deps.getWindowRegistry?.();
-  if (!reg) return { output: 'window registry unavailable', ok: false };
-  const w = reg.list().find(x => x.id === id);
-  if (!w) return { output: `unknown window win:${id}`, ok: false };
-  const current = w.getBounds();
-  const next = {
-    row: typeof args.row === 'number' ? args.row : current.row,
-    col: typeof args.col === 'number' ? args.col : current.col,
-    width: typeof args.width === 'number' ? args.width : current.width,
-    height: typeof args.height === 'number' ? args.height : current.height,
-  };
-  if (next.width < 10 || next.height < 4) {
-    return { output: `refused — minimum 10x4 (got ${next.width}x${next.height})`, ok: false };
-  }
-  w.setBounds(next);
-  publishControlEvent('window', String(id), { action: 'resize', bounds: next });
-  return { output: `win:${id} resized to ${next.width}x${next.height} @(${next.row},${next.col})`, ok: true, bounds: next };
-}
-
-export async function dispatchControlPaneResize(
-  args: Record<string, unknown>,
-): Promise<{ output: string; ok?: boolean }> {
-  const addr = String(args.addr ?? '');
-  const paneId = parsePaneAddr(addr);
-  if (!paneId) return { output: `invalid pane addr: ${addr}`, ok: false };
-  const axis = args.axis === 'h' || args.axis === 'v' ? args.axis : null;
-  if (!axis) return { output: `invalid axis: ${args.axis}`, ok: false };
-  const delta = typeof args.delta === 'number' ? Math.trunc(args.delta) : 0;
-  if (!Number.isFinite(delta) || delta === 0) return { output: 'delta must be non-zero integer', ok: false };
-  const reg = deps.getWindowRegistry?.();
-  if (!reg) return { output: 'window registry unavailable', ok: false };
-  for (const w of reg.list()) {
-    if (!w.listPanes().some(p => p.id === paneId)) continue;
-    const changed = w.resizePaneAt(paneId, axis, delta);
-    publishControlEvent('pane', paneId, { action: 'resize', axis, delta, changed });
-    return {
-      output: changed
-        ? `pane:${paneId} resized axis=${axis} delta=${delta}`
-        : `pane:${paneId} no-op (hit min size or no matching-axis split)`,
-      ok: changed,
-    };
-  }
-  return { output: `unknown pane:${paneId}`, ok: false };
-}
-
-export async function dispatchControlPaneLayout(
-  args: Record<string, unknown>,
-): Promise<{ output: string; ok?: boolean; paneCount?: number }> {
-  const wid = parseWinAddr(String(args.windowAddr ?? ''));
-  if (wid === null) return { output: `invalid windowAddr: ${args.windowAddr}`, ok: false };
-  const layout = String(args.layout ?? '');
-  const reg = deps.getWindowRegistry?.();
-  if (!reg) return { output: 'window registry unavailable', ok: false };
-  const entry = reg.list().find(x => x.id === wid);
-  if (!entry) return { output: `unknown window win:${wid}`, ok: false };
-
-  // Translate layout name → list of axes to split in order. Each
-  // split acts on the currently-focused pane (so layout names map
-  // directly to tmux-style conventions).
-  const plan: Array<{ axis: 'h' | 'v' }> = (() => {
-    switch (layout) {
-      case '2x1': return [{ axis: 'v' }];
-      case '1x2': return [{ axis: 'h' }];
-      case '1x3': return [{ axis: 'h' }, { axis: 'h' }];
-      case '3x1': return [{ axis: 'v' }, { axis: 'v' }];
-      case '2x2': return [{ axis: 'h' }, { axis: 'v' }, { axis: 'v' }];
-      default: return [];
-    }
-  })();
-  if (plan.length === 0) return { output: `invalid layout: ${layout}`, ok: false };
-
-  const spec = deps.defaultPaneSpec ?? ((slot: number): PaneContentSpec => ({
-    kind: 'terminal',
-    title: `slot-${slot + 2}`,
-  } as PaneContentSpec));
-  const paneDeps = deps.paneDeps ?? {};
-
-  // Use the registry's existing createPaneContent so we stay in sync
-  // with the PaneFactoryDeps that dashboard wires.
-  const { createPaneContent } = await import('../../virtual-windows/pane-content.js');
-  let slot = 0;
-  for (const step of plan) {
-    const content = createPaneContent(spec(slot), paneDeps);
-    entry.splitFocused(step.axis, content);
-    slot++;
-  }
-  publishControlEvent('window', String(wid), { action: 'layout', layout, paneCount: entry.listPanes().length });
-  return {
-    output: `win:${wid} laid out as ${layout} (${entry.listPanes().length} panes)`,
-    ok: true,
-    paneCount: entry.listPanes().length,
-  };
-}
-
 export async function dispatchControlToolToggle(
   args: Record<string, unknown>,
 ): Promise<{ output: string; ok: boolean }> {
@@ -277,7 +93,7 @@ export async function dispatchControlToolToggle(
   const entry = nativeToolCatalog.find(t => t.id === toolId || t.aliases.includes(toolId));
   if (!entry) return { output: `unknown tool: ${toolId}`, ok: false };
   entry.defaultEnabled = enabled;
-  publishControlEvent('tool', entry.id, { action: 'toggle', enabled });
+  publishControlEvent(entry.id, { action: 'toggle', enabled });
   return { output: `tool ${entry.id} ${enabled ? 'enabled' : 'disabled'}`, ok: true };
 }
 

package/src/skills/tools/dashboard-slash.ts

@@ -2,7 +2,7 @@
 //
 // Programmatically fire a slash command. The LLM in dashboard-
 // control mode (T6-K1/K2) uses this to run things like `/term list`
-// or `/window new scratch` without asking the user to type them.
+// without asking the user to type them.
 //
 // Allow-list: only a curated subset of SLASH_COMMANDS is callable
 // by the LLM. Mutating or confusing commands (e.g. /quit, /sync
@@ -49,9 +49,6 @@ export function _resetDashboardSlashExecutorForTesting(): void {
  *  additional command proves safe + useful in control mode. */
 export const ALLOWED_SLASHES: readonly string[] = Object.freeze([
   'term', 'terminal',
-  'window', 'win',
-  'bench',
-  'view',
   'provider', 'p',
   'context', 'ctx',
   'plugin', 'plugins',
@@ -64,15 +61,10 @@ export const ALLOWED_SLASHES: readonly string[] = Object.freeze([
   'api-allow', 'api',
   'prompt', 'prompts',
   'history', 'hist',
-  'scratch', 'sc',
-  'fullscreen', 'fs',
   'log',
   'claude',
   'codex',
-  'claude-vw',
-  'codex-vw',
-  'acp-vw',
-  'control', 'dm', 'default',
+  'control', 'default',
   'help', '?',
   'run-skill', 'rs',
 ]);
@@ -96,7 +88,7 @@ export function buildDashboardSlashExecuteTool(): LLMToolSpec {
   return {
     name: 'DashboardSlashExecute',
     description:
-      'Run a slash command programmatically from control mode. Only a curated allow-list is callable (term, window, view, provider, context, plugin, widget, memory, status, hint, api-allow, prompt, history, scratch, fullscreen, claude, codex, control, help, run-skill). Interactive/destructive commands (quit, clear, debug, perf, codex-setup, telegram) are blocked — ask the user to type those. Returns ok=false + reason when the command is blocked or unrecognized.',
+      'Run a slash command programmatically from control mode. Only a curated allow-list is callable (term, provider, context, plugin, widget, memory, status, hint, api-allow, prompt, history, claude, codex, control, help, run-skill). Interactive/destructive commands (quit, clear, debug, perf, codex-setup, telegram) are blocked — ask the user to type those. Returns ok=false + reason when the command is blocked or unrecognized.',
     parameters: {
       type: 'object',
       properties: {

package/src/skills/tools/dashboard-state.ts

@@ -3,8 +3,7 @@
 // On-demand structured pull of the full dashboard state snapshot.
 // The system-prompt injection (runTurn) already front-loads this
 // compact text, but tools like GetDashboardState let the LLM pull
-// a fresh JSON when it wants to make state-conditioned decisions
-// ("is win:3 still foreground? if yes, split vertically…").
+// a fresh JSON when it wants to make state-conditioned decisions.
 //
 // Output is the DashboardStateSnapshot JSON. The `output` string
 // is the same prompt-rendered summary (short), so when the model
@@ -23,9 +22,8 @@ export function buildGetDashboardStateTool(): LLMToolSpec {
   return {
     name: 'GetDashboardState',
     description:
-      'Return the CURRENT monad-agent dashboard state: virtual windows and their pane layout + sizes, active PTY shells, terminal-modal sessions, the workspace cwd/remoteHost, and which tools are exposed this turn. ' +
-      'Use when you need to branch on live layout (e.g. "is win:3 foreground?") or confirm pane sizes before splitting. ' +
-      'State is usually stable within a turn; do not call it twice without an intervening action that could change layout, sessions, cwd, or tool exposure. ' +
+      'Return the CURRENT monad-agent dashboard state: active PTY shells, terminal-modal sessions, the workspace cwd/remoteHost, and which tools are exposed this turn. ' +
+      'State is usually stable within a turn; do not call it twice without an intervening action that could change sessions, cwd, or tool exposure. ' +
       'Read-only; no approval, no audit log.',
     parameters: {
       type: 'object',

package/src/skills/tools/dev-harness.ts

@@ -13,7 +13,9 @@
 // ★ 제1원칙: front door 결정 observe(harness.frontdoor) — objective digest·autoDrive·terminal.
 //   autoDrive 'safe'(기본): 저위험 자율·고위험(PR open)만 ux.confirm(막 채널 없으면 fail-closed).
 
+import { createHash } from 'node:crypto';
 import { tierModel } from '../../llm/model-defaults.js';
+import { dispatchTask, type DispatchTaskDeps } from '../../execution-loop/dispatch-task.js';
 import type { LLMToolSpec } from '../../llm.js';
 import type { DaemonToolDispatchCtx } from '../../boot/daemon-tools/types.js';
 import type { SelfImplementSeams } from '../../self-implement/orchestrator.js';
@@ -29,7 +31,8 @@ import { resolveMainRepoRoot } from '../../git-fs/worktree.js';
 import { describeEntranceCommand, lookupEntrance } from '../../self-dev/entrance-registry.js';
 
 const AUTO_DRIVES = ['off', 'safe', 'on'] as const;
-const RUN_DEV_HARNESS_ENTRANCE = lookupEntrance('nl-run-dev-harness');
+// ⛔ 모듈 평가 시점에 조회하지 않는다 — entrance-registry → native-tool-catalog → 이 파일의 순환에서
+//    registry 가 아직 초기화 중이면 `byId` TDZ 로 적재가 죽는다(🅞 2026-09-27 · test/intake-plane-draft.test.ts).
 const RUN_DEV_HARNESS_REPLACEMENT = 'SelfImplement 또는 SolveMission';
 const RUN_DEV_HARNESS_DESCRIPTION =
   'Use this tool when the user mentions the harness: forms such as "하니스로 개발", "하니스:", "하니스로 구현해줘", "하니스 구현", English "harness", or "self dev" mean the same even with Korean particles or punctuation. ' +
@@ -66,7 +69,7 @@ export function buildRunDevHarnessTool(): LLMToolSpec {
   return {
     name: 'RunDevHarness',
     description: describeEntranceCommand(
-      RUN_DEV_HARNESS_ENTRANCE,
+      lookupEntrance('nl-run-dev-harness'),
       RUN_DEV_HARNESS_REPLACEMENT,
       RUN_DEV_HARNESS_DESCRIPTION,
     ),
@@ -95,6 +98,9 @@ export function buildRunDevHarnessTool(): LLMToolSpec {
 export interface DevHarnessDeps {
   /** 하니스 구동(기본 runStagedHarnessOnSurface). */
   runHarness?: (opts: RunHarnessOnSurfaceOptions) => Promise<HarnessResult>;
+  /** In-process 실행 직전의 관측 전용 디스패치 seam. */
+  dispatchTask?: typeof dispatchTask;
+  dispatchTaskDeps?: DispatchTaskDeps;
   /** seam 팩토리(기본 defaultSeams). */
   seamsFactory?: (o: DefaultSeamsOptions) => SelfImplementSeams;
   /** 비대화형 HITL relay 팩토리 seam(기본 buildLlmHitlRelay). */
@@ -467,6 +473,43 @@ export async function dispatchRunDevHarness(
   const runHarness = deps?.runHarness ?? runStagedHarnessOnSurface;
   const knobs = resolveHarnessKnobs(rawArgs, ctx?.userText);   // ★ B1 관통 — C1~C4 노브를 surface 파라미터에서 막으로
   const harnessMention = harnessMentionState(ctx?.userText);
+  // Outer pipeline/Pod observations are not repeated; this decision never controls the harness.
+  const dispatchSkipped = rawArgs.plan_staged === true ? 'plan-staged'
+    : rawArgs.dispatch_recorded === true || process.env.ELANOUS_DISPATCH_RECORDED === '1' ? 'dispatch-recorded'
+    : process.env.ELANOUS_EXECUTION_LOOP_DISPATCH === 'off' && !deps?.dispatchTask && !deps?.dispatchTaskDeps ? 'disabled'
+    : undefined;
+  if (dispatchSkipped) {
+    try { debug.log('execution-loop.gate', 'dispatch-skipped', { reason: dispatchSkipped, runId }); } catch { /* fail-soft */ }
+  } else {
+    try {
+      const spec = { input: { text: objective }, executor: { kind: 'self' as const }, plan: true, runId };
+      const observer = new AbortController();
+      const timeoutMs = Math.min(5_000, Math.max(0, deps?.dispatchTaskDeps?.timeoutMs ?? 5_000));
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      try {
+        await Promise.race([
+          Promise.resolve().then(() => (deps?.dispatchTask ?? dispatchTask)({
+            goalId: `request-${createHash('sha256').update(objective).digest('hex').slice(0, 32)}`,
+            title: objective.split(/\r?\n/, 1)[0]?.trim() || 'Untitled request',
+            goalText: objective,
+            targetPaths: [],
+            spec,
+            runKey: runId,
+          }, { ...deps?.dispatchTaskDeps, signal: observer.signal })),
+          new Promise<never>((_, reject) => {
+            timer = setTimeout(() => {
+              observer.abort();
+              reject(new Error(`dispatch observation timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+          }),
+        ]);
+      } finally {
+        if (timer) clearTimeout(timer);
+      }
+    } catch (error) {
+      try { debug.log('execution-loop.gate', 'dispatch-unavailable', { reason: String(error), runId }); } catch { /* fail-soft */ }
+    }
+  }
   const result = await runHarness({
     // ⛔⭐ `naturalLanguageDispatch` 를 «단정»하지 않는다 — 증거로 정한다.
     //   이 함수는 «둘» 이 지난다: ⑴ 모델이 부른 도구(사용자 턴 문면이 ctx.userText 로 온다)

package/src/skills/tools/omni-search.ts

@@ -35,6 +35,16 @@ export interface OmniSearchResult {
   };
 }
 
+export type OmniSearchEngineEvent =
+  | { engine: string; phase: 'start' }
+  | { engine: string; phase: 'complete'; hits: number; durationMs: number; error?: string };
+
+export interface OmniSearchDispatchOpts {
+  /** Observational only: callback failures must not interrupt a provider search. */
+  onEngine?: (event: OmniSearchEngineEvent) => void;
+  onSource?: (source: WebSearchHit & { engine: string }) => void;
+}
+
 const DEFAULT_LIMIT = 5;
 const MAX_LIMIT = 20;
 
@@ -63,7 +73,10 @@ export function buildOmniSearchTool(): LLMToolSpec {
   };
 }
 
-export async function dispatchOmniSearch(rawArgs: Record<string, unknown>): Promise<OmniSearchResult> {
+export async function dispatchOmniSearch(
+  rawArgs: Record<string, unknown>,
+  opts: OmniSearchDispatchOpts = {},
+): Promise<OmniSearchResult> {
   const args = validate(rawArgs);
   const merge = args.merge ?? 'interleave';
   const limit = Math.max(1, Math.min(args.limit ?? DEFAULT_LIMIT, MAX_LIMIT));
@@ -82,8 +95,15 @@ export async function dispatchOmniSearch(rawArgs: Record<string, unknown>): Prom
 
   // Parallel fan-out. Per-provider failures don't fail the whole call.
   const perEngine: Record<string, { hits: WebSearchHit[]; durationMs: number; error?: string }> = {};
+  const emit = (event: OmniSearchEngineEvent): void => {
+    if (!opts.onEngine) return;
+    try {
+      void Promise.resolve(opts.onEngine(event)).catch(() => {});
+    } catch { /* Observers cannot change search results. */ }
+  };
   await Promise.all(providers.map(async (p) => {
     const start = Date.now();
+    emit({ engine: p.id, phase: 'start' });
     try {
       const result = await p.search({
         query: args.query,
@@ -93,6 +113,11 @@ export async function dispatchOmniSearch(rawArgs: Record<string, unknown>): Prom
         recencyDays: args.recency_days,
       });
       perEngine[p.id] = { hits: result.hits, durationMs: Date.now() - start };
+      for (const hit of result.hits) {
+        try {
+          if (opts.onSource) void Promise.resolve(opts.onSource({ ...hit, engine: p.id })).catch(() => {});
+        } catch { /* Observers cannot change search results. */ }
+      }
     } catch (err) {
       perEngine[p.id] = {
         hits: [],
@@ -100,6 +125,9 @@ export async function dispatchOmniSearch(rawArgs: Record<string, unknown>): Prom
         error: err instanceof Error ? err.message : String(err),
       };
     }
+    const info = perEngine[p.id]!;
+    emit({ engine: p.id, phase: 'complete', hits: info.hits.length, durationMs: info.durationMs,
+      ...(info.error !== undefined ? { error: info.error } : {}) });
   }));
 
   // Merge.

package/src/skills/tools/shell.ts

@@ -31,7 +31,6 @@ import {
   runShell as runnerDispatch,
   getShellRunnerDeps,
 } from '../../shell-runner/dispatch.js';
-import type { ShellMode } from '../../shell-runner/types.js';
 import type { ShellResult as RunnerResult } from '../../shell-runner/types.js';
 import { debug } from '../../debug/log.js';
 import { getSessionCwd } from '../../session/working-dir.js';
@@ -81,23 +80,14 @@ export function buildRunShellTool(): LLMToolSpec {
           enum: ['inherit', 'off'],
           description: "Network policy. Only enforced when sandbox != 'off'. Default 'inherit'.",
         },
-        // NT-C1b (session nt): shell-runner routing opt-in. When these
-        // fields are present the call is dispatched through the unified
-        // 4-mode runner; otherwise the legacy shell-primitive argv path
-        // is used as before (zero behavior change).
         mode: {
           type: 'string',
-          enum: ['auto', 'inline', 'bg', 'modal', 'vw'],
-          description:
-            "shell-runner mode. Omit for the legacy argv-only path. 'vw' (default when shell-runner deps are wired) hosts the command in a user-visible runner VW pane and returns only the new output slice. 'bg' registers as background for later ShellPoll. 'inline' is a chat-log one-liner. 'modal' is the legacy centered modal surface.",
+          enum: ['inline', 'bg'],
+          description: "Shell-runner mode. Omit for the legacy argv-only path. 'inline' captures command output; 'bg' registers it for later ShellPoll.",
         },
         description: {
           type: 'string',
-          description: 'Free-form label shown in surfaces (chat log, status-bar pill, runner pane title).',
-        },
-        vw_window_label: {
-          type: 'string',
-          description: "Only for mode='vw'. Label of the VW to reuse / create. Default 'runner'.",
+          description: 'Free-form label shown in shell logs and status.',
         },
       },
       required: ['command'],
@@ -113,9 +103,8 @@ export interface RunShellDispatchArgs {
   approval?: ShellRequest['approval'];
   sandbox?: ShellRequest['sandbox'];
   network?: ShellRequest['network'];
-  mode?: ShellMode;
+  mode?: 'inline' | 'bg';
   description?: string;
-  vw_window_label?: string;
 }
 
 export interface RunShellDispatchResult extends Record<string, unknown> {
@@ -164,11 +153,9 @@ function asNetwork(raw: unknown): ShellRequest['network'] {
   throw new Error(`invalid network value: ${JSON.stringify(raw)}`);
 }
 
-function asMode(raw: unknown): ShellMode | undefined {
+function asMode(raw: unknown): 'inline' | 'bg' | undefined {
   if (raw === undefined) return undefined;
-  if (raw === 'auto' || raw === 'inline' || raw === 'bg' || raw === 'modal' || raw === 'vw') {
-    return raw;
-  }
+  if (raw === 'inline' || raw === 'bg') return raw;
   throw new Error(`invalid mode value: ${JSON.stringify(raw)}`);
 }
 
@@ -204,7 +191,6 @@ export async function dispatchRunShell(
   const network = asNetwork(rawArgs.network);
   const mode = asMode(rawArgs.mode);
   const description = typeof rawArgs.description === 'string' ? rawArgs.description : undefined;
-  const vwLabel = typeof rawArgs.vw_window_label === 'string' ? rawArgs.vw_window_label : undefined;
   if (command[0] === 'cd') {
     logShellDispatch('cd.rejected', { reason: 'argv-state-does-not-persist' });
     return rejectedCdResult();
@@ -214,14 +200,12 @@ export async function dispatchRunShell(
   const boundaryReject = harnessCommandWriteReject(command, effectiveCwd, 'run-shell');
   if (boundaryReject) throw new Error(boundaryReject);
 
-  // NT-C1b-1: when mode is explicitly provided AND shell-runner deps
-  // are installed, route through the 4-mode dispatcher. Otherwise
-  // keep the legacy argv-only shell-primitive path (zero behavior
-  // change for callers not opting in).
+  // Explicit inline/bg uses the file-backed runner when its deps are installed;
+  // omitted mode and uninitialized hosts keep the legacy argv path.
   const deps = mode ? getShellRunnerDeps() : null;
   if (mode && deps) {
     const result = await dispatchViaRunner({
-      command, cwd, timeoutMs, mode, description, vwLabel,
+      command, cwd, timeoutMs, mode, description,
       signal: opts.signal,
       deps,
     });
@@ -255,16 +239,15 @@ export async function dispatchRunShell(
   };
 }
 
-/** Route a request through the 4-mode shell-runner and project its
+/** Route a request through the file-backed shell-runner and project its
  *  ShellResult back into the legacy RunShell response shape so
  *  callers keep the same output fields (exitCode/stdout/stderr/…). */
 async function dispatchViaRunner(args: {
   command: string[];
   cwd?: string;
   timeoutMs?: number;
-  mode: ShellMode;
+  mode: 'inline' | 'bg';
   description?: string;
-  vwLabel?: string;
   signal?: AbortSignal;
   deps: NonNullable<ReturnType<typeof getShellRunnerDeps>>;
 }): Promise<RunShellDispatchResult> {
@@ -275,7 +258,6 @@ async function dispatchViaRunner(args: {
     ...(args.timeoutMs !== undefined ? { timeoutMs: args.timeoutMs } : {}),
     ...(args.description !== undefined ? { description: args.description } : {}),
     ...(args.signal !== undefined ? { signal: args.signal } : {}),
-    ...(args.vwLabel !== undefined ? { vw: { windowLabel: args.vwLabel } } : {}),
   };
   const handle = runnerDispatch(req, args.deps);
   const result = await handle.result;

package/src/skills/tools/spawn-coding-agent-headless.ts

@@ -1,10 +1,8 @@
 // Native tool: SpawnCodingAgentHeadless — I2 (텔레그램 코딩 에이전트).
 //
-// The VW-less sibling of SpawnCodingAgentInVW (src/skills/tools/
-// spawn-coding-agent-vw.ts). That one lands claude-code / codex in a
-// dashboard virtual-window terminal pane; this one lands them in a bare
-// PtyShell so a HEADLESS surface (telegram / continuation) can spawn a
-// sub coding-agent and drive its live terminal with the PtyShell family:
+// Lands claude-code / codex in a bare PtyShell so a HEADLESS surface
+// (telegram / continuation) can spawn a sub coding-agent and drive its
+// live terminal with the PtyShell family:
 //
 //   SpawnCodingAgentHeadless → process_id
 //     · PtyShellSnapshot  — read the agent's screen (it's a full-screen TUI)
@@ -17,8 +15,7 @@
 // prefer it for fire-and-forget "delegate this coding task, give me the
 // result". This tool is for when you want to DRIVE or SEE the agent's
 // actual terminal (observe its work, steer mid-run, or run a CLI that has
-// no ACP). Reuses the brand→binary resolution + macOS keychain-unlock
-// wrap from the VW path so `claude` can read its credentials.
+// no ACP). The macOS keychain-unlock wrap lets `claude` read its credentials.
 
 import { spawnSync } from 'node:child_process';
 import type { LLMToolSpec } from '../../llm.js';
@@ -26,7 +23,7 @@ import { getSessionCwd } from '../../session/working-dir.js';
 import { startPty, unregisterPty, type PtyHandle } from '../../pty-shell/registry.js';
 import { CodingAgentBinaryMissing } from '../../terminal/coding-agent.js';
 import { wrapCommandForKeychainUnlock, shouldWrapForKeychainUnlock } from '../../terminal/keychain-unlock.js';
-import type { CodingAgentBrand } from './spawn-coding-agent-vw.js';
+export type CodingAgentBrand = 'claude-code' | 'codex';
 
 const sleep = (ms: number): Promise<void> => new Promise(r => setTimeout(r, ms));
 
@@ -100,7 +97,7 @@ function resolveAndSpawn(
     throw new CodingAgentBinaryMissing(binary);
   }
   // Only `claude` reads the macOS keychain — wrap it in the SSH unlock
-  // preamble (same gate as the VW path) so credentials resolve. codex
+  // preamble so credentials resolve. codex
   // spawns as a plain direct binary.
   const wrap = brand === 'claude-code' && shouldWrapForKeychainUnlock();
   const wrapCommand = deps.wrapCommand ?? wrapCommandForKeychainUnlock;

package/src/ssh/ssh-picker-modal.ts

@@ -1,6 +1,6 @@
 // SSH host picker modal — T4-E4.
 //
-// Sibling of session-picker-modal + window-picker-modal. Wraps
+// Sibling of session-picker-modal. Wraps
 // createSearchModal with the registered SSH hosts so Ctrl+K pops
 // a fuzz-matchable list; Enter switches the browser pane into
 // remote mode against the selected host, Esc cancels.