agileflow 4.0.0-alpha.23 → 4.0.0-alpha.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agileflow",
-  "version": "4.0.0-alpha.23",
+  "version": "4.0.0-alpha.24",
   "description": "AI-driven agile development toolkit for Claude Code — skills-first architecture with opt-in plugins (v4)",
   "keywords": [
     "agile",

package/src/cli/commands/launch.js

@@ -1155,6 +1155,11 @@ async function runInternalSnapshotSession(sessionName, deps = {}) {
   const runner = deps.runner || defaultTmuxRunner();
   const DELIM = "\x1f";
   const fmt = `#{window_index}${DELIM}#{window_name}${DELIM}#{pane_current_path}`;
+  // Capture timestamp BEFORE list-windows so concurrent subprocesses
+  // produce a stable ordering. The registry rejects writes whose
+  // capturedAt is older than what's already stored — without this,
+  // out-of-order lock acquisition can clobber newer state with older.
+  const capturedAt = Date.now();
   const result = runner.runSync(["list-windows", "-t", sessionName, "-F", fmt]);
   if (result.status !== 0) return;
   const lines = (result.stdout || "")
@@ -1177,7 +1182,7 @@ async function runInternalSnapshotSession(sessionName, deps = {}) {
     const {
       updateSession,
     } = require("../../runtime/launch/session-registry.js");
-    updateSession(sessionName, { windows });
+    updateSession(sessionName, { windows, windowsCapturedAt: capturedAt });
   } catch {
     // Registry might not exist or session might have been forgotten;
     // either way we can't usefully recover. Stay silent.

package/src/runtime/launch/session-registry.js

@@ -137,6 +137,10 @@ function withRegistryLock(home, fn) {
  *                                           by tmux hooks; replayed on
  *                                           restore so reboots bring back
  *                                           every tab in its original cwd
+ * @property {number} [windowsCapturedAt]  - epoch ms when `windows` was
+ *                                           captured. Newer captures
+ *                                           always win when concurrent
+ *                                           hook subprocesses race.
  *
  * @typedef {Object} RegistryShape
  * @property {1} version
@@ -233,6 +237,8 @@ function loadRegistry(home) {
             }
           : undefined,
       windows,
+      windowsCapturedAt:
+        typeof s.windowsCapturedAt === "number" ? s.windowsCapturedAt : 0,
     });
   }
   return { version: 1, sessions: sane };
@@ -369,7 +375,22 @@ function updateSession(name, patch, home) {
         if (patch.worktree !== undefined) s.worktree = patch.worktree;
         if (patch.pinned !== undefined) s.pinned = patch.pinned === true;
         if (patch.windows !== undefined) {
-          s.windows = Array.isArray(patch.windows) ? patch.windows : undefined;
+          // Stale-snapshot guard: hooks fire on every tab change, so
+          // when the user spams Alt+t multiple subprocesses can race.
+          // Lock acquisition isn't FIFO so an older capture can be
+          // committed after a newer one. Reject any update whose
+          // capturedAt timestamp is older than what's already stored.
+          const incomingTs =
+            typeof patch.windowsCapturedAt === "number"
+              ? patch.windowsCapturedAt
+              : Date.now();
+          if (!s.windowsCapturedAt || incomingTs >= s.windowsCapturedAt) {
+            s.windows = Array.isArray(patch.windows)
+              ? patch.windows
+              : undefined;
+            s.windowsCapturedAt = incomingTs;
+          }
+          // else: silently drop the stale write
         }
         updated = true;
       }

package/src/runtime/launch/tmux.js

@@ -344,9 +344,35 @@ function applyTabFormat(sessionName, runner, opts = {}) {
  */
 function installSessionHooks(sessionName, runner, opts = {}) {
   const agileflowBin = opts.agileflowBin || resolveAgileflowBin();
-  const snapshotCmd = `run-shell -b '${agileflowBin} launch __snapshot-session ${sessionName}'`;
+  // Double-quote the binary path and session name so paths with
+  // spaces (e.g., /Users/x with space/agileflow) work. The shell
+  // command is itself wrapped in double quotes for run-shell to
+  // accept it as a single argument.
+  const shellCmd = `"${agileflowBin}" launch __snapshot-session "${sessionName}"`;
+  const snapshotCmd = `run-shell -b "${shellCmd.replace(/"/g, '\\"')}"`;
+  /** @type {Array<{ event: string, stderr: string }>} */
+  const failures = [];
   for (const event of ["window-linked", "window-unlinked", "window-renamed"]) {
-    runner.runSync(["set-hook", "-t", sessionName, event, snapshotCmd]);
+    const r = runner.runSync([
+      "set-hook",
+      "-t",
+      sessionName,
+      event,
+      snapshotCmd,
+    ]);
+    if (r.status !== 0) {
+      failures.push({ event, stderr: (r.stderr || "").trim() });
+    }
+  }
+  if (failures.length > 0) {
+    // eslint-disable-next-line no-console
+    console.error(
+      `agileflow launch: tab persistence — ${failures.length} of 3 tmux hooks failed to install:`,
+    );
+    for (const f of failures) {
+      // eslint-disable-next-line no-console
+      console.error(`  ${f.event}: ${f.stderr || "(no error message)"}`);
+    }
   }
 }