elanous 0.2.0 → 0.2.4

package/src/agent/spawn-embodied-agent-in-vw.ts

@@ -1,110 +1,15 @@
-// H5 Phase 1 Step E · Spawn embodied agent into a VW pane via the
-// adapter bus.
-//
-// `/acp-vw <brand>` routes here for clc / gem / lll. The adapter
-// registry produces an EmbodiedAgentSession owning the PTY handle;
-// we then create a VW window whose initial content is a `pty-tail`
-// pane subscribed to that handle. Mount is driven from here (not
-// from pty-binding.ts) because mounting into a VW is a display
-// concern — the binding primitive stays pure.
-//
-// Bootstrap: call `initSpawnEmbodiedAgentInVW(registry)` once at
-// dashboard startup. That also registers the default codex-pty
-// adapter into `defaultAdapterRegistry` (lazy, idempotent). Tests
-// reset via `_resetSpawnEmbodiedAgentInVWForTesting()`.
+import type { EmbodiedAgentSession } from './embodiment.js';
 
-import { defaultAdapterRegistry } from './adapter-registry.js';
-import { registerDefaultCodexPtyAdapter } from './adapters/codex-pty.js';
-import { registerDefaultClaudePtyAdapter } from './adapters/claude-pty.js';
-import { registerDefaultGeminiPtyAdapter } from './adapters/gemini-pty.js';
-import { registerDefaultLocalLlmPtyAdapter } from './adapters/local-llm-pty.js';
-import { registerDefaultLocalLlmSshPtyAdapter } from './adapters/local-llm-ssh-pty.js';
-import { registerDefaultLocalLlmOllamaPtyAdapter } from './adapters/local-llm-ollama-pty.js';
-import { registerDefaultLocalLlmOllamaSshPtyAdapter } from './adapters/local-llm-ollama-ssh-pty.js';
-import { registerDefaultElanousAsChildAdapter } from './adapters/elanous-as-child.js';
-import { attachTransports } from './attach-transport.js';
-import type { WindowRegistry } from '../virtual-windows/window-registry.js';
-import {
-  createPaneContent,
-  type PaneFactoryDeps,
-} from '../virtual-windows/pane-content.js';
-import type {
-  AgentLaunchMode,
-  EmbodiedAgentSession,
-} from './embodiment.js';
-import { globalAcpAgentManager } from '../acp/agent-manager.js';
-
-let _registry: WindowRegistry | null = null;
-let _paneDeps: PaneFactoryDeps | null = null;
-let _adapterDisposers: Array<() => void> = [];
-
-/** H5 P2 · process-wide record of live sessions so tools like
- *  SnapshotPtyState can look a session up by id (or by the pane id
- *  the VW assigned when it mounted the PTY). Populated by
- *  `spawnEmbodiedAgentInVW` and pruned on session dispose. */
+/** Session lookup shape retained for showroom, voice and capture consumers. */
 interface LiveSessionEntry {
   readonly session: EmbodiedAgentSession;
   readonly paneId: string;
   readonly windowId: number;
   readonly ptyId: string;
 }
-const _liveSessions = new Map<string, LiveSessionEntry>();
-
-export function initSpawnEmbodiedAgentInVW(
-  registry: WindowRegistry,
-  paneDeps?: PaneFactoryDeps,
-): void {
-  _registry = registry;
-  // H6 P4 · paneDeps optional for back-compat — legacy callers only
-  // use `spawnEmbodiedAgentInVW` (pty-tail doesn't need paneDeps).
-  // Agent-room's `spawnEmbodiedAgentIntoPane` also uses pty-tail so
-  // an empty deps object works; callers that want llm-chat/terminal
-  // panes inside rooms can supply the real deps.
-  _paneDeps = paneDeps ?? {};
-  if (_adapterDisposers.length === 0) {
-    // Register one adapter per brand. Order matters only for display
-    // (first registered wins when supports() overlaps) — these four
-    // have disjoint brand sets so the order is cosmetic.
-    _adapterDisposers.push(registerDefaultCodexPtyAdapter(defaultAdapterRegistry));
-    _adapterDisposers.push(registerDefaultClaudePtyAdapter(defaultAdapterRegistry));
-    _adapterDisposers.push(registerDefaultGeminiPtyAdapter(defaultAdapterRegistry));
-    // H6 P2 Bundle 2 A · local-llm-pty (brand 'local-llm' / 'lll') ·
-    // spawns `lms chat <model>` as a PTY. Model comes in via
-    // spec.extraArgs[0] from spawn-local-llm-in-vw.ts.
-    _adapterDisposers.push(registerDefaultLocalLlmPtyAdapter(defaultAdapterRegistry));
-    // H6 P2 Bundle 2 A2 · local-llm-ssh-pty (brand 'local-llm-remote' /
-    // 'lll-remote') · spawns `ssh -t <node> lms chat <model>` as a PTY.
-    // nodeId + modelId arrive via spec.extraArgs from spawn-local-llm-in-vw.ts.
-    _adapterDisposers.push(registerDefaultLocalLlmSshPtyAdapter(defaultAdapterRegistry));
-    // H6 P2 Bundle 2 D · local-llm-ollama-pty (brand 'local-llm-ollama' /
-    // 'llo') · spawns `ollama run <model>` as a PTY. Selected by
-    // spawn-local-llm-in-vw.ts when the cached model runtime is 'ollama'.
-    _adapterDisposers.push(registerDefaultLocalLlmOllamaPtyAdapter(defaultAdapterRegistry));
-    // H6 P2 Bundle 2 D · local-llm-ollama-ssh-pty (brand 'local-llm-
-    // ollama-remote' / 'llo-remote') · spawns `ssh -t <node> ollama run
-    // <model>` as a PTY. Remote counterpart to the above.
-    _adapterDisposers.push(registerDefaultLocalLlmOllamaSshPtyAdapter(defaultAdapterRegistry));
-    // H5 P3 · elanous-as-child adapter (brand 'elanous' / 'elanous-child').
-    // NOT a PTY adapter — spawns sub-elanous with --acp-server and wraps
-    // as ACP transport. Lives in the same registry because the handoff
-    // tool treats all embodied launches uniformly.
-    _adapterDisposers.push(registerDefaultElanousAsChildAdapter(defaultAdapterRegistry));
-  }
-}
 
-export function _resetSpawnEmbodiedAgentInVWForTesting(): void {
-  _registry = null;
-  _paneDeps = null;
-  for (const d of _adapterDisposers) {
-    try { d(); } catch { /* swallow · test-reset best-effort */ }
-  }
-  _adapterDisposers = [];
-  defaultAdapterRegistry.clear();
-  _liveSessions.clear();
-}
+const _liveSessions = new Map<string, LiveSessionEntry>();
 
-/** Read-only snapshot of currently tracked sessions · exported for
- *  the session-lookup bridge that feeds H5 P2 snapshot tools. */
 export function listLiveEmbodiedSessions(): readonly LiveSessionEntry[] {
   return [..._liveSessions.values()];
 }
@@ -114,244 +19,8 @@ export function findLiveSessionById(id: string): LiveSessionEntry | undefined {
 }
 
 export function findLiveSessionByPaneId(paneId: string): LiveSessionEntry | undefined {
-  for (const e of _liveSessions.values()) {
-    if (e.paneId === paneId) return e;
+  for (const entry of _liveSessions.values()) {
+    if (entry.paneId === paneId) return entry;
   }
   return undefined;
 }
-
-export interface SpawnEmbodiedAgentOpts {
-  brand: string;
-  mode?: AgentLaunchMode;
-  cwd?: string;
-  extraArgs?: readonly string[];
-  env?: Record<string, string>;
-  title?: string;
-  _hybridDeps?: HybridAttachDeps;
-}
-
-export interface SpawnEmbodiedAgentResult {
-  readonly session: EmbodiedAgentSession;
-  readonly windowId: number;
-  readonly paneId: string;
-  readonly ptyId: string;
-}
-
-export async function spawnEmbodiedAgentInVW(
-  opts: SpawnEmbodiedAgentOpts,
-): Promise<SpawnEmbodiedAgentResult> {
-  if (!_registry) {
-    throw new Error(
-      'spawnEmbodiedAgentInVW not wired · call initSpawnEmbodiedAgentInVW(registry) first',
-    );
-  }
-  const baseSession = await defaultAdapterRegistry.launch({
-    brand: opts.brand,
-    mode: opts.mode ?? 'hybrid',
-    cwd: opts.cwd,
-    extraArgs: opts.extraArgs,
-    env: opts.env,
-  });
-  const session = await attachHybridTransportsIfNeeded(baseSession, opts, opts._hybridDeps);
-  const ptyTransport = session.transports.find((t) => t.kind === 'pty');
-  if (!ptyTransport) {
-    // Adapter matched but didn't produce a PTY · clean up and fail
-    // with a clear error so the slash caller surfaces it to the user.
-    await session.dispose();
-    throw new Error(
-      `adapter ${session.id} did not produce a PTY transport · cannot mount into VW`,
-    );
-  }
-  const title = opts.title ?? `${opts.brand} [${basenameSafe(opts.cwd ?? '')}]`;
-  const window = _registry.spawn({
-    title,
-    initialContent: {
-      kind: 'pty-tail',
-      title,
-      ptyId: ptyTransport.id,
-    },
-  });
-  const entry: LiveSessionEntry = {
-    session,
-    paneId: window.focused,
-    windowId: window.id,
-    ptyId: ptyTransport.id,
-  };
-  _liveSessions.set(session.id, entry);
-  // Prune on dispose · don't accumulate dead sessions in the lookup.
-  const origDispose = session.dispose.bind(session);
-  (session as { dispose: () => Promise<void> }).dispose = async () => {
-    _liveSessions.delete(session.id);
-    await origDispose();
-  };
-  return {
-    session,
-    windowId: window.id,
-    paneId: window.focused,
-    ptyId: ptyTransport.id,
-  };
-}
-
-function basenameSafe(p: string): string {
-  const parts = p.split('/').filter(Boolean);
-  return parts[parts.length - 1] ?? p ?? 'cwd';
-}
-
-// ─── H6 P4 · Agent Room variant ──────────────────────────────────
-//
-// `spawnEmbodiedAgentIntoPane` mounts a newly-launched agent's PTY
-// into an *existing* VW by splitting a target pane. The legacy
-// `spawnEmbodiedAgentInVW` always creates a new VW (1 VW = 1 agent);
-// this variant is the building block agent-room uses for N-pane
-// rooms.
-//
-// Why a separate entry point (vs. extending the legacy one):
-//   - Back-compat: every existing caller of spawnEmbodiedAgentInVW
-//     relies on the "new VW per call" contract. An optional
-//     `targetWindowId` flag would bifurcate internal flow and make
-//     the happy path harder to reason about.
-//   - The agent-room path needs tighter control over axis + ratio
-//     (N-pane equal-width requires specific ratios; see PLAN §D7).
-//
-// Axis/ratio convention: `axis='h'` produces a side-by-side split
-// (a | b) — matches `three-pane-split` preset. `ratio` is the
-// fraction the *existing* pane keeps (a gets `ratio`, new pane gets
-// `1-ratio`). See `src/virtual-windows/layout-tree.ts::splitPane`.
-
-export interface SpawnEmbodiedAgentIntoPaneOpts {
-  /** Existing VW id to mount into. */
-  targetWindowId: number;
-  /** Existing pane to split. The new pane appears to the right (axis
-   *  'h') or below (axis 'v') this pane. */
-  targetPaneId: string;
-  brand: string;
-  mode?: AgentLaunchMode;
-  cwd?: string;
-  extraArgs?: readonly string[];
-  env?: Record<string, string>;
-  title?: string;
-  /** Default 'h' (horizontal split = side-by-side). */
-  axis?: 'h' | 'v';
-  /** Default 0.5. Fraction the original pane keeps; new pane gets
-   *  1-ratio. Room-builder computes per-index ratios for equal
-   *  widths (see src/agent-room/room-builder.ts). */
-  ratio?: number;
-  _hybridDeps?: HybridAttachDeps;
-}
-
-export interface SpawnEmbodiedAgentIntoPaneResult {
-  readonly session: EmbodiedAgentSession;
-  readonly windowId: number;
-  readonly paneId: string;
-  readonly ptyId: string;
-}
-
-/** Launch an embodied agent and mount its PTY into an existing VW
- *  by splitting `targetPaneId`. Returns the session plus the newly
- *  assigned paneId. Failure semantics: (a) adapter launch throws →
- *  no VW mutation; (b) no PTY transport → session disposed + throw;
- *  (c) splitPaneAt throws (depth/size limits) → session disposed +
- *  throw. Callers (room-builder) wrap this in Promise.allSettled for
- *  parallel launch + all-or-nothing rollback. */
-export async function spawnEmbodiedAgentIntoPane(
-  opts: SpawnEmbodiedAgentIntoPaneOpts,
-): Promise<SpawnEmbodiedAgentIntoPaneResult> {
-  if (!_registry) {
-    throw new Error(
-      'spawnEmbodiedAgentIntoPane not wired · call initSpawnEmbodiedAgentInVW(registry, paneDeps) first',
-    );
-  }
-  const window = _registry.get(opts.targetWindowId);
-  if (!window) {
-    throw new Error(`spawnEmbodiedAgentIntoPane: window ${opts.targetWindowId} not found`);
-  }
-  const baseSession = await defaultAdapterRegistry.launch({
-    brand: opts.brand,
-    mode: opts.mode ?? 'hybrid',
-    cwd: opts.cwd,
-    extraArgs: opts.extraArgs,
-    env: opts.env,
-  });
-  const session = await attachHybridTransportsIfNeeded(baseSession, opts, opts._hybridDeps);
-  const ptyTransport = session.transports.find((t) => t.kind === 'pty');
-  if (!ptyTransport) {
-    await session.dispose();
-    throw new Error(
-      `adapter ${session.id} did not produce a PTY transport · cannot mount into pane`,
-    );
-  }
-  const title = opts.title ?? `${opts.brand} [${basenameSafe(opts.cwd ?? '')}]`;
-  const paneContent = createPaneContent(
-    { kind: 'pty-tail', title, ptyId: ptyTransport.id },
-    _paneDeps ?? {},
-  );
-  let newPaneId: string;
-  try {
-    newPaneId = window.splitPaneAt(
-      opts.targetPaneId,
-      opts.axis ?? 'h',
-      paneContent,
-      opts.ratio ?? 0.5,
-    );
-  } catch (err) {
-    // splitPane can throw (depth, min-size, etc). Clean up agent +
-    // pane-content so we don't leak a PTY behind the scenes.
-    try { paneContent.dispose(); } catch { /* ignore */ }
-    await session.dispose();
-    throw err;
-  }
-  const entry: LiveSessionEntry = {
-    session,
-    paneId: newPaneId,
-    windowId: window.id,
-    ptyId: ptyTransport.id,
-  };
-  _liveSessions.set(session.id, entry);
-  const origDispose = session.dispose.bind(session);
-  (session as { dispose: () => Promise<void> }).dispose = async () => {
-    _liveSessions.delete(session.id);
-    await origDispose();
-  };
-  return {
-    session,
-    windowId: window.id,
-    paneId: newPaneId,
-    ptyId: ptyTransport.id,
-  };
-}
-
-interface HybridAttachDeps {
-  acquireCodexRpcTransport?: (
-    cwd: string | undefined,
-  ) => Promise<{ kind: 'rpc'; id: string; label: string } | null>;
-}
-
-async function attachHybridTransportsIfNeeded(
-  session: EmbodiedAgentSession,
-  opts: { brand: string; mode?: AgentLaunchMode; cwd?: string },
-  deps?: HybridAttachDeps,
-): Promise<EmbodiedAgentSession> {
-  const mode = opts.mode ?? 'hybrid';
-  if (opts.brand !== 'codex' || (mode !== 'hybrid' && mode !== 'auto')) {
-    return session;
-  }
-  try {
-    const descriptor = deps?.acquireCodexRpcTransport
-      ? await deps.acquireCodexRpcTransport(opts.cwd)
-      : await acquireCodexRpcTransport(opts.cwd);
-    if (!descriptor) return session;
-    return attachTransports(session, [descriptor]);
-  } catch {
-    return session;
-  }
-}
-
-async function acquireCodexRpcTransport(
-  cwd: string | undefined,
-): Promise<{ kind: 'rpc'; id: string; label: string } | null> {
-  const agent = await globalAcpAgentManager().getAgent('codex-app-server', { cwd });
-  const maybe = agent as unknown as {
-    getRpcTransportDescriptor?: () => { kind: 'rpc'; id: string; label: string };
-  };
-  return maybe.getRpcTransportDescriptor ? maybe.getRpcTransportDescriptor() : null;
-}

package/src/agent/subagent-callable.ts

@@ -27,8 +27,10 @@
 // fail loud with status='failed' + an error message in `output`.
 
 import { resolveAgentLayered } from './definition-registry.js';
+import { resolveAgent } from './loader.js';
 import { globalAgentRegistry } from './registry.js';
 import type { AgentRegistry } from './registry.js';
+import type { LLMProvider, LLMToolSpec } from '../llm.js';
 import type { SubagentCallable } from '../task-orchestrator/surfaces/subagent.js';
 
 export interface CreateSubagentCallableOpts {
@@ -39,6 +41,11 @@ export interface CreateSubagentCallableOpts {
    *  inject a synchronous lookup table so they don't touch the
    *  filesystem. */
   resolveDefinition?: (name: string) => ReturnType<typeof resolveAgentLayered>;
+  /** Same catalog and dispatcher supplied to the host's interactive agent tools. */
+  hostTools?: LLMToolSpec[];
+  dispatchTool?: (name: string, args: Record<string, unknown>, signal?: AbortSignal) => Promise<unknown>;
+  provider?: LLMProvider;
+  cwd?: string;
 }
 
 /** Surface-agnostic factory — returns a `SubagentCallable` ready to
@@ -47,7 +54,11 @@ export function createGlobalSubagentCallable(
   opts: CreateSubagentCallableOpts = {},
 ): SubagentCallable {
   const registry = opts.registry ?? globalAgentRegistry;
-  const resolveDefinition = opts.resolveDefinition ?? resolveAgentLayered;
+  // The 4-layer map loads the builtin layer only when a builtin dir is passed, so the
+  // builtins (`general-purpose` …) were missing here while chat's Agent tool had them
+  // (2026-09-27 dogfood: every TOX `run` task failed «'general-purpose' not found»).
+  // Fall back to the builtin loader — the same order `dispatchAgent` uses.
+  const resolveDefinition = opts.resolveDefinition ?? ((name: string) => resolveAgentLayered(name) ?? resolveAgent(name));
 
   return async ({ definitionName, prompt, model, signal }) => {
     const startedAt = Date.now();
@@ -75,10 +86,37 @@ export function createGlobalSubagentCallable(
       ? { ...definition, model }
       : definition;
 
+    const allowed = new Set(effectiveDefinition.tools ?? []);
+    const denied = new Set(effectiveDefinition.disallowedTools ?? []);
+    const tools = (opts.hostTools ?? []).filter(tool =>
+      tool.name !== 'Agent' && allowed.has(tool.name) && !denied.has(tool.name));
+    const permittedNames = new Set(tools.map(tool => tool.name));
+    if (allowed.size > 0 && (tools.length === 0 || !opts.dispatchTool)) {
+      return {
+        address: `subagent:no-tools:${definitionName}`,
+        done: Promise.resolve({
+          status: 'failed' as const,
+          output: `no-tools: definition '${definitionName}' requires [${[...allowed].join(', ')}]; host tool count=${opts.hostTools === undefined ? 'unknown' : opts.hostTools.length}; usable=${tools.length}; dispatchTool=${Boolean(opts.dispatchTool)}`,
+          durationMs: Date.now() - startedAt,
+        }),
+      };
+    }
+
+    let childSignal: AbortSignal | undefined;
     const handle = registry.spawn({
       definition: effectiveDefinition,
       prompt,
+      tools,
+      dispatchTool: opts.dispatchTool
+        ? async (name, args) => {
+          if (!permittedNames.has(name)) throw new Error(`subagent tool '${name}' is not allowed`);
+          return opts.dispatchTool!(name, args, childSignal);
+        }
+        : undefined,
+      provider: opts.provider,
+      ...(opts.cwd ? { cwd: opts.cwd } : {}),
     });
+    childSignal = handle.task.controller?.signal;
 
     // External cancellation: chain caller signal into the registry's
     // own AbortController. Idempotent — registry.abort is a no-op on

package/src/agent-mission/browser-login.ts

@@ -0,0 +1,241 @@
+import { CHROME_NO_KEYCHAIN_FLAGS } from '../browser-cdp/chrome-flags.js';
+import { spawn, execFileSync, type ChildProcess } from 'node:child_process';
+import { mkdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { discoverChromeBinary, createCdpClientFromEndpoint, resolveDebuggerUrl, type CdpClient } from '../browser-cdp/client.js';
+import { debug } from '../debug/log.js';
+import { emitDecision, type DecisionEvent } from '../live/detail-switch.js';
+import { listPtyManifestRows } from '../pty-shell/pty-manifest.js';
+import { resolvePtyRef } from '../pty-shell/pty-ref.js';
+import { runPtySnapshot, runPtyText } from '../cli/pty-takeover-cli.js';
+
+export type LoginProvider = 'codex' | 'claude';
+export type LoginReason = 'no-backend' | 'host-not-allowed' | 'password' | 'two-factor' | 'captcha' | 'passkey' | 'account-choice' | 'unknown-page' | 'timeout';
+export interface LoginSnapshot {
+  url: string;
+  text: string;
+  inputs: { type: string; name?: string; autocomplete?: string }[];
+  buttons: string[];
+}
+export type LoginClassification = { headless: true; action: 'click' | 'enter-code' | 'read-code'; target: string } | { headless: false; reason: LoginReason };
+
+function allowed(url: string): boolean {
+  try {
+    const u = new URL(url);
+    return u.protocol === 'https:' && !u.username && !u.password && (
+      ['auth.openai.com', 'chatgpt.com', 'claude.ai', 'console.anthropic.com'].includes(u.hostname.toLowerCase())
+      || (u.hostname.toLowerCase() === 'github.com' && u.pathname === '/login/device')
+    );
+  } catch { return false; }
+}
+
+const APPROVE = /^(?:authorize|allow|continue|approve|승인|허용|계속)$/i;
+const CODE_MARKER = /\[login-code\]([^\[\]\r\n]{4,512})\[\/login-code\]/;
+export function classifyLoginPage(snapshot: LoginSnapshot): LoginClassification {
+  if (!allowed(snapshot.url)) return { headless: false, reason: 'host-not-allowed' };
+  const fields = snapshot.inputs.map(i => `${i.type} ${i.name ?? ''} ${i.autocomplete ?? ''}`.toLowerCase());
+  const text = snapshot.text.toLowerCase();
+  if (fields.some(f => /password|email|username/i.test(f))) return { headless: false, reason: 'password' };
+  if (fields.some(f => /one-time-code|otp|totp/.test(f)) || /verification code|2-step|two.factor/.test(text)) return { headless: false, reason: 'two-factor' };
+  if (/captcha|recaptcha|hcaptcha|turnstile/.test(text)) return { headless: false, reason: 'captcha' };
+  if (/passkey|webauthn|security key/.test(text)) return { headless: false, reason: 'passkey' };
+  if (/choose an account|select an account|계정 선택/.test(text)) return { headless: false, reason: 'account-choice' };
+  const approvals = snapshot.buttons.filter(b => APPROVE.test(b.trim()));
+  if (approvals.length > 1) return { headless: false, reason: 'account-choice' };
+  if (snapshot.inputs.length === 1 && fields.filter(f => /code|device/.test(f)).length === 1) return { headless: true, action: 'enter-code', target: 'device-code' };
+  const host = new URL(snapshot.url).hostname;
+  const code = CODE_MARKER.exec(snapshot.text)?.[1]?.trim();
+  if (['claude.ai', 'console.anthropic.com'].includes(host) && code) {
+    return { headless: true, action: 'read-code', target: code };
+  }
+  if (approvals.length === 1) return { headless: true, action: 'click', target: approvals[0]!.trim() };
+  return { headless: false, reason: 'unknown-page' };
+}
+
+// Read only rendered DOM. No cookie, localStorage, credential file or storageState access.
+const SNAPSHOT_JS = `(() => ({
+  url: location.href,
+  text: (document.body?.innerText || '').slice(0, 12000) + '\\n' + [...document.querySelectorAll('pre,code')].map(e => '[login-code]' + (e.textContent || '').trim().slice(0,512) + '[/login-code]').join('\\n'),
+  inputs: [...document.querySelectorAll('input')].map(e => ({type:e.type,name:e.name,autocomplete:e.autocomplete})),
+  buttons: [...document.querySelectorAll('button,input[type=submit],a[role=button]')].filter(e => e.getClientRects().length > 0).map(e => (e.innerText || e.value || '').trim())
+}))()`;
+
+export interface LoginDeps {
+  profileDir?: string;
+  profileExists?: (path: string) => boolean;
+  chromeBinary?: () => string | null;
+  spawnChrome?: (binary: string, args: string[]) => ChildProcess;
+  resolveChromePort?: (port: number) => Promise<unknown>;
+  connect?: (port: number) => Promise<CdpClient>;
+  log?: (event: string, data: Record<string, unknown>) => void;
+  decide?: (event: DecisionEvent) => unknown;
+  sleep?: (ms: number) => Promise<void>;
+}
+
+export function browserProfileDir(): string { return join(elanousStateRoot(), 'browser-profile'); }
+export function browserProfileStatus(dir = browserProfileDir()): { exists: boolean; lastUse: string | null } {
+  try {
+    const stat = statSync(dir);
+    return { exists: stat.isDirectory(), lastUse: stat.isDirectory() ? stat.mtime.toISOString() : null };
+  } catch { return { exists: false, lastUse: null }; }
+}
+export function launchBrowserProfileLogin(deps: Pick<LoginDeps, 'profileDir' | 'chromeBinary' | 'spawnChrome'> = {}): boolean {
+  const binary = (deps.chromeBinary ?? discoverChromeBinary)();
+  if (!binary) return false;
+  const dir = deps.profileDir ?? browserProfileDir();
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  (deps.spawnChrome ?? ((b, a) => spawn(b, a, { detached: true, stdio: 'ignore' })))(binary, [`--user-data-dir=${dir}`, ...CHROME_NO_KEYCHAIN_FLAGS, '--no-first-run', 'https://chatgpt.com']);
+  return true;
+}
+
+export type ApprovalResult = { outcome: 'approved'; code?: string } | { outcome: 'ask-human'; reason: LoginReason };
+export async function approveCliLogin(input: { url: string; code?: string; provider: LoginProvider }, deps: LoginDeps = {}): Promise<ApprovalResult> {
+  const log = (event: string, data: Record<string, unknown>) => (deps.log ?? ((e, d) => debug.log('agent-mission.browser-login', e, d)))(event, data);
+  const decide = (kind: DecisionEvent['kind'], reason: string, target: string) =>
+    (deps.decide ?? emitDecision)({ kind, what: 'CLI browser login', reason, purpose: 'approve existing session only', target });
+  const escalate = (reason: LoginReason): ApprovalResult => {
+    log('escalated', { reason }); decide('ESCALATE', reason, 'human');
+    return { outcome: 'ask-human', reason };
+  };
+  log('backend', { stage: 'start' });
+  decide('ROUTE', 'login = browser; use existing session', 'browser');
+  if (!allowed(input.url)) return escalate('host-not-allowed');
+  const connect = deps.connect ?? createCdpClientFromEndpoint;
+  let client: CdpClient | undefined;
+  let child: ChildProcess | undefined;
+  let backend = '';
+  const dir = deps.profileDir ?? browserProfileDir();
+  const hasProfile = (deps.profileExists ?? ((path: string) => { try { return statSync(path).isDirectory(); } catch { return false; } }))(dir);
+  const binary = hasProfile ? (deps.chromeBinary ?? discoverChromeBinary)() : null;
+  if (hasProfile && binary) {
+    // An owned Chrome must have its own loopback CDP port, separate from the user's 9222 session.
+    const port = 20000 + Math.floor(Math.random() * 30000);
+    try {
+      child = (deps.spawnChrome ?? ((b, a) => spawn(b, a, { stdio: 'ignore' })))(binary, [
+        '--headless=new', `--user-data-dir=${dir}`, ...CHROME_NO_KEYCHAIN_FLAGS, `--remote-debugging-port=${port}`,
+        '--remote-debugging-address=127.0.0.1', '--no-first-run', 'about:blank',
+      ]);
+      await (deps.resolveChromePort ?? ((p) => resolveDebuggerUrl(p, { attachTimeoutMs: 4000 })))(port);
+      client = await connect(port);
+      backend = 'profile';
+    } catch { try { await client?.close(); } catch { /* fail-soft */ } child?.kill(); child = undefined; client = undefined; }
+  }
+  if (!client) {
+    try { client = await connect(9222); backend = 'cdp-9222'; } catch { return escalate('no-backend'); }
+  }
+  log('backend', { backend });
+  try {
+    const navigation = await client.navigate(input.url);
+    if (navigation.errorText) return escalate('unknown-page');
+    const sleep = deps.sleep ?? (ms => Bun.sleep(ms));
+    await sleep(400);
+    let acted = false;
+    let enteredCode = false;
+    for (let step = 1; step <= 4; step++) {
+      const snapshot = await client.evaluate(SNAPSHOT_JS) as LoginSnapshot;
+      if (!snapshot || !Array.isArray(snapshot.inputs) || !Array.isArray(snapshot.buttons) || typeof snapshot.text !== 'string') return escalate('unknown-page');
+      const classified = classifyLoginPage(snapshot);
+      log('classified', { backend, step, action: classified.headless ? classified.action : 'escalate', reason: classified.headless ? undefined : classified.reason });
+      if (!classified.headless) {
+        if (acted && classified.reason === 'unknown-page' && allowed(snapshot.url)) {
+          log('done', { backend, steps: step - 1 }); decide('VERIFY', 'approval action completed', backend);
+          return { outcome: 'approved' };
+        }
+        return escalate(classified.reason);
+      }
+      if (classified.action === 'enter-code' && enteredCode) return escalate('timeout');
+      decide('ROUTE', `step ${step}: ${classified.action}`, backend);
+      if (classified.action === 'read-code') {
+        const fresh = classifyLoginPage(await client.evaluate(SNAPSHOT_JS) as LoginSnapshot);
+        if (!fresh.headless || fresh.action !== 'read-code' || fresh.target !== classified.target) return escalate(fresh.headless ? 'unknown-page' : fresh.reason);
+        log('acted', { backend, step, action: 'read-code', codeLength: classified.target.length });
+        log('done', { backend, steps: step }); decide('VERIFY', 'code transferred to caller', backend);
+        return { outcome: 'approved', code: classified.target };
+      }
+      if (classified.action === 'enter-code' && !input.code) return escalate('unknown-page');
+      // Re-observe immediately before mutation; never act if a dangerous signal appeared meanwhile.
+      const fresh = classifyLoginPage(await client.evaluate(SNAPSHOT_JS) as LoginSnapshot);
+      if (!fresh.headless || fresh.action !== classified.action || fresh.target !== classified.target) return escalate(fresh.headless ? 'unknown-page' : fresh.reason);
+      const action = classified.action;
+      const target = classified.target;
+      const code = input.code;
+      const result = await client.evaluate(`(() => {
+        const snapshot = ${SNAPSHOT_JS};
+        const candidates = [...document.querySelectorAll('button,input[type=submit],a[role=button]')];
+        const fields = [...document.querySelectorAll('input')];
+        if (snapshot.url !== ${JSON.stringify(snapshot.url)} || snapshot.inputs.some(i => /password|email|username|one-time-code|otp|totp/i.test(i.type+' '+i.name+' '+i.autocomplete)) || /captcha|recaptcha|hcaptcha|turnstile|passkey|webauthn|security key|verification code|2-step|choose an account|select an account/i.test(snapshot.text)) return false;
+        if (${JSON.stringify(action)} === 'click') {
+          const matches = candidates.filter(e => e.getClientRects().length > 0 && (e.innerText || e.value || '').trim() === ${JSON.stringify(target)});
+          if (matches.length !== 1 || candidates.filter(e => e.getClientRects().length > 0 && /^(authorize|allow|continue|approve|승인|허용|계속)$/i.test((e.innerText || e.value || '').trim())).length !== 1) return false;
+          matches[0].click(); return true;
+        }
+        const matches = fields.filter(e => e.getClientRects().length > 0 && /code|device/i.test(e.type+' '+e.name+' '+e.autocomplete));
+        if (fields.length !== 1 || matches.length !== 1 || !${JSON.stringify(!!code)}) return false;
+        matches[0].value = ${JSON.stringify(code ?? '')};
+        matches[0].dispatchEvent(new Event('input', {bubbles:true}));
+        matches[0].dispatchEvent(new Event('change', {bubbles:true}));
+        return true;
+      })()`);
+      if (result !== true) return escalate('unknown-page');
+      acted = true;
+      if (action === 'enter-code') enteredCode = true;
+      log('acted', { backend, step, action, ...(action === 'enter-code' ? { codeLength: code!.length } : {}) });
+      await sleep(400);
+    }
+    return escalate('timeout');
+  } catch { return escalate('timeout'); }
+  finally {
+    try { await client.close(); } catch { /* closed by owner */ }
+    child?.kill();
+  }
+}
+
+export interface LoginPtyDeps extends LoginDeps {
+  snapshot?: (ref: string) => Promise<string | null>;
+  text?: (ref: string, text: string) => Promise<boolean>;
+  codexStatus?: () => string;
+}
+export type BrowserLoginResult = { outcome: 'verified'; provider: LoginProvider } | { outcome: 'ask-human'; url: string; code?: string; reason: LoginReason };
+export async function loginViaBrowser(ptyRef: string, provider: LoginProvider, deps: LoginPtyDeps = {}): Promise<BrowserLoginResult> {
+  const rows = deps.snapshot ? [] : listPtyManifestRows().filter(row => row.alive && row.terminalOriginCategory !== 'external-tool');
+  const resolved = resolvePtyRef(ptyRef, rows.map(row => ({ id: row.id, kind: row.kind, nickname: row.nickname })));
+  const ref = resolved.match?.id ?? ptyRef;
+  if (!deps.snapshot && (!resolved.match || resolved.reason === 'ambiguous')) {
+    return { outcome: 'ask-human', url: '', reason: 'unknown-page' };
+  }
+  const snapshot = deps.snapshot ?? (async (id: string) => {
+    if (!resolved.match || resolved.reason === 'ambiguous') return null;
+    const r = await runPtySnapshot(id);
+    return r.exitCode === 0 && r.message.startsWith('PtyShellSnapshot ') && !r.message.split('\n', 1)[0]?.includes('source=frame') ? r.message : null;
+  });
+  let screen: string | null;
+  try { screen = await snapshot(ref); } catch { screen = null; }
+  const url = screen?.match(/https:\/\/[^\s<>"'\x1b]+/)?.[0]?.replace(/[),.;]+$/, '') ?? '';
+  const code = provider === 'codex' ? screen?.match(/(?:one.time code|device code|enter the code|code:)\s*(?:is\s+)?([A-Z0-9]{4,12}(?:-[A-Z0-9]{4,12})?)/i)?.[1] : undefined;
+  if (!url || !allowed(url)) return { outcome: 'ask-human', url, ...(code ? { code } : {}), reason: url ? 'host-not-allowed' : 'unknown-page' };
+  const approved = await approveCliLogin({ url, code, provider }, deps);
+  if (approved.outcome === 'ask-human') return { ...approved, url, ...(code ? { code } : {}) };
+  const text = deps.text ?? (async (id: string, value: string) => {
+    if (!resolved.match || resolved.reason === 'ambiguous') return false;
+    const r = await runPtyText(id, value, true, undefined, 'agent');
+    return r.exitCode === 0;
+  });
+  if (provider === 'claude' && approved.code) {
+    try { if (!(await text(ref, approved.code))) return { outcome: 'ask-human', url, reason: 'timeout' }; }
+    catch { return { outcome: 'ask-human', url, reason: 'timeout' }; }
+  }
+  const sleep = deps.sleep ?? (ms => Bun.sleep(ms));
+  for (let i = 0; i < 5; i++) {
+    if (provider === 'codex') {
+      try {
+        if (/^logged in\b/i.test((deps.codexStatus ?? (() => execFileSync('codex', ['login', 'status'], { encoding: 'utf8', timeout: 5000 })))().trim())) return { outcome: 'verified', provider };
+      } catch { /* not yet logged in */ }
+    } else {
+      try { if (/Login successful/i.test((await snapshot(ref)) ?? '')) return { outcome: 'verified', provider }; }
+      catch { /* PTY unavailable: report timeout to caller */ }
+    }
+    await sleep(400);
+  }
+  return { outcome: 'ask-human', url, ...(code ? { code } : {}), reason: 'timeout' };
+}