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

package/dist/panes/agent_cli.js

@@ -0,0 +1,295 @@
+/**
+ * Agent CLIs that run in ZTC panes under the user's own accounts.
+ *
+ * ZTC hosts Claude Code and Codex the way a terminal does: it runs the user's
+ * own, unmodified `claude` or `codex` binary in a pane, and the user signs in
+ * through that CLI's own flow. ZTC never reads, stores or forwards their
+ * credentials. (Anthropic's terms for Claude subscription sign-in:
+ * https://code.claude.com/docs/en/legal-and-compliance.)
+ *
+ * What ZTC adds is a session-scoped MCP server, `ztc workspace-mcp`, passed on
+ * the command line (Claude Code `--mcp-config`, Codex `-c mcp_servers.ztc.*`),
+ * so the agent can list, open, read, type into, message and close the other
+ * panes of the workspace. The user's own CLI configuration is never edited.
+ */
+import { accessSync, constants, existsSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, join } from 'node:path';
+import { resolveOwnedCliLaunch } from '../desktop/cli_launch.js';
+import { buildUserSubprocessEnvOverrides } from '../utils/subprocess_env.js';
+export const AGENT_CLIS = Object.freeze({
+    claude: {
+        id: 'claude',
+        label: 'Claude Code',
+        binary: 'claude',
+        setupUrl: 'https://code.claude.com/docs/en/setup',
+        install: 'curl -fsSL https://claude.ai/install.sh | bash',
+    },
+    codex: {
+        id: 'codex',
+        label: 'Codex',
+        binary: 'codex',
+        setupUrl: 'https://developers.openai.com/codex/cli',
+        install: 'npm install -g @openai/codex',
+    },
+});
+export const AGENT_CLI_IDS = Object.freeze(['claude', 'codex']);
+export function isAgentCliId(value) {
+    return AGENT_CLI_IDS.includes(value);
+}
+const SYSTEM_BIN_DIRS = ['/opt/homebrew/bin', '/usr/local/bin', '/usr/bin'];
+function isExecutableFile(path) {
+    try {
+        if (!statSync(path).isFile())
+            return false;
+        accessSync(path, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Where the installers put the launcher, checked when PATH lacks it: a desktop
+ * app started from Finder has a bare PATH, and the login shell a pane runs in
+ * never reads ~/.zshrc, where installers usually add ~/.local/bin.
+ */
+function installDirs(id, home, systemDirs) {
+    const dirs = [join(home, '.local', 'bin')];
+    if (id === 'claude')
+        dirs.push(join(home, '.claude', 'local'));
+    return [...dirs, ...systemDirs];
+}
+/** The absolute path of the user's `claude` or `codex`, or null when it is not installed. */
+export function findAgentCli(id, lookup = {}) {
+    const env = lookup.env ?? process.env;
+    const platform = lookup.platform ?? process.platform;
+    const home = lookup.home ?? homedir();
+    const names = platform === 'win32'
+        ? [`${AGENT_CLIS[id].binary}.exe`, `${AGENT_CLIS[id].binary}.cmd`]
+        : [AGENT_CLIS[id].binary];
+    const pathDirs = (env.PATH ?? '').split(platform === 'win32' ? ';' : ':').filter(Boolean);
+    for (const dir of [...pathDirs, ...installDirs(id, home, lookup.systemDirs ?? SYSTEM_BIN_DIRS)]) {
+        for (const name of names) {
+            const candidate = join(dir, name);
+            if (isExecutableFile(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}
+// ── Arguments ───────────────────────────────────────────────────────────────
+export class CliArgumentsError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CliArgumentsError';
+    }
+}
+/**
+ * Split words the way a POSIX shell does, without expanding anything: quotes
+ * group, a backslash escapes, and `$`, backticks, globs and `;` stay literal.
+ */
+export function splitCliArguments(raw) {
+    const words = [];
+    let word = '';
+    let inWord = false;
+    let quote = null;
+    for (let i = 0; i < raw.length; i++) {
+        const char = raw[i];
+        if (quote === "'") {
+            if (char === "'")
+                quote = null;
+            else
+                word += char;
+            continue;
+        }
+        if (quote === '"') {
+            if (char === '"') {
+                quote = null;
+            }
+            else if (char === '\\' && i + 1 < raw.length && '"\\$`\n'.includes(raw[i + 1])) {
+                i++;
+                if (raw[i] !== '\n')
+                    word += raw[i];
+            }
+            else {
+                word += char;
+            }
+            continue;
+        }
+        if (char === "'" || char === '"') {
+            quote = char;
+            inWord = true;
+        }
+        else if (char === '\\') {
+            if (i + 1 >= raw.length) {
+                word += char;
+                inWord = true;
+            }
+            else if (raw[i + 1] === '\n') {
+                i++; // line continuation
+            }
+            else {
+                word += raw[++i];
+                inWord = true;
+            }
+        }
+        else if (/\s/.test(char)) {
+            if (inWord) {
+                words.push(word);
+                word = '';
+                inWord = false;
+            }
+        }
+        else {
+            word += char;
+            inWord = true;
+        }
+    }
+    if (quote) {
+        throw new CliArgumentsError(`Unclosed ${quote === '"' ? 'double' : 'single'} quote in the arguments.`);
+    }
+    if (inWord)
+        words.push(word);
+    return words;
+}
+/** Words as a shell would accept them back: quoted only where needed. */
+export function formatCliArguments(words) {
+    return words
+        .map(word => (/^[A-Za-z0-9_@%+=:,./-]+$/.test(word) ? word : `'${word.replace(/'/g, `'\\''`)}'`))
+        .join(' ');
+}
+/**
+ * Read the text after `/claude` or `/codex`. Text that starts with a flag is
+ * the CLI's own arguments, split like a shell command line (`/claude
+ * --continue`, `/codex -m gpt-5 "review this"`). Anything else is the opening
+ * prompt, kept exactly as typed, apostrophes and all (`/claude don't touch the
+ * migrations`).
+ */
+export function parseAgentCommandBody(body) {
+    const text = body.trim();
+    if (!text)
+        return { words: [] };
+    if (text.startsWith('-'))
+        return { words: splitCliArguments(text) };
+    return { words: [], prompt: text };
+}
+export const WORKSPACE_MCP_SERVER_NAME = 'ztc';
+/**
+ * Variables the workspace server reads. Codex starts MCP servers with a short
+ * allowlist of variables, so these are named for it to forward; Claude Code
+ * passes its whole environment. They reach the pane through its environment,
+ * never its command line.
+ */
+export const WORKSPACE_MCP_ENV = Object.freeze([
+    'ZTC_PANE_ID',
+    'ZTC_PANE_RELAY',
+    'ZTC_MIRROR_PORT',
+    'ZTC_MIRROR_INTERNAL_TOKEN',
+    'ZTC_MIRROR_GROUP',
+    'ZTC_NAVIGATOR_GROUP',
+    'ZTC_PROFILE',
+]);
+function tomlString(value) {
+    return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/[\u0000-\u001f\u007f]/g, char => `\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`)}"`;
+}
+function tomlArray(values) {
+    return `[${values.map(tomlString).join(',')}]`;
+}
+/** The CLI's own arguments that attach the workspace server, or nothing without one. */
+export function workspaceMcpArgs(id, server) {
+    if (!server)
+        return [];
+    if (id === 'claude') {
+        return ['--mcp-config', JSON.stringify({
+                mcpServers: { [WORKSPACE_MCP_SERVER_NAME]: { type: 'stdio', command: server.command, args: server.args } },
+            })];
+    }
+    const key = `mcp_servers.${WORKSPACE_MCP_SERVER_NAME}`;
+    return [
+        '-c', `${key}.command=${tomlString(server.command)}`,
+        '-c', `${key}.args=${tomlArray(server.args)}`,
+        '-c', `${key}.env_vars=${tomlArray(WORKSPACE_MCP_ENV)}`,
+        '-c', `${key}.startup_timeout_sec=30`,
+    ];
+}
+/**
+ * The CLI's full argument list. Codex takes its overrides first, before any
+ * subcommand. Claude Code's `--mcp-config` takes several values, so it goes
+ * after the user's flags, ahead of a `--` they typed, and a prompt follows its
+ * own `--` so a prompt starting with "-" is never read as a flag.
+ */
+export function agentCliArgs(id, request, server) {
+    const attach = workspaceMcpArgs(id, server);
+    const prompt = request.prompt?.trim() ? ['--', request.prompt] : [];
+    if (id === 'codex')
+        return [...attach, ...request.words, ...prompt];
+    const separator = request.words.indexOf('--');
+    if (separator !== -1) {
+        return [...request.words.slice(0, separator), ...attach, ...request.words.slice(separator), ...(request.prompt?.trim() ? [request.prompt] : [])];
+    }
+    return [...request.words, ...attach, ...prompt];
+}
+const POSIX_SHELLS = new Set(['sh', 'bash', 'zsh', 'dash', 'ksh', 'mksh', 'yash', 'ash']);
+/**
+ * Run the binary from a login shell, as custom panes are, so PATH and the rest
+ * of the login environment apply. The binary and its arguments travel as
+ * separate argv entries (`exec "$0" "$@"`): no shell ever re-parses them, so
+ * quotes, `$` and `;` in a prompt arrive exactly as written. A shell outside
+ * the POSIX family (fish, nushell), or no shell at all, is replaced by /bin/sh
+ * for this one step.
+ */
+export function loginShellExec(binary, args, shell, platform = process.platform) {
+    if (platform === 'win32')
+        return { command: binary, args: [...args] };
+    const login = shell && POSIX_SHELLS.has(basename(shell)) ? shell : '/bin/sh';
+    return { command: login, args: ['-lc', 'exec "$0" "$@"', binary, ...args] };
+}
+/** "Claude Code", then "Claude Code 2", "Claude Code 3"… so every pane name stays unique. */
+export function nextPaneTitle(label, existing) {
+    const taken = new Set(existing.map(title => title.trim().toLowerCase()));
+    if (!taken.has(label.toLowerCase()))
+        return label;
+    for (let n = 2;; n++) {
+        const candidate = `${label} ${n}`;
+        if (!taken.has(candidate.toLowerCase()))
+            return candidate;
+    }
+}
+/**
+ * The pane's environment overrides: ZTC's control variables are cleared as for
+ * any user program, except what the workspace server needs to reach this
+ * workspace. Everything else is the user's own environment, untouched, so the
+ * CLI offers every sign-in method it normally would.
+ */
+export function agentPaneEnv(source = process.env) {
+    const env = buildUserSubprocessEnvOverrides();
+    for (const key of WORKSPACE_MCP_ENV) {
+        if (key === 'ZTC_PANE_ID')
+            continue; // the renderer sets each pane's own
+        const value = source[key];
+        if (value)
+            env[key] = value;
+    }
+    return env;
+}
+/**
+ * How to start `ztc workspace-mcp` from the running installation: the desktop
+ * app's own launcher, or this Node and entrypoint.
+ */
+export function workspaceMcpProgram(argv = process.argv) {
+    const owned = resolveOwnedCliLaunch(['workspace-mcp']);
+    if (owned)
+        return { command: owned.command, args: owned.args };
+    const script = argv[1] || '';
+    if (!/(^|[\\/])cli_(main|ratatui)\.(js|ts)$/.test(script)) {
+        return new Error('the running ZTC entrypoint is unknown');
+    }
+    if (script.endsWith('.ts')) {
+        const tsx = join(dirname(dirname(script)), 'node_modules', '.bin', process.platform === 'win32' ? 'tsx.cmd' : 'tsx');
+        if (!existsSync(tsx))
+            return new Error('tsx is not installed next to the ZTC sources');
+        return { command: tsx, args: [script, 'workspace-mcp'] };
+    }
+    return { command: process.execPath, args: [script, 'workspace-mcp'] };
+}

package/dist/panes/agent_panes.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Opening agent CLI panes, and typing messages into them.
+ *
+ * `/claude`, `/codex`, the Ctrl+B c chooser, the desktop app's new-pane menu
+ * and the workspace MCP server all open agent panes here, so every entry point
+ * launches the same way. The pane is created through whichever pane transport
+ * the process has: the overseer's renderer connection, or a child pane's relay.
+ */
+import type { PaneCommandTransport } from '../ui/ratatui/pane_relay.js';
+import type { SplitDirection } from '../ui/ratatui/protocol.js';
+import { type AgentCliId, type AgentLaunchRequest, type PaneProgram } from './agent_cli.js';
+/** Request ids of agent pane launches start with this, so the overseer can tell them apart. */
+export declare const AGENT_PANE_REQUEST_PREFIX = "agent-pane:";
+/** Which agent CLI a `create_pane` request id launched, if any. */
+export declare function agentCliFromRequestId(requestId: string | undefined): AgentCliId | null;
+export interface OpenAgentPaneOptions {
+    cli: AgentCliId;
+    request?: AgentLaunchRequest;
+    cwd?: string;
+    /** Pane name; defaults to the next free "Claude Code"/"Codex" name. */
+    title?: string;
+    direction?: SplitDirection;
+    ratio?: number;
+    target?: number;
+    newWindow?: boolean;
+    findBinary?: (id: AgentCliId) => string | null;
+    /** The workspace server to attach; an Error opens the pane without it. */
+    server?: PaneProgram | Error | null;
+    /** Source of SHELL and the workspace variables (default: this process). */
+    env?: NodeJS.ProcessEnv;
+}
+export interface OpenAgentPaneResult {
+    paneId?: number;
+    title?: string;
+    cwd?: string;
+    error?: string;
+    /** Set when the pane opened but something about it should be said. */
+    notice?: string;
+}
+/** Open the user's own `claude` or `codex` in a new pane, attached to this workspace. */
+export declare function openAgentPane(transport: PaneCommandTransport | null, options: OpenAgentPaneOptions): Promise<OpenAgentPaneResult>;
+interface PaneMessage {
+    from: {
+        id: number;
+        name: string;
+    };
+    text: string;
+}
+/**
+ * A bus message as it is typed into an agent pane: one line, saying who sent
+ * it and, for a question or request, how to answer.
+ */
+export declare function formatAgentPaneMessage(message: PaneMessage): string;
+/** Delay between typed text and its Enter for programs that read a burst of input as a paste. */
+export declare const TYPED_ENTER_DELAY_MS = 120;
+/**
+ * Type a line into a program that is not ZTC (an agent CLI or a shell), then
+ * press Enter as a separate keystroke.
+ */
+export declare function typeLineIntoPane(transport: PaneCommandTransport, paneId: number, line: string): boolean;
+export {};

package/dist/panes/agent_panes.js

@@ -0,0 +1,119 @@
+/**
+ * Opening agent CLI panes, and typing messages into them.
+ *
+ * `/claude`, `/codex`, the Ctrl+B c chooser, the desktop app's new-pane menu
+ * and the workspace MCP server all open agent panes here, so every entry point
+ * launches the same way. The pane is created through whichever pane transport
+ * the process has: the overseer's renderer connection, or a child pane's relay.
+ */
+import { randomUUID } from 'node:crypto';
+import { listWorkspacePanes, waitForPaneCreatedOrError } from '../agent/tools/pane.js';
+import { AGENT_CLIS, agentCliArgs, agentPaneEnv, findAgentCli, isAgentCliId, loginShellExec, nextPaneTitle, workspaceMcpProgram, } from './agent_cli.js';
+import { sessionNamePaneTitle } from './labels.js';
+/** Request ids of agent pane launches start with this, so the overseer can tell them apart. */
+export const AGENT_PANE_REQUEST_PREFIX = 'agent-pane:';
+/** Which agent CLI a `create_pane` request id launched, if any. */
+export function agentCliFromRequestId(requestId) {
+    if (!requestId?.startsWith(AGENT_PANE_REQUEST_PREFIX))
+        return null;
+    const id = requestId.slice(AGENT_PANE_REQUEST_PREFIX.length).split(':')[0] ?? '';
+    return isAgentCliId(id) ? id : null;
+}
+const NEEDS_PANES = 'needs ZTC\'s panes: start ZTC with zmux (plain `ztc`) or use the desktop app';
+async function existingTitles(transport) {
+    const panes = await listWorkspacePanes(transport, 3000);
+    return panes instanceof Error ? [] : panes.map(pane => pane.labels?.manual_title || pane.title);
+}
+/** Open the user's own `claude` or `codex` in a new pane, attached to this workspace. */
+export async function openAgentPane(transport, options) {
+    const spec = AGENT_CLIS[options.cli];
+    if (!transport || !transport.isMuxMode)
+        return { error: `${spec.label} opens in a pane, which ${NEEDS_PANES}.` };
+    const binary = (options.findBinary ?? findAgentCli)(options.cli);
+    if (!binary) {
+        return { error: `${spec.label} is not installed. Install it from ${spec.setupUrl}, for example with \`${spec.install}\`, then try again.` };
+    }
+    const env = options.env ?? process.env;
+    const server = options.server === undefined ? workspaceMcpProgram() : options.server;
+    const attached = server && !(server instanceof Error) ? server : null;
+    const title = options.title?.trim() || nextPaneTitle(spec.label, await existingTitles(transport));
+    const program = loginShellExec(binary, agentCliArgs(options.cli, options.request ?? { words: [] }, attached), env.SHELL);
+    const requestId = `${AGENT_PANE_REQUEST_PREFIX}${options.cli}:${randomUUID()}`;
+    const created = waitForPaneCreatedOrError(transport, { requestId }, 15000);
+    const sent = transport.send({
+        type: 'create_pane',
+        request_id: requestId,
+        command: program.command,
+        args: program.args,
+        ...(options.cwd ? { cwd: options.cwd } : {}),
+        title,
+        pane_type: 'command',
+        ...(options.direction ? { direction: options.direction } : {}),
+        ...(options.ratio !== undefined ? { ratio: options.ratio } : {}),
+        ...(options.target !== undefined ? { target: options.target } : {}),
+        ...(options.newWindow ? { new_window: true } : {}),
+        env: agentPaneEnv(env),
+    });
+    if (!sent) {
+        created.catch(() => { });
+        return { error: `Could not open ${spec.label}: the renderer is not connected.` };
+    }
+    let event;
+    try {
+        event = await created;
+    }
+    catch (error) {
+        return { error: `Could not open ${spec.label}: no pane appeared (${error.message}).` };
+    }
+    if (event.type === 'error')
+        return { error: `Could not open ${spec.label}: the renderer refused the pane (${event.message}).` };
+    if (event.type !== 'pane_created')
+        return { error: `Could not open ${spec.label}: unexpected response from the renderer.` };
+    // The CLI sets its own terminal title as it works; the pane keeps its name.
+    transport.send(sessionNamePaneTitle(event.pane_id, title));
+    const result = { paneId: event.pane_id, title };
+    if (options.cwd)
+        result.cwd = options.cwd;
+    if (!attached) {
+        const why = server instanceof Error ? server.message : 'none was given';
+        result.notice = `${title} opened without ZTC's workspace tools (${why}), so it cannot open or message other panes.`;
+    }
+    return result;
+}
+/**
+ * A bus message as it is typed into an agent pane: one line, saying who sent
+ * it and, for a question or request, how to answer.
+ */
+export function formatAgentPaneMessage(message) {
+    let text = message.text;
+    let kind = 'Message';
+    try {
+        const parsed = JSON.parse(text);
+        if (parsed && parsed.__ztc_request === true && typeof parsed.text === 'string') {
+            text = parsed.text;
+            kind = parsed.kind === 'request' ? 'Request' : 'Question';
+        }
+    }
+    catch {
+        // Plain text.
+    }
+    const line = text.replace(/\s*[\r\n]+\s*/g, ' ').trim();
+    const who = `${message.from.name} (pane ${message.from.id})`;
+    return kind === 'Message'
+        ? `[Message from ${who}] ${line}`
+        : `[${kind} from ${who} — answer with the ztc send_message tool, to: ${message.from.id}] ${line}`;
+}
+/** Delay between typed text and its Enter for programs that read a burst of input as a paste. */
+export const TYPED_ENTER_DELAY_MS = 120;
+/**
+ * Type a line into a program that is not ZTC (an agent CLI or a shell), then
+ * press Enter as a separate keystroke.
+ */
+export function typeLineIntoPane(transport, paneId, line) {
+    if (!transport.send({ type: 'write_pane', pane_id: paneId, input: line, submit: false }))
+        return false;
+    setTimeout(() => {
+        transport.send({ type: 'write_pane', pane_id: paneId, input: '\r', submit: false });
+    }, TYPED_ENTER_DELAY_MS);
+    return true;
+}

package/dist/panes/new_pane_choices.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The rows of the new-pane chooser (Ctrl+B c): a shell, a ZTC agent, the
+ * agent CLIs the user has installed, then their own custom options.
+ */
+import type { CustomPaneOption } from '../config/types.js';
+import { type AgentCliId } from './agent_cli.js';
+export interface NewPaneChoice {
+    value: string;
+    label: string;
+    description: string;
+}
+/** `agent:claude` and `agent:codex` name the agent CLI rows. */
+export declare function agentCliFromChoice(value: string): AgentCliId | null;
+export declare function newPaneChoices(custom: readonly CustomPaneOption[], installed: Partial<Record<AgentCliId, string | null>>): NewPaneChoice[];

package/dist/panes/new_pane_choices.js

@@ -0,0 +1,36 @@
+/**
+ * The rows of the new-pane chooser (Ctrl+B c): a shell, a ZTC agent, the
+ * agent CLIs the user has installed, then their own custom options.
+ */
+import { basename } from 'node:path';
+import { AGENT_CLIS, AGENT_CLI_IDS } from './agent_cli.js';
+/** `agent:claude` and `agent:codex` name the agent CLI rows. */
+export function agentCliFromChoice(value) {
+    const id = value.startsWith('agent:') ? value.slice('agent:'.length) : '';
+    return AGENT_CLI_IDS.includes(id) ? id : null;
+}
+function runsBinary(command, binary) {
+    const first = command.trim().split(/\s+/)[0] ?? '';
+    return basename(first) === binary;
+}
+export function newPaneChoices(custom, installed) {
+    const choices = [
+        { value: 'bash', label: 'bash', description: 'A shell pane' },
+        { value: 'ztc', label: 'ZTC', description: 'A ZTC agent pane' },
+    ];
+    for (const id of AGENT_CLI_IDS) {
+        const spec = AGENT_CLIS[id];
+        // Not installed, or already offered by the user's own custom option.
+        if (!installed[id] || custom.some(option => runsBinary(option.command, spec.binary)))
+            continue;
+        choices.push({
+            value: `agent:${id}`,
+            label: spec.label,
+            description: `${spec.label} on your own account, with ZTC's pane and message tools`,
+        });
+    }
+    custom.forEach((option, index) => {
+        choices.push({ value: `custom:${index}`, label: option.label, description: option.command });
+    });
+    return choices;
+}

package/dist/ui/ratatui/protocol.d.ts

@@ -51,6 +51,8 @@ export interface PaneLabels {
     group?: string;
     pinned?: boolean;
 }
+/** What a renderer's new-pane menu asks the owner to open; absent means a ZTC pane. */
+export type PaneRequestKind = 'ztc' | 'shell' | 'claude_code' | 'codex';
 export interface PaneInfo {
     id: number;
     title: string;
@@ -533,6 +535,7 @@ export type RustEvent = DesktopTaskAction | DesktopRuntimeAction | DesktopSessio
     target?: number;
     new_window?: boolean;
     cwd?: string;
+    kind?: PaneRequestKind;
 } | {
     type: 'pane_created';
     pane_id: number;

package/dist/web/mirror_stream.d.ts

@@ -418,6 +418,7 @@ export declare class MirrorStreamServer implements MirrorPublisher {
     private multiPaneMode;
     private paneInputCallback;
     private paneControlCallback;
+    private agentPaneMessageCallback;
     private muxCommandCallback;
     private supervisionCommandCallback;
     private paneViewportCallback;
@@ -641,6 +642,12 @@ export declare class MirrorStreamServer implements MirrorPublisher {
      */
     onPaneInput(cb: (paneId: number, input: MessageInput) => void): void;
     onPaneControl(cb: (paneId: number, controlLine: string) => void): void;
+    /**
+     * Claim messages for panes that run another agent CLI (Claude Code, Codex).
+     * The callback returns true when it delivered the message (the owner types
+     * it into the pane with its sender); false leaves the usual fallbacks.
+     */
+    onAgentPaneMessage(cb: (paneId: number, msg: BusMessage) => boolean): void;
     onMuxCommand(cb: (command: MirrorMuxCommand) => Promise<MirrorMuxCommandResult>): void;
     onSupervisionCommand(cb: (command: MirrorSupervisionCommand) => Promise<MirrorSupervisionCommandResult>): void;
     onPaneViewport(cb: (paneId: number, ansi?: boolean) => Promise<MirrorPaneViewportResult>): void;

package/dist/web/mirror_stream.js

@@ -167,6 +167,7 @@ export class MirrorStreamServer {
     // rather than replaying it to the LLM. Kept separate from paneInputCallback (the
     // user-prompt channel) so the two can never be confused by content.
     paneControlCallback = null;
+    agentPaneMessageCallback = null;
     muxCommandCallback = null;
     supervisionCommandCallback = null;
     paneViewportCallback = null;
@@ -558,6 +559,14 @@ export class MirrorStreamServer {
     onPaneControl(cb) {
         this.paneControlCallback = cb;
     }
+    /**
+     * Claim messages for panes that run another agent CLI (Claude Code, Codex).
+     * The callback returns true when it delivered the message (the owner types
+     * it into the pane with its sender); false leaves the usual fallbacks.
+     */
+    onAgentPaneMessage(cb) {
+        this.agentPaneMessageCallback = cb;
+    }
     onMuxCommand(cb) {
         this.muxCommandCallback = cb;
     }
@@ -724,6 +733,14 @@ export class MirrorStreamServer {
                     return;
                 }
             }
+            // A pane running Claude Code or Codex has no bus connection: the owner
+            // types an agent's message into it, saying who sent it.
+            if (typeof targetId === 'number' && targetId !== 0 && msg.type === 'ztc_message'
+                && this.agentPaneMessageCallback?.(targetId, msg)) {
+                if (process.env.ZTC_DEBUG)
+                    process.stderr.write(`${tag} delivered to an agent CLI pane\n`);
+                return;
+            }
             // Headless ZTC pane children read input from their own stdin — they have no
             // bus callback or SSE connection.
             // A ztc_message is an internal control command ({"__ztc_cmd":...}), NOT user

package/dist/zlm-embed.mjs

@@ -78502,7 +78502,7 @@ var invokeSkillTool = makeInvokeSkillTool(resolveAmbientSkills);
 // src/zlm.ts
 var ZLM_EMBED_API_VERSION = "zerglang.ztc-embed/1";
 var ZLM_STDIO_PROTOCOL = "zerglang.ztc-host/1";
-var ZLM_ZTC_VERSION = true ? "0.9.0-beta.1" : "development";
+var ZLM_ZTC_VERSION = true ? "0.10.0-beta.1" : "development";
 var ZLM_MAX_HOST_TOOLS = 64;
 var ZLM_MAX_SYSTEM_PROMPT_BYTES = 128 * 1024;
 var ZLM_HOST_APPROVAL_CAPABILITIES = Object.freeze([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zergai/ztc",
-  "version": "0.9.0-beta.1",
+  "version": "0.10.0-beta.1",
   "description": "Zerg Terminal Client - CLI agent for continual AI systems",
   "license": "SEE LICENSE IN LICENSE.md",
   "homepage": "https://zergai.com/docs/ztc",
@@ -277,7 +277,7 @@
   "zergRelease": {
     "branch": "main",
     "channel": "next",
-    "sourceCommit": "eac530d341d6b7057b5fcc242ce3d9c835ceeeb1",
+    "sourceCommit": "f987bf5a7f5b3b8c9b6ed6e5ace077242bdb2be6",
     "sourceVersion": "0.2.0-canary.2"
   },
   "publishConfig": {