elanous 0.2.0 → 0.2.4

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

@@ -29,7 +29,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 +67,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,
     ),

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.

package/src/steward/directive.ts

@@ -0,0 +1,99 @@
+import { createHash } from 'node:crypto';
+import { getSecretAsync } from '../nexus/config/secrets/index.js';
+import { getUserConfig } from '../user-config.js';
+
+export type DirectiveSource = 'telegram' | 'pwa' | 'tui' | 'cli';
+export interface DirectiveIssue { id: string; identifier: string; title: string; description?: string | null }
+export interface DirectiveDeps {
+  fetch?: typeof fetch;
+  getSecret?: (id: string) => Promise<string | undefined>;
+  team?: string;
+  now?: () => Date;
+}
+
+export function directiveHash(text: string): string {
+  return createHash('sha256').update(text.normalize('NFKC').trim().replace(/\s+/g, ' ').toLocaleLowerCase()).digest('hex');
+}
+
+async function graphql<T>(key: string, query: string, variables: Record<string, unknown>, fetchFn: typeof fetch): Promise<T> {
+  let response: Response;
+  try {
+    response = await fetchFn('https://api.linear.app/graphql', {
+      method: 'POST', headers: { Authorization: key, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ query, variables }),
+    });
+  } catch { throw new Error('Linear GraphQL request failed'); }
+  if (!response.ok) throw new Error(`Linear GraphQL HTTP ${response.status}`);
+  let payload: { data?: T; errors?: unknown[] };
+  try { payload = await response.json() as typeof payload; }
+  catch { throw new Error('Linear GraphQL invalid JSON response'); }
+  if (payload.errors?.length || !payload.data) throw new Error('Linear GraphQL returned errors or missing data');
+  return payload.data;
+}
+
+/** The same entry point is used by the CLI and conversational surfaces. */
+export async function addDirective(text: string, options: { source?: DirectiveSource; dryRun?: boolean } = {}, deps: DirectiveDeps = {}): Promise<{ status: 'created' | 'repeated' | 'dry-run'; issue?: string; hash: string }> {
+  const original = text.trim();
+  if (!original) throw new Error('directive text is required');
+  const source = options.source ?? 'cli';
+  if (!['telegram', 'pwa', 'tui', 'cli'].includes(source)) throw new Error('invalid directive source');
+  const hash = directiveHash(original);
+  if (options.dryRun) return { status: 'dry-run', hash };
+  const key = await (deps.getSecret ?? getSecretAsync)('connector.linear.apiKey');
+  if (!key) throw new Error('connector.linear.apiKey missing; run elanous connector linear set-key');
+  const teamKey = deps.team ?? getUserConfig().loops?.steward?.linearTeam ?? 'ELA';
+  const request = <T>(query: string, variables: Record<string, unknown>) => graphql<T>(key, query, variables, deps.fetch ?? fetch);
+  const team = await request<{ teams: { nodes: Array<{ id: string }> } }>(
+    'query($key:String!){teams(filter:{key:{eq:$key}}){nodes{id}}}', { key: teamKey });
+  const teamId = team.teams?.nodes?.[0]?.id;
+  if (!teamId) throw new Error('Linear team not found');
+  let after: string | null = null;
+  const seen = new Set<string>();
+  let duplicate: DirectiveIssue | undefined;
+  do {
+    const data: { issues: { nodes: Array<DirectiveIssue & { state?: { type?: string } }>; pageInfo: { hasNextPage: boolean; endCursor: string | null } } } = await request<{ issues: { nodes: Array<DirectiveIssue & { state?: { type?: string } }>; pageInfo: { hasNextPage: boolean; endCursor: string | null } } }>(
+      'query($key:String!,$after:String){issues(filter:{team:{key:{eq:$key}}},first:100,after:$after){nodes{id identifier title description state{type}} pageInfo{hasNextPage endCursor}}}',
+      { key: teamKey, after });
+    if (!Array.isArray(data.issues?.nodes)) throw new Error('Linear issues missing');
+    duplicate = data.issues.nodes.find(issue => {
+      if (['completed', 'canceled', 'duplicate'].includes(issue.state?.type ?? '')) return false;
+      if (issue.description?.includes(`[directive-hash:${hash}]`)) return true;
+      const firstLine = issue.description?.split('\n')[0]?.trim();
+      const candidate = firstLine && firstLine.length > 0 ? firstLine : issue.title;
+      return directiveHash(candidate) === hash;
+    });
+    if (duplicate) break;
+    const page = data.issues.pageInfo;
+    if (page?.hasNextPage && (!page.endCursor || seen.has(page.endCursor))) throw new Error('Linear pagination cursor missing or repeated');
+    after = page?.hasNextPage ? page.endCursor : null;
+    if (after) seen.add(after);
+  } while (after);
+  const at = (deps.now ?? (() => new Date()))().toISOString();
+  if (duplicate) {
+    const result = await request<{ commentCreate: { success: boolean } }>(
+      'mutation($input:CommentCreateInput!){commentCreate(input:$input){success}}',
+      { input: { issueId: duplicate.id, body: `다시 말함 · ${source} · ${at}\n\n${original}` } });
+    if (!result.commentCreate?.success) throw new Error('Linear comment creation failed');
+    return { status: 'repeated', issue: duplicate.identifier, hash };
+  }
+  const labels = await request<{ issueLabels: { nodes: Array<{ id: string; name: string }> } }>(
+    'query($name:String!){issueLabels(filter:{name:{eq:$name}}){nodes{id name}}}', { name: 'from-directive' });
+  let labelId = labels.issueLabels?.nodes?.find(item => item.name === 'from-directive')?.id;
+  if (!labelId) {
+    const createdLabel = await request<{ issueLabelCreate: { success: boolean; issueLabel?: { id: string } } }>(
+      'mutation($input:IssueLabelCreateInput!){issueLabelCreate(input:$input){success issueLabel{id}}}',
+      { input: { teamId, name: 'from-directive' } });
+    labelId = createdLabel.issueLabelCreate?.success ? createdLabel.issueLabelCreate.issueLabel?.id : undefined;
+    if (!labelId) throw new Error('Linear label from-directive creation failed');
+  }
+  const created = await request<{ issueCreate: { success: boolean; issue?: DirectiveIssue } }>(
+    'mutation($input:IssueCreateInput!){issueCreate(input:$input){success issue{id identifier title}}}',
+    { input: { teamId, title: original.slice(0, 240), description: `${original}\n\n출처: ${source}\n시각: ${at}\n[directive-hash:${hash}]`, labelIds: [labelId], priority: 0 } });
+  if (!created.issueCreate?.success || !created.issueCreate.issue?.identifier) throw new Error('Linear issue creation failed');
+  return { status: 'created', issue: created.issueCreate.issue.identifier, hash };
+}
+
+export async function runDirectiveCli(text: string, options: { source?: DirectiveSource; dryRun?: boolean }): Promise<void> {
+  const result = await addDirective(text, options);
+  console.log(`${result.status}\t${result.issue ?? '-'}\t${result.hash}`);
+}