agileflow 4.0.0-alpha.10 → 4.0.0-alpha.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agileflow",
-  "version": "4.0.0-alpha.10",
+  "version": "4.0.0-alpha.12",
   "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

@@ -980,17 +980,40 @@ async function runWhere() {
 async function runInternalCloseWindow(deps = {}) {
   const runner = deps.runner || defaultTmuxRunner();
   const pushClosedImpl = deps.pushClosedImpl || closedWindows.pushClosed;
+  const exit = deps.exit || ((code) => process.exit(code));
   // ASCII Unit Separator — never appears in a session/window name or
   // filesystem path, so splitting on it is unambiguous.
   const DELIM = "\x1f";
-  const fmt = `#S${DELIM}#I${DELIM}#W${DELIM}#{pane_current_path}`;
-  const probe = runner.runSync(["display-message", "-p", "-F", fmt]);
+  // When the tmux keybind passes session+index positionally, target
+  // that exact window. This avoids a wrong-window kill if focus shifts
+  // between Alt+w being pressed and this subprocess starting.
+  const argSession = (deps.targetSession || "").trim();
+  const argIndex = (deps.targetIndex || "").trim();
+  let probeArgs;
+  if (argSession && argIndex) {
+    probeArgs = [
+      "display-message",
+      "-p",
+      "-t",
+      `${argSession}:${argIndex}`,
+      "-F",
+      `#S${DELIM}#I${DELIM}#W${DELIM}#{pane_current_path}`,
+    ];
+  } else {
+    probeArgs = [
+      "display-message",
+      "-p",
+      "-F",
+      `#S${DELIM}#I${DELIM}#W${DELIM}#{pane_current_path}`,
+    ];
+  }
+  const probe = runner.runSync(probeArgs);
   if (probe.status !== 0) {
     // eslint-disable-next-line no-console
     console.error(
       `agileflow launch __close-window: tmux display-message failed: ${probe.stderr || "unknown"}`,
     );
-    return;
+    return exit(1);
   }
   const parts = (probe.stdout || "").trimEnd().split(DELIM);
   if (parts.length !== 4) {
@@ -998,7 +1021,7 @@ async function runInternalCloseWindow(deps = {}) {
     console.error(
       `agileflow launch __close-window: unexpected display-message output (got ${parts.length} fields)`,
     );
-    return;
+    return exit(1);
   }
   const [sessionName, windowIndex, windowName, cwd] = parts;
   if (!sessionName || !windowIndex || !cwd) {
@@ -1006,7 +1029,7 @@ async function runInternalCloseWindow(deps = {}) {
     console.error(
       "agileflow launch __close-window: missing session/index/cwd; skipping kill",
     );
-    return;
+    return exit(1);
   }
   // Kill first with the explicit target captured above. If this fails
   // we abort without touching the log — the window is still alive and
@@ -1021,7 +1044,7 @@ async function runInternalCloseWindow(deps = {}) {
     console.error(
       `agileflow launch __close-window: kill-window failed: ${kill.stderr || "unknown"}`,
     );
-    return;
+    return exit(1);
   }
   try {
     pushClosedImpl({ sessionName, name: windowName || "", cwd });
@@ -1053,16 +1076,23 @@ async function runInternalRestoreWindow(deps = {}) {
   const runner = deps.runner || defaultTmuxRunner();
   const popClosedImpl = deps.popClosedImpl || closedWindows.popClosed;
   const pushClosedImpl = deps.pushClosedImpl || closedWindows.pushClosed;
-  const probe = runner.runSync(["display-message", "-p", "-F", "#S"]);
-  if (probe.status !== 0) {
-    // eslint-disable-next-line no-console
-    console.error(
-      `agileflow launch __restore-window: tmux display-message failed: ${probe.stderr || "unknown"}`,
-    );
-    return;
+  const exit = deps.exit || ((code) => process.exit(code));
+  // Keybind passes #{session_name} so the restore targets the session
+  // the user actually pressed Alt+T from. Fall back to display-message
+  // for manual invocations (which only works inside tmux).
+  let sessionName = (deps.targetSession || "").trim();
+  if (!sessionName) {
+    const probe = runner.runSync(["display-message", "-p", "-F", "#S"]);
+    if (probe.status !== 0) {
+      // eslint-disable-next-line no-console
+      console.error(
+        `agileflow launch __restore-window: tmux display-message failed: ${probe.stderr || "unknown"}`,
+      );
+      return exit(1);
+    }
+    sessionName = (probe.stdout || "").trim();
   }
-  const sessionName = (probe.stdout || "").trim();
-  if (!sessionName) return;
+  if (!sessionName) return exit(1);
   /** @type {ReturnType<typeof closedWindows.popClosed>} */
   let entry;
   try {
@@ -1072,7 +1102,7 @@ async function runInternalRestoreWindow(deps = {}) {
     console.error(
       `agileflow launch __restore-window: log pop failed: ${err && err.message ? err.message : err}`,
     );
-    return;
+    return exit(1);
   }
   if (!entry) {
     // Empty stack — silent. The user pressed Alt+T with nothing to undo.
@@ -1102,6 +1132,7 @@ async function runInternalRestoreWindow(deps = {}) {
         `agileflow launch __restore-window: failed to re-push entry after new-window failure: ${pushErr && pushErr.message ? pushErr.message : pushErr}`,
       );
     }
+    return exit(1);
   }
 }
 
@@ -1269,19 +1300,24 @@ async function launch(sub, nameArg, _options) {
       return;
     }
     if (sub === "__close-window") {
-      // Hidden subcommand invoked from tmux keybind (Alt+w). Captures
-      // the current window's name + pane cwd, pushes onto the
-      // closed-windows log, then issues kill-window so Alt+T can
-      // resurrect it later. No UI; failures are silent.
-      await runInternalCloseWindow();
+      // Hidden subcommand invoked from tmux keybind (Alt+w). The keybind
+      // passes session name + window index as positional args so we
+      // target the exact tab the user pressed Alt+w on, regardless of
+      // any focus shift during the confirmation prompt. nameArg is the
+      // session name; we read the window index from raw argv since
+      // commander's signature only declares two positionals.
+      const targetSession = nameArg || "";
+      const targetIndex = (process.argv && process.argv[5]) || "";
+      await runInternalCloseWindow({ targetSession, targetIndex });
       return;
     }
     if (sub === "__restore-window") {
       // Hidden subcommand invoked from tmux keybind (Alt+T). Pops the
-      // most recent closed entry for the current session and spawns
-      // a new window in that cwd with the original name. No-op when
-      // the log is empty for this session.
-      await runInternalRestoreWindow();
+      // most recent closed entry for the session the user pressed
+      // Alt+T from (passed positionally via #{session_name}) and
+      // spawns a new window in that cwd with the original name. No-op
+      // when the log is empty for this session.
+      await runInternalRestoreWindow({ targetSession: nameArg || "" });
       return;
     }
     if (sub && sub !== "setup") {

package/src/runtime/launch/tabs.js

@@ -259,9 +259,11 @@ function buildTabFormat(opts = {}) {
  */
 const TAB_KEYBINDS = [
   {
-    key: "M-c",
+    // Alt+t = new tab. Matches Chrome/Safari's Ctrl+T / Cmd+T —
+    // browser muscle memory carries straight over.
+    key: "M-t",
     action: ["new-window"],
-    hint: "Alt+c → new tab",
+    hint: "Alt+t → new tab",
   },
   {
     // -I prefills the prompt with the current name so the user can
@@ -272,14 +274,16 @@ const TAB_KEYBINDS = [
   },
   {
     // confirm-before runs the command on `y` and does nothing on `n`.
-    // The bookkeeping happens server-side via the agileflow callback —
-    // it captures #W + cwd, pushes onto the closed log, then kill-windows.
+    // We pass session+index as positional args so the callback targets
+    // the exact window the user pressed Alt+w on — without this, the
+    // callback would re-probe display-message and could close the
+    // wrong tab if focus moved during the confirmation prompt.
     key: "M-w",
     action: [
       "confirm-before",
       "-p",
       "kill tab #W? (y/n)",
-      "run-shell '%AGILEFLOW% launch __close-window'",
+      "run-shell '%AGILEFLOW% launch __close-window #{session_name} #{window_index}'",
     ],
     hint: "Alt+w → close current tab (with confirm)",
   },
@@ -291,8 +295,14 @@ const TAB_KEYBINDS = [
     hint: "Alt+W → tab picker",
   },
   {
+    // Pass session name explicitly so the callback restores into the
+    // session the user actually triggered from — works even if the
+    // active session shifts before run-shell fires.
     key: "M-T",
-    action: ["run-shell", "%AGILEFLOW% launch __restore-window"],
+    action: [
+      "run-shell",
+      "%AGILEFLOW% launch __restore-window #{session_name}",
+    ],
     hint: "Alt+T → reopen last closed tab",
   },
   // Numeric switchers Alt+1..Alt+9 → select-window -t :N

package/src/runtime/launch/tmux.js

@@ -197,15 +197,29 @@ function detectTmuxVersion(runner) {
  * @returns {{ applied: boolean, stderr: string }}
  */
 function applyTabFormat(sessionName, runner, opts = {}) {
+  const theme = { ...tabs.DEFAULT_TAB_THEME, ...(opts.theme || {}) };
   const format = tabs.buildTabFormat({
     tmuxVersion: opts.tmuxVersion,
     theme: opts.theme,
   });
+  // Override tmux's default green status-style so the strip's dark
+  // background isn't broken up by tmux's stock green bar. Also clear
+  // status-left / status-right — they default to session info + clock
+  // on green; the tab strip already shows what the user needs.
+  runner.runSync([
+    "set-option",
+    "-t",
+    sessionName,
+    "status-style",
+    `bg=${theme.stripBg} fg=${theme.inactiveFg}`,
+  ]);
+  runner.runSync(["set-option", "-t", sessionName, "status-left", ""]);
+  runner.runSync(["set-option", "-t", sessionName, "status-right", ""]);
   const result = runner.runSync([
     "set-option",
     "-t",
     sessionName,
-    "status-format[1]",
+    "status-format[0]",
     format,
   ]);
   return {
@@ -538,8 +552,9 @@ async function launchInTmux(opts) {
     // Re-apply the tab strip every attach so prefs / theme changes
     // since session creation take effect (and so a session created by
     // an older agileflow without a strip picks one up on reattach).
-    // Requires status lines = 2 so the tab strip on line[1] renders.
-    runner.runSync(["set-option", "-t", base, "status", "2"]);
+    // Single dark status line — the tab strip on line[0] replaces
+    // tmux's default green status bar entirely.
+    runner.runSync(["set-option", "-t", base, "status", "1"]);
     applyTabFormat(base, runner, { tmuxVersion });
     log(`agileflow launch: resuming session ${base}`);
     return attachSession(base, runner);
@@ -604,7 +619,7 @@ async function launchInTmux(opts) {
           log(`agileflow launch: keybind skipped — ${f.hint}`);
         }
       }
-      runner.runSync(["set-option", "-t", name, "status", "2"]);
+      runner.runSync(["set-option", "-t", name, "status", "1"]);
       applyTabFormat(name, runner, { tmuxVersion });
       return attachSession(name, runner);
     }
@@ -624,11 +639,11 @@ async function launchInTmux(opts) {
       log(`agileflow launch: keybind skipped — ${f.hint}`);
     }
   }
-  // Two-line status so the tab strip on status-format[1] is visible.
-  // Per-session so other tmux clients are unaffected. Then write the
-  // tab format itself. Both are best-effort; failure shouldn't block
-  // the attach.
-  runner.runSync(["set-option", "-t", name, "status", "2"]);
+  // Single dark status line — the tab strip on status-format[0]
+  // replaces tmux's default green status bar entirely. Per-session
+  // so other tmux clients are unaffected. Then write the tab format
+  // itself. Both are best-effort; failure shouldn't block the attach.
+  runner.runSync(["set-option", "-t", name, "status", "1"]);
   applyTabFormat(name, runner, { tmuxVersion });
   log(`agileflow launch: starting new session ${name}`);
   return attachSession(name, runner);