wezard 1.2.7 → 1.2.9

package/dist/daemon/mirror-bridge.js

@@ -92,7 +92,7 @@ const readCwdFromJsonl = (path) => {
 // that merely happens to be newer in the same directory would hand the chat to
 // a session it can neither resume (`claude --resume` wouldn't find the sid) nor
 // parse (wrong jsonl dialect). Only genuine discovery searches the union.
-const rankedJsonlsForCwd = (cwd, only) => projectDirsFor(expandHome(cwd))
+const rankedJsonlsForCwd = (cwd, only, exclude) => projectDirsFor(expandHome(cwd))
     .filter(({ backend }) => !only || backend.name === only.name)
     .flatMap(({ dir }) => {
     let names;
@@ -103,9 +103,12 @@ const rankedJsonlsForCwd = (cwd, only) => projectDirsFor(expandHome(cwd))
         return [];
     }
     return names.flatMap((n) => {
+        const sid = n.replace(/\.jsonl$/, "");
+        if (exclude?.has(sid))
+            return []; // already bound to another chat/peer — never steal it
         const p = join(dir, n);
         try {
-            return [{ sessionId: n.replace(/\.jsonl$/, ""), jsonlPath: p, mtime: statSync(p).mtimeMs }];
+            return [{ sessionId: sid, jsonlPath: p, mtime: statSync(p).mtimeMs }];
         }
         catch {
             return [];
@@ -117,8 +120,8 @@ const rankedJsonlsForCwd = (cwd, only) => projectDirsFor(expandHome(cwd))
 // `/new`) rotation always leaves a fresh jsonl here, so this is how the mirror
 // re-finds the live session after a rotation it didn't itself record — used by
 // resolveSession's auto-pick and by restoreFromStore's heal path.
-const latestJsonlForCwd = (cwd, only) => {
-    const top = rankedJsonlsForCwd(cwd, only)[0];
+const latestJsonlForCwd = (cwd, only, exclude) => {
+    const top = rankedJsonlsForCwd(cwd, only, exclude)[0];
     return top ? { sessionId: top.sessionId, jsonlPath: top.jsonlPath } : undefined;
 };
 // Locate a transcript by sessionId across every sibling project dir of every
@@ -216,8 +219,8 @@ const findInjectOffset = (path, fp) => {
 // the real session. Reliable for worktree dirs (one session lives there);
 // restore + the drift follower only consult it on cross-dir moves, where that
 // assumption holds.
-const liveSessionForCwd = (cwd, only) => {
-    for (const c of rankedJsonlsForCwd(cwd, only)) {
+const liveSessionForCwd = (cwd, only, exclude) => {
+    for (const c of rankedJsonlsForCwd(cwd, only, exclude)) {
         if (jsonlHasUserLine(c.jsonlPath))
             return { sessionId: c.sessionId, jsonlPath: c.jsonlPath };
     }
@@ -2314,11 +2317,41 @@ export const startMirror = (deps) => {
     // Re-attach a stored binding for `principal`. Returns the resulting state, or
     // undefined if the on-disk transcript is gone (in which case the entry is
     // dropped so the next inbound flows through /new auto-spawn).
+    // Every sessionId already bound to a DIFFERENT principal (live attachment or
+    // persisted store). The cwd-newest heal must never hand one of these to
+    // another peer: a chat's siblings all share one cwd, so "newest jsonl in cwd"
+    // is a different peer's live transcript, not this one's rotation. Healing onto
+    // it collapses N distinct peers onto one sessionId (attach() then dedupes by
+    // sid and silently detaches all-but-one). Excluding claimed sids keeps each
+    // peer on its own session.
+    const sidsClaimedByOthers = (principal) => {
+        const s = new Set();
+        for (const [k, v] of Object.entries(deps.store.all()))
+            if (k !== principal && v.sessionId)
+                s.add(v.sessionId);
+        for (const [k, a] of byTarget)
+            if (k !== principal && a.sessionId)
+                s.add(a.sessionId);
+        return s;
+    };
     const restoreFromStore = async (principal) => {
         const rec = deps.store.get(principal);
         if (!rec)
             return undefined;
         let jsonlAbs = expandHome(rec.jsonlPath);
+        // Prefer the stored pane id and validate via display-message. Pane ids
+        // (`%N`) are monotonic per tmux server lifetime, so they're stable across
+        // daemon reloads as long as the tmux server didn't restart. With the
+        // shared `wezard` session hosting many chats, listing panes by session
+        // name would mis-route to whichever window happens to be first — never
+        // do that. If the stored pane is dead, leave tmuxPane empty and let
+        // dispatch's respawn check reincarnate via `claude --resume <sid>`.
+        // Resolved BEFORE the heal below: a live pane authoritatively owns
+        // `rec.sessionId` (spawned as `--session-id <uuid>`), so a not-yet-written
+        // jsonl means "no input yet", NOT "rotated away" — healing it onto some
+        // unrelated newest-in-cwd file is exactly the cross-wire we must avoid.
+        const storedPane = (rec.tmuxPane ?? "").trim();
+        const livePane = storedPane && (await tmuxPaneAlive(storedPane)) ? storedPane : "";
         if (!existsSync(jsonlAbs)) {
             // First: the SAME-sid transcript may have merely relocated to a sibling
             // project dir (Claude Code EnterWorktree/ExitWorktree moved it while the
@@ -2334,35 +2367,34 @@ export const startMirror = (deps) => {
                 jsonlAbs = relocated;
                 deps.store.set(principal, rec);
             }
+            else if (livePane) {
+                // Live pane, no transcript yet: a freshly-spawned peer that hasn't
+                // received its first turn. The pane owns `rec.sessionId` and will write
+                // `<sid>.jsonl` on first input; keep spawn-mode (the tail tolerates a
+                // missing file). Do NOT heal — that is what made every idle sibling in a
+                // shared cwd collapse onto the same newest jsonl.
+                log.info({ principal, sessionId: rec.sessionId, pane: livePane }, "mirror restore: live pane, transcript not written yet — keeping spawn-mode binding");
+            }
             else {
-                // Recorded session rotated out from under us — a `/clear` or native `/new`
-                // the daemon didn't record (e.g. it restarted while the /clear migration
-                // watcher was still open). The rotation left a newer jsonl in the same
-                // project dir; heal onto it instead of dropping the binding, else the
-                // chat silently loses all further responses. Fail-closed drop only when
-                // the project dir is truly empty.
-                const healed = latestJsonlForCwd(rec.cwd || cfg.wrc.cwd, owner);
+                // Pane dead AND transcript gone. Either the session rotated (`/clear` /
+                // native `/new` the daemon missed, leaving a newer jsonl) or the peer was
+                // spawned-then-killed before writing anything. Heal onto the newest jsonl
+                // in the project dir — but skip any sid already bound to another peer, so
+                // a dead node can't steal a live sibling's transcript. Fail-closed drop
+                // when nothing unclaimed remains.
+                const healed = latestJsonlForCwd(rec.cwd || cfg.wrc.cwd, owner, sidsClaimedByOthers(principal));
                 if (!healed) {
-                    log.warn({ principal, jsonlPath: rec.jsonlPath }, "mirror restore: jsonl missing and no sibling, dropping entry");
+                    log.warn({ principal, jsonlPath: rec.jsonlPath }, "mirror restore: jsonl missing and no unclaimed sibling, dropping entry");
                     deps.store.drop(principal);
                     return undefined;
                 }
-                log.warn({ principal, from: rec.sessionId, to: healed.sessionId }, "mirror restore: recorded jsonl gone, healed to latest in project dir");
+                log.warn({ principal, from: rec.sessionId, to: healed.sessionId }, "mirror restore: recorded jsonl gone, healed to latest unclaimed in project dir");
                 rec.sessionId = healed.sessionId;
                 rec.jsonlPath = healed.jsonlPath;
                 jsonlAbs = healed.jsonlPath;
                 deps.store.set(principal, rec);
             }
         }
-        // Prefer the stored pane id and validate via display-message. Pane ids
-        // (`%N`) are monotonic per tmux server lifetime, so they're stable across
-        // daemon reloads as long as the tmux server didn't restart. With the
-        // shared `wezard` session hosting many chats, listing panes by session
-        // name would mis-route to whichever window happens to be first — never
-        // do that. If the stored pane is dead, leave tmuxPane empty and let
-        // dispatch's respawn check reincarnate via `claude --resume <sid>`.
-        const storedPane = (rec.tmuxPane ?? "").trim();
-        const livePane = storedPane && (await tmuxPaneAlive(storedPane)) ? storedPane : "";
         // Pane-cwd worktree re-home: the stored jsonl can EXIST yet be stale because
         // the live pane entered/selected a git worktree, switching it to a DIFFERENT
         // sessionId in a sibling project dir. Trust the pane's real cwd — if its
@@ -2380,7 +2412,7 @@ export const startMirror = (deps) => {
                 // session belonging to a non-primary CLI.
                 const paneDir = projectDirFor(jsonlAbs, expandHome(paneCwd));
                 if (paneDir !== dirname(jsonlAbs)) {
-                    const live = liveSessionForCwd(paneCwd, backendForPath(jsonlAbs));
+                    const live = liveSessionForCwd(paneCwd, backendForPath(jsonlAbs), sidsClaimedByOthers(principal));
                     if (live && live.sessionId !== rec.sessionId) {
                         log.info({ principal, from: rec.sessionId, to: live.sessionId, paneCwd }, "mirror restore: pane in worktree, re-homed to live session");
                         rec.sessionId = live.sessionId;
@@ -2631,9 +2663,16 @@ export const startMirror = (deps) => {
                 return;
             }
             const current = listJsonls(projectDir);
+            // Exclude sids already bound to OTHER targets: when several panes in one
+            // cwd fork/spawn concurrently (a graph's #t3/#sp/base all resuming), each
+            // watcher sees ALL the new jsonls, not just its own pane's. Without this a
+            // resume-fork watcher grabs a sibling's freshly-written transcript (newest
+            // + has content) and two tags collapse onto one sessionId. The claimed set
+            // pins each watcher off its siblings' sessions.
+            const claimed = sidsClaimedByOthers(a.target);
             const candidates = [];
             for (const name of current)
-                if (!baseline.has(name))
+                if (!baseline.has(name) && !claimed.has(name.replace(/\.jsonl$/, "")))
                     candidates.push(name);
             // Pick newest-mtime candidate that has user content. Older candidates
             // without content stay in the running until they accrue — never aborts.
@@ -2820,7 +2859,7 @@ export const startMirror = (deps) => {
                 const paneDir = projectDirFor(a.jsonlPath, expandHome(cwd));
                 if (paneDir === dirname(a.jsonlPath))
                     continue; // same project dir — no drift
-                const live = liveSessionForCwd(cwd, backendForPath(a.jsonlPath));
+                const live = liveSessionForCwd(cwd, backendForPath(a.jsonlPath), sidsClaimedByOthers(a.target));
                 if (!live || live.sessionId === a.sessionId)
                     continue; // empty dir, or same-sid rename (tail follows it)
                 a.runningCwd = expandHome(cwd); // migrateAttachment persists this to store
@@ -2958,6 +2997,14 @@ export const startMirror = (deps) => {
             // 只有换过 pane 才是断点 —— 首次 /wrc 建会话时 prev 为空, 那不是"不连续", 是开局。
             if (prev)
                 spawned.ctxCut = "new";
+            // A freshly spawned session is empty — nothing in the cache to keep warm.
+            // Pause keepalive like /stop; the first real turn (WeCom inbound, or the
+            // pane going busy after the resume grace) re-earns the budget. Mirrors
+            // interruptPane so /new can't strand a ping loop on an idle blank session.
+            spawned.keepaliveOff = true;
+            spawned.keepaliveOffAt = Date.now();
+            spawned.keepalive = undefined; // re-anchors cleanly on resume
+            persistPause(spawned);
         }
         // Clear the chat's pendingCwd on the BASE record too — the queued switch
         // has just been consumed by this respawn. Without this, a subsequent /new
@@ -3601,15 +3648,24 @@ export const startMirror = (deps) => {
                 }
                 return;
             }
-            // A real inbound is a new conversation → lift any `/stop` keepalive pause
-            // and re-anchor both clocks to now (this turn is real work). Pane-side new
-            // turns re-anchor via the tick's stamps; this covers the WeCom-driven path.
-            a.keepaliveOff = false;
-            if (a.keepalive) {
-                a.keepalive.lastMs = Date.now();
-                a.keepalive.lastRealMs = Date.now();
+            // `/clear` resets to an empty session — nothing in the cache to keep warm,
+            // so pause keepalive like `/stop` instead of lifting it. Every other inbound
+            // is real work: lift any prior pause and re-anchor both clocks to now.
+            // Pane-side new turns re-anchor via the tick's stamps; this covers the
+            // WeCom-driven path.
+            if (isClearCommand(text)) {
+                a.keepaliveOff = true;
+                a.keepaliveOffAt = Date.now();
+                a.keepalive = undefined; // re-anchors cleanly on resume
+            }
+            else {
+                a.keepaliveOff = false;
+                if (a.keepalive) {
+                    a.keepalive.lastMs = Date.now();
+                    a.keepalive.lastRealMs = Date.now();
+                }
             }
-            persistPause(a); // clear the persisted pause too, else a reload would re-pause
+            persistPause(a); // persist the pause/resume too, else a reload would revert it
             // Finalize prior live stream (if any) so this new turn renders into its
             // own message bubble. Then open a fresh stream tied to the new frame and
             // ack immediately so WeCom doesn't time out while inject queues.