@zergai/ztc 0.10.0-beta.1 → 0.10.1-dev.202611052216

package/README.md

@@ -1357,6 +1357,34 @@ Codex pane is typed into it as `[Message from ben (pane 2)] …` (a question als
 says how to answer), and the answer comes back as a message from that pane.
 Broadcasts to `all` reach ZTC agents only.
 
+#### Sign-in profiles of ZTC's own
+
+`/claude @work …` and `/codex @work …` open the pane on a ZTC profile named
+`work`: a config directory of its own under `~/.ztc/agent-profiles/<cli>/`,
+handed to the CLI through its documented variable (`CLAUDE_CONFIG_DIR`,
+`CODEX_HOME`). The first time, the CLI asks you to sign in, with its own login;
+it keeps that sign-in in the profile, so the CLI's sign-in in iTerm or Ghostty
+doesn't change. Codex panes on a profile keep their sign-in in the profile's
+files (`cli_auth_credentials_store="file"`). `/subs` lists your profiles, and
+`/subs use claude|codex [profile]` sets the one new panes start on (no profile:
+the CLI's own sign-in). ZTC never reads what a CLI stores in a profile and
+never moves a pane to another profile on its own. A profile starts without your
+usual CLI settings, MCP servers or plugins, since those live in the CLI's
+default config directory.
+
+#### In Zerg Router's Command Central
+
+With MotSi installed and its remote view on (`motsi remote view on`), ZTC
+starts the panes it opens — ZTC agents, Claude Code, Codex, shells and custom
+panes — through `motsi run --title=<pane name> --`. Zerg Router's Command
+Central then lists each pane under its name and shows it live as a real
+terminal. MotSi redacts likely secrets on this computer before anything leaves
+it, and lets a viewer type only into an agent (Claude Code, Codex or ZTC),
+never into a shell. Nothing leaves the computer while MotSi's remote view is
+off. To start panes without MotSi, set `panes.remoteView` to `false` in ZTC's
+config. The pane ZTC itself starts in is not one ZTC opens; to share it, start
+ZTC as `motsi run -- ztc`.
+
 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

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

@@ -15,6 +15,8 @@ export interface AgentCliCommandDeps {
     findBinary?: (id: AgentCliId) => string | null;
     server?: () => PaneProgram | Error;
     env?: () => NodeJS.ProcessEnv;
+    /** `motsi` to start the pane through; default: MotSi's remote view (see panes/motsi.ts). */
+    motsi?: () => string | null;
 }
 export declare function createAgentCliCommand(id: AgentCliId, deps?: AgentCliCommandDeps): Command;
 export declare const claudeCommand: Command;

package/dist/agent/commands/agent_cli.js

@@ -48,6 +48,7 @@ export function createAgentCliCommand(id, deps = {}) {
                 findBinary: deps.findBinary ?? findAgentCli,
                 server: (deps.server ?? workspaceMcpProgram)(),
                 env: (deps.env ?? (() => process.env))(),
+                ...(deps.motsi ? { motsi: deps.motsi() } : {}),
             });
             if (result.error) {
                 ctx.addMessage({ role: 'system', content: result.error });

package/dist/agent/commands/index.js

@@ -31,6 +31,7 @@ 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 { subsCommand } from './subs.js';
 import { diffCommand } from './diff.js';
 import { rawCommand } from './raw.js';
 import { themeCommand } from './theme.js';
@@ -83,7 +84,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, 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);
+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, subsCommand, 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/commands/subs.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `/subs` — ZTC's sign-in profiles for Claude Code and Codex panes, and which
+ * one new panes start on.
+ *
+ * A profile keeps the CLI's own sign-in in a directory of ZTC's (see
+ * panes/agent_profiles.ts), so choosing one here never changes the CLI's
+ * sign-in in iTerm or Ghostty. Nothing switches on its own: the user picks.
+ */
+import type { Command } from './types.js';
+export interface SubsCommandDeps {
+    home?: () => string;
+}
+export declare function createSubsCommand(deps?: SubsCommandDeps): Command;
+export declare const subsCommand: Command;

package/dist/agent/commands/subs.js

@@ -0,0 +1,64 @@
+/**
+ * `/subs` — ZTC's sign-in profiles for Claude Code and Codex panes, and which
+ * one new panes start on.
+ *
+ * A profile keeps the CLI's own sign-in in a directory of ZTC's (see
+ * panes/agent_profiles.ts), so choosing one here never changes the CLI's
+ * sign-in in iTerm or Ghostty. Nothing switches on its own: the user picks.
+ */
+import { homedir } from 'node:os';
+import { AGENT_CLIS } from '../../panes/agent_cli.js';
+import { ensureAgentProfile, isProfileName, listAgentProfiles } from '../../panes/agent_profiles.js';
+const USAGE = 'Usage: /subs  ·  /subs use claude|codex [profile]  (no profile: the CLI\'s own sign-in)';
+export function createSubsCommand(deps = {}) {
+    return {
+        name: 'subs',
+        description: 'Show and choose the sign-in profiles Claude Code and Codex panes start on',
+        usage: '[use <claude|codex> [profile]]',
+        handler: async (args, ctx) => {
+            const home = (deps.home ?? homedir)();
+            const panes = ctx.config.get().panes ?? {};
+            const chosen = panes.agentProfiles ?? {};
+            if (args.length === 0) {
+                const lines = ['claude', 'codex'].map(cli => {
+                    const label = AGENT_CLIS[cli].label;
+                    const profiles = listAgentProfiles(cli, home);
+                    const using = chosen[cli] ? `the "${chosen[cli]}" profile` : `${label}'s own sign-in`;
+                    const known = profiles.length > 0 ? `Profiles: ${profiles.join(', ')}.` : 'No ZTC profiles yet.';
+                    return `${label}: new panes use ${using}. ${known}`;
+                });
+                lines.push('Open one on a profile with /claude @<profile> or /codex @<profile>, and sign in there the first time; '
+                    + 'the CLI keeps that sign-in in ZTC\'s profile, so iTerm and Ghostty keep theirs. /subs use claude|codex [profile] sets the default.');
+                ctx.addMessage({ role: 'system', content: lines.join('\n') });
+                return;
+            }
+            const cli = args[1];
+            if (args[0] !== 'use' || (cli !== 'claude' && cli !== 'codex') || args.length > 3) {
+                ctx.addMessage({ role: 'system', content: USAGE });
+                return;
+            }
+            const label = AGENT_CLIS[cli].label;
+            const name = args[2];
+            const next = { ...chosen };
+            if (name) {
+                if (!isProfileName(name)) {
+                    ctx.addMessage({ role: 'system', content: `"${name}" is not a profile name: use letters, digits, ".", "_" or "-", up to 32.` });
+                    return;
+                }
+                ensureAgentProfile(cli, name, home);
+                next[cli] = name;
+            }
+            else {
+                delete next[cli];
+            }
+            ctx.config.set('panes', { ...panes, agentProfiles: next });
+            ctx.addMessage({
+                role: 'system',
+                content: name
+                    ? `New ${label} panes use the "${name}" profile. Sign in there the first time one opens; ${label}'s sign-in in other terminals doesn't change.`
+                    : `New ${label} panes use ${label}'s own sign-in.`,
+            });
+        },
+    };
+}
+export const subsCommand = createSubsCommand();

package/dist/cli_ratatui.d.ts

@@ -1300,6 +1300,12 @@ export declare class RatatuiApp {
     private spawnAgentCliPane;
     /** Where the user's own `claude` and `codex` are installed, if they are. */
     private installedAgentClis;
+    /**
+     * The `motsi` that panes start through so Zerg Router's Command Central can
+     * show them, or null: MotSi installed, its remote view on, and
+     * `panes.remoteView` not false (see panes/motsi.ts).
+     */
+    private paneMotsi;
     /**
      * Create a ZTC agent pane on the user's behalf: no agent turn, no tool call.
      *

package/dist/cli_ratatui.js

@@ -8,6 +8,7 @@ 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 { MOTSI_PANE_ENV, remoteViewMotsi, throughMotsi } from './panes/motsi.js';
 import { IntakeNotifications } from './intake/notifications.js';
 import { projectGoal } from './goal_contract.js';
 import { isToolResultMessage } from './utils/tool_result_message.js';
@@ -13037,6 +13038,7 @@ export class RatatuiApp {
             ...options,
             cwd: options.cwd || this.shellCwd || process.cwd(),
             findBinary: id => this.installedAgentClis()[id] ?? null,
+            motsi: this.paneMotsi(),
         });
         if (result.notice)
             this.addSystemMessage(result.notice);
@@ -13046,6 +13048,14 @@ export class RatatuiApp {
     installedAgentClis() {
         return { claude: findAgentCli('claude'), codex: findAgentCli('codex') };
     }
+    /**
+     * The `motsi` that panes start through so Zerg Router's Command Central can
+     * show them, or null: MotSi installed, its remote view on, and
+     * `panes.remoteView` not false (see panes/motsi.ts).
+     */
+    paneMotsi() {
+        return remoteViewMotsi(configStore.get().panes);
+    }
     /**
      * Create a ZTC agent pane on the user's behalf: no agent turn, no tool call.
      *
@@ -13096,11 +13106,13 @@ export class RatatuiApp {
         // leaving the user waiting out the timeout on a failed launch.
         (event) => event.type === 'error'
             || (event.type === 'pane_created' && event.request_id === requestId), 15000);
+        const motsi = this.paneMotsi();
+        const launched = motsi ? throughMotsi(motsi, title, child) : child;
         const sent = this.tui.send({
             type: 'create_pane',
             request_id: requestId,
-            command: child.command,
-            args: child.args,
+            command: launched.command,
+            args: launched.args,
             cwd: child.cwd,
             title,
             pane_type: 'ztc',
@@ -13108,7 +13120,11 @@ export class RatatuiApp {
             ratio: options?.ratio ?? 0.5,
             target: options?.target,
             new_window: options?.newWindow,
-            env: { ...this.childZtcPaneEnv(), ...(captured ? { ZTC_INITIAL_PANE_INPUT: captured.path } : {}) },
+            env: {
+                ...this.childZtcPaneEnv(),
+                ...(captured ? { ZTC_INITIAL_PANE_INPUT: captured.path } : {}),
+                ...(motsi ? MOTSI_PANE_ENV : {}),
+            },
         });
         if (!sent) {
             created.catch(() => { });
@@ -13204,10 +13220,12 @@ export class RatatuiApp {
         const requestId = `create-shell-${generateSessionId()}`;
         const cwd = options?.cwd || this.shellCwd || process.cwd();
         const title = options?.title || 'Shell';
+        const motsi = this.paneMotsi();
+        const launched = motsi ? throughMotsi(motsi, title, { command: shellCommand, args: [] }) : { command: shellCommand, args: [] };
         this.trackPendingPaneLaunch(requestId, {
             kind: 'process',
-            command: shellCommand,
-            args: [],
+            command: launched.command,
+            args: launched.args,
             cwd,
             title,
             paneType: 'process',
@@ -13215,11 +13233,12 @@ export class RatatuiApp {
         return this.tui.send({
             type: 'create_pane',
             request_id: requestId,
-            command: shellCommand,
-            args: [],
+            command: launched.command,
+            args: launched.args,
             cwd,
             title,
             pane_type: 'process',
+            ...(motsi ? { env: { ...MOTSI_PANE_ENV } } : {}),
             ...(options?.direction ? { direction: options.direction } : {}),
             ...(options?.ratio !== undefined ? { ratio: options.ratio } : {}),
             ...(options?.target !== undefined ? { target: options.target } : {}),
@@ -13244,10 +13263,12 @@ export class RatatuiApp {
         const requestId = `create-command-${generateSessionId()}`;
         const cwd = options?.cwd || this.shellCwd || process.cwd();
         const title = options?.title || fallbackTitle;
+        const motsi = this.paneMotsi();
+        const launched = motsi ? throughMotsi(motsi, title, { command: shellCommand, args: shellArgs }) : { command: shellCommand, args: shellArgs };
         this.trackPendingPaneLaunch(requestId, {
             kind: 'process',
-            command: shellCommand,
-            args: shellArgs,
+            command: launched.command,
+            args: launched.args,
             cwd,
             title,
             paneType: 'command',
@@ -13255,11 +13276,12 @@ export class RatatuiApp {
         return this.tui.send({
             type: 'create_pane',
             request_id: requestId,
-            command: shellCommand,
-            args: shellArgs,
+            command: launched.command,
+            args: launched.args,
             cwd,
             title,
             pane_type: 'command',
+            ...(motsi ? { env: { ...MOTSI_PANE_ENV } } : {}),
         })
             ? null
             : 'failed to create command pane';

package/dist/config/types.d.ts

@@ -279,6 +279,14 @@ export interface CustomPaneOption {
 export interface PanesSettings {
     /** Extra chooser rows, in the order they are offered. */
     custom?: CustomPaneOption[];
+    /**
+     * Start panes through MotSi (`motsi run`) so Zerg Router's Command Central
+     * can show them. Unset: whenever MotSi is installed and its remote view is
+     * on. False: never.
+     */
+    remoteView?: boolean;
+    /** The ZTC sign-in profile new Claude Code / Codex panes start on; unset for the CLI's own sign-in. */
+    agentProfiles?: Partial<Record<'claude' | 'codex', string>>;
 }
 /**
  * Which rule triggers auto-compaction. `percent` watches the model's context

package/dist/mcp/workspace_server.d.ts

@@ -35,6 +35,8 @@ export interface WorkspaceMcpOptions {
     env?: NodeJS.ProcessEnv;
     /** Working directory for panes opened without one. */
     cwd?: string;
+    /** `motsi` to start panes through (Zerg Router's Command Central); null for none; default: MotSi's remote view. */
+    motsi?: string | null;
 }
 /** The MCP server, connected to a workspace through `transport`. */
 export declare function createWorkspaceMcpServer(options: WorkspaceMcpOptions): Server;

package/dist/mcp/workspace_server.js

@@ -18,6 +18,8 @@ import { childZtcPaneEnv, closeTerminalPaneTool, listWorkspacePanes, readTermina
 import { AGENT_CLIS, findAgentCli, nextPaneTitle, workspaceMcpProgram } from '../panes/agent_cli.js';
 import { TYPED_ENTER_DELAY_MS, formatAgentPaneMessage, openAgentPane } from '../panes/agent_panes.js';
 import { sessionNamePaneTitle } from '../panes/labels.js';
+import { MOTSI_PANE_ENV, remoteViewMotsi, throughMotsi } from '../panes/motsi.js';
+import { configStore } from '../config.js';
 import { buildZtcPaneLaunchCommand, createZtcLaunchSpec } from '../panes/ztc_launch.js';
 import { PaneRelayClient } from '../ui/ratatui/pane_relay.js';
 import { buildUserSubprocessEnvOverrides } from '../utils/subprocess_env.js';
@@ -117,6 +119,8 @@ const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 export function createWorkspaceMcpServer(options) {
     const { transport, ownPaneId } = options;
     const env = options.env ?? process.env;
+    // Panes this agent opens show in Zerg Router's Command Central too, when MotSi's remote view is on.
+    const paneMotsi = () => (options.motsi !== undefined ? options.motsi : remoteViewMotsi(configStore.get().panes, { env }));
     if (transport) {
         setPaneToolsTuiProcess(transport);
         if (ownPaneId !== null)
@@ -184,18 +188,21 @@ export function createWorkspaceMcpServer(options) {
         const requestId = `ztc-pane-${randomUUID()}`;
         const created = waitForPaneCreatedOrError(tui, { requestId }, 15000);
         const placement = placementOf(args.placement, ownPaneId);
+        const motsi = paneMotsi();
+        const child = { command: built.command, args: task ? [...built.args, '--', task] : built.args };
+        const launched = motsi ? throughMotsi(motsi, title, child) : child;
         const sent = tui.send({
             type: 'create_pane',
             request_id: requestId,
-            command: built.command,
-            args: task ? [...built.args, '--', task] : built.args,
+            command: launched.command,
+            args: launched.args,
             cwd: built.cwd || cwd,
             title,
             pane_type: 'ztc',
             ...(placement.direction ? { direction: placement.direction, ratio: 0.5 } : {}),
             ...(placement.target !== undefined ? { target: placement.target } : {}),
             ...(placement.newWindow ? { new_window: true } : {}),
-            env: childZtcPaneEnv(),
+            env: { ...childZtcPaneEnv(), ...(motsi ? MOTSI_PANE_ENV : {}) },
         });
         if (!sent) {
             created.catch(() => { });
@@ -216,18 +223,21 @@ export function createWorkspaceMcpServer(options) {
         const requestId = `create-shell-${randomUUID()}`;
         const created = waitForPaneCreatedOrError(tui, { requestId }, 15000);
         const placement = placementOf(args.placement, ownPaneId);
+        const motsi = paneMotsi();
+        const shell = { command: env.SHELL || '/bin/sh', args: [] };
+        const launched = motsi ? throughMotsi(motsi, title, shell) : shell;
         const sent = tui.send({
             type: 'create_pane',
             request_id: requestId,
-            command: env.SHELL || '/bin/sh',
-            args: [],
+            command: launched.command,
+            args: launched.args,
             cwd,
             title,
             pane_type: 'process',
             ...(placement.direction ? { direction: placement.direction, ratio: 0.5 } : {}),
             ...(placement.target !== undefined ? { target: placement.target } : {}),
             ...(placement.newWindow ? { new_window: true } : {}),
-            env: buildUserSubprocessEnvOverrides(),
+            env: { ...buildUserSubprocessEnvOverrides(), ...(motsi ? MOTSI_PANE_ENV : {}) },
         });
         if (!sent) {
             created.catch(() => { });
@@ -278,6 +288,7 @@ export function createWorkspaceMcpServer(options) {
                 findBinary: options.findBinary ?? findAgentCli,
                 server: options.server === undefined ? workspaceMcpProgram(process.argv.slice(0, 2)) : options.server,
                 env,
+                motsi: paneMotsi(),
             });
             if (result.error)
                 throw new ToolError(result.error);

package/dist/panes/agent_cli.d.ts

@@ -46,17 +46,19 @@ export declare class CliArgumentsError extends Error {
 export declare function splitCliArguments(raw: string): string[];
 /** Words as a shell would accept them back: quoted only where needed. */
 export declare function formatCliArguments(words: readonly string[]): string;
-/** What to start the CLI with: its own flags, an opening prompt, or both. */
+/** What to start the CLI with: its own flags, an opening prompt, or both, on a ZTC profile or not. */
 export interface AgentLaunchRequest {
     words: string[];
     prompt?: string;
+    /** A ZTC sign-in profile (see panes/agent_profiles.ts). */
+    profile?: string;
 }
 /**
- * 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`).
+ * Read the text after `/claude` or `/codex`. A leading `@name` picks a ZTC
+ * sign-in profile. 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 declare function parseAgentCommandBody(body: string): AgentLaunchRequest;
 export interface PaneProgram {

package/dist/panes/agent_cli.js

@@ -16,6 +16,7 @@ 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 { isProfileName } from './agent_profiles.js';
 import { buildUserSubprocessEnvOverrides } from '../utils/subprocess_env.js';
 export const AGENT_CLIS = Object.freeze({
     claude: {
@@ -160,19 +161,29 @@ export function formatCliArguments(words) {
         .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`).
+ * Read the text after `/claude` or `/codex`. A leading `@name` picks a ZTC
+ * sign-in profile. 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();
+    let text = body.trim();
+    let profile;
+    const named = /^@(\S+)(?:\s+|$)/.exec(text);
+    if (named) {
+        profile = named[1];
+        if (!isProfileName(profile)) {
+            throw new CliArgumentsError(`"${profile}" is not a profile name: use letters, digits, ".", "_" or "-", up to 32.`);
+        }
+        text = text.slice(named[0].length).trim();
+    }
+    const withProfile = (request) => (profile ? { ...request, profile } : request);
     if (!text)
-        return { words: [] };
+        return withProfile({ words: [] });
     if (text.startsWith('-'))
-        return { words: splitCliArguments(text) };
-    return { words: [], prompt: text };
+        return withProfile({ words: splitCliArguments(text) });
+    return withProfile({ words: [], prompt: text });
 }
 export const WORKSPACE_MCP_SERVER_NAME = 'ztc';
 /**

package/dist/panes/agent_panes.d.ts

@@ -28,6 +28,19 @@ export interface OpenAgentPaneOptions {
     server?: PaneProgram | Error | null;
     /** Source of SHELL and the workspace variables (default: this process). */
     env?: NodeJS.ProcessEnv;
+    /**
+     * The `motsi` to start the pane through, so Zerg Router's Command Central
+     * shows it; null for none. Default: when MotSi's remote view is on and
+     * ZTC's `panes.remoteView` isn't false.
+     */
+    motsi?: string | null;
+    /**
+     * A ZTC sign-in profile to start the CLI on; null for the CLI's own sign-in.
+     * Default: the request's `@profile`, else `panes.agentProfiles[cli]`.
+     */
+    profile?: string | null;
+    /** Home directory the profiles live under (default: the user's). */
+    profilesHome?: string;
 }
 export interface OpenAgentPaneResult {
     paneId?: number;

package/dist/panes/agent_panes.js

@@ -10,6 +10,9 @@ 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';
+import { MOTSI_PANE_ENV, remoteViewMotsi, throughMotsi } from './motsi.js';
+import { agentProfileEnv, ensureAgentProfile } from './agent_profiles.js';
+import { configStore } from '../config.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. */
@@ -36,8 +39,30 @@ export async function openAgentPane(transport, options) {
     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 profile = options.profile !== undefined
+        ? options.profile
+        : options.request?.profile ?? configStore.get().panes?.agentProfiles?.[options.cli] ?? null;
+    let profileEnv = {};
+    if (profile) {
+        try {
+            profileEnv = agentProfileEnv(options.cli, ensureAgentProfile(options.cli, profile, options.profilesHome));
+        }
+        catch (error) {
+            return { error: `Could not prepare the "${profile}" profile for ${spec.label}: ${error.message}` };
+        }
+    }
+    const label = profile ? `${spec.label} (${profile})` : spec.label;
+    const title = options.title?.trim() || nextPaneTitle(label, await existingTitles(transport));
+    const cliArgs = [
+        // On a profile, Codex keeps the sign-in in the profile's files, never a keyring entry other terminals share.
+        ...(profile && options.cli === 'codex' ? ['-c', 'cli_auth_credentials_store="file"'] : []),
+        ...agentCliArgs(options.cli, options.request ?? { words: [] }, attached),
+    ];
+    const motsi = options.motsi === undefined ? remoteViewMotsi(configStore.get().panes, { env }) : options.motsi;
+    // Through MotSi, the login shell still runs first, then `motsi run` around the CLI.
+    const program = motsi
+        ? loginShellExec(motsi, throughMotsi(motsi, title, { command: binary, args: cliArgs }).args, env.SHELL)
+        : loginShellExec(binary, cliArgs, env.SHELL);
     const requestId = `${AGENT_PANE_REQUEST_PREFIX}${options.cli}:${randomUUID()}`;
     const created = waitForPaneCreatedOrError(transport, { requestId }, 15000);
     const sent = transport.send({
@@ -52,7 +77,7 @@ export async function openAgentPane(transport, options) {
         ...(options.ratio !== undefined ? { ratio: options.ratio } : {}),
         ...(options.target !== undefined ? { target: options.target } : {}),
         ...(options.newWindow ? { new_window: true } : {}),
-        env: agentPaneEnv(env),
+        env: { ...agentPaneEnv(env), ...(motsi ? MOTSI_PANE_ENV : {}), ...profileEnv },
     });
     if (!sent) {
         created.catch(() => { });

package/dist/panes/agent_profiles.d.ts

@@ -0,0 +1,22 @@
+/**
+ * ZTC's own sign-in profiles for Claude Code and Codex panes.
+ *
+ * A profile is a config directory of its own, handed to the CLI through its
+ * documented variable (Claude Code's CLAUDE_CONFIG_DIR, Codex's CODEX_HOME).
+ * The user signs in there with the CLI's own login the first time a pane opens
+ * on it, and the CLI keeps that sign-in there, so a ZTC pane can use another
+ * account than the CLI uses in iTerm or Ghostty without changing it there.
+ * ZTC creates the directory and never reads what the CLI stores in it, and it
+ * never moves a pane to another profile on its own: the user picks.
+ */
+import type { AgentCliId } from './agent_cli.js';
+/** Letters, digits, `.`, `_` and `-`, up to 32, starting with a letter or digit. */
+export declare const PROFILE_NAME: RegExp;
+export declare function isProfileName(value: string): boolean;
+export declare function agentProfileDir(cli: AgentCliId, name: string, home?: string): string;
+/** The profile's directory, created private to the user if it is new. */
+export declare function ensureAgentProfile(cli: AgentCliId, name: string, home?: string): string;
+/** The CLI's profiles, by name. */
+export declare function listAgentProfiles(cli: AgentCliId, home?: string): string[];
+/** The variable that points the CLI at the profile. */
+export declare function agentProfileEnv(cli: AgentCliId, dir: string): Record<string, string>;

package/dist/panes/agent_profiles.js

@@ -0,0 +1,49 @@
+/**
+ * ZTC's own sign-in profiles for Claude Code and Codex panes.
+ *
+ * A profile is a config directory of its own, handed to the CLI through its
+ * documented variable (Claude Code's CLAUDE_CONFIG_DIR, Codex's CODEX_HOME).
+ * The user signs in there with the CLI's own login the first time a pane opens
+ * on it, and the CLI keeps that sign-in there, so a ZTC pane can use another
+ * account than the CLI uses in iTerm or Ghostty without changing it there.
+ * ZTC creates the directory and never reads what the CLI stores in it, and it
+ * never moves a pane to another profile on its own: the user picks.
+ */
+import { mkdirSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/** Letters, digits, `.`, `_` and `-`, up to 32, starting with a letter or digit. */
+export const PROFILE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,31}$/;
+export function isProfileName(value) {
+    return PROFILE_NAME.test(value) && value !== '.' && value !== '..';
+}
+function profilesRoot(cli, home) {
+    return join(home, '.ztc', 'agent-profiles', cli);
+}
+export function agentProfileDir(cli, name, home = homedir()) {
+    if (!isProfileName(name))
+        throw new Error(`"${name}" is not a profile name.`);
+    return join(profilesRoot(cli, home), name);
+}
+/** The profile's directory, created private to the user if it is new. */
+export function ensureAgentProfile(cli, name, home = homedir()) {
+    const dir = agentProfileDir(cli, name, home);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    return dir;
+}
+/** The CLI's profiles, by name. */
+export function listAgentProfiles(cli, home = homedir()) {
+    try {
+        return readdirSync(profilesRoot(cli, home), { withFileTypes: true })
+            .filter(entry => entry.isDirectory() && isProfileName(entry.name))
+            .map(entry => entry.name)
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+/** The variable that points the CLI at the profile. */
+export function agentProfileEnv(cli, dir) {
+    return cli === 'claude' ? { CLAUDE_CONFIG_DIR: dir } : { CODEX_HOME: dir };
+}

package/dist/panes/motsi.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Panes Zerg Router can show, through MotSi.
+ *
+ * MotSi's `motsi run -- <command>` runs a program in a pseudo-terminal it
+ * passes through unchanged and, while the owner watches it in Zerg Router's
+ * Command Central, streams it there, redacted on this computer first. Whether
+ * a viewer may type is MotSi's to decide, and it allows it only into an agent
+ * (Claude Code, Codex, ZTC), never a shell.
+ *
+ * ZTC starts its panes through it when MotSi is installed and MotSi's own
+ * remote view switch is on (`motsi remote view on|off`, kept on this computer),
+ * unless ZTC's `panes.remoteView` setting is false. ZTC reads only that switch
+ * from MotSi's settings, nothing else of MotSi's.
+ */
+import type { PaneProgram } from './agent_cli.js';
+export interface MotsiLookup {
+    env?: NodeJS.ProcessEnv;
+    home?: string;
+    systemDirs?: readonly string[];
+}
+/** The `motsi` binary: PATH first, then `go install`'s and the installers' directories. */
+export declare function findMotsi(lookup?: MotsiLookup): string | null;
+/** MotSi's own switch, from its settings (`$MOTSI_HOME` or `~/.config/motsi`). Anything but a true is off. */
+export declare function motsiRemoteViewOn(lookup?: MotsiLookup): boolean;
+/** The `motsi` to start panes through, or null when panes start as they always have. */
+export declare function remoteViewMotsi(panes: {
+    remoteView?: boolean;
+} | undefined, lookup?: MotsiLookup): string | null;
+/** The same program and arguments, as a MotSi terminal named after the pane. */
+export declare function throughMotsi(motsi: string, title: string, program: PaneProgram): PaneProgram;
+/**
+ * Pane environment for a MotSi terminal: an inherited terminal id would make
+ * `motsi run` treat the pane as part of the terminal ZTC itself runs in.
+ */
+export declare const MOTSI_PANE_ENV: Readonly<Record<string, string>>;

package/dist/panes/motsi.js

@@ -0,0 +1,75 @@
+/**
+ * Panes Zerg Router can show, through MotSi.
+ *
+ * MotSi's `motsi run -- <command>` runs a program in a pseudo-terminal it
+ * passes through unchanged and, while the owner watches it in Zerg Router's
+ * Command Central, streams it there, redacted on this computer first. Whether
+ * a viewer may type is MotSi's to decide, and it allows it only into an agent
+ * (Claude Code, Codex, ZTC), never a shell.
+ *
+ * ZTC starts its panes through it when MotSi is installed and MotSi's own
+ * remote view switch is on (`motsi remote view on|off`, kept on this computer),
+ * unless ZTC's `panes.remoteView` setting is false. ZTC reads only that switch
+ * from MotSi's settings, nothing else of MotSi's.
+ */
+import { accessSync, constants, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+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;
+    }
+}
+/** The `motsi` binary: PATH first, then `go install`'s and the installers' directories. */
+export function findMotsi(lookup = {}) {
+    const env = lookup.env ?? process.env;
+    const home = lookup.home ?? homedir();
+    const dirs = [
+        ...(env.PATH ?? '').split(':').filter(Boolean),
+        join(home, 'go', 'bin'),
+        join(home, '.local', 'bin'),
+        ...(lookup.systemDirs ?? SYSTEM_BIN_DIRS),
+    ];
+    for (const dir of dirs) {
+        const candidate = join(dir, 'motsi');
+        if (isExecutableFile(candidate))
+            return candidate;
+    }
+    return null;
+}
+/** MotSi's own switch, from its settings (`$MOTSI_HOME` or `~/.config/motsi`). Anything but a true is off. */
+export function motsiRemoteViewOn(lookup = {}) {
+    const env = lookup.env ?? process.env;
+    const dir = env.MOTSI_HOME || join(lookup.home ?? homedir(), '.config', 'motsi');
+    try {
+        const settings = JSON.parse(readFileSync(join(dir, 'settings.json'), 'utf8'));
+        return settings?.remote_view === true;
+    }
+    catch {
+        return false;
+    }
+}
+/** The `motsi` to start panes through, or null when panes start as they always have. */
+export function remoteViewMotsi(panes, lookup = {}) {
+    if (panes?.remoteView === false)
+        return null;
+    if (!motsiRemoteViewOn(lookup))
+        return null;
+    return findMotsi(lookup);
+}
+/** The same program and arguments, as a MotSi terminal named after the pane. */
+export function throughMotsi(motsi, title, program) {
+    return { command: motsi, args: ['run', `--title=${title}`, '--', program.command, ...program.args] };
+}
+/**
+ * Pane environment for a MotSi terminal: an inherited terminal id would make
+ * `motsi run` treat the pane as part of the terminal ZTC itself runs in.
+ */
+export const MOTSI_PANE_ENV = Object.freeze({ MOTSI_TERMINAL_ID: '' });

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.10.0-beta.1" : "development";
+var ZLM_ZTC_VERSION = true ? "0.10.1-dev.202611052216" : "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.10.0-beta.1",
+  "version": "0.10.1-dev.202611052216",
   "description": "Zerg Terminal Client - CLI agent for continual AI systems",
   "license": "SEE LICENSE IN LICENSE.md",
   "homepage": "https://zergai.com/docs/ztc",
@@ -275,13 +275,13 @@
     "node": "^20.19.0 || >=22.12.0"
   },
   "zergRelease": {
-    "branch": "main",
-    "channel": "next",
-    "sourceCommit": "f987bf5a7f5b3b8c9b6ed6e5ace077242bdb2be6",
+    "branch": "development",
+    "channel": "dev",
+    "sourceCommit": "eedc94d57cd6224856beab9b16b5d6c235978ece",
     "sourceVersion": "0.2.0-canary.2"
   },
   "publishConfig": {
-    "tag": "next",
+    "tag": "dev",
     "access": "public"
   }
 }