wezard 1.3.22 → 1.4.0

package/dist/daemon/mirror-bridge.js

@@ -20,11 +20,12 @@ import { activeBackends, backendForPath, projectDirFor, projectDirsFor, } from "
 import { isModalPane, isAskqSubmitPage, parseModalOptions, pickModalAnswer, pickAutoAllowAnswer, parseConfirmContext, looksLikePicker } from "../shared/modal-pane.js";
 import { hasMirrorAskq, runMirrorAskqFlow, hasMirrorPlan, mootMirrorPlan, runMirrorPlanFlow, hasMirrorPicker, mootMirrorPicker, runMirrorPickerFlow } from "./approval.js";
 import { isAutoWindowActive } from "./session-cache.js";
+import { noticeSuffixFor } from "./notices.js";
 import { dangerOf } from "./danger.js";
 import { runTmux as runTmuxCmd, spawnTmuxClaude } from "./spawn-tmux.js";
 import { startSubagentWatch } from "./subagent-tail.js";
 import { recordTool, recordToolResult, recordMark, recordTurnStart, recordTurnItem, recordTurnUsage, recordTurnClose, recordCloseOpenTurns, buildDetailUrl, buildChatUrl } from "./detail.js";
-import { labelFor, tagOfKey, baseOfKey, keyOf, withTagHeader, parseTagHeader } from "../shared/session-label.js";
+import { labelFor, tagOfKey, baseOfKey, keyOf, withTagHeader, headSep, parseTagHeader } from "../shared/session-label.js";
 import { splitMarkdown } from "../shared/md-chunk.js";
 import { randomTip } from "./tips.js";
 import { chatBaseOf, chatNameOf, listChatNames, normChatName, parsePeerRef, peerAddress } from "./chat-name.js";
@@ -1683,7 +1684,7 @@ export const startMirror = (deps) => {
         const prefix = linkedTagPrefix(a.target, turnId ?? a.briefTurnId);
         if (prefix) {
             const seqBit = seq ? ` ${seq}` : "";
-            return `${prefix}${seqBit} ${content}`;
+            return `${prefix}${seqBit}${headSep(content)}${content}`;
         }
         return withSessionTag(a.target, content, seq);
     };
@@ -2109,12 +2110,15 @@ export const startMirror = (deps) => {
         a.pendingOrigin = undefined;
         return p && Date.now() - p.at <= ORIGIN_TTL_MS ? p.origin : undefined;
     };
+    // 详情页要按后端的名字称呼它 ("Claude 正在思考" / "CodeBuddy 正在思考") —— 后端
+    // 由 transcript 落盘路径唯一确定, 所以每次开 turn 时现算, 不必额外记在 AttachState 上。
+    const cliOf = (a) => a.jsonlPath ? backendForPath(a.jsonlPath).name : undefined;
     const startBriefTurn = async (a, frame, streamId, isSlash = false, userQuery = "") => {
         const turnId = newTurnId();
         a.queryEpoch = (a.queryEpoch ?? 0) + 1; // WeCom 侧的新一轮同样是 query 边界
         a.turnFromChat = true; // 出处确凿: 这一轮有 frame, 群里就是它的主场
         a.pendingFromCli = false; // 人改从聊天里说话了, 之前那条 CLI 输入不再是出处
-        recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, cwd: a.runningCwd || undefined, userQuery: userQuery.trim() || undefined, origin: consumeOrigin(a) });
+        recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, cli: cliOf(a), cwd: a.runningCwd || undefined, userQuery: userQuery.trim() || undefined, origin: consumeOrigin(a) });
         // hardTimer 兜底: turn 若无终句 / turn_end 收口 (卡死/漏收), 到点仍收气泡。
         const bubble = { frame, streamId, hardTimer: undefined, done: false };
         const q = { turnId, bubble, isSlash };
@@ -2160,7 +2164,7 @@ export const startMirror = (deps) => {
         const fromCli = a.pendingFromCli === true;
         a.pendingFromCli = false;
         a.turnFromChat = fromCli ? false : a.turnFromChat ?? true;
-        recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, cwd: a.runningCwd || undefined, userQuery: query || undefined, origin: consumeOrigin(a) });
+        recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, cli: cliOf(a), cwd: a.runningCwd || undefined, userQuery: query || undefined, origin: consumeOrigin(a) });
         a.briefTurnId = turnId;
         a.briefBubble = undefined;
         a.briefIsSlash = false;
@@ -2311,6 +2315,7 @@ export const startMirror = (deps) => {
                 id: turnId,
                 target: a.target,
                 sessionId: a.sessionId,
+                cli: cliOf(a),
                 cwd: a.runningCwd || undefined,
                 userQuery: task,
                 agent: { id: agentId, type: resolved?.type, description: resolved?.description, parentTurnId: a.briefTurnId },
@@ -2665,7 +2670,7 @@ export const startMirror = (deps) => {
         if (!a.keepaliveTurnId) {
             const turnId = newTurnId();
             a.keepaliveTurnId = turnId;
-            recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, userQuery: text });
+            recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, cli: cliOf(a), userQuery: text });
         }
     };
     // A keepalive ping turn is swallowed wholesale — the reply content doesn't
@@ -3057,7 +3062,7 @@ export const startMirror = (deps) => {
     const detailUrlFor = (id, principal) => cfg.daemon.detailLinksInMirror && id
         ? buildDetailUrl(cfg.daemon.detailPublicBase, cfg.daemon.host, cfg.daemon.port, id, principal ? stripPrincipalPrefix(principal) : undefined)
         : "";
-    const attach = ({ sessionId, jsonlPath, target: targetOverride, tmuxPane, tmuxSession, cwd, pendingCwd }) => {
+    const attach = ({ sessionId, jsonlPath, target: targetOverride, tmuxPane, tmuxSession, cwd, model, pendingCwd }) => {
         const target = resolveTarget(targetOverride);
         if (!target)
             return { ok: false, reason: "no target chat (set wrc.mirror.pushChat or defaultChat, or pass target)" };
@@ -3083,6 +3088,10 @@ export const startMirror = (deps) => {
         // otherwise. `undefined` (omitted) → carry from prev (re-attach case);
         // `""` → explicit clear (newSession just consumed it); `"/foo"` → set.
         const carryPending = pendingCwd !== undefined ? pendingCwd : (prevByTarget?.pendingCwd ?? "");
+        // Same carry rule as pendingCwd, and for the same reason: a spawn knows the
+        // model it asked for (possibly "" = CLI default) and says so; a re-attach
+        // onto an already-running pane doesn't, so it keeps what was recorded.
+        const carryModel = model !== undefined ? model.trim() : (prevByTarget?.model ?? deps.store.get(target)?.model ?? "");
         if (prevByTarget)
             detach(prevByTarget, "target reassigned");
         // Build the attachment first so the tail's onItem closure can capture it.
@@ -3097,6 +3106,7 @@ export const startMirror = (deps) => {
             // collapsing to cfg.wrc.cwd (which would mislabel /pwd, /clear, /new).
             runningCwd: expandHome(((cwd ?? "").trim()) || readCwdFromJsonl(jsonlPath) || cfg.wrc.cwd),
             pendingCwd: carryPending,
+            model: carryModel,
             tail: { stop: () => undefined, drain: () => undefined, livePath: () => undefined }, // placeholder; replaced below
             standalonePending: Promise.resolve(),
             recentToolSigs: new Map(),
@@ -3133,6 +3143,7 @@ export const startMirror = (deps) => {
             tmuxSession: a.tmuxSession || undefined,
             tmuxPane: a.tmuxPane || undefined,
             cwd: a.runningCwd || undefined,
+            model: a.model || undefined,
             pendingCwd: a.pendingCwd || undefined,
             keepaliveOff: prevRec?.keepaliveOff,
             keepaliveOffAt: prevRec?.keepaliveOffAt,
@@ -3271,6 +3282,7 @@ export const startMirror = (deps) => {
             tmuxPane: livePane,
             tmuxSession: rec.tmuxSession ?? "",
             cwd: rec.cwd,
+            model: rec.model,
             pendingCwd: rec.pendingCwd,
         });
         if (!r.ok) {
@@ -3357,6 +3369,15 @@ export const startMirror = (deps) => {
         const t = text.trim();
         return t === "/clear" || t.startsWith("/clear ") || t.startsWith("/clear\n");
     };
+    /** mtime(ms), 0 when unreadable — "newest transcript wins" 的排序键。 */
+    const mtimeOf = (path) => {
+        try {
+            return statSync(path).mtimeMs;
+        }
+        catch {
+            return 0;
+        }
+    };
     const listJsonls = (dir) => {
         try {
             return new Set(readdirSync(dir).filter((n) => n.endsWith(".jsonl")));
@@ -3832,6 +3853,20 @@ export const startMirror = (deps) => {
     // /new path: kill the old pane (so we don't leak orphan tmux windows) and
     // spawn a fresh claude in pendingCwd ?? runningCwd ?? default. Returns the
     // new sessionId/cwd so callers can render the user-facing reply.
+    // 身份提供者。newSession / 重生 / clone 全都从这里取「这个 target 是谁」, 于是
+    // 无论是群里手打的 /new、pane 死了的自愈重生, 还是编排生出来的分身, 新进程一
+    // 睁眼就知道自己是谁 —— 而不是只有走 wizard 路由那一条路才有身份。
+    // 由 index.ts 在启动时装上 (注册表活在那边); 没装 = 退回无身份行为, 全链路无回归。
+    let charterOf;
+    const setCharterProvider = (fn) => { charterOf = fn; };
+    const charterFor = (target) => {
+        try {
+            return charterOf?.(target);
+        }
+        catch {
+            return undefined;
+        }
+    };
     const newSession = async (target, windowName, cli, opts) => {
         const prev = byTarget.get(target);
         // Resolution precedence (all chat-scoped except the running-cwd fallback):
@@ -3876,6 +3911,7 @@ export const startMirror = (deps) => {
             cwdOverride: eff,
             cli: effCli,
             model: opts?.model,
+            systemPrompt: opts?.systemPrompt ?? charterFor(target),
         });
         if (!r.ok)
             return { ok: false, reason: r.reason };
@@ -3888,6 +3924,9 @@ export const startMirror = (deps) => {
             cwd: r.cwd,
             // Explicit "" clears any carried-over pending — it has just been applied.
             pendingCwd: "",
+            // Likewise explicit: `/new` starts a NEW session, so an unnamed model
+            // means this CLI's default, not the dead pane's model.
+            model: opts?.model?.trim() ?? "",
         });
         if (!att.ok)
             return { ok: false, reason: att.reason };
@@ -3935,6 +3974,133 @@ export const startMirror = (deps) => {
             pushProjectInfo(target, "created");
         return { ok: true, sessionId: r.sessionId, cwd: r.cwd };
     };
+    // ── Clone ───────────────────────────────────────────────────────────
+    // 分身 = `--resume <父 sid> --fork-session` 起的新 pane: CLI 把父亲的 transcript
+    // 复制成一份新的再继续写, 于是子进程开局就带着父亲此刻读过的一切 (规范、目录、
+    // 刚啃完的那份文档), 而父亲毫发无损。这正是「先把公共材料载进一个基座, 再从它
+    // 身上分出 N 个干活的」所需要的语义: 材料只读一遍, 却进了 N 份上下文。
+    //
+    // 两件事非做不可:
+    //   `--fork-session` —— 少了它, 这个 pane 会**续写父亲的 jsonl**。两个 pane 写
+    //     同一个 transcript, 两个 target 指向同一个 sid, 群与群从此串线且无法回滚。
+    //   先说话再 attach —— 分叉文件不是开机就有的, CLI 在收到第一条消息那一刻才写。
+    //     所以 spawn 之后先注入开场白, 等分叉出现拿到它自己的 sid, 再 attach。等不到
+    //     就把 pane 一起收掉: 那时唯一已知的 sid 是父亲的, 认下去就是上面那种串线
+    //     (attach 也会正当地拒绝), 一个干净的失败远比一条错绑好收拾。
+    const FORK_POLL_MS = 400;
+    const FORK_WAIT_MS = 45_000;
+    const awaitFork = async (projectDir, baseline, claimed) => {
+        const deadline = Date.now() + FORK_WAIT_MS;
+        while (Date.now() < deadline) {
+            const born = [...listJsonls(projectDir)]
+                .filter((n) => !baseline.has(n) && !claimed.has(n.replace(/\.jsonl$/, "")))
+                .map((n) => ({ n, path: join(projectDir, n) }))
+                // 种子化的 fork 一落地就带着父亲的 user 行 —— 空文件 (刚 touch 出来的)
+                // 还不能认, 认早了 tail 会从一个还没写完的复制过程中间开始读。
+                .filter((c) => firstUserUuid(c.path) !== undefined)
+                .sort((x, y) => mtimeOf(y.path) - mtimeOf(x.path));
+            const hit = born[0];
+            if (hit)
+                return { sessionId: hit.n.replace(/\.jsonl$/, ""), jsonlPath: hit.path };
+            await sleepMs(FORK_POLL_MS);
+        }
+        return undefined;
+    };
+    const cloneSession = async (args) => {
+        const p = byTarget.get(args.parent) ?? (await restoreFromStore(args.parent));
+        // 继承上下文要求父亲有一个活着的 transcript, 且分身必须待在同一个项目目录 ——
+        // `--resume` 是按项目目录寻址 session 的。调用方点名换目录 = 明确放弃继承。
+        const sameCwd = !args.cwd?.trim() || expandHome(args.cwd.trim()) === (p?.runningCwd ?? "");
+        const canInherit = args.inherit !== false && !!p?.sessionId && !!p.jsonlPath && existsSync(p.jsonlPath) && sameCwd;
+        if (!canInherit) {
+            const r = await newSession(args.target, args.windowName, args.cli, {
+                model: args.model, cwd: args.cwd, systemPrompt: args.systemPrompt, silent: true,
+            });
+            return { ...r, inherited: false };
+        }
+        const parent = p;
+        const projectDir = dirname(parent.jsonlPath);
+        const baseline = listJsonls(projectDir);
+        const lg = log.child({ sub: "clone", target: args.target });
+        const r = await spawnTmuxClaude({
+            cfg,
+            log: lg,
+            resumeSessionId: parent.sessionId,
+            forkSession: true,
+            windowName: args.windowName ?? args.target,
+            cwdOverride: parent.runningCwd,
+            cli: backendForPath(parent.jsonlPath).name,
+            model: args.model,
+            systemPrompt: args.systemPrompt,
+        });
+        if (!r.ok)
+            return { ok: false, reason: r.reason, inherited: false };
+        // 分叉文件不是开机就有的: CLI 在这个 pane **收到第一条消息**的那一刻才把父亲的
+        // transcript 复制成新文件。所以必须先说一句话, 分身才会有自己的 sid —— 这句话
+        // 顺便就是它的开场白 (「你是谁、继承了什么、准备接什么」), 群里看到的第一条也是它。
+        const hello = args.bootstrap?.trim()
+            || "（wezard 分身初始化）用一句话说明: 你是谁、从谁那里继承了哪些上下文、准备接什么活。不要复述这条指令。";
+        rememberInject(hello);
+        const boot = await inject({
+            text: hello, images: [], cfg, log: lg,
+            sessionId: parent.sessionId, jsonlPath: parent.jsonlPath,
+            tmuxTarget: r.tmuxPane, freshSpawn: true,
+        });
+        if (!boot.ok) {
+            await tmuxRun(["kill-pane", "-t", r.tmuxPane ?? ""]);
+            return { ok: false, reason: `分身开场白注入失败: ${boot.reason ?? "unknown"}`, inherited: false };
+        }
+        const fork = await awaitFork(projectDir, baseline, sidsClaimedByOthers(args.target));
+        // 等不到分叉就必须收手: 此刻唯一已知的 sid 是父亲的, 认下去两个 target 会指向
+        // 同一个会话 (attach 也会正当地拒绝)。留一个孤儿 pane 比留一条错绑更好收拾 ——
+        // 所以连 pane 一起杀掉, 调用方拿到的是一个干净的失败。
+        if (!fork) {
+            await tmuxRun(["kill-pane", "-t", r.tmuxPane ?? ""]);
+            return { ok: false, reason: "分身没能在超时内分叉出自己的会话 (CLI 可能不支持 --fork-session)", inherited: false };
+        }
+        const att = attach({
+            sessionId: fork.sessionId,
+            jsonlPath: fork.jsonlPath,
+            target: args.target,
+            tmuxPane: r.tmuxPane,
+            tmuxSession: r.tmuxSession,
+            cwd: r.cwd,
+            pendingCwd: "",
+            model: args.model?.trim() ?? "",
+        });
+        if (!att.ok)
+            return { ok: false, reason: att.reason, inherited: false };
+        const spawned = byTarget.get(args.target);
+        if (spawned) {
+            // muteUntilInject 是给"全新 pane 的 greeting 噪音"准备的; 分身的开场白是正经
+            // 内容 (群里第一条就该是它), 所以这里不静音。
+            spawned.justSpawned = true;
+            spawned.keepaliveOff = true;
+            spawned.keepaliveOffAt = Date.now();
+            spawned.keepalive = undefined;
+            persistPause(spawned);
+        }
+        lg.info({ parent: args.parent, sessionId: fork.sessionId }, "clone: forked");
+        return { ok: true, sessionId: fork.sessionId, cwd: r.cwd, inherited: true };
+    };
+    /** 一个会话此刻的硬事实 —— whoami / 交接判断要用的那几个数。 */
+    const sessionInfo = (target) => {
+        const a = byTarget.get(target);
+        const rec = a ? undefined : deps.store.get(target);
+        const sessionId = a?.sessionId ?? rec?.sessionId ?? "";
+        const jsonlPath = a?.jsonlPath ?? (rec?.jsonlPath ? expandHome(rec.jsonlPath) : "");
+        if (!sessionId || !jsonlPath)
+            return undefined;
+        return {
+            sessionId,
+            jsonlPath,
+            cwd: a?.runningCwd || rec?.cwd || "",
+            cli: backendForPath(jsonlPath).name,
+            model: a?.model || rec?.model || "",
+            tmuxPane: a?.tmuxPane ?? rec?.tmuxPane ?? "",
+            contextTokens: lastContextTokens(jsonlPath),
+        };
+    };
     const getCwd = (target) => {
         // pendingCwd is chat-scoped — a `set_workspace` from any sibling session
         // queues the switch for the whole chat. runningCwd stays per-session (each
@@ -4057,7 +4223,9 @@ export const startMirror = (deps) => {
             return {
                 ok: false,
                 reason: `chat '${chat}' has no ${t ? `'#${t}'` : "default"} session — create it with new_claude_session({ chat: '${chat}'${t ? `, tag: '${t}'` : ""}, cwd })`,
-                candidates: allTargets().filter((k) => basePrincipalOf(k) === c.base),
+                // 候选给**地址**而不是裸 key —— 这份清单存在的意义就是让调用方照着改一个
+                // 能用的串; 隔壁两个分支早就这么做了, 只有这一条漏掉。
+                candidates: allTargets().filter((k) => basePrincipalOf(k) === c.base).map((k) => peerAddress(cfg, self, k)),
             };
         }
         const local = keyOf(basePrincipalOf(self), t);
@@ -4167,6 +4335,7 @@ export const startMirror = (deps) => {
             jsonlPath,
             cwd: a?.runningCwd || rec?.cwd || expandedDefaultCwd,
             cli: jsonlPath ? backendForPath(jsonlPath).name : (activeBackends()[0]?.name ?? "claude"),
+            model: a?.model || rec?.model || "",
             tmuxPane: pane,
             attached: !!a,
             paneAlive,
@@ -4289,7 +4458,7 @@ export const startMirror = (deps) => {
         if (!a.keepaliveTurnId) {
             const turnId = newTurnId();
             a.keepaliveTurnId = turnId;
-            recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, userQuery: text });
+            recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, cli: cliOf(a), userQuery: text });
         }
     };
     let keepaliveTicking = false;
@@ -4702,7 +4871,7 @@ export const startMirror = (deps) => {
                 // 队列内单条失败已在 sendStandalone 里 warn 过, 这里吞掉, 不阻塞发卡。
             }
         },
-        injectText: async (target, text, origin) => {
+        injectText: async (target, text, origin, opts) => {
             // Lazy restore, same as dispatch: a peer session that hasn't been talked
             // to in this process lifetime (or any session after a reload) has an empty
             // in-memory slot but a perfectly good persisted binding. Without this, an
@@ -4712,10 +4881,17 @@ export const startMirror = (deps) => {
                 return { ok: false, reason: "no mirror attached for target" };
             if (!text.trim())
                 return { ok: false, reason: "empty text" };
+            // 出处改写要早于 inject: tail 可能在 promise resolve 之前就开出 turn。
+            if (opts?.fromChat)
+                a.turnFromChat = true;
+            // 名册增量搭这趟车进去 —— 同伴派活 / 定时任务 / graph 步骤都走这里, 所以
+            // 一个从不被人直接说话的分身也能知道群里多了谁、少了谁。人说的话那一条
+            // 路径在 inbound.send 上挂 (dispatch 有自己的 inject)。
+            const full = text + noticeSuffixFor(target, text);
             // Pre-record so the tail's user-line emission is suppressed by the
             // recentInjects dedupe (otherwise the user sees their own demo prompt
             // echoed back as a quoted bubble).
-            rememberInject(text);
+            rememberInject(full);
             // 印章要早于 inject 落地 —— tail 是独立轮询的, 它可能在 inject 的 promise
             // resolve 之前就看到 user 行并开出 turn, 那时归因必须已经在位。
             if (origin)
@@ -4727,14 +4903,14 @@ export const startMirror = (deps) => {
                 // Same resume-fork hazard as dispatch: snapshot before spawn, re-bind
                 // onto the forked jsonl once it appears (EOF offset — fork is seeded).
                 const resumeBaseline = listJsonls(dirname(a.jsonlPath));
-                const r = await spawnTmuxClaude({ cfg, log: log.child({ sub: "respawn-init", sessionId: sid }), resumeSessionId: sid, windowName: tagOfTarget(target) || target, cwdOverride: a.runningCwd, cli: backendForPath(a.jsonlPath).name });
+                const r = await spawnTmuxClaude({ cfg, log: log.child({ sub: "respawn-init", sessionId: sid }), resumeSessionId: sid, windowName: tagOfTarget(target) || target, cwdOverride: a.runningCwd, cli: backendForPath(a.jsonlPath).name, model: a.model || undefined, systemPrompt: charterFor(target) });
                 if (!r.ok || !r.tmuxPane)
                     return { ok: false, reason: `respawn failed: ${r.reason ?? "unknown"}` };
                 a.tmuxPane = r.tmuxPane;
                 a.tmuxSession = r.tmuxSession ?? a.tmuxSession;
                 if (r.cwd)
                     a.runningCwd = r.cwd;
-                deps.store.set(target, { sessionId: sid, jsonlPath: a.jsonlPath, tmuxSession: a.tmuxSession, tmuxPane: a.tmuxPane, cwd: a.runningCwd || undefined, pendingCwd: a.pendingCwd || undefined });
+                deps.store.set(target, { sessionId: sid, jsonlPath: a.jsonlPath, tmuxSession: a.tmuxSession, tmuxPane: a.tmuxPane, cwd: a.runningCwd || undefined, model: a.model || undefined, pendingCwd: a.pendingCwd || undefined });
                 startMigrationWatcher(a, resumeBaseline, (p) => firstUserUuid(p) !== undefined);
             }
             // freshSpawn: true — the pane was just minted by /mirror/spawn, the TUI
@@ -4743,7 +4919,7 @@ export const startMirror = (deps) => {
             a.muteUntilInject = false;
             a.justSpawned = false;
             const r = await inject({
-                text, images: [], cfg, log: log.child({ principal: target, sessionId: sid, sub: "init-demo" }),
+                text: full, images: [], cfg, log: log.child({ principal: target, sessionId: sid, sub: "init-demo" }),
                 sessionId: sid, jsonlPath: a.jsonlPath, tmuxTarget: a.tmuxPane, freshSpawn: true,
             });
             return r;
@@ -4911,6 +5087,9 @@ export const startMirror = (deps) => {
         getCwd,
         setPendingCwd,
         newSession,
+        cloneSession,
+        sessionInfo,
+        setCharterProvider,
         shutdown: () => {
             clearInterval(paneDriftTimer);
             clearInterval(keepaliveTimer);
@@ -5092,7 +5271,7 @@ export const startMirror = (deps) => {
                     const resumeBaseline = !armMigration ? listJsonls(dirname(a.jsonlPath)) : undefined;
                     // Respawn in the binding's runningCwd (pendingCwd doesn't apply to a
                     // mid-turn reincarnation — only /new and /clear-with-pending swap cwd).
-                    const r = await spawnTmuxClaude({ cfg, log: log.child({ sub: "respawn", sessionId: sid }), resumeSessionId: sid, windowName: tagOfTarget(a.target) || a.target, cwdOverride: a.runningCwd, cli: backendForPath(a.jsonlPath).name });
+                    const r = await spawnTmuxClaude({ cfg, log: log.child({ sub: "respawn", sessionId: sid }), resumeSessionId: sid, windowName: tagOfTarget(a.target) || a.target, cwdOverride: a.runningCwd, cli: backendForPath(a.jsonlPath).name, model: a.model || undefined, systemPrompt: charterFor(a.target) });
                     if (r.ok && r.tmuxPane && r.tmuxSession) {
                         a.tmuxPane = r.tmuxPane;
                         a.tmuxSession = r.tmuxSession;
@@ -5105,6 +5284,7 @@ export const startMirror = (deps) => {
                             tmuxSession: a.tmuxSession,
                             tmuxPane: a.tmuxPane,
                             cwd: a.runningCwd || undefined,
+                            model: a.model || undefined,
                             pendingCwd: a.pendingCwd || undefined,
                         });
                         log.info({ target: a.target, sessionId: sid, newPane: a.tmuxPane, newSession: a.tmuxSession }, "mirror: tmux respawned");