@elizaos/agent 2.0.0-alpha.144 → 2.0.0-alpha.151

package/packages/typescript/src/features/orchestrator/services/debug-capture.js

@@ -1,113 +0,0 @@
-/**
- * Debug PTY Capture — optional session recording for offline analysis.
- *
- * Activated by setting `PARALLAX_DEBUG_CAPTURE=1`. When enabled, all PTY
- * output and stdin are recorded per-session using `pty-state-capture`.
- * Capture files persist in `.parallax/pty-captures/<sessionId>/` after
- * the agent session is killed, enabling post-mortem analysis of state
- * transitions, stall classifications, and coordinator timing.
- *
- * The `pty-state-capture` package is dynamically imported — if not
- * installed, capture is silently disabled. This means it can stay out
- * of production dependencies entirely.
- *
- * @module services/debug-capture
- */
-import { logger } from "@elizaos/core";
-let captureManager = null;
-let initAttempted = false;
-/**
- * Returns true if debug capture is enabled via environment variable.
- */
-export function isDebugCaptureEnabled() {
-    return process.env.PARALLAX_DEBUG_CAPTURE === "1";
-}
-/**
- * Lazily initialize the capture manager. Returns null if:
- * - PARALLAX_DEBUG_CAPTURE is not set to "1"
- * - pty-state-capture is not installed
- * - Initialization fails for any reason
- */
-async function ensureCaptureManager() {
-    if (captureManager)
-        return captureManager;
-    if (initAttempted)
-        return null;
-    initAttempted = true;
-    if (!isDebugCaptureEnabled())
-        return null;
-    try {
-        const mod = await import("pty-state-capture");
-        const { PTYStateCaptureManager } = mod;
-        captureManager = new PTYStateCaptureManager({
-            outputRootDir: ".parallax/pty-captures",
-            defaultRows: 80,
-            defaultCols: 220,
-        });
-        logger.info("[debug-capture] PTY state capture enabled — writing to .parallax/pty-captures/");
-        return captureManager;
-    }
-    catch {
-        logger.debug("[debug-capture] pty-state-capture not available — capture disabled");
-        return null;
-    }
-}
-/**
- * Open a capture session for a PTY session. Call this when spawning.
- */
-export async function captureSessionOpen(sessionId, agentType) {
-    const mgr = await ensureCaptureManager();
-    if (!mgr)
-        return;
-    try {
-        await mgr.openSession(sessionId, { source: agentType });
-    }
-    catch (err) {
-        logger.debug(`[debug-capture] Failed to open session ${sessionId}: ${err}`);
-    }
-}
-/**
- * Feed PTY output data to the capture. Call this on every data chunk.
- */
-export async function captureFeed(sessionId, chunk, direction = "stdout") {
-    if (!captureManager)
-        return;
-    try {
-        await captureManager.feed(sessionId, chunk, direction);
-    }
-    catch (err) {
-        logger.debug(`[debug-capture] Feed error for ${sessionId}: ${err}`);
-    }
-}
-/**
- * Record a lifecycle event (session_ready, session_stopped, etc.).
- */
-export async function captureLifecycle(sessionId, event, detail) {
-    if (!captureManager)
-        return;
-    try {
-        await captureManager.lifecycle(sessionId, event, detail);
-    }
-    catch (err) {
-        logger.debug(`[debug-capture] Lifecycle error for ${sessionId}: ${err}`);
-    }
-}
-/**
- * Get a snapshot of a capture session's current state.
- */
-export function captureSnapshot(sessionId) {
-    if (!captureManager)
-        return null;
-    try {
-        return captureManager.snapshot(sessionId);
-    }
-    catch (err) {
-        logger.debug(`[debug-capture] Snapshot error for ${sessionId}: ${err}`);
-        return null;
-    }
-}
-/** @internal Reset module state for testing only. */
-export function _resetForTesting() {
-    captureManager = null;
-    initAttempted = false;
-}

package/packages/typescript/src/features/orchestrator/services/pty-auto-response.d.ts

@@ -1,30 +0,0 @@
-/**
- * Auto-response rule management for PTY sessions.
- *
- * Contains logic for pushing default auto-response rules per agent type
- * and handling Gemini authentication flow.
- *
- * @module services/pty-auto-response
- */
-import type { IAgentRuntime } from "@elizaos/core";
-import type { BunCompatiblePTYManager, PTYManager } from "pty-manager";
-export interface AutoResponseContext {
-    manager: PTYManager | BunCompatiblePTYManager;
-    usingBunWorker: boolean;
-    runtime: IAgentRuntime;
-    log: (msg: string) => void;
-}
-/**
- * Push session-specific auto-response rules that depend on runtime config.
- * Trust prompts, update notices, and other static rules are handled by
- * adapter built-in rules (coding-agent-adapters). This only pushes rules
- * that need runtime values (e.g. API keys).
- */
-export declare function pushDefaultRules(ctx: AutoResponseContext, sessionId: string, agentType: string): Promise<void>;
-/**
- * Handle Gemini authentication when login_required fires.
- * Sends /auth to start the auth flow — auto-response rules
- * then handle menu selection and API key input.
- */
-export declare function handleGeminiAuth(ctx: AutoResponseContext, sessionId: string, sendKeysToSession: (sessionId: string, keys: string | string[]) => Promise<void>): Promise<void>;
-//# sourceMappingURL=pty-auto-response.d.ts.map

package/packages/typescript/src/features/orchestrator/services/pty-auto-response.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pty-auto-response.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/orchestrator/services/pty-auto-response.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EAEX,uBAAuB,EACvB,UAAU,EACV,MAAM,aAAa,CAAC;AAGrB,MAAM,WAAW,mBAAmB;IACnC,OAAO,EAAE,UAAU,GAAG,uBAAuB,CAAC;IAC9C,cAAc,EAAE,OAAO,CAAC;IACxB,OAAO,EAAE,aAAa,CAAC;IACvB,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CAC3B;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACrC,GAAG,EAAE,mBAAmB,EACxB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC,CA8Hf;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CACrC,GAAG,EAAE,mBAAmB,EACxB,SAAS,EAAE,MAAM,EACjB,iBAAiB,EAAE,CAClB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,KACnB,OAAO,CAAC,IAAI,CAAC,GAChB,OAAO,CAAC,IAAI,CAAC,CAwBf"}

package/packages/typescript/src/features/orchestrator/services/pty-auto-response.js

@@ -1,146 +0,0 @@
-/**
- * Auto-response rule management for PTY sessions.
- *
- * Contains logic for pushing default auto-response rules per agent type
- * and handling Gemini authentication flow.
- *
- * @module services/pty-auto-response
- */
-import { readConfigEnvKey } from "./config-env.js";
-/**
- * Push session-specific auto-response rules that depend on runtime config.
- * Trust prompts, update notices, and other static rules are handled by
- * adapter built-in rules (coding-agent-adapters). This only pushes rules
- * that need runtime values (e.g. API keys).
- */
-export async function pushDefaultRules(ctx, sessionId, agentType) {
-    const rules = [];
-    // Codex sometimes renders the workspace trust screen incrementally.
-    // The upstream adapter rule is one-shot; if it fires before the menu is fully
-    // interactive, Codex can keep showing the same prompt and block the session.
-    // Keep this session rule active until the prompt actually clears.
-    if (agentType === "codex") {
-        rules.push({
-            pattern: /higher.?risk.?of.?prompt.?injection|yes,?.?continue.*no,?.?quit|do.?you.?trust.?the.?contents|trust.?this.?directory|allow.?codex.?to.?work.?in.?this.?folder|without.?asking.?for.?approval/i,
-            type: "permission",
-            response: "",
-            responseType: "keys",
-            keys: ["enter"],
-            description: "Retry Codex workspace trust approval until the prompt clears",
-            safe: true,
-        });
-    }
-    // Aider gitignore prompt
-    if (agentType === "aider") {
-        rules.push({
-            pattern: /\.aider\*.*\.gitignore.*\(Y\)es\/\(N\)o/i,
-            type: "config",
-            response: "y",
-            description: "Auto-accept adding .aider* to .gitignore",
-            safe: true,
-        });
-    }
-    // Claude — API key confirmation prompt (appears when ANTHROPIC_API_KEY is set
-    // alongside a subscription login, or in CLAUDE_CODE_SIMPLE mode)
-    if (agentType === "claude") {
-        const llmProvider = readConfigEnvKey("PARALLAX_LLM_PROVIDER") || "subscription";
-        if (llmProvider === "api_keys" || llmProvider === "cloud") {
-            rules.push({
-                pattern: /Do you want to use this API key|(?:custom|detected).*API key.*environment/i,
-                type: "config",
-                response: "",
-                responseType: "keys",
-                keys: ["up", "enter"],
-                description: "Accept detected ANTHROPIC_API_KEY from environment",
-                safe: true,
-                once: true,
-            });
-        }
-    }
-    // Gemini — auth flow (update notices are informational, don't need a response)
-    if (agentType === "gemini") {
-        // Auth menu detection — select API key or Google login based on available credentials
-        const geminiApiKey = ctx.runtime.getSetting("GENERATIVE_AI_API_KEY");
-        if (geminiApiKey) {
-            // Have API key → select option 2 "Use an API key"
-            rules.push({
-                pattern: /Log in with Google|Use an API key|Use Vertex AI|gemini api key/i,
-                type: "config",
-                response: "2",
-                description: "Select 'Use an API key' from Gemini auth menu",
-                safe: true,
-            });
-            // Step 2: API key input prompt — send the actual key value.
-            // Tight regex: only matches the Gemini CLI's exact prompt format
-            // to prevent exfiltration via crafted terminal output.
-            // once: fire at most once per session to prevent repeated credential injection.
-            rules.push({
-                pattern: /^(?:\s|[>$#])*(?:Enter|Paste) (?:your )?(?:Google AI|Gemini) API key:/i,
-                type: "config",
-                response: geminiApiKey,
-                description: "Input Gemini API key from Gemini CLI auth prompt",
-                safe: true,
-                once: true,
-            });
-        }
-        else {
-            // No API key → select option 1 "Log in with Google" (opens browser OAuth)
-            rules.push({
-                pattern: /Log in with Google|Use an API key|Use Vertex AI|gemini api key/i,
-                type: "config",
-                response: "1",
-                description: "Select 'Log in with Google' from Gemini auth menu (browser OAuth)",
-                safe: true,
-            });
-        }
-    }
-    if (rules.length === 0)
-        return;
-    // Push rules to the session via the runtime API
-    try {
-        if (ctx.usingBunWorker) {
-            for (const rule of rules) {
-                await ctx.manager.addAutoResponseRule(sessionId, rule);
-            }
-        }
-        else {
-            const nodeManager = ctx.manager;
-            for (const rule of rules) {
-                nodeManager.addAutoResponseRule(sessionId, rule);
-            }
-        }
-        ctx.log(`Pushed ${rules.length} auto-response rules to session ${sessionId}`);
-        // Note: No retroactive check needed here. The worker's tryAutoResponse()
-        // runs on every data chunk and checks the full output buffer against all
-        // active rules. Once rules are pushed, the next data chunk will trigger
-        // matching. The old retroactive check caused ghost responses because it
-        // bypassed the worker's TUI-aware response logic (sendKeys vs writeRaw).
-    }
-    catch (err) {
-        ctx.log(`Failed to push rules to session ${sessionId}: ${err}`);
-    }
-}
-/**
- * Handle Gemini authentication when login_required fires.
- * Sends /auth to start the auth flow — auto-response rules
- * then handle menu selection and API key input.
- */
-export async function handleGeminiAuth(ctx, sessionId, sendKeysToSession) {
-    const apiKey = ctx.runtime.getSetting("GENERATIVE_AI_API_KEY");
-    if (apiKey) {
-        ctx.log(`Gemini auth: API key available, sending /auth to start API key flow`);
-    }
-    else {
-        ctx.log(`Gemini auth: no API key configured, sending /auth for Google OAuth flow`);
-    }
-    // Send /auth via sendKeys to avoid send() which sets status to "busy".
-    // We need to stay in "authenticating" so detectReady fires after auth completes.
-    try {
-        await sendKeysToSession(sessionId, "/auth");
-        await new Promise((r) => setTimeout(r, 50));
-        await sendKeysToSession(sessionId, "enter");
-    }
-    catch (err) {
-        ctx.log(`Gemini auth: failed to send /auth: ${err}`);
-    }
-}

package/packages/typescript/src/features/orchestrator/services/pty-init.d.ts

@@ -1,54 +0,0 @@
-/**
- * PTY manager initialization — extracted from PTYService.initialize().
- *
- * Creates either a BunCompatiblePTYManager (for Bun runtime) or PTYManager
- * (for Node), wires up event handlers, and returns the configured manager.
- *
- * @module services/pty-init
- */
-import { BunCompatiblePTYManager, PTYManager, type StallClassification } from "pty-manager";
-import type { CompletionMethod } from "./agent-metrics.ts";
-import type { PTYServiceConfig } from "./pty-types.ts";
-/**
- * All callbacks and state that the initialization logic needs
- * from the surrounding PTYService instance.
- */
-export interface InitContext {
-    serviceConfig: PTYServiceConfig;
-    classifyStall: (sessionId: string, recentOutput: string) => Promise<StallClassification | null>;
-    emitEvent: (sessionId: string, event: string, data: unknown) => void;
-    handleGeminiAuth: (sessionId: string) => void;
-    sessionOutputBuffers: Map<string, string[]>;
-    taskResponseMarkers: Map<string, number>;
-    metricsTracker: {
-        recordCompletion(type: string, method: CompletionMethod, durationMs: number): void;
-    };
-    traceEntries: Array<string | Record<string, unknown>>;
-    maxTraceEntries: number;
-    log: (msg: string) => void;
-    handleWorkerExit?: (info: {
-        code: number | null;
-        signal: string | null;
-    }) => void;
-    /** Check if a session has an active task in the coordinator. */
-    hasActiveTask?: (sessionId: string) => boolean;
-    /** Check if a session's task has started work (task delivered or decisions made). */
-    hasTaskActivity?: (sessionId: string) => boolean;
-    /** Mark a session's task as delivered (initial ready event processed). */
-    markTaskDelivered?: (sessionId: string) => void;
-}
-/** Value returned by {@link initializePTYManager}. */
-export interface InitResult {
-    manager: PTYManager | BunCompatiblePTYManager;
-    usingBunWorker: boolean;
-}
-/**
- * Create and configure a PTY manager for the current runtime.
- *
- * - **Bun**: instantiates a {@link BunCompatiblePTYManager} that spawns a
- *   Node worker process and communicates via JSON-RPC over stdio.
- * - **Node**: instantiates a {@link PTYManager} directly and registers
- *   all built-in adapters in-process.
- */
-export declare function initializePTYManager(ctx: InitContext): Promise<InitResult>;
-//# sourceMappingURL=pty-init.d.ts.map

package/packages/typescript/src/features/orchestrator/services/pty-init.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pty-init.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/orchestrator/services/pty-init.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,OAAO,EAEN,uBAAuB,EAEvB,UAAU,EAKV,KAAK,mBAAmB,EAGxB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAwDvD;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC3B,aAAa,EAAE,gBAAgB,CAAC;IAChC,aAAa,EAAE,CACd,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,KAChB,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CAAC;IACzC,SAAS,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACrE,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9C,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAC5C,mBAAmB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,cAAc,EAAE;QACf,gBAAgB,CACf,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,gBAAgB,EACxB,UAAU,EAAE,MAAM,GAChB,IAAI,CAAC;KACR,CAAC;IACF,YAAY,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACtD,eAAe,EAAE,MAAM,CAAC;IACxB,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3B,gBAAgB,CAAC,EAAE,CAAC,IAAI,EAAE;QACzB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QACpB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;KACtB,KAAK,IAAI,CAAC;IACX,gEAAgE;IAChE,aAAa,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;IAC/C,qFAAqF;IACrF,eAAe,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;IACjD,0EAA0E;IAC1E,iBAAiB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;CAChD;AAkBD,sDAAsD;AACtD,MAAM,WAAW,UAAU;IAC1B,OAAO,EAAE,UAAU,GAAG,uBAAuB,CAAC;IAC9C,cAAc,EAAE,OAAO,CAAC;CACxB;AAED;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CACzC,GAAG,EAAE,WAAW,GACd,OAAO,CAAC,UAAU,CAAC,CA0VrB"}

package/packages/typescript/src/features/orchestrator/services/pty-init.js

@@ -1,315 +0,0 @@
-/**
- * PTY manager initialization — extracted from PTYService.initialize().
- *
- * Creates either a BunCompatiblePTYManager (for Bun runtime) or PTYManager
- * (for Node), wires up event handlers, and returns the configured manager.
- *
- * @module services/pty-init
- */
-import { existsSync, readdirSync } from "node:fs";
-import { createRequire } from "node:module";
-import os from "node:os";
-import path from "node:path";
-import { createAllAdapters } from "coding-agent-adapters";
-import { BunCompatiblePTYManager, isBun, PTYManager, ShellAdapter, } from "pty-manager";
-import { captureTaskResponse } from "./ansi-utils.js";
-// Stall detector silence threshold. 60s — long enough that a bash, git,
-// WebSearch, or multi-step tool call can complete without tripping the
-// classifier, short enough to still catch real hangs within a minute.
-// Previously 4000ms, which misfired for every long tool call on claude-code
-// agents and caused completion re-injection loops on open-ended tasks.
-const STALL_TIMEOUT_MS = 60_000;
-// Resolve absolute path to coding-agent-adapters so the Node worker process
-// can load it regardless of its cwd.  The worker uses require() which does
-// cwd-relative resolution — passing the bare module name "coding-agent-adapters"
-// fails when the worker's cwd doesn't contain node_modules.
-const _require = createRequire(import.meta.url);
-let resolvedAdapterModule = "coding-agent-adapters";
-try {
-    resolvedAdapterModule = _require.resolve("coding-agent-adapters");
-}
-catch {
-    // Fallback to bare specifier if resolve fails (shouldn't happen)
-}
-function resolveNodeWorkerPath() {
-    const explicitCandidates = [
-        process.env.NODE,
-        process.env.NODE_BINARY,
-        "/opt/homebrew/bin/node",
-        "/usr/local/bin/node",
-    ].filter((value) => Boolean(value?.trim()));
-    for (const candidate of explicitCandidates) {
-        if (existsSync(candidate)) {
-            return candidate;
-        }
-    }
-    const nvmVersionsDir = path.join(os.homedir(), ".nvm", "versions", "node");
-    if (existsSync(nvmVersionsDir)) {
-        const versions = readdirSync(nvmVersionsDir)
-            .filter((entry) => entry.startsWith("v"))
-            .sort((a, b) => b.localeCompare(a, undefined, {
-            numeric: true,
-            sensitivity: "base",
-        }));
-        for (const version of versions) {
-            const candidate = path.join(nvmVersionsDir, version, "bin", "node");
-            if (existsSync(candidate)) {
-                return candidate;
-            }
-        }
-    }
-    return "node";
-}
-/**
- * Create and configure a PTY manager for the current runtime.
- *
- * - **Bun**: instantiates a {@link BunCompatiblePTYManager} that spawns a
- *   Node worker process and communicates via JSON-RPC over stdio.
- * - **Node**: instantiates a {@link PTYManager} directly and registers
- *   all built-in adapters in-process.
- */
-export async function initializePTYManager(ctx) {
-    const usingBunWorker = isBun();
-    const recentStructuredAuth = new Map();
-    const AUTH_EVENT_DEDUPE_MS = 5_000;
-    const emitStructuredAuthRequired = (session, info) => {
-        recentStructuredAuth.set(session.id, Date.now());
-        if (session.type === "gemini") {
-            ctx.handleGeminiAuth(session.id);
-        }
-        ctx.emitEvent(session.id, "login_required", {
-            instructions: info.instructions,
-            url: info.url,
-            deviceCode: info.deviceCode,
-            method: info.method,
-            promptSnippet: info.promptSnippet,
-            session,
-            source: "pty_manager",
-        });
-    };
-    const shouldSuppressLegacyLoginRequired = (sessionId) => {
-        const at = recentStructuredAuth.get(sessionId);
-        if (!at)
-            return false;
-        if (Date.now() - at > AUTH_EVENT_DEDUPE_MS) {
-            recentStructuredAuth.delete(sessionId);
-            return false;
-        }
-        return true;
-    };
-    if (usingBunWorker) {
-        // Use Bun-compatible manager that spawns a Node worker
-        ctx.log("Detected Bun runtime, using BunCompatiblePTYManager");
-        ctx.log(`Resolved adapter module: ${resolvedAdapterModule}`);
-        const bunManager = new BunCompatiblePTYManager({
-            adapterModules: [resolvedAdapterModule],
-            nodePath: resolveNodeWorkerPath(),
-            stallDetectionEnabled: true,
-            stallTimeoutMs: STALL_TIMEOUT_MS,
-            onStallClassify: async (sessionId, recentOutput, _stallDurationMs) => {
-                return ctx.classifyStall(sessionId, recentOutput);
-            },
-        });
-        // Set up event forwarding for worker-based manager. session_ready means
-        // the PTY prompt is visible again — it does NOT mean the agent is done
-        // (see the forwardReadyAsTaskComplete note above).
-        bunManager.on("session_ready", (session) => {
-            ctx.log(`session_ready event received for ${session.id} (type: ${session.type}, status: ${session.status})`);
-            ctx.emitEvent(session.id, "ready", { session, source: "pty_manager" });
-            ctx.markTaskDelivered?.(session.id);
-        });
-        bunManager.on("session_exit", (id, code) => {
-            ctx.emitEvent(id, "stopped", {
-                reason: `exit code ${code}`,
-                source: "pty_manager",
-            });
-        });
-        bunManager.on("session_error", (id, error) => {
-            ctx.emitEvent(id, "error", { message: error, source: "pty_manager" });
-        });
-        bunManager.on("blocking_prompt", (session, promptInfo, autoResponded) => {
-            const info = promptInfo;
-            ctx.log(`blocking_prompt for ${session.id}: type=${info?.type}, autoResponded=${autoResponded}, prompt="${(info?.prompt ?? "").slice(0, 80)}"`);
-            ctx.emitEvent(session.id, "blocked", {
-                promptInfo,
-                autoResponded,
-                source: "pty_manager",
-            });
-        });
-        bunManager.on("auth_required", (session, info) => {
-            emitStructuredAuthRequired(session, info);
-        });
-        bunManager.on("login_required", (session, instructions, url) => {
-            if (shouldSuppressLegacyLoginRequired(session.id)) {
-                return;
-            }
-            // Auto-handle Gemini auth flow
-            if (session.type === "gemini") {
-                ctx.handleGeminiAuth(session.id);
-            }
-            ctx.emitEvent(session.id, "login_required", {
-                instructions,
-                url,
-                source: "pty_manager",
-            });
-        });
-        bunManager.on("task_complete", (session) => {
-            const response = captureTaskResponse(session.id, ctx.sessionOutputBuffers, ctx.taskResponseMarkers);
-            const durationMs = session.startedAt
-                ? Date.now() - new Date(session.startedAt).getTime()
-                : 0;
-            ctx.metricsTracker.recordCompletion(session.type, "fast-path", durationMs);
-            ctx.log(`Task complete for ${session.id} (adapter fast-path), response: ${response.length} chars`);
-            ctx.emitEvent(session.id, "task_complete", {
-                session,
-                response,
-                source: "adapter_fast_path",
-            });
-        });
-        bunManager.on("tool_running", (session, info) => {
-            ctx.log(`tool_running for ${session.id}: ${info.toolName}${info.description ? ` — ${info.description}` : ""}`);
-            ctx.emitEvent(session.id, "tool_running", {
-                session,
-                ...info,
-                source: "pty_manager",
-            });
-        });
-        bunManager.on("message", (message) => {
-            ctx.emitEvent(message.sessionId, "message", {
-                ...message,
-                source: "pty_manager",
-            });
-        });
-        // Log worker-level stderr (pino logs from pty-manager worker process).
-        // Strip the "Invalid JSON from worker:" prefix that BunCompatiblePTYManager
-        // adds when stderr lines aren't valid JSON-RPC responses.
-        bunManager.on("worker_error", (err) => {
-            const raw = typeof err === "string" ? err : String(err);
-            const msg = raw.replace(/^Invalid JSON from worker:\s*/i, "").trim();
-            if (!msg)
-                return;
-            // Capture task completion trace entries for timeline analysis
-            if (msg.includes("Task completion trace")) {
-                ctx.traceEntries.push(msg);
-                if (ctx.traceEntries.length > ctx.maxTraceEntries) {
-                    ctx.traceEntries.splice(0, ctx.traceEntries.length - ctx.maxTraceEntries);
-                }
-            }
-            // Show operational logs at info level (suppress noisy loading-suppression messages)
-            if (msg.includes("suppressing stall emission")) {
-                // Loading pattern suppression fires every few seconds — too noisy for console
-                return;
-            }
-            if (msg.includes("ready") ||
-                msg.includes("blocking") ||
-                msg.includes("auto-response") ||
-                msg.includes("Auto-responding") ||
-                msg.includes("detectReady") ||
-                msg.includes("stall") ||
-                msg.includes("Stall") ||
-                msg.includes("Task completion") ||
-                msg.includes("Spawning") ||
-                msg.includes("PTY session")) {
-                console.log("[PTYService/Worker]", msg);
-            }
-            else {
-                console.error("[PTYService/Worker]", msg.slice(0, 200));
-            }
-        });
-        bunManager.on("worker_exit", (info) => {
-            ctx.handleWorkerExit?.(info);
-            console.error("[PTYService] Worker exited:", info);
-        });
-        await bunManager.waitForReady();
-        return { manager: bunManager, usingBunWorker: true };
-    }
-    // Use native PTYManager directly in Node
-    ctx.log("Using native PTYManager");
-    const managerConfig = {
-        maxLogLines: ctx.serviceConfig.maxLogLines,
-        stallDetectionEnabled: true,
-        stallTimeoutMs: STALL_TIMEOUT_MS,
-        onStallClassify: async (sessionId, recentOutput, _stallDurationMs) => {
-            return ctx.classifyStall(sessionId, recentOutput);
-        },
-    };
-    const nodeManager = new PTYManager(managerConfig);
-    // Register built-in adapters
-    nodeManager.registerAdapter(new ShellAdapter());
-    // Register coding agent adapters (claude, gemini, codex, aider).
-    // Pi currently routes through the generic shell adapter.
-    if (ctx.serviceConfig.registerCodingAdapters) {
-        const codingAdapters = createAllAdapters();
-        for (const adapter of codingAdapters) {
-            nodeManager.registerAdapter(adapter);
-            ctx.log(`Registered ${adapter.adapterType} adapter`);
-        }
-    }
-    // Set up event forwarding. session_ready means the PTY prompt is visible
-    // again — NOT that the agent is done (see the forwardReadyAsTaskComplete
-    // note above).
-    nodeManager.on("session_ready", (session) => {
-        ctx.emitEvent(session.id, "ready", { session, source: "pty_manager" });
-        ctx.markTaskDelivered?.(session.id);
-    });
-    nodeManager.on("blocking_prompt", (session, promptInfo, autoResponded) => {
-        ctx.emitEvent(session.id, "blocked", {
-            promptInfo,
-            autoResponded,
-            source: "pty_manager",
-        });
-    });
-    nodeManager.on("auth_required", (session, info) => {
-        emitStructuredAuthRequired(session, info);
-    });
-    nodeManager.on("login_required", (session, instructions, url) => {
-        if (shouldSuppressLegacyLoginRequired(session.id)) {
-            return;
-        }
-        if (session.type === "gemini") {
-            ctx.handleGeminiAuth(session.id);
-        }
-        ctx.emitEvent(session.id, "login_required", {
-            instructions,
-            url,
-            source: "pty_manager",
-        });
-    });
-    nodeManager.on("task_complete", (session) => {
-        const response = captureTaskResponse(session.id, ctx.sessionOutputBuffers, ctx.taskResponseMarkers);
-        const durationMs = session.startedAt
-            ? Date.now() - new Date(session.startedAt).getTime()
-            : 0;
-        ctx.metricsTracker.recordCompletion(session.type, "fast-path", durationMs);
-        ctx.log(`Task complete for ${session.id} (adapter fast-path), response: ${response.length} chars`);
-        ctx.emitEvent(session.id, "task_complete", {
-            session,
-            response,
-            source: "adapter_fast_path",
-        });
-    });
-    nodeManager.on("tool_running", (session, info) => {
-        ctx.log(`tool_running for ${session.id}: ${info.toolName}${info.description ? ` — ${info.description}` : ""}`);
-        ctx.emitEvent(session.id, "tool_running", {
-            session,
-            ...info,
-            source: "pty_manager",
-        });
-    });
-    nodeManager.on("session_stopped", (session, reason) => {
-        ctx.emitEvent(session.id, "stopped", { reason, source: "pty_manager" });
-    });
-    nodeManager.on("session_error", (session, error) => {
-        ctx.emitEvent(session.id, "error", {
-            message: error,
-            source: "pty_manager",
-        });
-    });
-    nodeManager.on("message", (message) => {
-        ctx.emitEvent(message.sessionId, "message", {
-            ...message,
-            source: "pty_manager",
-        });
-    });
-    return { manager: nodeManager, usingBunWorker: false };
-}