agileflow 4.0.0-alpha.16 → 4.0.0-alpha.18

package/package.json

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

@@ -1182,11 +1182,32 @@ async function maybeOfferAutoRestore(prefs) {
     if (ap !== bp) return bp - ap;
     return 0;
   });
-  const options = sorted.map((s) => ({
+  // Smart toggle at the top of the picker: one entry that flips the
+  // current selection state. If everything's selected, checking it
+  // deselects all; if anything's unselected, checking it selects all.
+  // Visually separated from session entries by a dash divider line
+  // so it doesn't blend in with real options.
+  const TOGGLE_ALL = "__toggle_all__";
+  const DIVIDER = "__divider__";
+  const allNames = sorted.map((s) => s.name);
+  const sessionOptions = sorted.map((s) => ({
     value: s.name,
-    label: `${s.pinned ? "★ " : "  "}${s.name}`,
+    label: `${s.pinned ? "* " : "  "}${s.name}`,
     hint: `${s.cli} — ${s.cwd}${s.worktree && s.worktree.branch ? ` [wt ${s.worktree.branch}]` : ""}`,
   }));
+  const options = [
+    {
+      value: TOGGLE_ALL,
+      label: "[ select all / deselect all ]",
+      hint: "toggles every session below",
+    },
+    {
+      value: DIVIDER,
+      label: "─────────────────────────────",
+      hint: "",
+    },
+    ...sessionOptions,
+  ];
   const anyPinned = sorted.some((s) => s.pinned === true);
   const initial = anyPinned
     ? sorted.filter((s) => s.pinned === true).map((s) => s.name)
@@ -1210,7 +1231,19 @@ async function maybeOfferAutoRestore(prefs) {
     process.exit(0);
   }
   /** @type {string[]} */
-  const chosen = Array.isArray(selection) ? selection : [];
+  let chosen = Array.isArray(selection) ? selection : [];
+  // Strip the synthetic divider always (it's never a real choice).
+  // Resolve the toggle: if the user checked it, flip the current
+  // selection state — everything selected goes to nothing, anything
+  // partial or empty goes to everything.
+  const toggled = chosen.includes(TOGGLE_ALL);
+  chosen = chosen.filter((v) => v !== TOGGLE_ALL && v !== DIVIDER);
+  if (toggled) {
+    const allSelected =
+      chosen.length === allNames.length &&
+      allNames.every((n) => chosen.includes(n));
+    chosen = allSelected ? [] : [...allNames];
+  }
   if (chosen.length === 0) {
     prompts.outro(
       "Skipped. Run `agileflow launch restore` later to bring them back.",

package/src/runtime/launch/restore.js

@@ -19,6 +19,8 @@ const {
   sessionExists,
   createSession,
   applyKeybindPreset,
+  applyTabFormat,
+  detectTmuxVersion,
 } = require("./tmux.js");
 const { loadRegistry } = require("./session-registry.js");
 const { resolveAgileflowBin } = require("./alias-installer.js");
@@ -117,6 +119,14 @@ function runRestore(opts) {
       log(`agileflow launch: failed to restore ${entry.name} — ${stderr}`);
       continue;
     }
+    // Apply the same per-session styling launchInTmux does for fresh
+    // sessions so the tab strip looks consistent on restore. Without
+    // this, restored sessions show tmux's default green status bar
+    // instead of the AgileFlow dark strip.
+    runner.runSync(["set-option", "-t", entry.name, "status", "1"]);
+    applyTabFormat(entry.name, runner, {
+      tmuxVersion: detectTmuxVersion(runner),
+    });
     result.restored++;
     log(`agileflow launch: restored session ${entry.name} (${entry.cwd})`);
   }

package/src/runtime/launch/tabs.js

@@ -273,17 +273,15 @@ const TAB_KEYBINDS = [
     hint: "Alt+, → rename current tab",
   },
   {
-    // Direct close — no confirm-before. The earlier confirm-before
-    // path was brittle under tmux's bind-key parsing (deferred-command
-    // quoting issues caused the keybind to silently no-op on some
-    // tmux builds). Alt+Shift+T (Alt+T) restores the last closed
-    // tab in the same cwd, so the close is effectively reversible —
-    // matches Chrome's instant-close + Ctrl+Shift+T undo.
+    // Direct kill-window — no CLI roundtrip. The previous
+    // run-shell-to-agileflow approach added Node-startup latency
+    // (150ms+) and could no-op silently if the binary path resolution
+    // returned stale state (e.g. after npx cache cleanup). Killing
+    // via tmux directly is instant and bulletproof. Undo is provided
+    // by Alt+Shift+T (which reads the closed-windows log populated by
+    // the window-unlinked hook installed in applyTabFormat).
     key: "M-w",
-    action: [
-      "run-shell",
-      "%AGILEFLOW% launch __close-window #{session_name} #{window_index}",
-    ],
+    action: ["kill-window"],
     hint: "Alt+w → close current tab (Alt+Shift+T to undo)",
   },
   {

package/src/runtime/launch/tmux.js

@@ -241,24 +241,53 @@ function applyTabFormat(sessionName, runner, opts = {}) {
     `#[bg=${PILL_BG},fg=${ACCENT}] #h ` +
     `#[fg=${PILL_BG},bg=${BG}]${HALF_ROUND_CLOSE}`;
 
-  // Apply each option and collect failures. If ANYTHING fails we surface
-  // it on stderr so users debugging "why doesn't my tab strip look right"
-  // can see the tmux complaint instead of staring at default formatting.
+  // Apply each option with the correct tmux scope. Session-scope opts
+  // (status-style, status-left/right, status-justify) take
+  // `-t <session>`. Window-scope opts (window-status-format,
+  // window-status-current-format, window-status-separator) take
+  // `-wg` so every window in every session picks them up. Earlier
+  // code applied ALL options with `-t session`, which made tmux
+  // silently ignore the window-scope ones — the visible symptom
+  // was tmux's default green status bar surviving on every session.
   const ops = [
-    ["status-style", `bg=${BG},fg=${theme.inactiveFg}`],
-    ["status-justify", "centre"],
-    ["status-left", statusLeft],
-    ["status-left-length", "100"],
-    ["status-right", statusRight],
-    ["status-right-length", "100"],
-    ["window-status-separator", ""],
-    ["window-status-format", inactiveFormat],
-    ["window-status-current-format", activeFormat],
+    {
+      scope: "session",
+      option: "status-style",
+      value: `bg=${BG},fg=${theme.inactiveFg}`,
+    },
+    { scope: "session", option: "status-justify", value: "centre" },
+    { scope: "session", option: "status-left", value: statusLeft },
+    { scope: "session", option: "status-left-length", value: "100" },
+    { scope: "session", option: "status-right", value: statusRight },
+    { scope: "session", option: "status-right-length", value: "100" },
+    // Number windows from 1 so Alt+1 maps to the first tab (matches
+    // Chrome's Ctrl+1 mental model). Tmux default is base-index 0,
+    // which means Alt+1 with no other tabs open does nothing.
+    { scope: "session", option: "base-index", value: "1" },
+    // Keep tab indices contiguous after a close — without this,
+    // closing window 2 leaves indices 1, 3, 4 and Alt+2 becomes
+    // dead. tmux renumbers on close so Alt+1..N always works.
+    { scope: "session", option: "renumber-windows", value: "on" },
+    { scope: "window-global", option: "window-status-separator", value: "" },
+    {
+      scope: "window-global",
+      option: "window-status-format",
+      value: inactiveFormat,
+    },
+    {
+      scope: "window-global",
+      option: "window-status-current-format",
+      value: activeFormat,
+    },
   ];
   let lastResult = { status: 0, stderr: "" };
   const failures = [];
-  for (const [option, value] of ops) {
-    const r = runner.runSync(["set-option", "-t", sessionName, option, value]);
+  for (const { scope, option, value } of ops) {
+    const args =
+      scope === "session"
+        ? ["set-option", "-t", sessionName, option, value]
+        : ["set-option", "-wg", option, value];
+    const r = runner.runSync(args);
     lastResult = r;
     if (r.status !== 0) {
       failures.push({ option, stderr: (r.stderr || "").trim() });