botmux 3.10.0 → 3.23.1

package/dist/core/passthrough-commands.js

@@ -1,120 +0,0 @@
-/**
- * Passthrough / daemon command sets — extracted into a leaf module so both the
- * command router ({@link ../core/command-handler.js}) and the `/botconfig` config
- * store ({@link ../services/bot-config-store.js}) can share the normalization
- * without a circular import (command-handler already imports the config store).
- */
-/**
- * Slash commands handled by the daemon itself (open a conversation / act on the
- * chat) rather than relayed to the CLI. Used both for routing and to reject
- * `customPassthroughCommands` entries that would shadow a daemon command.
- */
-export const DAEMON_COMMANDS = new Set(['/close', '/restart', '/status', '/help', '/cd', '/repo', '/rename', '/schedule', '/role', '/botconfig', '/skills', '/pair', '/login', '/adopt', '/detach', '/disconnect', '/oncall', '/group', '/g', '/relay', '/fork', '/forklist', '/card', '/term', '/list-slash-command', '/slash', '/subscribe-lark-doc', '/watch-comment', '/vc', '/insight', '/dashboard', '/vc-auth', '/issue']);
-/**
- * Slash commands that are forwarded verbatim to the underlying CLI (e.g.
- * Claude Code's `/compact`, `/model`, `/usage`). The daemon does NOT handle
- * these — it just relays them to the worker via a raw_input IPC message,
- * bypassing the normal prompt-wrapping and bracketed-paste path so the CLI's
- * own slash-command parser sees them.
- */
-export const PASSTHROUGH_COMMANDS = new Set([
-    '/compact', '/model', '/clear', '/plugin', '/usage',
-    '/new',
-    // 只读 / 低副作用，飞书卡片里能直接吐文本：
-    '/context', '/cost', '/mcp', '/diff',
-    '/code-review', '/security-review', '/review',
-    // Codex：/btw 向当前会话追加一条旁注/引导消息
-    '/btw',
-    // 推理强度调档。放全局（而非某个 adapter 的 defaultPassthroughCommands）是刻意的：
-    //   ① 这里的命令本就是「尽力透传」——/plugin /mcp /btw 也并非所有 CLI 都支持，
-    //      CLI 认得就生效、认不得顶多回一句 unknown-command（不崩溃 / 不损坏 / 不泄露）。
-    //      Claude Code(2.1.220+) / Seed / Relay 原生支持 /effort，Codex 亦有 reasoning
-    //      effort；未来别的 CLI 补上后零改动自动生效，无需再逐个 adapter 加。
-    //   ② 全局集合刻意不带「空 topic 冷启动」能力（那只认 adapter 层的
-    //      defaultPassthroughCommands，见 isInitialSessionPassthrough）——/effort 是
-    //      「调档」而非「开一段工作」的命令，空话题里单发 /effort 不应凭空拉起会话。
-    //      对照 /goal（开启目标工作）仍留在 adapter 层，保留其冷启动语义。
-    '/effort',
-    // Codex 原生 /fast 切换 service_tier。放全局 passthrough（同 /effort，非 adapter
-    // 冷启动层）：botmux 不接管,只把命令透传给 Codex 让它自己切档,卡片只读展示当前
-    // 档位徽标。刻意不进 adapter defaultPassthroughCommands —— owner 政策是空话题里
-    // 单发 /fast 不该凭空拉起会话（它是「调档」非「开一段工作」）。别的 CLI 认不得
-    // 顶多回 unknown-command,不崩溃 / 不泄露。
-    //
-    // ⚠️ 能力边界（只对原生 paste TUI 成立）：passthrough 是往 CLI 敲字（PTY write）。
-    // Codex RPC 模式的 pane 是纯 viewer、无 terminal input（turn 走 JSON-RPC）,
-    // /fast 敲进去到不了 app-server;codex+Riff 后端把文本+回车当两次远端 task。这两
-    // 种形态下 /fast 不会真正切档,徽标也只反映 rollout 实际记录（RPC app-server 仍写
-    // rollout;Riff 无 rollout/tier 概念,tracker 只在 structuredBridgeIsCodex 且有
-    // rollout 时 bind,天然 fail-closed 不显示徽标）。此处仅登记 passthrough 语义,不
-    // 声称在非 paste 形态下能切档。
-    '/fast',
-]);
-/**
- * Shape of a slash-command token: leading `/`, an alphanumeric first char, then
- * `[a-z0-9:_-]`. Shared by passthrough normalization AND the grant-restriction
- * gate ({@link ../daemon.js}'s `grantRestrictedSlashCommandText`) so a custom
- * passthrough command can't slip past the restriction check via a shape one
- * recognizes but the other doesn't (e.g. `/foo:bar`, `/1cmd` — colon / leading
- * digit). Keep the two in lockstep: anything passthrough accepts must also be
- * recognized as a command by the restriction gate.
- */
-export const SLASH_COMMAND_SHAPE = /^\/[a-z0-9][a-z0-9:_-]*$/;
-/**
- * Normalize a single custom passthrough command: lowercase, must match the
- * slash-command shape, and must not shadow a daemon command (passthrough is
- * checked BEFORE DAEMON_COMMANDS in the router). Returns null for anything that
- * doesn't qualify. Does NOT prepend the leading `/` — callers that accept bare
- * user input should add it first (see {@link parseCustomPassthroughInput}).
- */
-export function normalizePassthroughCommand(cmd) {
-    if (typeof cmd !== 'string')
-        return null;
-    const normalized = cmd.trim().toLowerCase();
-    if (!SLASH_COMMAND_SHAPE.test(normalized))
-        return null;
-    if (DAEMON_COMMANDS.has(normalized))
-        return null;
-    return normalized;
-}
-/**
- * Parse free-text dashboard / `/botconfig` input (comma, space or newline
- * separated) into a normalized, deduped custom passthrough command list. The
- * leading `/` is optional per token (so users can type `goal export` or
- * `/goal, /export`); illegal and daemon-shadowing tokens are dropped. Mirrors
- * the normalization {@link ../bot-registry.js}'s parseBotConfigsFromText applies
- * when loading bots.json, so a round-trip through the card is stable.
- */
-export function parseCustomPassthroughInput(raw) {
-    const out = [];
-    for (const tok of String(raw ?? '').split(/[\s,]+/)) {
-        const trimmed = tok.trim();
-        if (!trimmed)
-            continue;
-        const withSlash = trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
-        const norm = normalizePassthroughCommand(withSlash);
-        if (norm)
-            out.push(norm);
-    }
-    return [...new Set(out)];
-}
-/**
- * Parse free-text input for `canTalkDaemonCommands` — the inverse filter of
- * {@link parseCustomPassthroughInput}: after the same normalization (lowercase,
- * auto `/`), keep ONLY entries that ARE daemon commands. The default stringList
- * parser (parseCustomPassthroughInput) rejects every daemon command, so wiring
- * it to this field would silently drop all valid input.
- */
-export function parseCanTalkDaemonCommandsInput(raw) {
-    const out = [];
-    for (const tok of String(raw ?? '').split(/[\s,]+/)) {
-        const trimmed = tok.trim().toLowerCase();
-        if (!trimmed)
-            continue;
-        const withSlash = trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
-        if (DAEMON_COMMANDS.has(withSlash))
-            out.push(withSlash);
-    }
-    return [...new Set(out)];
-}
-//# sourceMappingURL=passthrough-commands.js.map

package/dist/core/passthrough-commands.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"passthrough-commands.js","sourceRoot":"","sources":["../../src/core/passthrough-commands.ts"],"names":[],"mappings":"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"}

package/dist/core/pending-response.d.ts

@@ -1,4 +0,0 @@
-export declare const RECEIVED_REACTION_EMOJI_TYPE = "GoGoGo";
-export declare const SUBSTITUTE_RECEIVED_REACTION_EMOJI_TYPE = "Get";
-export declare const DONE_REACTION_EMOJI_TYPE = "DONE";
-//# sourceMappingURL=pending-response.d.ts.map

package/dist/core/pending-response.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pending-response.d.ts","sourceRoot":"","sources":["../../src/core/pending-response.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,4BAA4B,WAAW,CAAC;AACrD,eAAO,MAAM,uCAAuC,QAAQ,CAAC;AAC7D,eAAO,MAAM,wBAAwB,SAAS,CAAC"}

package/dist/core/pending-response.js

@@ -1,11 +0,0 @@
-// Two-phase turn reactions (auto-on for card-off sessions, i.e. streaming card disabled):
-//   - RECEIVED lands the instant the bot starts working on the turn (冲! `GoGoGo`).
-//   - On turn completion the RECEIVED reaction is removed and DONE (✅) replaces it.
-// These are the DEFAULTS; a bot can override either emoji_type via bots.json
-// (receivedReactionEmoji / doneReactionEmoji). Setting both to the same value
-// keeps the marker visually unchanged on turn-end — handy for CLIs whose idle
-// detection can fire early (e.g. Pi), where a premature ✅ would mislead.
-export const RECEIVED_REACTION_EMOJI_TYPE = 'GoGoGo';
-export const SUBSTITUTE_RECEIVED_REACTION_EMOJI_TYPE = 'Get';
-export const DONE_REACTION_EMOJI_TYPE = 'DONE';
-//# sourceMappingURL=pending-response.js.map

package/dist/core/pending-response.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pending-response.js","sourceRoot":"","sources":["../../src/core/pending-response.ts"],"names":[],"mappings":"AAAA,0FAA0F;AAC1F,mFAAmF;AACnF,oFAAoF;AACpF,6EAA6E;AAC7E,8EAA8E;AAC9E,8EAA8E;AAC9E,yEAAyE;AACzE,MAAM,CAAC,MAAM,4BAA4B,GAAG,QAAQ,CAAC;AACrD,MAAM,CAAC,MAAM,uCAAuC,GAAG,KAAK,CAAC;AAC7D,MAAM,CAAC,MAAM,wBAAwB,GAAG,MAAM,CAAC"}

package/dist/core/per-bot-env.d.ts

@@ -1,38 +0,0 @@
-/**
- * Per-bot environment variables (`bots.json` → `env`).
- *
- * A bot entry may declare `env: { KEY: value, ... }` to inject extra environment
- * variables into THAT bot's CLI process — e.g. point one bot at a third-party
- * Anthropic/OpenAI-compatible provider (GLM / Kimi / a self-hosted gateway) via
- * `ANTHROPIC_BASE_URL` + `ANTHROPIC_AUTH_TOKEN`, set an `HTTPS_PROXY`, or flip a
- * CLI-specific feature flag.
- *
- * IMPORTANT — injection layer: this env is delivered to the CLI **per session**,
- * NOT into the daemon's own process env. Under the tmux/zellij backends every
- * bot shares ONE backing server whose global env is captured from whichever
- * pane starts it first; putting provider creds into that shared global would let
- * bot A's base-url/token leak into bot B's panes (startup-order dependent). So
- * the worker passes this env as `SpawnOpts.injectEnv`, and the persistent
- * backends inject it via the per-pane `/usr/bin/env KEY=VAL` prefix (after rcfile
- * load, authoritative for that pane only) — never into the shared server env.
- * The pty backend, which has no shared server, merges it into the child env.
- *
- * This is NOT a secret vault: values live in `bots.json` and the process
- * environment in plaintext, visible to local diagnostic tools.
- *
- * Caveat — file sandbox: when a session runs inside the bwrap file sandbox the
- * CLI's env is carried via `bwrap --setenv` (not the backend's injectEnv path),
- * so per-bot env may not reach a sandboxed CLI. The common provider use case
- * (GLM etc.) doesn't run sandboxed; sandbox + per-bot env is a possible follow-up.
- */
-/** Whether `key` is botmux-controlled and therefore rejected from per-bot env. */
-export declare function isReservedPerBotEnvKey(key: string): boolean;
-/**
- * Sanitize a raw `env` value (from bots.json / dashboard / a config command)
- * into a clean `KEY -> string` map: drops anything that isn't a plain object,
- * keys with an invalid env-var name or a botmux-reserved name, and values that
- * aren't a string/number/boolean (primitives are stringified). Pure + total —
- * always returns an object, never throws.
- */
-export declare function sanitizePerBotEnv(raw: unknown): Record<string, string>;
-//# sourceMappingURL=per-bot-env.d.ts.map

package/dist/core/per-bot-env.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"per-bot-env.d.ts","sourceRoot":"","sources":["../../src/core/per-bot-env.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAwCH,kFAAkF;AAClF,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAG3D;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAatE"}

package/dist/core/per-bot-env.js

@@ -1,94 +0,0 @@
-/**
- * Per-bot environment variables (`bots.json` → `env`).
- *
- * A bot entry may declare `env: { KEY: value, ... }` to inject extra environment
- * variables into THAT bot's CLI process — e.g. point one bot at a third-party
- * Anthropic/OpenAI-compatible provider (GLM / Kimi / a self-hosted gateway) via
- * `ANTHROPIC_BASE_URL` + `ANTHROPIC_AUTH_TOKEN`, set an `HTTPS_PROXY`, or flip a
- * CLI-specific feature flag.
- *
- * IMPORTANT — injection layer: this env is delivered to the CLI **per session**,
- * NOT into the daemon's own process env. Under the tmux/zellij backends every
- * bot shares ONE backing server whose global env is captured from whichever
- * pane starts it first; putting provider creds into that shared global would let
- * bot A's base-url/token leak into bot B's panes (startup-order dependent). So
- * the worker passes this env as `SpawnOpts.injectEnv`, and the persistent
- * backends inject it via the per-pane `/usr/bin/env KEY=VAL` prefix (after rcfile
- * load, authoritative for that pane only) — never into the shared server env.
- * The pty backend, which has no shared server, merges it into the child env.
- *
- * This is NOT a secret vault: values live in `bots.json` and the process
- * environment in plaintext, visible to local diagnostic tools.
- *
- * Caveat — file sandbox: when a session runs inside the bwrap file sandbox the
- * CLI's env is carried via `bwrap --setenv` (not the backend's injectEnv path),
- * so per-bot env may not reach a sandboxed CLI. The common provider use case
- * (GLM etc.) doesn't run sandboxed; sandbox + per-bot env is a possible follow-up.
- */
-/** Valid POSIX-ish env var name: letter/underscore start, then word chars. */
-const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
-/**
- * Names botmux owns to route the session, locate the daemon, and carry bot
- * creds — a per-bot `env` must never set these, or user config could hijack
- * session identity, clobber the CLI data root (Seed/Relay), or shadow a
- * botmux-managed flag. Mirrors the worker's injected/redacted keys
- * (BOTMUX_INJECTED_ENV_KEYS + REDACTED_CHILD_ENV_KEYS); kept as a local literal
- * so this stays a dependency-free leaf module. `LARK_APP_` covers both bare
- * creds; `BOTMUX` prefix covers all session-routing keys.
- */
-const RESERVED_ENV_PREFIXES = ['BOTMUX', 'LARK_APP_'];
-const RESERVED_ENV_KEYS = new Set([
-    '__OWNER_OPEN_ID',
-    'SESSION_DATA_DIR',
-    'IS_SANDBOX',
-    // Claude session-identity markers (mirrors CLAUDE_SESSION_MARKER_ENV_KEYS in
-    // utils/child-env.ts): explicitly configuring one would mark the bot's CLI
-    // as a nested Claude child session (CLAUDE_CODE_CHILD_SESSION silently turns
-    // transcript persistence off) or pin a foreign session identity. CLAUDE_EFFORT
-    // stays configurable — it's a behavior knob, not an identity marker.
-    'CLAUDECODE',
-    'CLAUDE_CODE_CHILD_SESSION',
-    'CLAUDE_CODE_SESSION_ID',
-    'CLAUDE_CODE_ENTRYPOINT',
-    'CLAUDE_CODE_EXECPATH',
-    'CLAUDE_PID',
-    'CLAUDE_CONFIG_DIR',
-    'CODEX_HOME',
-    // Grok data root: daemon installs hooks/skills and drains transcripts under
-    // the process-level GROK_HOME. A per-bot inject would only reach the child
-    // CLI and split-brain path resolution (see grok-paths header).
-    'GROK_HOME',
-    'CLAUDE_CODE_RESUME_TOKEN_THRESHOLD',
-    'CJADK_INTERACTIVE',
-]);
-/** Whether `key` is botmux-controlled and therefore rejected from per-bot env. */
-export function isReservedPerBotEnvKey(key) {
-    if (RESERVED_ENV_KEYS.has(key))
-        return true;
-    return RESERVED_ENV_PREFIXES.some((p) => key.startsWith(p));
-}
-/**
- * Sanitize a raw `env` value (from bots.json / dashboard / a config command)
- * into a clean `KEY -> string` map: drops anything that isn't a plain object,
- * keys with an invalid env-var name or a botmux-reserved name, and values that
- * aren't a string/number/boolean (primitives are stringified). Pure + total —
- * always returns an object, never throws.
- */
-export function sanitizePerBotEnv(raw) {
-    const obj = raw && typeof raw === 'object' && !Array.isArray(raw)
-        ? raw
-        : {};
-    const out = {};
-    for (const [key, value] of Object.entries(obj)) {
-        if (!ENV_KEY_RE.test(key))
-            continue;
-        if (isReservedPerBotEnvKey(key))
-            continue;
-        if (typeof value === 'string')
-            out[key] = value;
-        else if (typeof value === 'number' || typeof value === 'boolean')
-            out[key] = String(value);
-    }
-    return out;
-}
-//# sourceMappingURL=per-bot-env.js.map

package/dist/core/per-bot-env.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"per-bot-env.js","sourceRoot":"","sources":["../../src/core/per-bot-env.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,8EAA8E;AAC9E,MAAM,UAAU,GAAG,0BAA0B,CAAC;AAE9C;;;;;;;;GAQG;AACH,MAAM,qBAAqB,GAAG,CAAC,QAAQ,EAAE,WAAW,CAAU,CAAC;AAC/D,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAAS;IACxC,iBAAiB;IACjB,kBAAkB;IAClB,YAAY;IACZ,6EAA6E;IAC7E,2EAA2E;IAC3E,6EAA6E;IAC7E,+EAA+E;IAC/E,qEAAqE;IACrE,YAAY;IACZ,2BAA2B;IAC3B,wBAAwB;IACxB,wBAAwB;IACxB,sBAAsB;IACtB,YAAY;IACZ,mBAAmB;IACnB,YAAY;IACZ,4EAA4E;IAC5E,2EAA2E;IAC3E,+DAA+D;IAC/D,WAAW;IACX,oCAAoC;IACpC,mBAAmB;CACpB,CAAC,CAAC;AAEH,kFAAkF;AAClF,MAAM,UAAU,sBAAsB,CAAC,GAAW;IAChD,IAAI,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IAC5C,OAAO,qBAAqB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;AAC9D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAY;IAC5C,MAAM,GAAG,GACP,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC;QACnD,CAAC,CAAE,GAA+B;QAClC,CAAC,CAAC,EAAE,CAAC;IACT,MAAM,GAAG,GAA2B,EAAE,CAAC;IACvC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QAC/C,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC;YAAE,SAAS;QACpC,IAAI,sBAAsB,CAAC,GAAG,CAAC;YAAE,SAAS;QAC1C,IAAI,OAAO,KAAK,KAAK,QAAQ;YAAE,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;aAC3C,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,SAAS;YAAE,GAAG,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAC7F,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/core/persistent-backend.d.ts

@@ -1,107 +0,0 @@
-import type { BackendType, PersistentBackendTarget, SessionProbe } from '../adapters/backend/types.js';
-import type { DaemonSession } from './types.js';
-import type { Session } from '../types.js';
-export type PersistentBackendType = Extract<BackendType, 'tmux' | 'herdr' | 'zellij' | 'zmx'>;
-/**
- * Decide whether a post-kill probe still blocks a cold replacement.
- *
- * ZMX owns sessions by labels + frozen PID, so an inconclusive confirmation
- * must remain fail-closed. The older mux backends only have best-effort
- * process/session probes: after a successful kill, `unknown` is not proof that
- * the target survived (notably zellij reports zero live sessions with exit 1).
- */
-export declare function shouldRejectPersistentPostKillProbe(backendType: PersistentBackendType, probe: SessionProbe): boolean;
-export declare function isSuspendableBackendType(backendType: BackendType | undefined): backendType is PersistentBackendType;
-/**
- * Resolve which persistent backend (if any) backs a session.
- *
- * Precedence, most authoritative first:
- *   1. `ds.initConfig?.backendType` — the live worker's resolved backend this run.
- *   2. `ds.session.backendType` — the backend stamped on the persisted session
- *      at spawn time (survives daemon restart; see Session.backendType).
- *   3. An explicit per-bot `backendType` — authoritative even for legacy
- *      sessions, since the bot's choice didn't change across the PTY退役 flip.
- *
- * If NONE of those resolve, the session predates backendType stamping AND its
- * bot pins no backend, so it ran on the OLD probe-based daemon default — which
- * could have been PTY on a tmux-less host. We deliberately do NOT fall back to
- * the current `config.daemon.backendType` (now always tmux): doing so would
- * make `restoreActiveSessions` probe for a `bmx-<sid>` pane that never existed,
- * find it 'missing', and zombie-close a perfectly recoverable session. Treating
- * it as non-persistent keeps the worker-less active record for lazy resume; a
- * genuinely surviving tmux pane still reattaches lazily on the next message
- * (and gets stamped then).
- */
-export declare function getSessionPersistentBackendType(ds: DaemonSession): PersistentBackendType | undefined;
-/**
- * Freeze-once backend resolution for a forkWorker spawn. An already-running
- * session keeps the backend stamped at its FIRST spawn (`sessionStamp`); only a
- * brand-new session (no stamp) resolves from the bot's live config, then the
- * daemon default. worker-pool's forkWorker calls this so a live dashboard
- * backendType edit only affects NEW sessions and never re-derives a running
- * session onto a different backend (which would strand its persistent pane).
- */
-export declare function resolveSpawnBackendType(sessionStamp: BackendType | undefined, botType: BackendType | undefined, defaultType: BackendType): BackendType;
-/**
- * Enforce the `cliId === 'riff' ⇔ backendType === 'riff'` pairing invariant at
- * the ONE spawn chokepoint, so every config entry point (dashboard, `/config
- * set cli|backendType`, `botmux setup`, hand-edited bots.json) converges:
- *   - riff CLI on a local backend → force 'riff' (a pty/tmux spawn would fail
- *     on the empty resolvedBin);
- *   - non-riff CLI on the riff backend → fall back to the daemon default (the
- *     CLI's PTY chunked writes would otherwise fan out into riff tasks).
- * Manual pty/tmux/herdr/zellij overrides for non-riff CLIs pass through.
- */
-export declare function reconcileRiffBackendType(cliId: string, resolved: BackendType, defaultType: BackendType): BackendType;
-/** Resolve the frozen/live/default backend precedence and then enforce the
- * Riff CLI/backend pairing. Keep spawn-time callers on this single helper so
- * worktree push decisions cannot drift from the backend forkWorker will use. */
-export declare function resolvePairedSpawnBackendType(cliId: string, sessionStamp: BackendType | undefined, botType: BackendType | undefined, defaultType: BackendType): BackendType;
-/**
- * How a session's worker is torn down at daemon shutdown, branched on the
- * session's FROZEN backend (via getSessionPersistentBackendType), NOT live config:
- *   'detach' — persistent backend (tmux/herdr/zellij): SIGTERM the worker only,
- *              leaving the multiplexer session alive for re-attach.
- *   'close'  — non-persistent (frozen pty, or unresolvable legacy): killWorker.
- * Freezing here stops a live backendType edit from changing how a running session
- * tears down — e.g. detach-preserving a "herdr" session whose real pane is tmux.
- */
-export declare function shutdownBackendDisposition(ds: DaemonSession): 'detach' | 'close';
-/** Deterministic backing-session name (`bmx-<sid8>`, same rule across backends). */
-export declare function persistentSessionName(backendType: PersistentBackendType, sessionId: string): string;
-/**
- * Resolve the exact backing resource for daemon lifecycle work. The persisted
- * worker-selected target wins only when it still matches the frozen backend;
- * legacy rows fall back to the historical deterministic whole-session target.
- */
-export declare function resolvePersistentBackendTarget(backendType: PersistentBackendType, sessionId: string, persisted?: PersistentBackendTarget): PersistentBackendTarget;
-export declare function persistentBackendTargetForSession(ds: DaemonSession): PersistentBackendTarget | undefined;
-/** Exact managed resources to remove when a single-bot CLI changes.
- * Adopted panes are user-owned; machine-wide Herdr agents must be returned as
- * agent-scoped targets rather than collapsing to the shared host session. */
-export declare function managedTargetsForCliChange(backendType: PersistentBackendType, sessions: readonly Pick<Session, 'sessionId' | 'adoptedFrom' | 'persistentBackendTarget'>[]): PersistentBackendTarget[];
-export declare function probePersistentBackendTarget(target: PersistentBackendTarget): SessionProbe;
-/**
- * `sessionId` is REQUIRED for ZMX: its destruction is identity-verified against
- * the botmux labels stamped on the session, and `killPersistentSession` refuses
- * a name-only ZMX kill rather than risk destroying a same-named user session.
- * Callers that hold the owning session must always pass it through.
- */
-export declare function killPersistentBackendTarget(target: PersistentBackendTarget, sessionId?: string): void;
-export declare function probePersistentSession(backendType: PersistentBackendType, name: string): SessionProbe;
-/**
- * Take one liveness snapshot for a set of backing-session names.
- *
- * ZMX and Zellij expose all session states in one command, so probing each row
- * separately would repeatedly scan the same control plane (and makes `botmux
- * list` quadratic for ZMX). tmux and Herdr keep their established per-session
- * probes, but duplicate names are still coalesced here.
- */
-export declare function probePersistentSessions(backendType: PersistentBackendType, names: Iterable<string>): ReadonlyMap<string, SessionProbe>;
-/**
- * Kill a backing session. ZMX additionally requires the complete botmux UUID:
- * its public name contains only eight UUID characters, so name-only deletion
- * could destroy a different session after a prefix collision.
- */
-export declare function killPersistentSession(backendType: PersistentBackendType, name: string, sessionId?: string): void;
-//# sourceMappingURL=persistent-backend.d.ts.map

package/dist/core/persistent-backend.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"persistent-backend.d.ts","sourceRoot":"","sources":["../../src/core/persistent-backend.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,WAAW,EAAE,uBAAuB,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACvG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,MAAM,MAAM,qBAAqB,GAAG,OAAO,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAC,CAAC;AAE9F;;;;;;;GAOG;AACH,wBAAgB,mCAAmC,CACjD,WAAW,EAAE,qBAAqB,EAClC,KAAK,EAAE,YAAY,GAClB,OAAO,CAET;AAED,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,WAAW,GAAG,SAAS,GACnC,WAAW,IAAI,qBAAqB,CAEtC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,+BAA+B,CAAC,EAAE,EAAE,aAAa,GAAG,qBAAqB,GAAG,SAAS,CAQpG;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,WAAW,GAAG,SAAS,EACrC,OAAO,EAAE,WAAW,GAAG,SAAS,EAChC,WAAW,EAAE,WAAW,GACvB,WAAW,CAEb;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,WAAW,EACrB,WAAW,EAAE,WAAW,GACvB,WAAW,CAKb;AAED;;gFAEgF;AAChF,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,WAAW,GAAG,SAAS,EACrC,OAAO,EAAE,WAAW,GAAG,SAAS,EAChC,WAAW,EAAE,WAAW,GACvB,WAAW,CAMb;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,aAAa,GAAG,QAAQ,GAAG,OAAO,CAOhF;AAED,oFAAoF;AACpF,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,qBAAqB,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAKnG;AAED;;;;GAIG;AACH,wBAAgB,8BAA8B,CAC5C,WAAW,EAAE,qBAAqB,EAClC,SAAS,EAAE,MAAM,EACjB,SAAS,CAAC,EAAE,uBAAuB,GAClC,uBAAuB,CAOzB;AAED,wBAAgB,iCAAiC,CAAC,EAAE,EAAE,aAAa,GAAG,uBAAuB,GAAG,SAAS,CAQxG;AAED;;6EAE6E;AAC7E,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,qBAAqB,EAClC,QAAQ,EAAE,SAAS,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,aAAa,GAAG,yBAAyB,CAAC,EAAE,GAC1F,uBAAuB,EAAE,CAQ3B;AAED,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,uBAAuB,GAAG,YAAY,CAK1F;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,uBAAuB,EAC/B,SAAS,CAAC,EAAE,MAAM,GACjB,IAAI,CAMN;AAED,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,qBAAqB,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,CAKrG;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,qBAAqB,EAClC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,GACtB,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,CAiCnC;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,qBAAqB,EAClC,IAAI,EAAE,MAAM,EACZ,SAAS,CAAC,EAAE,MAAM,GACjB,IAAI,CAQN"}

package/dist/core/persistent-backend.js

@@ -1,235 +0,0 @@
-/**
- * Shared helpers for sessions backed by a persistent multiplexer
- * (tmux / herdr / zellij / zmx). These backends keep the CLI alive across worker
- * exits BY DESIGN (idle-suspend, lazy restore), so several daemon paths must
- * resolve / name / probe / kill the backing session WITHOUT a live worker:
- * the restore-time zombie sweep and terminal wake (session-manager.ts), and
- * the /close teardown of orphaned sessions (worker-pool.ts killWorker).
- *
- * This module owns the backend dispatch so those paths can't drift apart.
- * It must stay dependency-light (backends + registry + config only) — both
- * worker-pool and session-manager import it, and those two already form an
- * import cycle with each other.
- */
-import { getBot } from '../bot-registry.js';
-import { TmuxBackend } from '../adapters/backend/tmux-backend.js';
-import { HerdrBackend } from '../adapters/backend/herdr-backend.js';
-import { ZellijBackend } from '../adapters/backend/zellij-backend.js';
-import { ZmxBackend } from '../adapters/backend/zmx-backend.js';
-/**
- * Decide whether a post-kill probe still blocks a cold replacement.
- *
- * ZMX owns sessions by labels + frozen PID, so an inconclusive confirmation
- * must remain fail-closed. The older mux backends only have best-effort
- * process/session probes: after a successful kill, `unknown` is not proof that
- * the target survived (notably zellij reports zero live sessions with exit 1).
- */
-export function shouldRejectPersistentPostKillProbe(backendType, probe) {
-    return probe === 'exists' || (backendType === 'zmx' && probe === 'unknown');
-}
-export function isSuspendableBackendType(backendType) {
-    return backendType === 'tmux' || backendType === 'herdr' || backendType === 'zellij' || backendType === 'zmx';
-}
-/**
- * Resolve which persistent backend (if any) backs a session.
- *
- * Precedence, most authoritative first:
- *   1. `ds.initConfig?.backendType` — the live worker's resolved backend this run.
- *   2. `ds.session.backendType` — the backend stamped on the persisted session
- *      at spawn time (survives daemon restart; see Session.backendType).
- *   3. An explicit per-bot `backendType` — authoritative even for legacy
- *      sessions, since the bot's choice didn't change across the PTY退役 flip.
- *
- * If NONE of those resolve, the session predates backendType stamping AND its
- * bot pins no backend, so it ran on the OLD probe-based daemon default — which
- * could have been PTY on a tmux-less host. We deliberately do NOT fall back to
- * the current `config.daemon.backendType` (now always tmux): doing so would
- * make `restoreActiveSessions` probe for a `bmx-<sid>` pane that never existed,
- * find it 'missing', and zombie-close a perfectly recoverable session. Treating
- * it as non-persistent keeps the worker-less active record for lazy resume; a
- * genuinely surviving tmux pane still reattaches lazily on the next message
- * (and gets stamped then).
- */
-export function getSessionPersistentBackendType(ds) {
-    let backendType = ds.initConfig?.backendType ?? ds.session.backendType;
-    if (!backendType) {
-        try {
-            backendType = getBot(ds.larkAppId).config.backendType;
-        }
-        catch { /* bot deregistered */ }
-    }
-    return isSuspendableBackendType(backendType) ? backendType : undefined;
-}
-/**
- * Freeze-once backend resolution for a forkWorker spawn. An already-running
- * session keeps the backend stamped at its FIRST spawn (`sessionStamp`); only a
- * brand-new session (no stamp) resolves from the bot's live config, then the
- * daemon default. worker-pool's forkWorker calls this so a live dashboard
- * backendType edit only affects NEW sessions and never re-derives a running
- * session onto a different backend (which would strand its persistent pane).
- */
-export function resolveSpawnBackendType(sessionStamp, botType, defaultType) {
-    return sessionStamp ?? botType ?? defaultType;
-}
-/**
- * Enforce the `cliId === 'riff' ⇔ backendType === 'riff'` pairing invariant at
- * the ONE spawn chokepoint, so every config entry point (dashboard, `/config
- * set cli|backendType`, `botmux setup`, hand-edited bots.json) converges:
- *   - riff CLI on a local backend → force 'riff' (a pty/tmux spawn would fail
- *     on the empty resolvedBin);
- *   - non-riff CLI on the riff backend → fall back to the daemon default (the
- *     CLI's PTY chunked writes would otherwise fan out into riff tasks).
- * Manual pty/tmux/herdr/zellij overrides for non-riff CLIs pass through.
- */
-export function reconcileRiffBackendType(cliId, resolved, defaultType) {
-    if (cliId === 'riff')
-        return 'riff';
-    // defaultType 本身被误配成 riff 时兜底到确定可用的本地后端（pty 无外部依赖）。
-    if (resolved === 'riff')
-        return defaultType !== 'riff' ? defaultType : 'pty';
-    return resolved;
-}
-/** Resolve the frozen/live/default backend precedence and then enforce the
- * Riff CLI/backend pairing. Keep spawn-time callers on this single helper so
- * worktree push decisions cannot drift from the backend forkWorker will use. */
-export function resolvePairedSpawnBackendType(cliId, sessionStamp, botType, defaultType) {
-    return reconcileRiffBackendType(cliId, resolveSpawnBackendType(sessionStamp, botType, defaultType), defaultType);
-}
-/**
- * How a session's worker is torn down at daemon shutdown, branched on the
- * session's FROZEN backend (via getSessionPersistentBackendType), NOT live config:
- *   'detach' — persistent backend (tmux/herdr/zellij): SIGTERM the worker only,
- *              leaving the multiplexer session alive for re-attach.
- *   'close'  — non-persistent (frozen pty, or unresolvable legacy): killWorker.
- * Freezing here stops a live backendType edit from changing how a running session
- * tears down — e.g. detach-preserving a "herdr" session whose real pane is tmux.
- */
-export function shutdownBackendDisposition(ds) {
-    // riff：远端任务独立于本地进程存活。daemon shutdown 走 'close' 会经 worker 的
-    // destroySession() 取消远端任务——重启不该杀任务（血缘已持久化，重启后
-    // follow-up 续上，agent 的 botmux send 照常送达）。detach = 仅 SIGTERM worker。
-    const frozen = ds.initConfig?.backendType ?? ds.session.backendType;
-    if (frozen === 'riff')
-        return 'detach';
-    return getSessionPersistentBackendType(ds) ? 'detach' : 'close';
-}
-/** Deterministic backing-session name (`bmx-<sid8>`, same rule across backends). */
-export function persistentSessionName(backendType, sessionId) {
-    if (backendType === 'tmux')
-        return TmuxBackend.sessionName(sessionId);
-    if (backendType === 'zellij')
-        return ZellijBackend.sessionName(sessionId);
-    if (backendType === 'zmx')
-        return ZmxBackend.sessionName(sessionId);
-    return HerdrBackend.sessionName(sessionId);
-}
-/**
- * Resolve the exact backing resource for daemon lifecycle work. The persisted
- * worker-selected target wins only when it still matches the frozen backend;
- * legacy rows fall back to the historical deterministic whole-session target.
- */
-export function resolvePersistentBackendTarget(backendType, sessionId, persisted) {
-    if (persisted?.backendType === backendType && persisted.sessionName.trim()) {
-        if (persisted.backendType !== 'herdr' || persisted.agentName === undefined || persisted.agentName.trim()) {
-            return persisted;
-        }
-    }
-    return { backendType, sessionName: persistentSessionName(backendType, sessionId) };
-}
-export function persistentBackendTargetForSession(ds) {
-    const backendType = getSessionPersistentBackendType(ds);
-    if (!backendType)
-        return undefined;
-    return resolvePersistentBackendTarget(backendType, ds.session.sessionId, ds.session.persistentBackendTarget);
-}
-/** Exact managed resources to remove when a single-bot CLI changes.
- * Adopted panes are user-owned; machine-wide Herdr agents must be returned as
- * agent-scoped targets rather than collapsing to the shared host session. */
-export function managedTargetsForCliChange(backendType, sessions) {
-    return sessions
-        .filter(session => !session.adoptedFrom)
-        .map(session => resolvePersistentBackendTarget(backendType, session.sessionId, session.persistentBackendTarget));
-}
-export function probePersistentBackendTarget(target) {
-    if (target.backendType === 'herdr' && target.agentName) {
-        return HerdrBackend.probeAgent(target.sessionName, target.agentName);
-    }
-    return probePersistentSession(target.backendType, target.sessionName);
-}
-/**
- * `sessionId` is REQUIRED for ZMX: its destruction is identity-verified against
- * the botmux labels stamped on the session, and `killPersistentSession` refuses
- * a name-only ZMX kill rather than risk destroying a same-named user session.
- * Callers that hold the owning session must always pass it through.
- */
-export function killPersistentBackendTarget(target, sessionId) {
-    if (target.backendType === 'herdr' && target.agentName) {
-        HerdrBackend.killAgent(target.sessionName, target.agentName);
-        return;
-    }
-    killPersistentSession(target.backendType, target.sessionName, sessionId);
-}
-export function probePersistentSession(backendType, name) {
-    if (backendType === 'tmux')
-        return TmuxBackend.probeSession(name);
-    if (backendType === 'zellij')
-        return ZellijBackend.probeSession(name);
-    if (backendType === 'zmx')
-        return ZmxBackend.probeSession(name);
-    return HerdrBackend.probeSession(name);
-}
-/**
- * Take one liveness snapshot for a set of backing-session names.
- *
- * ZMX and Zellij expose all session states in one command, so probing each row
- * separately would repeatedly scan the same control plane (and makes `botmux
- * list` quadratic for ZMX). tmux and Herdr keep their established per-session
- * probes, but duplicate names are still coalesced here.
- */
-export function probePersistentSessions(backendType, names) {
-    const uniqueNames = [...new Set(names)];
-    const result = new Map();
-    if (backendType === 'zmx') {
-        const snapshot = ZmxBackend.probeSessions();
-        for (const name of uniqueNames) {
-            result.set(name, !snapshot.ok
-                ? 'unknown'
-                : snapshot.sessions.includes(name)
-                    ? 'exists'
-                    : snapshot.unhealthySessions.includes(name)
-                        ? 'unknown'
-                        : 'missing');
-        }
-        return result;
-    }
-    if (backendType === 'zellij') {
-        const snapshot = ZellijBackend.probeLiveSessions();
-        for (const name of uniqueNames) {
-            result.set(name, !snapshot.ok ? 'unknown' : snapshot.sessions.includes(name) ? 'exists' : 'missing');
-        }
-        return result;
-    }
-    for (const name of uniqueNames) {
-        result.set(name, probePersistentSession(backendType, name));
-    }
-    return result;
-}
-/**
- * Kill a backing session. ZMX additionally requires the complete botmux UUID:
- * its public name contains only eight UUID characters, so name-only deletion
- * could destroy a different session after a prefix collision.
- */
-export function killPersistentSession(backendType, name, sessionId) {
-    if (backendType === 'tmux')
-        TmuxBackend.killSession(name);
-    else if (backendType === 'zellij')
-        ZellijBackend.killSession(name);
-    else if (backendType === 'zmx') {
-        if (!sessionId)
-            throw new Error(`refusing name-only ZMX kill for ${name}`);
-        ZmxBackend.killManagedSession(name, sessionId);
-    }
-    else
-        HerdrBackend.killSession(name);
-}
-//# sourceMappingURL=persistent-backend.js.map