botmux 3.0.0 → 3.1.1

package/dist/utils/ready-gate.d.ts

@@ -34,11 +34,16 @@
 /**
  * Decide whether the worker should ARM the ready-gate for a given spawn. The
  * gate is only valid when a SessionStart hook will actually fire — i.e. a FRESH
- * Claude-family spawn that re-runs the CLI binary with our `--settings`:
+ * ready-gated spawn whose hook/transport preflight succeeded:
  *
  *   - `injectsReadyHook`        — the adapter injects the hook (claude / seed).
+ *   - `readySignalAvailable`    — the effective config contains the hook (or the
+ *                                 CLI has a direct ready-command integration),
+ *                                 and an isolated child has a usable callback
+ *                                 route to the daemon.
  *   - NOT `adoptMode`           — adopt panes are pre-existing, never spawned with
- *                                 our `--settings`, so they can't get the hook.
+ *                                 our ready integration, so they can't get a
+ *                                 fresh SessionStart signal.
  *   - NOT `willReattachPersistent` — on daemon restart / worker recovery the
  *                                 worker re-attaches to an existing tmux/zellij/
  *                                 herdr session and does NOT re-run the CLI's
@@ -51,13 +56,14 @@
  * exactly as before (readyPattern + quiescence).
  *
  * NB: `wrapperCli=aiden x claude` strips our process-level `--settings`, but the
- * SessionStart hook is ALSO installed globally (~/.claude/settings.json — see
+ * SessionStart hook is installed in the effective settings.json (see
  * claude-code.ts hookInstall.sessionStartCommand), which aiden's Claude still
  * reads. So the real signal fires there too → we KEEP arming for that case
  * (no readyPattern fallback, which could misjudge).
  */
 export declare function shouldArmReadyGate(state: {
     injectsReadyHook: boolean;
+    readySignalAvailable: boolean;
     adoptMode: boolean;
     willReattachPersistent: boolean;
 }): boolean;

package/dist/utils/ready-gate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ready-gate.d.ts","sourceRoot":"","sources":["../../src/utils/ready-gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE;IACxC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,SAAS,EAAE,OAAO,CAAC;IACnB,sBAAsB,EAAE,OAAO,CAAC;CACjC,GAAG,OAAO,CAEV;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,QAAQ,CAAS;IAEzB,oFAAoF;IACpF,GAAG,IAAI,IAAI;IAIX,qFAAqF;IACrF,UAAU,IAAI,OAAO;IAIrB;;;;;;OAMG;IACH,OAAO,IAAI,OAAO;IAOlB,qEAAqE;IACrE,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,gEAAgE;IAChE,IAAI,UAAU,IAAI,OAAO,CAExB;CACF"}
+{"version":3,"file":"ready-gate.d.ts","sourceRoot":"","sources":["../../src/utils/ready-gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE;IACxC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,oBAAoB,EAAE,OAAO,CAAC;IAC9B,SAAS,EAAE,OAAO,CAAC;IACnB,sBAAsB,EAAE,OAAO,CAAC;CACjC,GAAG,OAAO,CAKV;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,QAAQ,CAAS;IAEzB,oFAAoF;IACpF,GAAG,IAAI,IAAI;IAIX,qFAAqF;IACrF,UAAU,IAAI,OAAO;IAIrB;;;;;;OAMG;IACH,OAAO,IAAI,OAAO;IAOlB,qEAAqE;IACrE,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,gEAAgE;IAChE,IAAI,UAAU,IAAI,OAAO,CAExB;CACF"}

package/dist/utils/ready-gate.js

@@ -34,11 +34,16 @@
 /**
  * Decide whether the worker should ARM the ready-gate for a given spawn. The
  * gate is only valid when a SessionStart hook will actually fire — i.e. a FRESH
- * Claude-family spawn that re-runs the CLI binary with our `--settings`:
+ * ready-gated spawn whose hook/transport preflight succeeded:
  *
  *   - `injectsReadyHook`        — the adapter injects the hook (claude / seed).
+ *   - `readySignalAvailable`    — the effective config contains the hook (or the
+ *                                 CLI has a direct ready-command integration),
+ *                                 and an isolated child has a usable callback
+ *                                 route to the daemon.
  *   - NOT `adoptMode`           — adopt panes are pre-existing, never spawned with
- *                                 our `--settings`, so they can't get the hook.
+ *                                 our ready integration, so they can't get a
+ *                                 fresh SessionStart signal.
  *   - NOT `willReattachPersistent` — on daemon restart / worker recovery the
  *                                 worker re-attaches to an existing tmux/zellij/
  *                                 herdr session and does NOT re-run the CLI's
@@ -51,13 +56,16 @@
  * exactly as before (readyPattern + quiescence).
  *
  * NB: `wrapperCli=aiden x claude` strips our process-level `--settings`, but the
- * SessionStart hook is ALSO installed globally (~/.claude/settings.json — see
+ * SessionStart hook is installed in the effective settings.json (see
  * claude-code.ts hookInstall.sessionStartCommand), which aiden's Claude still
  * reads. So the real signal fires there too → we KEEP arming for that case
  * (no readyPattern fallback, which could misjudge).
  */
 export function shouldArmReadyGate(state) {
-    return state.injectsReadyHook && !state.adoptMode && !state.willReattachPersistent;
+    return state.injectsReadyHook
+        && state.readySignalAvailable
+        && !state.adoptMode
+        && !state.willReattachPersistent;
 }
 export class ReadyGate {
     armed = false;

package/dist/utils/ready-gate.js.map

@@ -1 +1 @@
-{"version":3,"file":"ready-gate.js","sourceRoot":"","sources":["../../src/utils/ready-gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAIlC;IACC,OAAO,KAAK,CAAC,gBAAgB,IAAI,CAAC,KAAK,CAAC,SAAS,IAAI,CAAC,KAAK,CAAC,sBAAsB,CAAC;AACrF,CAAC;AAED,MAAM,OAAO,SAAS;IACZ,KAAK,GAAG,KAAK,CAAC;IACd,QAAQ,GAAG,KAAK,CAAC;IAEzB,oFAAoF;IACpF,GAAG;QACD,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;IACpB,CAAC;IAED,qFAAqF;IACrF,UAAU;QACR,OAAO,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;IACtC,CAAC;IAED;;;;;;OAMG;IACH,OAAO;QACL,IAAI,IAAI,CAAC,QAAQ;YAAE,OAAO,KAAK,CAAC;QAChC,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC;QAC9B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,qEAAqE;IACrE,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED,gEAAgE;IAChE,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;CACF"}
+{"version":3,"file":"ready-gate.js","sourceRoot":"","sources":["../../src/utils/ready-gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAKlC;IACC,OAAO,KAAK,CAAC,gBAAgB;WACxB,KAAK,CAAC,oBAAoB;WAC1B,CAAC,KAAK,CAAC,SAAS;WAChB,CAAC,KAAK,CAAC,sBAAsB,CAAC;AACrC,CAAC;AAED,MAAM,OAAO,SAAS;IACZ,KAAK,GAAG,KAAK,CAAC;IACd,QAAQ,GAAG,KAAK,CAAC;IAEzB,oFAAoF;IACpF,GAAG;QACD,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;IACpB,CAAC;IAED,qFAAqF;IACrF,UAAU;QACR,OAAO,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;IACtC,CAAC;IAED;;;;;;OAMG;IACH,OAAO;QACL,IAAI,IAAI,CAAC,QAAQ;YAAE,OAAO,KAAK,CAAC;QAChC,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC;QAC9B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,qEAAqE;IACrE,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED,gEAAgE;IAChE,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;CACF"}

package/dist/worker.js

@@ -72,7 +72,7 @@ import { createCliAdapterSync, locateOnPath } from './adapters/cli/registry.js';
 import { buildWrappedLaunch, parseWrapperCli, isTtadkWrapper } from './setup/cli-selection.js';
 import { cliUnavailableMessage } from './setup/cli-availability.js';
 import { findLaunchedCliPid, scheduleWrapperRealCliPid, readComm, isBareShellComm, bareShellLaunchKind } from './core/session-discovery.js';
-import { claudeJsonlPathForSession, resolveJsonlFromPid, findOpenClaudeSessionIds, DEFAULT_CLAUDE_DATA_DIR } from './adapters/cli/claude-code.js';
+import { claudeJsonlPathForSession, resolveJsonlFromPid, findOpenClaudeSessionIds, syncClaudeResumeTargetToCwd, DEFAULT_CLAUDE_DATA_DIR } from './adapters/cli/claude-code.js';
 import { sessionReadyHookCommand } from './adapters/hook-command.js';
 import { mtrSessionIdForBotmuxSession } from './adapters/cli/mtr.js';
 import { HerdrBackend } from './adapters/backend/herdr-backend.js';
@@ -83,7 +83,7 @@ import { ZellijObserveBackend } from './adapters/backend/zellij-observe-backend.
 import { zellijEnv } from './setup/ensure-zellij.js';
 import { isObserveBackend } from './adapters/backend/types.js';
 import { selectSessionBackend, decideBackendGate, backendGateUserMessage } from './adapters/backend/session-backend-selector.js';
-import { deriveRiffReposFromDirs, deriveRiffRepoFromWorkingDir, isValidRiffBaseUrl } from './adapters/backend/riff-backend.js';
+import { deriveRiffReposFromDirs, deriveRiffRepoFromWorkingDir, isValidRiffBaseUrl, isValidRiffSandboxCluster, } from './adapters/backend/riff-backend.js';
 import { prepareSandbox, attachSandboxOutbox, startOutboxWatcher, sandboxEnabled, sandboxedClaudeDataDir, localSandboxApplies } from './adapters/backend/sandbox.js';
 import { tmuxEnv, probeTmuxFunctionalWithRetry } from './setup/ensure-tmux.js';
 import { tmuxRestartJitterMs } from './core/tmux-recovery.js';
@@ -102,12 +102,13 @@ import { config, resolveChatBotDiscoveryConfig } from './config.js';
 import * as sessionStore from './services/session-store.js';
 import * as pty from 'node-pty';
 import { createHash } from 'node:crypto';
-import { installHook } from './adapters/hook-installer.js';
+import { hasInstalledSessionReadyHook, installHook, } from './adapters/hook-installer.js';
 import { hookCommandFor } from './adapters/hook-command.js';
+import { parseDaemonIpcPort } from './utils/daemon-discovery.js';
 import { withCodexAppContext } from './utils/codex-app-context.js';
 import { resolveCodexAppFinalTurnIdentity } from './adapters/cli/codex-app-turn.js';
 import { RunnerControlDecoder } from './adapters/cli/runner-control-channel.js';
-import { managedOriginCapabilityPath, RELAY_ORIGIN_CAPABILITY_BASENAME, replaceManagedOriginCapabilityFile, } from './core/managed-origin-capability.js';
+import { hasMatchingManagedOriginCapability, managedOriginCapabilityPath, RELAY_ORIGIN_CAPABILITY_BASENAME, replaceManagedOriginCapabilityFile, } from './core/managed-origin-capability.js';
 // ─── State ───────────────────────────────────────────────────────────────────
 let cliAdapter = null;
 let backend = null;
@@ -186,6 +187,24 @@ function provisionIsolatedBotHome(botHome, workingDir, isClaude, cliId, hookInst
         if (isClaude) {
             const cdir = join(botHome, 'claude');
             mkdirSync(cdir, { recursive: true });
+            // Settings: read-isolated Claude uses a fresh CLAUDE_CONFIG_DIR, so it
+            // otherwise loses provider auth/model/proxy values held in the shared
+            // ~/.claude/settings.json `env` map. Merge that map on EVERY cold spawn,
+            // then install botmux hooks into the same per-bot file. Global hooks and
+            // unrelated top-level settings are not inherited.
+            const isolatedSettingsPath = join(cdir, 'settings.json');
+            if (hookInstall) {
+                try {
+                    installHook(cliId, {
+                        ...hookInstall,
+                        configPath: isolatedSettingsPath,
+                        inheritClaudeEnvFrom: join(homedir(), '.claude', 'settings.json'),
+                    }, hookCommandFor(cliId));
+                }
+                catch (e) {
+                    log(`[read-isolation] WARN per-bot settings/hook install failed: ${e.message}`);
+                }
+            }
             // Auth: a fresh CLAUDE_CONFIG_DIR does NOT inherit the shared account's OAuth
             // token → keep <cdir>/.credentials.json synced to the FRESHEST valid credential
             // on EVERY spawn (verified: Claude logs in from that file). Refreshing here (not
@@ -194,24 +213,14 @@ function provisionIsolatedBotHome(botHome, workingDir, isClaude, cliId, hookInst
             const fresh = freshestClaudeCred();
             if (fresh)
                 writeCredIfChanged(join(cdir, '.credentials.json'), fresh);
-            else if (!existsSync(join(cdir, '.credentials.json'))) {
-                log(`[read-isolation] WARN no Claude credential found (keychain or ~/.claude/.credentials.json) — bot may hit login screen`);
+            else if (!existsSync(join(cdir, '.credentials.json'))
+                && !claudeSettingsHasProviderAuth(isolatedSettingsPath)) {
+                log(`[read-isolation] WARN no Claude provider auth found (global settings env, keychain, or ~/.claude/.credentials.json) — bot may hit login screen`);
             }
             // State: seed <cdir>/.claude.json from the GLOBAL one MINUS `projects` (keeps the
             // onboarding/promo "seen" flags + account so no dialogs appear, without leaking
             // other projects' data), then trust this bot's cwd. Merge-safe on resume.
             seedAndTrustClaudeState(join(cdir, '.claude.json'), workingDir, log);
-            // Hooks: install the SessionStart-ready + askUserQuestion hooks into the PER-BOT
-            // settings.json (global ~/.claude/settings.json is Seatbelt-denied), else the
-            // worker's ready gate falls back to a slow timeout and AskUserQuestion won't relay.
-            if (hookInstall) {
-                try {
-                    installHook(cliId, { ...hookInstall, configPath: join(cdir, 'settings.json') }, hookCommandFor(cliId));
-                }
-                catch (e) {
-                    log(`[read-isolation] WARN per-bot hook install failed: ${e.message}`);
-                }
-            }
         }
         else {
             const cdir = join(botHome, 'codex');
@@ -232,6 +241,22 @@ function provisionIsolatedBotHome(botHome, workingDir, isClaude, cliId, hookInst
         log(`[read-isolation] WARN provisioning bot home failed: ${e.message}`);
     }
 }
+function claudeSettingsHasProviderAuth(settingsPath) {
+    try {
+        const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+        const env = settings.env;
+        if (!env || typeof env !== 'object' || Array.isArray(env))
+            return false;
+        const record = env;
+        return ((typeof record.ANTHROPIC_AUTH_TOKEN === 'string' && record.ANTHROPIC_AUTH_TOKEN.length > 0)
+            || (typeof record.ANTHROPIC_API_KEY === 'string' && record.ANTHROPIC_API_KEY.length > 0)
+            || record.CLAUDE_CODE_USE_BEDROCK === '1'
+            || record.CLAUDE_CODE_USE_VERTEX === '1');
+    }
+    catch {
+        return false;
+    }
+}
 /** Pick the FRESHEST valid Claude OAuth credential: macOS keychain vs the global
  *  `~/.claude/.credentials.json`, by `claudeAiOauth.expiresAt` (longest runway
  *  wins — a re-login updates one of the two, and this picks whichever is newer).
@@ -724,6 +749,15 @@ async function deliverRawInput(msg) {
     const targetBackend = backend;
     if (!targetBackend)
         return;
+    // A passthrough is still an accepted input boundary. Rotate (or revoke) the
+    // marker immediately before the literal command reaches the CLI so it can
+    // never inherit a previous human turn. System-generated raw commands omit
+    // turnId and therefore publish an explicitly unattributed marker.
+    currentBotmuxTurnId = msg.turnId;
+    currentBotmuxDispatchAttempt = undefined;
+    currentVcMeetingImTurnOrigin = undefined;
+    writeCliPidMarker();
+    publishSandboxRelayCapability();
     let sent = false;
     try {
         await sendRawCommandLineSerially(targetBackend, msg.content);
@@ -741,7 +775,7 @@ async function deliverRawInput(msg) {
     // Enter lands. sendToPty also observes commandLineWritesPending, so another
     // raw command's text -> Enter window cannot be interrupted by the follow-up.
     if (sent && msg.followUpContent) {
-        sendToPty(msg.followUpContent, undefined, {
+        sendToPty(msg.followUpContent, msg.followUpTurnId, {
             codexAppInput: msg.followUpCodexAppInput,
         });
         log(`Enqueued follow-up after raw input (${msg.followUpContent.length} chars)`);
@@ -789,18 +823,28 @@ function publishSandboxRelayCapability(opts = {}) {
                 }]
             : []),
     ];
+    let publishError;
     for (const file of files) {
         try {
             replaceManagedOriginCapabilityFile(file.path, file.body);
         }
         catch (err) {
             log(`Failed to publish managed origin capability: ${err?.message ?? err}`);
-            if (opts.failClosed) {
-                unlinkManagedOriginCapabilityFiles();
-                throw err;
-            }
+            publishError = err;
+            break;
         }
     }
+    if (publishError) {
+        // The disk/daemon/worker views must rotate as one authority generation. If
+        // the child-visible transport cannot publish the new token, revoke the old
+        // generation and leave no in-memory authority for ready/send preflights to
+        // mistake as usable. Any files written before a later failure are removed
+        // by the revocation helper as well.
+        completeManagedTurnOriginRevocation(sandboxRelayCapability, currentBotmuxTurnId, currentBotmuxDispatchAttempt);
+        if (opts.failClosed)
+            throw publishError;
+        return false;
+    }
     sandboxRelayCapability = capability;
     if (sessionId) {
         send({
@@ -813,6 +857,7 @@ function publishSandboxRelayCapability(opts = {}) {
                 : {}),
         });
     }
+    return true;
 }
 function unlinkManagedOriginCapabilityFiles() {
     const files = [
@@ -4381,8 +4426,14 @@ function detectBareShellLaunch() {
     else {
         message =
             `⚠️ 会话没能启动：pane 里还停在 \`${comm}\`，${cli} 没真正跑起来——我没把消息打进去（否则会被当 shell 命令执行）。\n\n` +
-                `可能原因：rc 文件启动过慢/报错，或 \`${cli}\` 的可执行文件不在 PATH 上（CLI 没找到）。\n` +
-                `建议：在 web 终端里手动敲一下启动命令看报什么错；确认 CLI 二进制能在 PATH 上找到；或精简 rc 启动逻辑后重启 daemon 再试。`;
+                `最常见原因：rc 文件里有交互式提示卡住了 shell 启动，例如：\n` +
+                `① Oh My Zsh 升级提示（"Would you like to update Oh My Zsh? [Y/n]"）——${comm} source ~/.zshrc 时弹出，等你按 Y/n，CLI 的启动命令没机会跑\n` +
+                `② git 凭据弹窗（GIT_TERMINAL_PROMPT）或其它需要交互输入的启动脚本\n` +
+                `③ ${cli} 的可执行文件不在 PATH 上（CLI 没找到）\n\n` +
+                `修法（任选其一，改完重启 daemon 再发一条消息）：\n` +
+                `• 最省事：升级 botmux 到含自动注入 DISABLE_AUTO_UPDATE=true 的版本（仅 botmux 托管 shell 启动时跳过 oh-my-zsh 升级检查，不影响你自己的终端）\n` +
+                `• 手动修：在 ~/.zshrc 的 source $ZSH/oh-my-zsh.sh 之前加一行 DISABLE_UPDATE_PROMPT="true"（自动升级不弹提示）；或加 DISABLE_AUTO_UPDATE="true"（完全跳过升级检查）\n` +
+                `• 在 web 终端里手动敲一下启动命令看报什么错；确认 CLI 二进制能在 PATH 上找到；或精简 rc 启动逻辑后重启 daemon 再试`;
     }
     send({ type: 'user_notify', turnId: currentBotmuxTurnId, dispatchAttempt: currentBotmuxDispatchAttempt, message });
     return true;
@@ -5300,6 +5351,9 @@ function spawnCli(cfg) {
         if (!isValidRiffBaseUrl(cfg.backendConfig.baseUrl)) {
             throw new Error(`riff baseUrl 未配置或非法（需 http(s) URL，当前: ${JSON.stringify(cfg.backendConfig.baseUrl ?? null)}）——请在 dashboard 的 Riff 配置中填写`);
         }
+        if (cfg.backendConfig.sandboxCluster !== undefined && !isValidRiffSandboxCluster(cfg.backendConfig.sandboxCluster)) {
+            throw new Error(`riff sandboxCluster 非法（仅支持 boe/cn，当前: ${JSON.stringify(cfg.backendConfig.sandboxCluster)}）——请在 dashboard 的 Riff 配置中重新选择`);
+        }
         const sessionEnv = {
             BOTMUX_SESSION_ID: cfg.sessionId,
             BOTMUX_CHAT_ID: cfg.chatId,
@@ -5372,6 +5426,7 @@ function spawnCli(cfg) {
     // JSONL/pid/bridge gate below keys off it instead of `cliId === 'claude-code'`,
     // so a fork inherits the whole submit-confirm + bridge-fallback machinery.
     let claudeDataDir = cliAdapter.claudeDataDir;
+    let effectiveReadyHookInstall = cliAdapter.hookInstall;
     // When this session will be file-sandboxed, the CLI's session jsonl is written
     // into the overlay's EPHEMERAL home upper (CLAUDE_CONFIG_DIR lives under $HOME),
     // invisible at the real path the bridge normally watches → "Bridge mark expired"
@@ -5382,7 +5437,10 @@ function spawnCli(cfg) {
         (effectiveBackendType === 'pty' || effectiveBackendType === 'tmux') &&
         !!process.env.SESSION_DATA_DIR;
     if (claudeDataDir && willFileSandbox) {
-        const redirected = sandboxedClaudeDataDir(cfg.sessionId, claudeDataDir);
+        const redirected = sandboxedClaudeDataDir(cfg.sessionId, claudeDataDir, {
+            sourceWorkingDir: cfg.workingDir,
+            dataDir: process.env.SESSION_DATA_DIR,
+        });
         log(`[sandbox] redirecting Claude bridge dataDir → overlay upper: ${redirected}`);
         claudeDataDir = redirected;
     }
@@ -5465,6 +5523,12 @@ function spawnCli(cfg) {
         // Provision the per-bot config dir (auth + onboarding/trust seed + hooks for claude;
         // auth/config copy for codex) so the CLI starts fully set up under the Seatbelt wrapper.
         provisionIsolatedBotHome(isolationBotHome, cfg.workingDir, isClaudeFam, cfg.cliId, cliAdapter.hookInstall, log);
+        if (isClaudeFam && effectiveReadyHookInstall) {
+            effectiveReadyHookInstall = {
+                ...effectiveReadyHookInstall,
+                configPath: join(claudeDataDir, 'settings.json'),
+            };
+        }
         if (cliAdapter.mcpGateway) {
             const isolatedConfigPath = isClaudeFam
                 ? join(claudeDataDir, '.claude.json')
@@ -5586,6 +5650,26 @@ function spawnCli(cfg) {
     let effectiveResume = cfg.resume ?? false;
     let effectiveCliSessionId = cfg.cliSessionId;
     let effectiveAdapterSessionId = adapterSessionId;
+    // Claude-family transcripts are scoped by cwd. `/cd` keeps the same Botmux /
+    // CLI session id, so mirror the newest native transcript into the new cwd's
+    // project directory before the adapter probes or launches `--resume`.
+    // `claudeDataDir` is already the effective root here (global, per-bot read
+    // isolation root, or a preserved sandbox upper), so this never crosses bot
+    // isolation boundaries.
+    if (effectiveResume && !willReattachPersistent && claudeDataDir) {
+        const resumeSessionId = effectiveCliSessionId ?? effectiveAdapterSessionId;
+        try {
+            const synced = syncClaudeResumeTargetToCwd(resumeSessionId, cfg.workingDir, claudeDataDir);
+            if (synced.copied && synced.sourcePath) {
+                log(`Claude resume transcript synced for cwd change: ${synced.sourcePath} → ${synced.targetPath}`);
+            }
+        }
+        catch (err) {
+            // Preserve the existing fail-safe: the adapter probe / two-tier fallback
+            // below still decides whether resume is possible.
+            log(`WARN Claude resume transcript sync failed: ${err.message}`);
+        }
+    }
     const tier2ForceFresh = effectiveResume && consecutiveInWorkerRestarts >= 2;
     let tier1ProbeFalse = false;
     if (effectiveResume && !tier2ForceFresh && !willReattachPersistent) {
@@ -6461,15 +6545,22 @@ function spawnCli(cfg) {
             codexBridgeStartTimer();
         }
     }
-    // Arm the ready-gate for FRESH Claude-family spawns (which inject the
-    // SessionStart hook via --settings; see claude-code.ts buildArgs). Until
+    // Arm the ready-gate for FRESH ready-integrated spawns. Until
     // `botmux session-ready` fires (daemon → 'session_ready' IPC → releaseReadyGate)
     // we hold the first prompt so a cjadk-style startup selector's ❯ can't eat it.
-    // shouldArmReadyGate() excludes adopt (pre-existing pane, no --settings) AND
+    // shouldArmReadyGate() excludes adopt (pre-existing pane, no fresh hook) AND
     // persistent-backend reattach (daemon restart re-attaches an already-running
     // tmux/zellij/herdr Claude WITHOUT re-running its bin/args → no new
     // SessionStart hook → arming would hold the first post-recovery message until
-    // the timeout). Fallback: release after READY_SIGNAL_TIMEOUT_MS → readyPattern.
+    // the timeout).
+    //
+    // Installation is best-effort, so verify the hook in the EFFECTIVE config
+    // (global for ordinary sessions, per-bot CLAUDE_CONFIG_DIR under read
+    // isolation) before arming. Isolated children also need the injected loopback
+    // port plus a published rotating capability; without either the hook could
+    // run but never reach the daemon. A failed preflight leaves the gate open and
+    // immediately falls back to the adapter's normal readyPattern/quiescence path
+    // instead of blindly waiting READY_SIGNAL_TIMEOUT_MS.
     readyGate = new ReadyGate();
     if (readySignalTimer) {
         clearTimeout(readySignalTimer);
@@ -6483,8 +6574,29 @@ function spawnCli(cfg) {
     promptReadyDetectedDuringSettle = false;
     // Reset quiescence baseline so the settle measures silence from THIS spawn.
     lastPtyOutputAtMs = Date.now();
+    const readyHookAvailable = effectiveReadyHookInstall
+        ? hasInstalledSessionReadyHook(effectiveReadyHookInstall)
+        : true; // Hermes emits BOTMUX_READY_COMMAND directly instead of a config hook.
+    const isolatedReadyTransportRequired = sandboxOn || willReadIsolate;
+    const readyPortAvailable = !isolatedReadyTransportRequired
+        || parseDaemonIpcPort(childEnv.BOTMUX_DAEMON_IPC_PORT) !== undefined;
+    const readyCapabilityAvailable = !isolatedReadyTransportRequired
+        || hasMatchingManagedOriginCapability(process.env.SESSION_DATA_DIR ?? '', cfg.sessionId, sandboxRelayCapability?.token, sandboxRelayOutbox ?? undefined);
+    const readySignalAvailable = readyHookAvailable && readyPortAvailable && readyCapabilityAvailable;
+    const freshReadyGateCandidate = cliAdapter.injectsReadyHook === true
+        && cfg.adoptMode !== true
+        && !willReattachPersistent;
+    if (freshReadyGateCandidate && !readySignalAvailable) {
+        const reasons = [
+            ...(!readyHookAvailable ? ['SessionStart hook missing from effective config'] : []),
+            ...(!readyPortAvailable ? ['BOTMUX_DAEMON_IPC_PORT missing/invalid'] : []),
+            ...(!readyCapabilityAvailable ? ['ready capability transport missing, unreadable, or stale'] : []),
+        ];
+        log(`Ready gate skipped — preflight failed: ${reasons.join('; ')}`);
+    }
     if (shouldArmReadyGate({
         injectsReadyHook: cliAdapter.injectsReadyHook === true,
+        readySignalAvailable,
         adoptMode: cfg.adoptMode === true,
         willReattachPersistent,
     })) {