cli-wechat-bridge 1.1.2 → 1.1.3

package/dist/bridge/bridge-adapters.shared.js

@@ -40,13 +40,19 @@ export const OPENCODE_SERVER_READY_TIMEOUT_MS = 10_000;
 export const OPENCODE_SSE_RECONNECT_DELAY_MS = 2_000;
 export const OPENCODE_SESSION_IDLE_SETTLE_MS = 1_500;
 export const OPENCODE_WECHAT_WORKING_NOTICE_DELAY_MS = 12_000;
+// `opencode serve` binds its TCP port before the HTTP layer is ready. The
+// health probe therefore retries within this total budget so the startup
+// race self-heals instead of hanging until undici's ~300s headersTimeout.
+export const OPENCODE_HTTP_READY_TIMEOUT_MS = 15_000;
+export const OPENCODE_HTTP_READY_PROBE_TIMEOUT_MS = 3_000;
+export const OPENCODE_HTTP_READY_PROBE_INTERVAL_MS = 500;
 export function buildCodexCliArgs(remoteUrl, options = {}) {
     assertNoReservedExtraCliArgs(options.extraCliArgs ?? [], ["--remote", "--remote-auth-token-env"], "Codex remote connection");
     const args = [];
     if (options.resumeThreadId) {
         args.push("resume", options.resumeThreadId);
     }
-    args.push("--enable", "tui_app_server", "--remote", remoteUrl);
+    args.push("--remote", remoteUrl);
     if (options.inlineMode) {
         args.push("--no-alt-screen");
     }
@@ -691,7 +697,7 @@ export function resolveDefaultAdapterCommand(kind, options = {}) {
 export function buildCliEnvironment(kind, options = {}) {
     const sourceEnv = options.env ?? process.env;
     const platform = options.platform ?? process.platform;
-    if (kind === "codex" || kind === "claude" || kind === "opencode") {
+    if (kind === "codex" || kind === "claude" || kind === "opencode" || kind === "pi") {
         // Pass the full environment through on every platform. A previous
         // Windows-only allowlist silently dropped user-configured variables such
         // as ANTHROPIC_BASE_URL / ANTHROPIC_AUTH_TOKEN / OPENAI_API_KEY, which
@@ -1170,7 +1176,8 @@ export function resolveSpawnTarget(command, kind, options = {}) {
         return { file: trimmed, args: [...forwardArgs] };
     }
     const resolved = resolveCommandPath(trimmed, platform, env) ?? trimmed;
-    if (platform !== "win32" || (kind !== "codex" && kind !== "claude" && kind !== "opencode")) {
+    if (platform !== "win32" ||
+        (kind !== "codex" && kind !== "claude" && kind !== "opencode" && kind !== "pi")) {
         return { file: resolved, args: [...forwardArgs] };
     }
     const bundledExe = kind === "codex" || kind === "claude"

package/dist/bridge/bridge-state.js

@@ -59,6 +59,7 @@ export function normalizeBridgeLockPayload(value) {
     const adapter = record.adapter === "codex" ||
         record.adapter === "claude" ||
         record.adapter === "opencode" ||
+        record.adapter === "pi" ||
         record.adapter === "shell"
         ? record.adapter
         : null;

package/dist/bridge/bridge-utils.js

@@ -802,15 +802,25 @@ export function formatMirroredUserInputMessage(adapter, text) {
             ? "Local Claude input"
             : adapter === "opencode"
                 ? "Local OpenCode input"
-                : "Local input";
+                : adapter === "pi"
+                    ? "Local Pi input"
+                    : "Local input";
     return `${label}:\n${truncatePreview(text, 500)}`;
 }
 export function formatFinalReplyMessage(adapter, text) {
-    if (adapter === "claude" || adapter === "codex" || adapter === "opencode") {
+    if (adapter === "claude" || adapter === "codex" || adapter === "opencode" || adapter === "pi") {
         return text;
     }
     // After the early return above, only "shell" remains.
-    const label = adapter === "codex" ? "Codex" : adapter === "claude" ? "Claude" : adapter === "opencode" ? "OpenCode" : adapter;
+    const label = adapter === "codex"
+        ? "Codex"
+        : adapter === "claude"
+            ? "Claude"
+            : adapter === "opencode"
+                ? "OpenCode"
+                : adapter === "pi"
+                    ? "Pi"
+                    : adapter;
     return `${label} final reply:\n${text}`;
 }
 const OPENCODE_WORKING_NOTICE_RE = /^OpenCode is still working on:\s*$/i;
@@ -1016,7 +1026,15 @@ function cleanupVisibleWechatReplyText(text) {
         .trim();
 }
 export function formatTaskFailedMessage(adapter, text) {
-    const label = adapter === "codex" ? "Codex" : adapter === "claude" ? "Claude" : adapter === "opencode" ? "OpenCode" : adapter;
+    const label = adapter === "codex"
+        ? "Codex"
+        : adapter === "claude"
+            ? "Claude"
+            : adapter === "opencode"
+                ? "OpenCode"
+                : adapter === "pi"
+                    ? "Pi"
+                    : adapter;
     return `${label} task failed:\n${text}`;
 }
 export function formatApprovalMessage(pending, adapterState) {
@@ -1090,22 +1108,35 @@ function parseSingleUserInputAnswer(question, rawValue) {
             answers: [trimmed],
         };
     }
-    const separatorIndex = trimmed.indexOf("|");
+    const customAnswerMode = question.customAnswerMode ?? "note";
+    const separatorIndex = customAnswerMode === "note" ? trimmed.indexOf("|") : -1;
     const selection = separatorIndex >= 0 ? trimmed.slice(0, separatorIndex).trim() : trimmed;
     let note = separatorIndex >= 0 ? trimmed.slice(separatorIndex + 1).trim() : "";
     const answers = [];
     if (selection) {
-        const selectedLabel = resolveUserInputOptionLabel(question, selection);
-        if (selectedLabel) {
-            answers.push(selectedLabel);
-        }
-        else if (question.isOther) {
-            note = note ? `${selection}; ${note}` : selection;
-        }
-        else {
-            return {
-                error: `Question "${question.header}" expects an option number or label.`,
-            };
+        const selections = question.multiple
+            ? selection.split(",").map((value) => value.trim()).filter(Boolean)
+            : [selection];
+        for (const value of selections) {
+            const selectedLabel = resolveUserInputOptionLabel(question, value);
+            if (selectedLabel) {
+                if (!answers.includes(selectedLabel)) {
+                    answers.push(selectedLabel);
+                }
+            }
+            else if (question.isOther && customAnswerMode === "value") {
+                if (!answers.includes(value)) {
+                    answers.push(value);
+                }
+            }
+            else if (question.isOther) {
+                note = note ? `${value}; ${note}` : value;
+            }
+            else {
+                return {
+                    error: `Question "${question.header}" expects an option number or label.`,
+                };
+            }
         }
     }
     if (note) {
@@ -1210,8 +1241,13 @@ export function formatUserInputRequestMessage(pending, adapterState) {
                 lines.push(`  ${optionIndex + 1}. ${option.label} - ${truncatePreview(option.description, 160)}`);
             });
         }
+        if (question.multiple) {
+            lines.push("multiple selections: allowed (separate values with commas)");
+        }
         if (question.isOther) {
-            lines.push("custom note: allowed");
+            lines.push(question.customAnswerMode === "value"
+                ? "custom answer: allowed"
+                : "custom note: allowed");
         }
     });
     lines.push("");
@@ -1221,8 +1257,13 @@ export function formatUserInputRequestMessage(pending, adapterState) {
             return lines.join("\n");
         }
         if (question.options?.length) {
-            lines.push("Reply with /answer <option number or exact label>.");
-            if (question.isOther) {
+            lines.push(question.multiple
+                ? "Reply with /answer <option numbers or exact labels separated by commas>."
+                : "Reply with /answer <option number or exact label>.");
+            if (question.isOther && question.customAnswerMode === "value") {
+                lines.push("You may enter a custom answer instead of an option.");
+            }
+            else if (question.isOther) {
                 lines.push('Add "| your note" to include extra context.');
             }
         }
@@ -1234,7 +1275,10 @@ export function formatUserInputRequestMessage(pending, adapterState) {
         lines.push("Reply with /answer questionId=value; questionId2=value.");
         lines.push("You can use question numbers instead of ids.");
         lines.push("For option questions, value can be the option number or exact label.");
-        lines.push('Add "| your note" after an option answer to include extra context.');
+        lines.push("For multi-select questions, separate option values with commas.");
+        if (pending.questions.some((question) => question.customAnswerMode !== "value")) {
+            lines.push('Add "| your note" after an option answer to include extra context.');
+        }
     }
     lines.push("Use /stop to interrupt the active turn instead.");
     return lines.join("\n");
@@ -1243,11 +1287,11 @@ export function formatPendingUserInputReminder(pending) {
     if (pending.questions.length === 1) {
         const question = pending.questions[0];
         if (!question) {
-            return "Codex is waiting for user input. Reply with /answer and your response, or use /stop to interrupt.";
+            return "The active CLI is waiting for user input. Reply with /answer and your response, or use /stop to interrupt.";
         }
-        return `Codex is waiting for user input for ${question.header}. Reply with /answer and your response, or use /stop to interrupt.`;
+        return `The active CLI is waiting for user input for ${question.header}. Reply with /answer and your response, or use /stop to interrupt.`;
     }
-    return `Codex is waiting for answers to ${pending.questions.length} questions. Reply with /answer questionId=value; questionId2=value, or use /stop to interrupt.`;
+    return `The active CLI is waiting for answers to ${pending.questions.length} questions. Reply with /answer questionId=value; questionId2=value, or use /stop to interrupt.`;
 }
 export class OutputBatcher {
     onFlush;

package/dist/bridge/wechat-bridge.js

@@ -46,7 +46,7 @@ export function formatUserFacingBridgeFatalError(message) {
     return `Bridge error: ${message.replace(/\s+Recent app-server log:.*$/s, "").trim()}`;
 }
 export function shouldForwardBridgeEventToWechat(adapter, eventType, options = {}) {
-    if (adapter !== "opencode") {
+    if (adapter !== "opencode" && adapter !== "pi") {
         return true;
     }
     switch (eventType) {
@@ -55,7 +55,7 @@ export function shouldForwardBridgeEventToWechat(adapter, eventType, options = {
         case "thread_switched":
             return false;
         case "notice":
-            return /^OpenCode local draft:\s*/i.test(options.text ?? "");
+            return adapter === "pi" || /^OpenCode local draft:\s*/i.test(options.text ?? "");
         case "mirrored_user_input":
             return true;
         default:
@@ -159,7 +159,7 @@ export function parseCliArgs(argv) {
         const next = argv[i + 1];
         switch (arg) {
             case "--adapter":
-                if (!next || !["codex", "claude", "opencode", "shell"].includes(next)) {
+                if (!next || !["codex", "claude", "opencode", "pi", "shell"].includes(next)) {
                     throw new Error(`Invalid adapter: ${next ?? "(missing)"}`);
                 }
                 adapter = next;
@@ -212,7 +212,7 @@ export function parseCliArgs(argv) {
         }
     }
     if (!adapter) {
-        throw new Error("Missing required --adapter <codex|claude|opencode|shell>");
+        throw new Error("Missing required --adapter <codex|claude|opencode|pi|shell>");
     }
     const defaultCommand = resolveDefaultAdapterCommand(adapter);
     return {
@@ -226,12 +226,13 @@ export function parseCliArgs(argv) {
 }
 function printUsageAndExit() {
     process.stdout.write([
-        "Usage: wechat-bridge --adapter <codex|claude|opencode|shell> [--cmd <executable>] [--cwd <path>] [--profile <name-or-path>] [--lifecycle <persistent|companion_bound>] [--session-start-mode <restore|new>]",
+        "Usage: wechat-bridge --adapter <codex|claude|opencode|pi|shell> [--cmd <executable>] [--cwd <path>] [--profile <name-or-path>] [--lifecycle <persistent|companion_bound>] [--session-start-mode <restore|new>]",
         "",
         "Examples:",
         "  wechat-bridge-codex",
         "  wechat-bridge-claude --cwd ~/work/my-project",
         "  wechat-bridge-opencode --cwd ~/work/my-project",
+        "  wechat-bridge-pi --cwd ~/work/my-project",
         "  wechat-bridge-shell --cmd pwsh   # headless shell executor for non-interactive commands/scripts",
         "  wechat-bridge-shell --cmd bash   # headless shell executor for non-interactive commands/scripts",
         "  wechat-bridge-codex --lifecycle companion_bound",
@@ -1122,9 +1123,9 @@ async function handleInboundMessage(params) {
         return null;
     }
     if (adapterState.status === "busy") {
-        if ((options.adapter === "codex" || options.adapter === "opencode") &&
+        if ((options.adapter === "codex" || options.adapter === "opencode" || options.adapter === "pi") &&
             adapterState.activeTurnOrigin === "local") {
-            await queueWechatMessage(message.senderId, `${options.adapter === "opencode" ? "OpenCode" : "codex"} is currently busy with a local terminal turn. Wait for it to finish or use /stop.`);
+            await queueWechatMessage(message.senderId, `${options.adapter === "opencode" ? "OpenCode" : options.adapter === "pi" ? "Pi" : "codex"} is currently busy with a local terminal turn. Wait for it to finish or use /stop.`);
             return null;
         }
         await queueWechatMessage(message.senderId, `${options.adapter} is still working. Wait for the current reply or use /stop.`);

package/dist/companion/local-companion-link.js

@@ -7,7 +7,11 @@ function normalizeEndpoint(value) {
         return null;
     }
     const record = value;
-    const kind = record.kind === "codex" || record.kind === "claude" || record.kind === "opencode" || record.kind === "shell"
+    const kind = record.kind === "codex" ||
+        record.kind === "claude" ||
+        record.kind === "opencode" ||
+        record.kind === "pi" ||
+        record.kind === "shell"
         ? record.kind
         : "codex";
     const sharedSessionId = typeof record.sharedSessionId === "string"
@@ -118,6 +122,7 @@ export function clearLocalCompanionEndpoint(cwd, instanceId, options = {}) {
                 getWorkspaceAdapterEndpointFile(cwd, "codex"),
                 getWorkspaceAdapterEndpointFile(cwd, "claude"),
                 getWorkspaceAdapterEndpointFile(cwd, "opencode"),
+                getWorkspaceAdapterEndpointFile(cwd, "pi"),
                 getWorkspaceAdapterEndpointFile(cwd, "shell"),
             ];
         for (const filePath of files) {

package/dist/companion/local-companion-start.js

@@ -38,7 +38,7 @@ export function formatRestartUnhealthyMessage(cwd) {
     return `Detected unhealthy companion state for ${cwd}. Restarting bridge...`;
 }
 export function defaultSessionStartMode(adapter) {
-    return adapter === "claude" || adapter === "opencode" ? "new" : "restore";
+    return adapter === "codex" ? "restore" : "new";
 }
 export function decideLaunchAction(input) {
     if (input.lockShouldAutoReclaim) {
@@ -59,7 +59,9 @@ export function decideLaunchAction(input) {
         };
     }
     if (input.sessionStartMode === "new" &&
-        (input.requestedAdapter === "claude" || input.requestedAdapter === "opencode")) {
+        (input.requestedAdapter === "claude" ||
+            input.requestedAdapter === "opencode" ||
+            input.requestedAdapter === "pi")) {
         return {
             kind: "start_bridge",
             message: `Starting a fresh ${input.requestedAdapter} session for ${input.requestedCwd}...`,
@@ -95,6 +97,7 @@ export function parseCliArgs(argv) {
     let cwd = process.cwd();
     let profile;
     let timeoutMs = DEFAULT_WAIT_TIMEOUT_MS;
+    let sessionStartMode;
     const cliArgs = [];
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
@@ -107,10 +110,12 @@ export function parseCliArgs(argv) {
                 "Usage: wechat-codex-start [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [...codex args]",
                 "       wechat-claude-start [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [...claude args]",
                 "       wechat-opencode-start [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [...opencode args]",
-                "       local-companion-start [--adapter <codex|claude|opencode>] [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [...cli args]",
+                "       wechat-pi-start [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [...pi args]",
+                "       local-companion-start [--adapter <codex|claude|opencode|pi>] [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [...cli args]",
                 "",
                 "Starts a bridge for the current directory, waits for the local endpoint, then opens the visible companion or panel.",
-                "Claude and OpenCode launchers start a fresh CLI session by default.",
+                "Claude, OpenCode, and Pi launchers start a fresh CLI session by default.",
+                "Use --session-start-mode restore to explicitly restore the previous session.",
                 "All adapters are companion-bound: closing the companion/panel also stops the bridge.",
                 "Unknown arguments are forwarded to the visible CLI client.",
                 "",
@@ -118,7 +123,7 @@ export function parseCliArgs(argv) {
             process.exit(0);
         }
         if (arg === "--adapter") {
-            if (!next || !["codex", "claude", "opencode"].includes(next)) {
+            if (!next || !["codex", "claude", "opencode", "pi"].includes(next)) {
                 throw new Error(`Invalid adapter: ${next ?? "(missing)"}`);
             }
             adapter = next;
@@ -153,6 +158,14 @@ export function parseCliArgs(argv) {
             i += 1;
             continue;
         }
+        if (arg === "--session-start-mode") {
+            if (!next || !["restore", "new"].includes(next)) {
+                throw new Error(`Invalid session start mode: ${next ?? "(missing)"}`);
+            }
+            sessionStartMode = next;
+            i += 1;
+            continue;
+        }
         cliArgs.push(arg);
     }
     return {
@@ -160,7 +173,7 @@ export function parseCliArgs(argv) {
         cwd,
         profile,
         timeoutMs,
-        sessionStartMode: defaultSessionStartMode(adapter),
+        sessionStartMode: sessionStartMode ?? defaultSessionStartMode(adapter),
         cliArgs,
     };
 }
@@ -203,7 +216,10 @@ async function stopExistingBridge(lock, requestedAdapter) {
     if (!(await waitForProcessExit(pid, 10_000))) {
         throw new Error(`Timed out waiting for existing bridge pid=${pid} to exit.`);
     }
-    if (lock.adapter === "codex" || lock.adapter === "claude" || lock.adapter === "opencode") {
+    if (lock.adapter === "codex" ||
+        lock.adapter === "claude" ||
+        lock.adapter === "opencode" ||
+        lock.adapter === "pi") {
         clearLocalCompanionEndpoint(cwd, undefined, { adapter: lock.adapter });
     }
     else {
@@ -383,7 +399,7 @@ export async function tryDelegateToDaemon(options, deps = {}) {
         cliArgs: options.cliArgs,
         openVisible: true,
         sessionStartMode: options.sessionStartMode,
-        reuseExistingVisible: true,
+        reuseExistingVisible: options.adapter !== "pi" || options.sessionStartMode !== "new",
     });
     if (!response.ok) {
         throw new Error(response.error);

package/dist/companion/local-companion.js

@@ -23,7 +23,7 @@ function parseCliArgs(argv) {
         const next = argv[i + 1];
         if (arg === "--help" || arg === "-h") {
             process.stdout.write([
-                "Usage: local-companion --adapter <codex|claude|opencode> [--cwd <path>] [...cli args]",
+                "Usage: local-companion --adapter <codex|claude|opencode|pi> [--cwd <path>] [...cli args]",
                 "",
                 'Starts the visible local companion and connects it to the matching running bridge for the current directory.',
                 "Unknown arguments are forwarded to the visible CLI client.",
@@ -32,7 +32,7 @@ function parseCliArgs(argv) {
             process.exit(0);
         }
         if (arg === "--adapter") {
-            if (!next || !["codex", "claude", "opencode"].includes(next)) {
+            if (!next || !["codex", "claude", "opencode", "pi"].includes(next)) {
                 throw new Error(`Invalid adapter: ${next ?? "(missing)"}`);
             }
             adapter = next;
@@ -58,7 +58,7 @@ function parseCliArgs(argv) {
         cliArgs.push(arg);
     }
     if (!adapter) {
-        throw new Error("Missing required --adapter <codex|claude|opencode>");
+        throw new Error("Missing required --adapter <codex|claude|opencode|pi>");
     }
     return { adapter, cwd, sessionStartMode, cliArgs };
 }

package/dist/companion/pi-tui-bridge-extension.js

@@ -0,0 +1,256 @@
+import net from "node:net";
+const BRIDGE_HOST = "127.0.0.1";
+const INTERNAL_NEW_COMMAND = "__cli_bridge_new";
+const INTERNAL_SWITCH_COMMAND = "__cli_bridge_switch";
+const MAX_BUFFER_SIZE = 8 * 1024 * 1024;
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function extractAssistantText(message) {
+    if (!isRecord(message) || message.role !== "assistant") {
+        return "";
+    }
+    if (typeof message.content === "string") {
+        return message.content.trim();
+    }
+    if (!Array.isArray(message.content)) {
+        return "";
+    }
+    return message.content
+        .filter((block) => isRecord(block))
+        .filter((block) => block.type === "text" && typeof block.text === "string")
+        .map((block) => block.text)
+        .join("\n")
+        .trim();
+}
+function parseControlArgs(args) {
+    const trimmed = args.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const separatorIndex = trimmed.indexOf(" ");
+    if (separatorIndex < 0) {
+        return { id: trimmed };
+    }
+    return {
+        id: trimmed.slice(0, separatorIndex),
+        value: trimmed.slice(separatorIndex + 1),
+    };
+}
+export default function piTuiBridgeExtension(pi) {
+    const bridgePort = Number(process.env.CLI_BRIDGE_PI_TUI_PORT ?? "");
+    const bridgeToken = process.env.CLI_BRIDGE_PI_TUI_TOKEN ?? "";
+    if (!Number.isInteger(bridgePort) || bridgePort <= 0 || !bridgeToken) {
+        return;
+    }
+    const socket = net.connect({ host: BRIDGE_HOST, port: bridgePort });
+    let buffer = "";
+    let connected = false;
+    const queuedFrames = [];
+    const queuedCommands = [];
+    let latestContext = null;
+    const writeFrame = (frame) => {
+        if (socket.destroyed) {
+            return;
+        }
+        if (!connected) {
+            queuedFrames.push(frame);
+            return;
+        }
+        socket.write(`${JSON.stringify(frame)}\n`);
+    };
+    const writeSessionState = (context, reason) => {
+        writeFrame({
+            type: "session_state",
+            sessionId: context.sessionManager.getSessionId(),
+            sessionFile: context.sessionManager.getSessionFile(),
+            reason,
+        });
+    };
+    pi.registerCommand(INTERNAL_NEW_COMMAND, {
+        description: "Internal CLI WeChat Bridge session command",
+        handler: async (args, context) => {
+            const parsed = parseControlArgs(args);
+            if (!parsed) {
+                return;
+            }
+            try {
+                let sessionState = {};
+                const result = await context.newSession({
+                    withSession: async (nextContext) => {
+                        writeSessionState(nextContext, "new");
+                        sessionState = {
+                            sessionId: nextContext.sessionManager.getSessionId(),
+                            sessionFile: nextContext.sessionManager.getSessionFile(),
+                        };
+                    },
+                });
+                writeFrame({
+                    type: "response",
+                    id: parsed.id,
+                    success: true,
+                    data: { ...result, ...sessionState },
+                });
+            }
+            catch (error) {
+                writeFrame({
+                    type: "response",
+                    id: parsed.id,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        },
+    });
+    pi.registerCommand(INTERNAL_SWITCH_COMMAND, {
+        description: "Internal CLI WeChat Bridge session command",
+        handler: async (args, context) => {
+            const parsed = parseControlArgs(args);
+            if (!parsed?.value) {
+                return;
+            }
+            try {
+                let sessionState = {};
+                const result = await context.switchSession(parsed.value, {
+                    withSession: async (nextContext) => {
+                        writeSessionState(nextContext, "resume");
+                        sessionState = {
+                            sessionId: nextContext.sessionManager.getSessionId(),
+                            sessionFile: nextContext.sessionManager.getSessionFile(),
+                        };
+                    },
+                });
+                writeFrame({
+                    type: "response",
+                    id: parsed.id,
+                    success: true,
+                    data: { ...result, ...sessionState },
+                });
+            }
+            catch (error) {
+                writeFrame({
+                    type: "response",
+                    id: parsed.id,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        },
+    });
+    const executeCommand = (command) => {
+        try {
+            if (command.type === "prompt" && typeof command.text === "string") {
+                if (!latestContext?.isIdle()) {
+                    throw new Error("Pi TUI is already processing a turn.");
+                }
+                pi.sendUserMessage(command.text);
+                writeFrame({ type: "response", id: command.id, success: true });
+            }
+            else if (command.type === "abort") {
+                latestContext?.abort();
+                writeFrame({ type: "response", id: command.id, success: true });
+            }
+            else if (command.type === "new_session" && typeof command.id === "string") {
+                pi.sendUserMessage(`/${INTERNAL_NEW_COMMAND} ${command.id}`, {
+                    expandPromptTemplates: true,
+                });
+            }
+            else if (command.type === "switch_session" &&
+                typeof command.id === "string" &&
+                typeof command.sessionPath === "string") {
+                pi.sendUserMessage(`/${INTERNAL_SWITCH_COMMAND} ${command.id} ${command.sessionPath}`, { expandPromptTemplates: true });
+            }
+        }
+        catch (error) {
+            writeFrame({
+                type: "response",
+                id: command.id,
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    };
+    const dispatchCommand = (command) => {
+        if (!latestContext) {
+            queuedCommands.push(command);
+            return;
+        }
+        executeCommand(command);
+    };
+    socket.setEncoding("utf8");
+    socket.on("connect", () => {
+        socket.setNoDelay(true);
+        socket.write(`${JSON.stringify({ type: "hello", token: bridgeToken })}\n`);
+        connected = true;
+        for (const frame of queuedFrames.splice(0)) {
+            writeFrame(frame);
+        }
+    });
+    socket.on("data", (chunk) => {
+        buffer += chunk;
+        if (buffer.length > MAX_BUFFER_SIZE) {
+            buffer = "";
+            socket.destroy();
+            return;
+        }
+        while (true) {
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex < 0) {
+                return;
+            }
+            const line = buffer.slice(0, newlineIndex).replace(/\r$/, "");
+            buffer = buffer.slice(newlineIndex + 1);
+            if (!line.trim()) {
+                continue;
+            }
+            try {
+                const parsed = JSON.parse(line);
+                if (isRecord(parsed)) {
+                    dispatchCommand(parsed);
+                }
+            }
+            catch {
+                // Ignore malformed bridge commands and keep the native TUI alive.
+            }
+        }
+    });
+    socket.on("error", () => {
+        // The visible TUI remains usable if the bridge side disappears.
+    });
+    pi.on("session_start", (event, context) => {
+        latestContext = context;
+        writeSessionState(context, typeof event.reason === "string" ? event.reason : "startup");
+        for (const command of queuedCommands.splice(0)) {
+            executeCommand(command);
+        }
+    });
+    pi.on("input", (event, context) => {
+        latestContext = context;
+        if (event.source === "interactive" && typeof event.text === "string") {
+            writeFrame({ type: "local_input", text: event.text });
+        }
+    });
+    pi.on("message_end", (event, context) => {
+        latestContext = context;
+        const text = extractAssistantText(event.message);
+        if (!text) {
+            return;
+        }
+        const message = isRecord(event.message) ? event.message : {};
+        writeFrame({
+            type: "assistant_message",
+            text,
+            stopReason: message.stopReason,
+            errorMessage: message.errorMessage,
+        });
+    });
+    pi.on("agent_start", (_event, context) => {
+        latestContext = context;
+        writeFrame({ type: "agent_start" });
+    });
+    pi.on("agent_settled", (_event, context) => {
+        latestContext = context;
+        writeSessionState(context, "settled");
+        writeFrame({ type: "agent_settled" });
+    });
+}