@zergai/ztc 0.9.0-beta.1 → 0.10.0-beta.1

package/README.md

@@ -1322,6 +1322,49 @@ npm run web            # Web UI at http://localhost:3000
 npm start              # Production entry point
 ```
 
+### Claude Code and Codex in panes
+
+ZTC hosts your own Claude Code and Codex next to its agents. Each pane runs
+your installed, unmodified `claude` or `codex`, signed in with your own account
+through that CLI's own sign-in; ZTC never reads, stores or forwards those
+credentials. Panes need zmux (plain `ztc`) or the desktop app.
+
+- `/claude [prompt | flags]` and `/codex [prompt | flags]` open one in this
+  pane's directory. Plain text is the opening prompt (`/claude fix the failing
+  test`); text that starts with a flag goes to the CLI as its arguments
+  (`/claude --continue`, `/codex -m gpt-5 "review the diff"`).
+- Ctrl+B c offers Claude Code and Codex next to bash and ZTC when they are
+  installed. In the desktop app, the tab strip's + opens a menu: New ZTC Pane,
+  New Claude Code Pane, New Codex Pane, New Shell Pane. Cmd+T still opens a ZTC
+  tab directly.
+
+Each of these panes starts with ZTC's workspace MCP server (`ztc
+workspace-mcp`) attached for that session only, through Claude Code's
+`--mcp-config` or Codex's `-c mcp_servers.ztc.*`, so your own CLI configuration
+is never edited. Its tools give the agent the workspace:
+
+| Tool | What it does |
+|------|--------------|
+| `list_panes` | Each pane's id, name and kind, and which pane is the agent's own |
+| `open_pane` | Open a ZTC agent, Claude Code, Codex or a shell, optionally with a first task |
+| `read_pane` | Read a pane's scrollback, or what is on screen |
+| `type_into_pane` | Type into a pane, then press Enter |
+| `send_message` | Message another agent over ZTC's bus |
+| `close_pane` | Close another pane |
+
+A ZTC agent reaches these panes by name as well: a message for a Claude Code or
+Codex pane is typed into it as `[Message from ben (pane 2)] …` (a question also
+says how to answer), and the answer comes back as a message from that pane.
+Broadcasts to `all` reach ZTC agents only.
+
+ZTC's own agent loop uses an Anthropic API key for Claude models (`/config key`
+or `ANTHROPIC_API_KEY`). Anthropic's [legal and compliance
+terms](https://code.claude.com/docs/en/legal-and-compliance) reserve Claude
+subscription sign-in for Claude Code and Anthropic's own apps: third-party tools
+may not route requests through Free, Pro, Max or Ultra plan credentials or
+handle Claude.ai credentials. Running your own Claude Code in a pane is how to
+use a Claude subscription alongside ZTC.
+
 ### Claude Code CLI OAuth
 
 ZTC can use Claude Code subscription/OAuth auth through the official Claude Code CLI instead of direct Anthropic API-key billing:

package/dist/agent/commands/agent_cli.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `/claude` and `/codex` — open the user's own Claude Code or Codex in a new
+ * pane, in this pane's directory.
+ *
+ * The CLI signs in with the user's own account through its own flow; ZTC only
+ * runs it, unmodified, and attaches its workspace MCP server so the agent can
+ * open, read, type into and message other panes. Plain text after the command
+ * is the opening prompt; text starting with a flag is the CLI's arguments.
+ */
+import { type AgentCliId, type PaneProgram } from '../../panes/agent_cli.js';
+import type { PaneCommandTransport } from '../../ui/ratatui/pane_relay.js';
+import type { Command } from './types.js';
+export interface AgentCliCommandDeps {
+    transport?: () => PaneCommandTransport | null;
+    findBinary?: (id: AgentCliId) => string | null;
+    server?: () => PaneProgram | Error;
+    env?: () => NodeJS.ProcessEnv;
+}
+export declare function createAgentCliCommand(id: AgentCliId, deps?: AgentCliCommandDeps): Command;
+export declare const claudeCommand: Command;
+export declare const codexCommand: Command;

package/dist/agent/commands/agent_cli.js

@@ -0,0 +1,66 @@
+/**
+ * `/claude` and `/codex` — open the user's own Claude Code or Codex in a new
+ * pane, in this pane's directory.
+ *
+ * The CLI signs in with the user's own account through its own flow; ZTC only
+ * runs it, unmodified, and attaches its workspace MCP server so the agent can
+ * open, read, type into and message other panes. Plain text after the command
+ * is the opening prompt; text starting with a flag is the CLI's arguments.
+ */
+import { getMuxTransport } from '../tools/pane.js';
+import { AGENT_CLIS, findAgentCli, formatCliArguments, parseAgentCommandBody, workspaceMcpProgram, } from '../../panes/agent_cli.js';
+import { openAgentPane } from '../../panes/agent_panes.js';
+function shownCommand(binary, request) {
+    const words = [...request.words, ...(request.prompt ? ['--', request.prompt] : [])];
+    return words.length > 0 ? `${binary} ${formatCliArguments(words)}` : binary;
+}
+export function createAgentCliCommand(id, deps = {}) {
+    const spec = AGENT_CLIS[id];
+    const account = id === 'claude' ? 'Claude' : 'ChatGPT';
+    return {
+        name: id,
+        description: `Open ${spec.label} in a new pane, signed in with your own ${account} account`,
+        usage: '[prompt | flags]',
+        agentRunnable: true,
+        category: 'panes',
+        handler: async (args, ctx) => {
+            let request;
+            try {
+                request = parseAgentCommandBody(args.join(' '));
+            }
+            catch (error) {
+                ctx.addMessage({ role: 'system', content: `/${id}: ${error.message}` });
+                return;
+            }
+            const transport = (deps.transport ?? getMuxTransport)();
+            if (!transport) {
+                ctx.addMessage({
+                    role: 'system',
+                    content: `/${id} opens ${spec.label} in a pane, which needs ZTC's panes: start ZTC with zmux (plain \`ztc\`) or use the desktop app. You can also run \`${spec.binary}\` in another terminal.`,
+                });
+                return;
+            }
+            const cwd = ctx.shell.getCwd();
+            const result = await openAgentPane(transport, {
+                cli: id,
+                request,
+                cwd,
+                findBinary: deps.findBinary ?? findAgentCli,
+                server: (deps.server ?? workspaceMcpProgram)(),
+                env: (deps.env ?? (() => process.env))(),
+            });
+            if (result.error) {
+                ctx.addMessage({ role: 'system', content: result.error });
+                return;
+            }
+            ctx.addMessage({
+                role: 'system',
+                content: `Opened ${result.title} in pane ${result.paneId} (${cwd}): ${shownCommand(spec.binary, request)}`,
+            });
+            if (result.notice)
+                ctx.addMessage({ role: 'system', content: result.notice });
+        },
+    };
+}
+export const claudeCommand = createAgentCliCommand('claude');
+export const codexCommand = createAgentCliCommand('codex');

package/dist/agent/commands/index.js

@@ -30,6 +30,7 @@ import { connectCommand } from './connect.js';
 import { reloadCommand, restartCommand } from './restart.js';
 import { initCommand } from './init.js';
 import { forkCommand, sideCommand } from './fork.js';
+import { claudeCommand, codexCommand } from './agent_cli.js';
 import { diffCommand } from './diff.js';
 import { rawCommand } from './raw.js';
 import { themeCommand } from './theme.js';
@@ -82,7 +83,7 @@ import { effortCommand, thinkingCommand, reasoningCommand, fastCommand } from '.
 import { runtimePluginRegistry } from '../../plugin/runtime_registry.js';
 const commandList = [];
 const helpCommand = makeHelpCommand(() => commandList);
-commandList.push(helpCommand, authCommand, loginCommand, logoutCommand, accountsCommand, zergCommand, zergsCommand, configCommand, debugCommand, clearCommand, handoffCommand, statusCommand, runtimeCommand, environmentCommand, jobCommand, shareCommand, hooksCommand, emulationCommand, shellCommand, cdCommand, clipboardCommand, modelsCommand, modelCommand, permissionsCommand, resourcesCommand, initCommand, forkCommand, sideCommand, diffCommand, rawCommand, themeCommand, doctorCommand, intentCommand, profileCommand, skillsCommand, runbooksCommand, keybindingsCommand, keymapCommand, shortcutsCommand, updateCommand, desktopCommand, layoutCommand, setupCommand, connectCommand, keysCommand, restartCommand, reloadCommand, inputModeCommand, retryCommand, dictationStatusCommand, embeddedCommand, benchCommand, voiceCommand, sfxCommand, compactCommand, automodeCommand, sessionsCommand, resumeCommand, rewindCommand, renameCommand, labelCommand, inboxCommand, attentionCommand, contextCommand, evidenceCommand, boardCommand, usageCommand, shannonRunnerCommand, planCommand, executeCommand, modeCommand, modeListCommand, exitModeCommand, validateCommand, previewCommand, saveCommand, dcaigCommand, manifestCommand, swarmCommand, swarmStopCommand, swarmStatusCommand, superviseCommand, superviseStopCommand, superviseStatusCommand, zlickyCommand, zlickyStopCommand, zlickyStatusCommand, zlickyActCommand, zlickyPresenceCommand, zlickyPttCommand, simCommand, simStopCommand, simStatusCommand, simRunCommand, simCheckpointCommand, simResumeCommand, evolveCommand, evolveStopCommand, evolveStatusCommand, evolveBestCommand, optimizeCommand, batchCommand, batchStatusCommand, batchStopCommand, workflowsCommand, mirrorCommand, settingsCommand, mcpCommand, loopCommand, goalCommand, effortCommand, thinkingCommand, reasoningCommand, fastCommand, exitCommand);
+commandList.push(helpCommand, authCommand, loginCommand, logoutCommand, accountsCommand, zergCommand, zergsCommand, configCommand, debugCommand, clearCommand, handoffCommand, statusCommand, runtimeCommand, environmentCommand, jobCommand, shareCommand, hooksCommand, emulationCommand, shellCommand, cdCommand, clipboardCommand, modelsCommand, modelCommand, permissionsCommand, resourcesCommand, initCommand, forkCommand, sideCommand, claudeCommand, codexCommand, diffCommand, rawCommand, themeCommand, doctorCommand, intentCommand, profileCommand, skillsCommand, runbooksCommand, keybindingsCommand, keymapCommand, shortcutsCommand, updateCommand, desktopCommand, layoutCommand, setupCommand, connectCommand, keysCommand, restartCommand, reloadCommand, inputModeCommand, retryCommand, dictationStatusCommand, embeddedCommand, benchCommand, voiceCommand, sfxCommand, compactCommand, automodeCommand, sessionsCommand, resumeCommand, rewindCommand, renameCommand, labelCommand, inboxCommand, attentionCommand, contextCommand, evidenceCommand, boardCommand, usageCommand, shannonRunnerCommand, planCommand, executeCommand, modeCommand, modeListCommand, exitModeCommand, validateCommand, previewCommand, saveCommand, dcaigCommand, manifestCommand, swarmCommand, swarmStopCommand, swarmStatusCommand, superviseCommand, superviseStopCommand, superviseStatusCommand, zlickyCommand, zlickyStopCommand, zlickyStatusCommand, zlickyActCommand, zlickyPresenceCommand, zlickyPttCommand, simCommand, simStopCommand, simStatusCommand, simRunCommand, simCheckpointCommand, simResumeCommand, evolveCommand, evolveStopCommand, evolveStatusCommand, evolveBestCommand, optimizeCommand, batchCommand, batchStatusCommand, batchStopCommand, workflowsCommand, mirrorCommand, settingsCommand, mcpCommand, loopCommand, goalCommand, effortCommand, thinkingCommand, reasoningCommand, fastCommand, exitCommand);
 export const commands = commandList;
 export function refreshPluginCommands() {
     const existing = new Set(commandList.map(command => command.name));

package/dist/agent/tools/bus_message.js

@@ -5,7 +5,7 @@
  * from cli_ratatui.ts at startup.
  */
 import { readPaneResponseSnapshot } from '../../utils/pane_response.js';
-import { resolvePaneIdByName } from './pane.js';
+import { listWorkspacePanes, resolvePaneIdByName } from './pane.js';
 // --- Setter-based transport access ---
 let busTransportRef = null;
 export function setBusTransport(transport) {
@@ -34,6 +34,18 @@ async function resolveBusRecipient(value) {
         return parsed;
     return resolvePaneIdByName(String(value).trim());
 }
+/**
+ * The name of a pane that is not a ZTC agent (Claude Code, Codex, a shell), or
+ * null. Such a pane writes no ZTC response to wait for: its agent answers later
+ * with a message of its own.
+ */
+async function nonZtcPaneName(paneId) {
+    const panes = await listWorkspacePanes(undefined, 3000);
+    if (panes instanceof Error)
+        return null;
+    const pane = panes.find(candidate => candidate.id === paneId);
+    return pane && pane.pane_type !== 'ztc' ? (pane.labels?.manual_title || pane.title) : null;
+}
 async function waitForNewPaneResponse(paneId, baseline, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
@@ -182,10 +194,17 @@ export const sendMessageTool = {
         }
         const rawKind = String(args.kind || 'statement').toLowerCase();
         const kind = rawKind === 'question' || rawKind === 'request' || rawKind === 'reply' ? rawKind : 'statement';
-        const waitForResponse = typeof to === 'number' && (kind === 'question' || kind === 'request');
-        const baseline = waitForResponse ? readPaneResponseSnapshot(to) : null;
-        const outgoingText = waitForResponse ? buildZtcRequestPayload(text, kind) : text;
+        const asks = typeof to === 'number' && (kind === 'question' || kind === 'request');
+        // The baseline is read and the message sent before anything awaits, so a
+        // reply written right after delivery is never mistaken for the baseline.
+        const baseline = asks ? readPaneResponseSnapshot(to) : null;
+        const outgoingText = asks ? buildZtcRequestPayload(text, kind) : text;
         busTransportRef.sendBusMessage(to, outgoingText, 'ztc_message');
+        const external = asks ? await nonZtcPaneName(to) : null;
+        if (external !== null) {
+            return `${kind === 'question' ? 'Question' : 'Request'} sent to ${external} (pane ${to}). It is not a ZTC agent, so its answer arrives later as a message from that pane.`;
+        }
+        const waitForResponse = asks;
         if (waitForResponse && baseline) {
             try {
                 const response = await waitForNewPaneResponse(to, baseline, 90_000);
@@ -311,6 +330,10 @@ export const askZtcPaneTool = {
             : 90;
         const baseline = readPaneResponseSnapshot(paneId);
         busTransportRef.sendBusMessage(paneId, buildZtcRequestPayload(text, 'request'), 'ztc_message');
+        const external = await nonZtcPaneName(paneId);
+        if (external !== null) {
+            return `Sent to ${external} (pane ${paneId}). It is not a ZTC agent, so its answer arrives later as a message from that pane.`;
+        }
         try {
             const response = await waitForNewPaneResponse(paneId, baseline, timeoutSeconds * 1000);
             return `Response from ZTC ${paneId}:\n${response}`;

package/dist/agent/tools/pane.d.ts

@@ -1,6 +1,6 @@
 import { Tool } from './types.js';
 import type { PaneCommandTransport } from '../../ui/ratatui/pane_relay.js';
-import type { RustEvent } from '../../ui/ratatui/protocol.js';
+import type { PaneInfo, RustEvent } from '../../ui/ratatui/protocol.js';
 import { resolveModelAndProvider } from '../../panes/model_catalog.js';
 import type { PaneLaunchSpec } from '../../panes/types.js';
 export { resolveModelAndProvider };
@@ -36,6 +36,8 @@ export declare function getPaneToolsTransport(): PaneCommandTransport | null;
  * Resolves "ben" to the one other pane named ben. People address panes by the
  * names they gave them with /rename, not by pane number.
  */
+/** The renderer's current pane list, through the given transport (default: the pane tools'). */
+export declare function listWorkspacePanes(transport?: PaneCommandTransport | null, timeoutMs?: number): Promise<PaneInfo[] | Error>;
 export declare function resolvePaneIdByName(name: string): Promise<number | Error>;
 export declare function waitForPaneCreatedOrError(tui: PaneCommandTransport, expected: {
     paneType?: string;
@@ -43,6 +45,8 @@ export declare function waitForPaneCreatedOrError(tui: PaneCommandTransport, exp
     requestId?: string;
 }, timeoutMs?: number): Promise<RustEvent>;
 export declare function paneLimitReached(): boolean;
+/** Environment a ZTC child pane needs to join this workspace (relay, mirror bus, PATH). */
+export declare function childZtcPaneEnv(): Record<string, string>;
 export declare function buildChildZtcPaneLaunch(extraArgs?: string[], childSessionId?: string, options?: {
     mirrorPort?: number;
     entrypoint?: string;

package/dist/agent/tools/pane.js

@@ -277,23 +277,33 @@ function paneName(title) {
  * Resolves "ben" to the one other pane named ben. People address panes by the
  * names they gave them with /rename, not by pane number.
  */
-export async function resolvePaneIdByName(name) {
-    if (!tuiProcessRef || !tuiProcessRef.isMuxMode) {
-        return new Error('Error: Pane names are only available with panes (zmux or the desktop app).');
+/** The renderer's current pane list, through the given transport (default: the pane tools'). */
+export async function listWorkspacePanes(transport = tuiProcessRef, timeoutMs = 5000) {
+    if (!transport || !transport.isMuxMode) {
+        return new Error('Error: Panes are only available with zmux or the desktop app.');
     }
-    const transport = tuiProcessRef;
-    const listed = waitForEvent(transport, (event) => event.type === 'pane_list', 5000);
+    const listed = waitForEvent(transport, (event) => event.type === 'pane_list', timeoutMs);
     if (!transport.send({ type: 'list_panes' })) {
         listed.catch(() => { });
-        return new Error('Error: Unable to list panes to find that name.');
+        return new Error('Error: Unable to list panes.');
     }
     const event = await listed.catch((error) => error);
     if (event instanceof Error)
         return new Error(`Error: ${event.message}`);
     if (event.type !== 'pane_list')
         return new Error('Error: Unexpected response while listing panes.');
+    return event.panes;
+}
+export async function resolvePaneIdByName(name) {
+    if (!tuiProcessRef || !tuiProcessRef.isMuxMode) {
+        return new Error('Error: Pane names are only available with panes (zmux or the desktop app).');
+    }
+    const panes = await listWorkspacePanes(tuiProcessRef);
+    if (panes instanceof Error) {
+        return new Error(panes.message === 'Error: Unable to list panes.' ? 'Error: Unable to list panes to find that name.' : panes.message);
+    }
     const wanted = paneName(name);
-    const others = event.panes.filter((pane) => pane.id !== ownPaneId);
+    const others = panes.filter((pane) => pane.id !== ownPaneId);
     const matches = others.filter((pane) => paneName(pane.title) === wanted);
     if (matches.length === 1)
         return matches[0].id;
@@ -417,7 +427,8 @@ function filterChildZtcArgs(args) {
     }
     return filtered;
 }
-function childZtcPaneEnv() {
+/** Environment a ZTC child pane needs to join this workspace (relay, mirror bus, PATH). */
+export function childZtcPaneEnv() {
     const env = {
         ZTC_PARENT_PID: String(process.pid),
     };

package/dist/app/command_context.js

@@ -76,9 +76,11 @@ export function routeUserInput(text) {
                     tokens.push(token);
                 return { type: 'command', cmd, args: tokens.slice(1) };
             }
-            if (cmd.toLowerCase() === 'fork' || cmd.toLowerCase() === 'side') {
-                // A fork's body is authored task data, not tokenized command options.
-                // Remove exactly the command separator and retain the remaining bytes.
+            if (['fork', 'side', 'claude', 'codex'].includes(cmd.toLowerCase())) {
+                // A fork's body is authored task data, not tokenized command options,
+                // and /claude and /codex read theirs as a prompt or a shell-quoted
+                // argument list. Remove exactly the command separator and retain the
+                // remaining bytes.
                 const task = line.slice(cmd.length + 2);
                 return { type: 'command', cmd, args: task.length ? [task] : [] };
             }

package/dist/cli_main.js

@@ -76,6 +76,19 @@ if (commandArgs[0] === 'attach') {
     const { runTerminalAttachCli } = await import('./terminal_attach.js');
     process.exit(await runTerminalAttachCli(commandArgs.slice(1)));
 }
+// The MCP server Claude Code and Codex panes start: stdio only, no agent, no TTY,
+// and nothing on stdout but the protocol.
+if (commandArgs[0] === 'workspace-mcp') {
+    try {
+        const { runWorkspaceMcpServer } = await import('./mcp/workspace_server.js');
+        await runWorkspaceMcpServer();
+    }
+    catch (error) {
+        console.error(`[ztc workspace-mcp] ${error.message}`);
+        process.exit(1);
+    }
+    process.exit(0);
+}
 // Adapters must be able to deliver receipts without starting an agent or a TTY.
 if (commandArgs[0] === 'inbox') {
     try {

package/dist/cli_ratatui.d.ts

@@ -420,6 +420,8 @@ export declare class RatatuiApp {
     private desktopMode;
     private desktopRuntime;
     private childPaneIds;
+    /** Panes running the user's own Claude Code or Codex, by pane id. */
+    private readonly agentCliPanes;
     private colonyPaneIds;
     /** Cache of latest pane list from pane_state events (including colony panes, filtered in switcher) */
     private knownPanes;
@@ -1290,6 +1292,14 @@ export declare class RatatuiApp {
      * working. Ctrl+B c does not come through here — that raises the chooser.
      */
     private handleCreatePaneRequest;
+    /**
+     * Open the user's own Claude Code or Codex in a pane: the chooser's and the
+     * desktop menu's entry point. Returns what to tell the user (an error or a
+     * notice), or null.
+     */
+    private spawnAgentCliPane;
+    /** Where the user's own `claude` and `codex` are installed, if they are. */
+    private installedAgentClis;
     /**
      * Create a ZTC agent pane on the user's behalf: no agent turn, no tool call.
      *

package/dist/cli_ratatui.js

@@ -5,6 +5,9 @@ import { reconcileOrderedTranscript } from './app/ordered_transcript.js';
 import { listCommandJobs, shutdownCommandJobs, subscribeCommandJobs } from './agent/runtime/command_jobs.js';
 import { CommandPaneManager, commandPaneText } from './agent/runtime/command_panes.js';
 import { waitForPaneCreatedOrError } from './agent/tools/pane.js';
+import { findAgentCli } from './panes/agent_cli.js';
+import { agentCliFromRequestId, formatAgentPaneMessage, openAgentPane, typeLineIntoPane } from './panes/agent_panes.js';
+import { agentCliFromChoice, newPaneChoices } from './panes/new_pane_choices.js';
 import { IntakeNotifications } from './intake/notifications.js';
 import { projectGoal } from './goal_contract.js';
 import { isToolResultMessage } from './utils/tool_result_message.js';
@@ -772,6 +775,8 @@ export class RatatuiApp {
     desktopMode = false;
     desktopRuntime;
     childPaneIds = new Set();
+    /** Panes running the user's own Claude Code or Codex, by pane id. */
+    agentCliPanes = new Map();
     colonyPaneIds = new Set();
     /** Cache of latest pane list from pane_state events (including colony panes, filtered in switcher) */
     knownPanes = [];
@@ -1468,6 +1473,13 @@ export class RatatuiApp {
                     debugLog(`[Mirror] Pane control via stdin (bare): pane=${paneId} cmd=${controlLine.slice(0, 60)}`);
                     this.tui.send({ type: 'write_pane', pane_id: paneId, input: controlLine, control: true });
                 });
+                // An agent's message for a Claude Code or Codex pane is typed in, one
+                // line saying who sent it, with Enter as its own keystroke.
+                this.mirrorServer.onAgentPaneMessage((paneId, msg) => {
+                    if (!this.agentCliPanes.has(paneId))
+                        return false;
+                    return typeLineIntoPane(this.tui, paneId, formatAgentPaneMessage(msg));
+                });
             }
             // Handle input from browser mirror (single-pane mode fallback)
             this.mirrorServer.onInput((input) => {
@@ -6793,6 +6805,9 @@ export class RatatuiApp {
             case 'pane_created': {
                 this.childPaneIds.add(event.pane_id);
                 this.notePaneCreated(event.pane_id, event.request_id);
+                const agentCli = agentCliFromRequestId(event.request_id);
+                if (agentCli)
+                    this.agentCliPanes.set(event.pane_id, agentCli);
                 const launchSpec = this.paneRegistry.get(event.pane_id)?.launchSpec
                     || this.paneRegistry.consumePendingCreate(event.request_id)
                     || this.resumedPaneSpecs.find((pane) => pane.paneId === event.pane_id)?.launchSpec;
@@ -6910,6 +6925,7 @@ export class RatatuiApp {
                 this.childPaneModels.delete(event.pane_id);
                 this.childPaneSessionIds.delete(event.pane_id);
                 this.colonyPaneIds.delete(event.pane_id);
+                this.agentCliPanes.delete(event.pane_id);
                 this.paneRegistry.remove(event.pane_id);
                 if (this.mirrorServer) {
                     this.mirrorServer.unregisterPane(event.pane_id);
@@ -12988,18 +13004,48 @@ export class RatatuiApp {
      * working. Ctrl+B c does not come through here — that raises the chooser.
      */
     handleCreatePaneRequest(event) {
-        void this.spawnZtcPane({
-            cwd: event.cwd,
-            direction: event.direction,
-            ratio: event.ratio,
-            target: event.target,
-            newWindow: event.new_window,
-        }).then((result) => {
+        const placement = { direction: event.direction, ratio: event.ratio, target: event.target, newWindow: event.new_window };
+        // The desktop app's new-pane menu names what it wants; no kind is a ZTC pane.
+        if (event.kind === 'shell') {
+            const error = this.spawnShellPane({ cwd: event.cwd, ...placement });
+            if (error)
+                this.addSystemMessage(`Could not open a shell pane: ${error}`);
+            return;
+        }
+        if (event.kind === 'claude_code' || event.kind === 'codex') {
+            void this.spawnAgentCliPane(event.kind === 'codex' ? 'codex' : 'claude', { cwd: event.cwd, ...placement })
+                .then((message) => { if (message)
+                this.addSystemMessage(message); });
+            return;
+        }
+        void this.spawnZtcPane({ cwd: event.cwd, ...placement }).then((result) => {
             if (result.error) {
                 debugLog(`[handleCreatePaneRequest] ${result.error}`);
             }
         });
     }
+    /**
+     * Open the user's own Claude Code or Codex in a pane: the chooser's and the
+     * desktop menu's entry point. Returns what to tell the user (an error or a
+     * notice), or null.
+     */
+    async spawnAgentCliPane(cli, options) {
+        if (!this.muxMode || this.paneMode)
+            return 'Opening Claude Code or Codex needs a zmux session or the desktop app.';
+        const result = await openAgentPane(this.tui, {
+            cli,
+            ...options,
+            cwd: options.cwd || this.shellCwd || process.cwd(),
+            findBinary: id => this.installedAgentClis()[id] ?? null,
+        });
+        if (result.notice)
+            this.addSystemMessage(result.notice);
+        return result.error ?? null;
+    }
+    /** Where the user's own `claude` and `codex` are installed, if they are. */
+    installedAgentClis() {
+        return { claude: findAgentCli('claude'), codex: findAgentCli('codex') };
+    }
     /**
      * Create a ZTC agent pane on the user's behalf: no agent turn, no tool call.
      *
@@ -13108,20 +13154,12 @@ export class RatatuiApp {
             return;
         }
         const ctx = this.buildCommandContext((msg) => this.controller.addMessage(msg));
-        const custom = customPaneOptions(configStore.get());
+        const choices = newPaneChoices(customPaneOptions(configStore.get()), this.installedAgentClis());
         ctx.select.showSelect({
             title: 'New pane',
             question: 'What should the new pane be?',
             type: 'select',
-            options: [
-                { value: 'bash', label: 'bash', description: 'A shell pane' },
-                { value: 'ztc', label: 'ZTC', description: 'A ZTC agent pane' },
-                ...custom.map((option, index) => ({
-                    value: `custom:${index}`,
-                    label: option.label,
-                    description: option.command,
-                })),
-            ],
+            options: choices,
         }, async (value) => {
             if (value === null || value === undefined)
                 return;
@@ -13145,6 +13183,9 @@ export class RatatuiApp {
             const result = await this.spawnZtcPane({ cwd });
             return result.error ?? null;
         }
+        const agentCli = agentCliFromChoice(choice);
+        if (agentCli)
+            return this.spawnAgentCliPane(agentCli, { cwd });
         if (choice.startsWith('custom:')) {
             const option = customPaneOptions(configStore.get())[Number(choice.slice('custom:'.length))];
             if (!option)
@@ -13179,6 +13220,10 @@ export class RatatuiApp {
             cwd,
             title,
             pane_type: 'process',
+            ...(options?.direction ? { direction: options.direction } : {}),
+            ...(options?.ratio !== undefined ? { ratio: options.ratio } : {}),
+            ...(options?.target !== undefined ? { target: options.target } : {}),
+            ...(options?.newWindow ? { new_window: true } : {}),
         })
             ? null
             : 'failed to create shell pane';

package/dist/mcp/workspace_server.d.ts

@@ -0,0 +1,44 @@
+/**
+ * `ztc workspace-mcp` — the MCP server attached to Claude Code and Codex panes.
+ *
+ * The CLI starts it from its session-scoped MCP config (see panes/agent_cli.ts).
+ * It reaches this workspace through the pane relay ($ZTC_PANE_RELAY) as pane
+ * $ZTC_PANE_ID, and gives the agent the workspace: list panes; open a ZTC
+ * agent, Claude Code, Codex or a shell; read a pane; type into one; message
+ * another agent; close a pane. Messages travel over ZTC's bus when the mirror
+ * is reachable, so ZTC panes receive them as messages from this pane;
+ * otherwise they are typed in with the sender's name.
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { type AgentCliId, type PaneProgram } from '../panes/agent_cli.js';
+import { type PaneCommandTransport } from '../ui/ratatui/pane_relay.js';
+export interface WorkspaceBusMessage {
+    from: {
+        id: number;
+        name: string;
+    };
+    to: number | 'all';
+    type: 'ztc_message';
+    text: string;
+}
+export interface WorkspaceBusSender {
+    send(message: WorkspaceBusMessage): Promise<void>;
+}
+export interface WorkspaceMcpOptions {
+    /** The pane relay; null outside a ZTC workspace (every tool then says so). */
+    transport: PaneCommandTransport | null;
+    ownPaneId: number | null;
+    bus?: WorkspaceBusSender | null;
+    findBinary?: (id: AgentCliId) => string | null;
+    /** The server to attach to agent panes this one opens. */
+    server?: PaneProgram | Error | null;
+    env?: NodeJS.ProcessEnv;
+    /** Working directory for panes opened without one. */
+    cwd?: string;
+}
+/** The MCP server, connected to a workspace through `transport`. */
+export declare function createWorkspaceMcpServer(options: WorkspaceMcpOptions): Server;
+/** Posts bus messages to the overseer's mirror, as MirrorClient does, without joining the bus. */
+export declare function mirrorBusSender(env?: NodeJS.ProcessEnv): WorkspaceBusSender | null;
+/** Entry point for `ztc workspace-mcp`: serve on stdio until the CLI closes it. */
+export declare function runWorkspaceMcpServer(env?: NodeJS.ProcessEnv): Promise<void>;