@sma1lboy/kobe 0.7.17 → 0.7.19

package/dist/cli/index.js

@@ -90,7 +90,7 @@ var init_package = __esm(() => {
   package_default = {
     $schema: "https://json.schemastore.org/package.json",
     name: "@sma1lboy/kobe",
-    version: "0.7.17",
+    version: "0.7.19",
     description: "TUI orchestrator for Claude Code (codename)",
     type: "module",
     packageManager: "bun@1.3.13",
@@ -3918,7 +3918,10 @@ var init_protocol = __esm(() => {
     "active-task",
     "update",
     "engine-state",
-    "ui-prefs"
+    "ui-prefs",
+    "keybindings",
+    "task.jobs",
+    "worktree.changes"
   ];
 });
 
@@ -4066,6 +4069,7 @@ class KobeDaemonClient {
     this.disposed = true;
     this.socket?.end();
     this.socket = null;
+    this.failPending();
   }
   forceDisconnect() {
     const socket = this.socket;
@@ -4073,6 +4077,15 @@ class KobeDaemonClient {
       return;
     this.socket = null;
     socket.destroy();
+    this.failPending();
+  }
+  failPending() {
+    if (this.pending.size === 0)
+      return;
+    const err = new Error("daemon connection closed");
+    for (const pending of this.pending.values())
+      pending.reject(err);
+    this.pending.clear();
   }
   on(name, handler) {
     let set = this.handlers.get(name);
@@ -4147,9 +4160,7 @@ class KobeDaemonClient {
     if (this.socket !== which)
       return;
     this.socket = null;
-    for (const pending of this.pending.values())
-      pending.reject(new Error("daemon connection closed"));
-    this.pending.clear();
+    this.failPending();
     this.emitLifecycle("close");
   }
   emitLifecycle(name) {
@@ -5131,6 +5142,16 @@ function kobeCliInvocation() {
 var init_invocation = () => {};
 
 // src/tmux/session-layout.ts
+function clampTasksPaneWidth(width) {
+  if (!Number.isFinite(width))
+    return TASKS_PANE_WIDTH;
+  return Math.max(TASKS_PANE_WIDTH_MIN, Math.min(TASKS_PANE_WIDTH_MAX, Math.round(width)));
+}
+function clampPanePercent(percent) {
+  if (!Number.isFinite(percent))
+    return null;
+  return Math.max(PANE_PERCENT_MIN, Math.min(PANE_PERCENT_MAX, Math.round(percent)));
+}
 function shellQuote(s) {
   return `'${s.replace(/'/g, "'\\''")}'`;
 }
@@ -5201,7 +5222,7 @@ function opsPaneCommand(args) {
   }
   return fallbackOpsScript(args.cwd);
 }
-var TASKS_PANE_WIDTH = 32, CLAUDE_PANE_PERCENT = 60, OPS_PANE_PERCENT = 50;
+var TASKS_PANE_WIDTH = 32, TASKS_WIDTH_OPTION = "@kobe_tasks_width", TASKS_PANE_WIDTH_MIN = 16, TASKS_PANE_WIDTH_MAX = 120, CLAUDE_PANE_PERCENT = 60, OPS_PANE_PERCENT = 50, RIGHT_COLUMN_WIDTH_OPTION = "@kobe_right_width_pct", OPS_HEIGHT_OPTION = "@kobe_ops_height_pct", PANE_PERCENT_MIN = 10, PANE_PERCENT_MAX = 90;
 
 // src/engine/claude-code-local/hook-adapter.ts
 import { mkdir as mkdir5, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
@@ -5930,7 +5951,7 @@ function parseEvents(raw, fallbackSessionId) {
       if (!text)
         continue;
       if (!firstUserMessage)
-        firstUserMessage = text.slice(0, PREVIEW_CHAR_CAP);
+        firstUserMessage = Buffer.from(text.slice(0, PREVIEW_CHAR_CAP), "utf8").toString("utf8");
       messages.push({ role: "user", blocks: [{ type: "text", text }], timestamp, sessionId });
       continue;
     }
@@ -6266,7 +6287,8 @@ function titleFromMessages(messages) {
   if (!firstUser)
     return "";
   const text = firstUser.blocks.filter((b) => b.type === "text").map((b) => b.text).join(" ");
-  return deriveTitleFromPrompt(text);
+  const title = deriveTitleFromPrompt(text);
+  return title.length > 0 ? Buffer.from(title, "utf8").toString("utf8") : title;
 }
 async function deriveTitleFromSession(worktree, vendor = DEFAULT_TASK_VENDOR) {
   if (!worktree)
@@ -6317,8 +6339,10 @@ __export(exports_client, {
   paneIdByRole: () => paneIdByRole,
   newWindow: () => newWindow,
   killSession: () => killSession,
+  globalTasksPaneWidth: () => globalTasksPaneWidth,
   getSessionOptions: () => getSessionOptions,
   getSessionOption: () => getSessionOption,
+  getServerOption: () => getServerOption,
   ensureFallbackSession: () => ensureFallbackSession,
   currentSessionName: () => currentSessionName,
   claudePaneIdStrict: () => claudePaneIdStrict,
@@ -6452,6 +6476,15 @@ async function getSessionOptions(session, options) {
   }
   return values;
 }
+async function getServerOption(option) {
+  const { code, stdout } = await runTmuxCapturing(["show-options", "-sqv", option]);
+  return code === 0 ? stdout.trim() : "";
+}
+async function globalTasksPaneWidth() {
+  const raw = await getServerOption(TASKS_WIDTH_OPTION);
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? clampTasksPaneWidth(n) : TASKS_PANE_WIDTH;
+}
 async function tagPaneRole(paneId, role) {
   await runTmux(["set-option", "-p", "-t", paneId, PANE_ROLE_OPTION, role]);
 }
@@ -6551,6 +6584,7 @@ async function ensureFallbackSession() {
   ]);
   const mainPane = r0.stdout.trim();
   if (mainPane) {
+    const tasksWidth = await globalTasksPaneWidth();
     const r1 = await runTmuxCapturing([
       "split-window",
       "-h",
@@ -6558,7 +6592,7 @@ async function ensureFallbackSession() {
       "-t",
       mainPane,
       "-l",
-      `${TASKS_PANE_WIDTH}`,
+      `${tasksWidth}`,
       "-c",
       SAFE_SPAWN_CWD,
       "-P",
@@ -7048,8 +7082,20 @@ function createDaemonHandlerRegistry() {
       name: "task.ensureWorktree",
       async handle(payload, ctx) {
         const taskId = requireString(payload, "taskId");
-        const path11 = await ctx.orch.ensureWorktree(taskId);
-        return { worktreePath: path11 };
+        ctx.bus.publish("task.jobs", { taskId, kind: "ensureWorktree", phase: "running" });
+        try {
+          const path11 = await ctx.orch.ensureWorktree(taskId);
+          ctx.bus.publish("task.jobs", { taskId, kind: "ensureWorktree", phase: "done" });
+          return { worktreePath: path11 };
+        } catch (err) {
+          ctx.bus.publish("task.jobs", {
+            taskId,
+            kind: "ensureWorktree",
+            phase: "error",
+            error: err instanceof Error ? err.message : String(err)
+          });
+          throw err;
+        }
       }
     },
     {
@@ -7181,12 +7227,66 @@ var init_handlers = __esm(() => {
   init_protocol();
 });
 
-// ../kobe-daemon/src/daemon/ui-prefs-watcher.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, watch } from "fs";
+// ../kobe-daemon/src/daemon/keybindings-watcher.ts
+import { mkdirSync as mkdirSync2, watch } from "fs";
 import { homedir as homedir13 } from "os";
 import { basename as basename3, dirname as dirname5, join as join4 } from "path";
-function defaultUiPrefsStatePath(homeDir2 = process.env.KOBE_HOME_DIR ?? homedir13()) {
-  return join4(homeDir2, ".config", "kobe", "state.json");
+function defaultKeybindingsPath(homeDir2 = process.env.KOBE_HOME_DIR ?? homedir13()) {
+  return join4(homeDir2, ".kobe", "settings", "keybindings.yaml");
+}
+function startKeybindingsWatcher(bus, options = {}) {
+  const debounceMs = options.debounceMs ?? DEFAULT_KEYBINDINGS_DEBOUNCE_MS;
+  if (debounceMs <= 0)
+    return () => {};
+  const filePath = options.path ?? defaultKeybindingsPath();
+  const dir = dirname5(filePath);
+  const baseYaml = basename3(filePath);
+  const baseYml = baseYaml.replace(/\.yaml$/, ".yml");
+  let rev = 0;
+  bus.publish("keybindings", { rev });
+  let timer = null;
+  const bump = () => {
+    timer = null;
+    try {
+      rev += 1;
+      bus.publish("keybindings", { rev });
+    } catch (err) {
+      logDaemonError("keybindings-watcher", err);
+    }
+  };
+  let watcher = null;
+  try {
+    mkdirSync2(dir, { recursive: true });
+    watcher = watch(dir, (_event, filename) => {
+      if (filename !== null && filename !== baseYaml && filename !== baseYml)
+        return;
+      if (timer)
+        clearTimeout(timer);
+      timer = setTimeout(bump, debounceMs);
+      timer.unref?.();
+    });
+    watcher.on("error", (err) => logDaemonError("keybindings-watcher", err));
+  } catch (err) {
+    logDaemonError("keybindings-watcher", err);
+  }
+  return () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    watcher?.close();
+    watcher = null;
+  };
+}
+var DEFAULT_KEYBINDINGS_DEBOUNCE_MS = 200;
+var init_keybindings_watcher = () => {};
+
+// ../kobe-daemon/src/daemon/ui-prefs-watcher.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, watch as watch2 } from "fs";
+import { homedir as homedir14 } from "os";
+import { basename as basename4, dirname as dirname6, join as join5 } from "path";
+function defaultUiPrefsStatePath(homeDir2 = process.env.KOBE_HOME_DIR ?? homedir14()) {
+  return join5(homeDir2, ".config", "kobe", "state.json");
 }
 function readUiPrefsFromStateFile(statePath2) {
   let parsed = {};
@@ -7198,18 +7298,20 @@ function readUiPrefsFromStateFile(statePath2) {
   const theme = typeof parsed.activeTheme === "string" && parsed.activeTheme.length > 0 ? parsed.activeTheme : "claude";
   const transparentBackground = parsed.transparentBackground === true;
   const focusAccent = typeof parsed.focusAccent === "string" && FOCUS_ACCENT_SLOT_NAMES.includes(parsed.focusAccent) ? parsed.focusAccent : null;
-  return { theme, transparentBackground, focusAccent };
+  const sortMode = parsed.activeSortMode === "recent" ? "recent" : "default";
+  const keysCollapsed = parsed["tasksPane.keysCollapsed"] === true;
+  return { theme, transparentBackground, focusAccent, sortMode, keysCollapsed };
 }
 function samePrefs(a, b) {
-  return a.theme === b.theme && a.transparentBackground === b.transparentBackground && a.focusAccent === b.focusAccent;
+  return a.theme === b.theme && a.transparentBackground === b.transparentBackground && a.focusAccent === b.focusAccent && a.sortMode === b.sortMode && a.keysCollapsed === b.keysCollapsed;
 }
 function startUiPrefsWatcher(bus, options = {}) {
   const debounceMs = options.debounceMs ?? DEFAULT_UI_PREFS_DEBOUNCE_MS;
   if (debounceMs <= 0)
     return () => {};
   const statePath2 = options.statePath ?? defaultUiPrefsStatePath();
-  const stateDir = dirname5(statePath2);
-  const stateFile = basename3(statePath2);
+  const stateDir = dirname6(statePath2);
+  const stateFile = basename4(statePath2);
   let last = readUiPrefsFromStateFile(statePath2);
   bus.publish("ui-prefs", last);
   let timer = null;
@@ -7227,8 +7329,8 @@ function startUiPrefsWatcher(bus, options = {}) {
   };
   let watcher = null;
   try {
-    mkdirSync2(stateDir, { recursive: true });
-    watcher = watch(stateDir, (_event, filename) => {
+    mkdirSync3(stateDir, { recursive: true });
+    watcher = watch2(stateDir, (_event, filename) => {
       if (filename !== null && filename !== stateFile)
         return;
       if (timer)
@@ -7254,10 +7356,236 @@ var init_ui_prefs_watcher = __esm(() => {
   FOCUS_ACCENT_SLOT_NAMES = ["primary", "success", "info"];
 });
 
+// src/lib/poll-scheduling.ts
+import { spawn as spawn2 } from "child_process";
+function computeNextAllowedAt(startedAt, finishedAt, timedOut, cfg) {
+  if (timedOut)
+    return startedAt + cfg.slowRetryMs;
+  return finishedAt + Math.max(cfg.minIntervalMs, (finishedAt - startedAt) * 5);
+}
+function shouldPoll(state, now) {
+  return !state.inFlight && now >= state.nextAllowedAt;
+}
+function maybeStartScheduledRun(state, cfg, run, onValue) {
+  const startedAt = Date.now();
+  if (!shouldPoll(state, startedAt))
+    return false;
+  state.inFlight = true;
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), cfg.timeoutMs);
+  (async () => {
+    let value;
+    let ok = false;
+    try {
+      value = await run(controller.signal);
+      ok = true;
+    } catch {}
+    clearTimeout(timer);
+    const timedOut = controller.signal.aborted;
+    state.nextAllowedAt = computeNextAllowedAt(startedAt, Date.now(), timedOut, cfg);
+    state.inFlight = false;
+    if (ok && !timedOut)
+      onValue(value);
+  })();
+  return true;
+}
+function spawnCapture(cmd, args, opts) {
+  return new Promise((resolve2) => {
+    let out = "";
+    let settled = false;
+    const finish = (status) => {
+      if (settled)
+        return;
+      settled = true;
+      resolve2({ status, stdout: out });
+    };
+    const child = spawn2(cmd, args.slice(), {
+      cwd: opts.cwd,
+      stdio: ["ignore", "pipe", "ignore"],
+      env: opts.env,
+      signal: opts.signal,
+      killSignal: "SIGKILL"
+    });
+    child.stdout?.on("data", (chunk) => {
+      out += String(chunk);
+    });
+    child.on("error", () => finish(null));
+    child.on("close", (code) => finish(code));
+  });
+}
+var init_poll_scheduling = () => {};
+
+// src/tui/panes/sidebar/worktree-changes.ts
+var exports_worktree_changes = {};
+__export(exports_worktree_changes, {
+  sameWorktreeChanges: () => sameWorktreeChanges,
+  readWorktreeChanges: () => readWorktreeChanges,
+  pickPushedChanges: () => pickPushedChanges,
+  parsePorcelain: () => parsePorcelain2
+});
+import { spawnSync as spawnSync7 } from "child_process";
+function sameWorktreeChanges(a, b) {
+  return a.added === b.added && a.deleted === b.deleted;
+}
+function pickPushedChanges(pushed, worktreePath) {
+  if (!pushed)
+    return null;
+  return pushed.get(worktreePath) ?? ZERO;
+}
+function readWorktreeChanges(worktreePath) {
+  if (!worktreePath)
+    return ZERO;
+  try {
+    const out = spawnSync7("git", ["status", "--porcelain=v1"], {
+      cwd: worktreePath,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" }
+    });
+    if (out.status !== 0 || !out.stdout)
+      return ZERO;
+    return parsePorcelain2(out.stdout);
+  } catch {
+    return ZERO;
+  }
+}
+function parsePorcelain2(text) {
+  let added = 0;
+  let deleted = 0;
+  for (const line of text.split(`
+`)) {
+    if (!line || line.startsWith("##"))
+      continue;
+    const x = line.charAt(0);
+    const y = line.charAt(1);
+    if (x === "D" || y === "D")
+      deleted += 1;
+    else
+      added += 1;
+  }
+  return { added, deleted };
+}
+var ZERO;
+var init_worktree_changes = __esm(() => {
+  ZERO = { added: 0, deleted: 0 };
+});
+
+// ../kobe-daemon/src/daemon/worktree-changes-collector.ts
+async function runGitStatus(worktreePath, signal) {
+  const res = await spawnCapture("git", ["status", "--porcelain=v1"], {
+    cwd: worktreePath,
+    env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" },
+    signal
+  });
+  if (res.status !== 0)
+    throw new Error("git status failed");
+  return parsePorcelain2(res.stdout);
+}
+function trackedWorktreePaths(tasks) {
+  const paths = new Set;
+  for (const task of tasks) {
+    if (task.archived)
+      continue;
+    if (!task.worktreePath)
+      continue;
+    if (isRemoteRepoKey(task.repo) || isRemoteRepoKey(task.worktreePath))
+      continue;
+    paths.add(task.worktreePath);
+  }
+  return paths;
+}
+
+class WorktreeChangesCollector {
+  orch;
+  bus;
+  options;
+  entries = new Map;
+  stopped = false;
+  constructor(orch, bus, options = {}) {
+    this.orch = orch;
+    this.bus = bus;
+    this.options = options;
+  }
+  tick() {
+    if (this.stopped)
+      return;
+    try {
+      const tracked = trackedWorktreePaths(this.orch.listTasks());
+      let pruned = false;
+      for (const path11 of this.entries.keys()) {
+        if (tracked.has(path11))
+          continue;
+        const entry = this.entries.get(path11);
+        if (entry?.value)
+          pruned = true;
+        this.entries.delete(path11);
+      }
+      if (pruned)
+        this.publish();
+      for (const path11 of tracked)
+        this.maybeCollect(path11);
+    } catch (err) {
+      logDaemonError("worktree-changes", err);
+    }
+  }
+  stop() {
+    this.stopped = true;
+  }
+  maybeCollect(worktreePath) {
+    let entry = this.entries.get(worktreePath);
+    if (!entry) {
+      entry = { inFlight: false, nextAllowedAt: 0 };
+      this.entries.set(worktreePath, entry);
+    }
+    const cadence = this.options.cadence ?? {
+      timeoutMs: WORKTREE_CHANGES_TIMEOUT_MS,
+      slowRetryMs: WORKTREE_CHANGES_SLOW_RETRY_MS,
+      minIntervalMs: WORKTREE_CHANGES_MIN_INTERVAL_MS
+    };
+    const run = this.options.run ?? runGitStatus;
+    maybeStartScheduledRun(entry, cadence, (signal) => run(worktreePath, signal), (value) => {
+      if (this.stopped)
+        return;
+      if (this.entries.get(worktreePath) !== entry)
+        return;
+      if (entry.value && sameWorktreeChanges(entry.value, value))
+        return;
+      entry.value = value;
+      this.publish();
+    });
+  }
+  publish() {
+    const changes = {};
+    for (const [path11, entry] of this.entries) {
+      if (entry.value)
+        changes[path11] = entry.value;
+    }
+    this.bus.publish("worktree.changes", { changes });
+  }
+}
+function startWorktreeChangesCollector(orch, bus, tickMs = DEFAULT_WORKTREE_CHANGES_TICK_MS) {
+  if (tickMs <= 0)
+    return () => {};
+  const collector = new WorktreeChangesCollector(orch, bus);
+  collector.tick();
+  const timer = setInterval(() => collector.tick(), tickMs);
+  timer.unref?.();
+  return () => {
+    clearInterval(timer);
+    collector.stop();
+  };
+}
+var DEFAULT_WORKTREE_CHANGES_TICK_MS = 2000, WORKTREE_CHANGES_TIMEOUT_MS = 4000, WORKTREE_CHANGES_SLOW_RETRY_MS = 60000, WORKTREE_CHANGES_MIN_INTERVAL_MS = 1500;
+var init_worktree_changes_collector = __esm(() => {
+  init_poll_scheduling();
+  init_repos();
+  init_worktree_changes();
+});
+
 // ../kobe-daemon/src/daemon/server.ts
 import { mkdir as mkdir6, readFile as readFile8, unlink as unlink4, writeFile as writeFile4 } from "fs/promises";
 import { createServer } from "net";
-import { dirname as dirname6 } from "path";
+import { dirname as dirname7 } from "path";
 function resolveIdleGraceMs() {
   const raw = process.env.KOBE_DAEMON_IDLE_GRACE_MS;
   if (raw === undefined)
@@ -7306,8 +7634,8 @@ async function startDaemonServer(orch, options = {}) {
     broadcast(clients, { type: "event", name: event.channel, payload: event.payload });
   });
   const activity = new DaemonActivityRegistry(bus);
-  await mkdir6(dirname6(socketPath), { recursive: true });
-  await mkdir6(dirname6(pidPath), { recursive: true });
+  await mkdir6(dirname7(socketPath), { recursive: true });
+  await mkdir6(dirname7(pidPath), { recursive: true });
   await unlink4(socketPath).catch(() => {});
   const server = createServer((socket) => {
     const client = {
@@ -7353,6 +7681,11 @@ async function startDaemonServer(orch, options = {}) {
     statePath: defaultUiPrefsStatePath(options.homeDir),
     debounceMs: options.uiPrefsDebounceMs ?? DEFAULT_UI_PREFS_DEBOUNCE_MS
   });
+  const stopKeybindingsWatcher = startKeybindingsWatcher(bus, {
+    path: defaultKeybindingsPath(options.homeDir),
+    debounceMs: options.keybindingsDebounceMs ?? DEFAULT_KEYBINDINGS_DEBOUNCE_MS
+  });
+  const stopWorktreeChangesCollector = startWorktreeChangesCollector(orch, bus, options.worktreeChangesTickMs ?? DEFAULT_WORKTREE_CHANGES_TICK_MS);
   const serverApi = {
     socketPath,
     pidPath,
@@ -7366,6 +7699,8 @@ async function startDaemonServer(orch, options = {}) {
         clearInterval(updateTimer);
       stopAutoTitlePoller();
       stopUiPrefsWatcher();
+      stopKeybindingsWatcher();
+      stopWorktreeChangesCollector();
       activity.close();
       broadcast(clients, { type: "event", name: "daemon.stopping", payload: {} });
       for (const client of Array.from(clients)) {
@@ -7485,9 +7820,11 @@ var init_server = __esm(() => {
   init_activity_registry();
   init_auto_title_poller();
   init_handlers();
+  init_keybindings_watcher();
   init_paths2();
   init_protocol();
   init_ui_prefs_watcher();
+  init_worktree_changes_collector();
   init_handlers();
   DEFAULT_UPDATE_POLL_MS = 6 * 60 * 60 * 1000;
 });
@@ -7556,21 +7893,21 @@ __export(exports_daemon_process, {
   connectOrStartDaemon: () => connectOrStartDaemon,
   connectIfRunning: () => connectIfRunning
 });
-import { spawn as spawn2 } from "child_process";
-import { closeSync, existsSync as existsSync5, mkdirSync as mkdirSync3, openSync } from "fs";
-import { dirname as dirname7, resolve as resolve2 } from "path";
+import { spawn as spawn3 } from "child_process";
+import { closeSync, existsSync as existsSync5, mkdirSync as mkdirSync4, openSync } from "fs";
+import { dirname as dirname8, resolve as resolve2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function spawnDetachedDaemon(command, args, env, logPath) {
   let stdio = "ignore";
   let logFd;
   try {
-    mkdirSync3(dirname7(logPath), { recursive: true });
+    mkdirSync4(dirname8(logPath), { recursive: true });
     logFd = openSync(logPath, "a");
     stdio = ["ignore", logFd, logFd];
   } catch {
     stdio = "ignore";
   }
-  const child = spawn2(command, [...args], { detached: true, stdio, env });
+  const child = spawn3(command, [...args], { detached: true, stdio, env });
   child.unref();
   if (logFd !== undefined) {
     try {
@@ -7631,7 +7968,7 @@ function resolveKobeSpawn(subcommand) {
   if (here.startsWith("/$bunfs") || here.startsWith("B:\\~BUN")) {
     return [process.execPath, ...subcommand];
   }
-  const dir = dirname7(here);
+  const dir = dirname8(here);
   const candidates = [
     resolve2(dir, "../cli/index.ts"),
     resolve2(dir, "../../../kobe/src/cli/index.ts"),
@@ -7730,13 +8067,13 @@ async function runRepoSubcommand(args) {
   }
   const { getRepoInitOverride: getRepoInitOverride2, setRepoInitOverride: setRepoInitOverride2, resolveRepoRoot: resolveRepoRoot2 } = await Promise.resolve().then(() => (init_repos(), exports_repos));
   const { existsSync: existsSync6 } = await import("fs");
-  const { join: join5 } = await import("path");
+  const { join: join6 } = await import("path");
   if (verb === "show") {
     const [pathArg] = rest.filter((a) => !a.startsWith("-"));
     const repo = resolveRepoRoot2(resolve3(process.cwd(), pathArg ?? "."));
     const override = getRepoInitOverride2(repo);
-    const hasFileScript = existsSync6(join5(repo, ".kobe", "init.sh"));
-    const hasFilePrompt = existsSync6(join5(repo, ".kobe", "init-prompt.md"));
+    const hasFileScript = existsSync6(join6(repo, ".kobe", "init.sh"));
+    const hasFilePrompt = existsSync6(join6(repo, ".kobe", "init-prompt.md"));
     console.log(`repo: ${repo}`);
     console.log(`  .kobe/init.sh:        ${hasFileScript ? "present (wins)" : "absent"}`);
     console.log(`  .kobe/init-prompt.md: ${hasFilePrompt ? "present (wins)" : "absent"}`);
@@ -7853,7 +8190,7 @@ var init_interactive_command = __esm(() => {
 });
 
 // src/lib/feedback.ts
-import { spawnSync as spawnSync7 } from "child_process";
+import { spawnSync as spawnSync8 } from "child_process";
 function parseRepoSlug(slug) {
   const [owner, name] = slug.split("/");
   if (!owner || !name)
@@ -7908,7 +8245,7 @@ function submitFeedback(input, deps = {}) {
     throw new Error("package repository is not a GitHub repository");
   const { owner, name } = parseRepoSlug(slug);
   const categorySlug = input.categorySlug?.trim() || DEFAULT_FEEDBACK_CATEGORY_SLUG;
-  const io = { spawn: deps.spawn ?? spawnSync7 };
+  const io = { spawn: deps.spawn ?? spawnSync8 };
   const categoryData = runGhGraphql(DISCUSSION_CATEGORY_QUERY, { owner, name }, io);
   const repository = categoryData.repository;
   const repositoryId = repository?.id;
@@ -8009,6 +8346,9 @@ var init_daemon_session = __esm(() => {
 
 // src/state/keybindings-file.ts
 import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+function resetKeybindingsFileCache() {
+  cached = null;
+}
 function resolveConfigFile() {
   const canonical = keybindingsConfigPath();
   if (existsSync6(canonical))
@@ -8044,6 +8384,13 @@ var init_keybindings_file = __esm(() => {
 });
 
 // src/tui/lib/keymap-overrides.ts
+function pairContract(first, second) {
+  const layout = `alternating [${first}, ${second}] pairs`;
+  return {
+    layout,
+    validateCount: (count) => count >= 2 && count % 2 === 0 ? null : `needs ${layout} (an even number of chords \u2014 got ${count})`
+  };
+}
 function normalizeChord(raw, opts) {
   const trimmed = raw.trim().toLowerCase();
   if (!trimmed)
@@ -8183,6 +8530,14 @@ function applyKeymapOverrides(keymap, entries) {
       warnings.push(`${entry.id}: not customizable \u2014 the key is handled outside the keymap (doc-only row)`);
       continue;
     }
+    const contract = SLOT_CONTRACTS[entry.id];
+    if (contract && entry.keys.length > 0) {
+      const problem = contract.validateCount(entry.keys.length);
+      if (problem) {
+        warnings.push(`${entry.id}: ${problem} \u2014 keeping the default`);
+        continue;
+      }
+    }
     const keys = entry.keys.filter((chord) => {
       if (chord.length === 1 && NO_BARE_LETTER_SCOPES.has(row.scope)) {
         warnings.push(`${entry.id}: "${chord}" dropped \u2014 a bare character on a ${row.scope}-scope binding would steal typed input (add a modifier)`);
@@ -8194,6 +8549,10 @@ function applyKeymapOverrides(keymap, entries) {
       warnings.push(`${entry.id}: no chords survived validation \u2014 keeping the default`);
       continue;
     }
+    if (contract && keys.length !== entry.keys.length) {
+      warnings.push(`${entry.id}: a dropped chord would shift the slot layout (${contract.layout}) \u2014 keeping the default`);
+      continue;
+    }
     const defaultKeys = row.keys;
     const mutable = row;
     mutable.keys = keys;
@@ -8224,21 +8583,23 @@ function applyKeymapOverrides(keymap, entries) {
   }
   return { applied, warnings };
 }
-var FIXED_BINDING_IDS, NO_BARE_LETTER_SCOPES, MOD_ALIASES, KEY_ALIASES, KNOWN_NAMED_KEYS, MOD_ORDER;
+var FIXED_BINDING_IDS, SLOT_CONTRACTS, NO_BARE_LETTER_SCOPES, MOD_ALIASES, KEY_ALIASES, KNOWN_NAMED_KEYS, MOD_ORDER;
 var init_keymap_overrides = __esm(() => {
   FIXED_BINDING_IDS = {
-    "focus.numeric": "pane focus is positional (h/j/k/l \u2192 pane) and mirrors the tmux-layer ctrl+hjkl bindings",
-    "sidebar.nav": "handler maps j/down vs k/up by key name",
-    "sidebar.goto": "gg vs Shift+G is discriminated inside the handler",
-    "sidebar.pin": "Shift+P is discriminated inside the handler",
-    "sidebar.localMerge": "Shift+M is discriminated inside the handler",
-    "sidebar.view": "[ vs ] direction is read from the key name",
-    "sidebar.search.nav": "handler maps down vs up by key name",
-    "files.nav": "handler maps j/down vs k/up by key name",
-    "files.hierarchy": "handler maps h/left vs l/right by key name",
-    "files.tab": "[ vs ] direction is read from the key name",
-    "chat.question.nav": "handler maps j/down vs k/up by key name",
-    "chat.question.pick-number": "digits map to options by key name"
+    "focus.numeric": "pane focus is positional (h/j/k/l \u2192 pane) and mirrors the tmux-layer ctrl+hjkl bindings \u2014 rebind tmux.focus instead",
+    "sidebar.goto": "gg vs Shift+G is discriminated via evt.shift; shift+<letter> chords are inexpressible, so a rebind can't carry both halves",
+    "sidebar.pin": "fires on Shift+P via evt.shift; shift+<letter> chords are inexpressible, so a rebind can't work",
+    "sidebar.localMerge": "fires on Shift+M via evt.shift; shift+<letter> chords are inexpressible, so a rebind can't work",
+    "chat.question.nav": "the question picker has no live registration site (display-only row) \u2014 rebinding would change Help without changing behavior",
+    "chat.question.pick-number": "digits map to options positionally and the question picker has no live registration site (display-only row)"
+  };
+  SLOT_CONTRACTS = {
+    "sidebar.nav": pairContract("down", "up"),
+    "files.nav": pairContract("down", "up"),
+    "sidebar.search.nav": pairContract("down", "up"),
+    "files.hierarchy": pairContract("collapse", "expand"),
+    "sidebar.view": pairContract("previous view", "next view"),
+    "files.tab": pairContract("previous tab", "next tab")
   };
   NO_BARE_LETTER_SCOPES = new Set(["global", "workspace", "terminal"]);
   MOD_ALIASES = {
@@ -8399,6 +8760,9 @@ function resolveTmuxKeyEntries(entries) {
 function tmuxChordOptsFor(id) {
   return id.startsWith("tmux.") ? { allowShiftCharacter: true } : {};
 }
+function resetTmuxKeysCache() {
+  cached2 = null;
+}
 function resolveUserTmuxKeys() {
   if (cached2)
     return cached2;
@@ -9948,9 +10312,9 @@ var init_schema = () => {};
 
 // src/tui/context/theme/loader.ts
 import { readFileSync as readFileSync6, readdirSync } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 function userThemesDir() {
-  return join5(kobeStateDir(), "themes");
+  return join6(kobeStateDir(), "themes");
 }
 function loadUserThemes() {
   const dir = userThemesDir();
@@ -9964,7 +10328,7 @@ function loadUserThemes() {
   for (const file of entries) {
     if (!file.endsWith(".json"))
       continue;
-    const path11 = join5(dir, file);
+    const path11 = join6(dir, file);
     let parsed;
     try {
       const text = readFileSync6(path11, "utf8");
@@ -10166,11 +10530,106 @@ async function relaunchEngineInAllWindows(session, cwd, command, remoteKey) {
   return true;
 }
 async function healTaskPaneWidths(session) {
-  const rows = await listKobePanes(session);
-  if (!rows)
+  const target = await globalTasksPaneWidth();
+  const { code, stdout } = await runTmuxCapturing([
+    "list-panes",
+    "-s",
+    "-t",
+    `=${session}`,
+    "-F",
+    "#{pane_id}\t#{@kobe_role}\t#{pane_width}"
+  ]);
+  if (code !== 0)
+    return;
+  const mismatched = stdout.split(`
+`).map((line) => line.split("\t")).filter(([, role]) => role?.trim() === "tasks").filter(([, , width]) => Number.parseInt(width?.trim() ?? "", 10) !== target).map(([id]) => id?.trim()).filter((id) => !!id);
+  if (mismatched.length === 0)
+    return;
+  await runTmuxSequence(mismatched.map((pane) => ["resize-pane", "-t", pane, "-x", `${target}`]));
+}
+async function rightColumnPercents() {
+  const [width, height] = await Promise.all([
+    getServerOption(RIGHT_COLUMN_WIDTH_OPTION),
+    getServerOption(OPS_HEIGHT_OPTION)
+  ]);
+  return {
+    widthPct: clampPanePercent(Number.parseInt(width, 10)),
+    heightPct: clampPanePercent(Number.parseInt(height, 10))
+  };
+}
+function rightColumnResizeArgs(geom) {
+  const args = [];
+  if (geom.widthPct !== null)
+    args.push("-x", `${geom.widthPct}%`);
+  if (geom.heightPct !== null)
+    args.push("-y", `${geom.heightPct}%`);
+  return args;
+}
+async function globalRightColumnResizeArgs() {
+  return rightColumnResizeArgs(await rightColumnPercents());
+}
+async function healRightColumn(session) {
+  const args = await globalRightColumnResizeArgs();
+  if (args.length === 0)
+    return;
+  const { code, stdout } = await runTmuxCapturing([
+    "list-panes",
+    "-s",
+    "-t",
+    `=${session}`,
+    "-F",
+    "#{pane_id}\t#{@kobe_role}"
+  ]);
+  if (code !== 0)
+    return;
+  const opsPanes = stdout.split(`
+`).map((line) => line.split("\t")).filter(([, role]) => role?.trim() === "ops").map(([id]) => id?.trim()).filter((id) => !!id);
+  if (opsPanes.length === 0)
+    return;
+  await runTmuxSequence(opsPanes.map((pane) => ["resize-pane", "-t", pane, ...args]));
+}
+async function healSessionLayout(session) {
+  if (!await sessionExists(session))
+    return;
+  await healTaskPaneWidths(session);
+  await healRightColumn(session);
+}
+async function captureGlobalLayout(session) {
+  const { code, stdout } = await runTmuxCapturing([
+    "list-panes",
+    "-t",
+    `=${session}`,
+    "-F",
+    "#{@kobe_role}\t#{pane_width}\t#{pane_height}\t#{window_width}\t#{window_height}"
+  ]);
+  if (code !== 0)
+    return;
+  const rows = stdout.split(`
+`).map((line) => line.split("\t")).filter((cols) => (cols[0]?.trim() ?? "") !== "");
+  if (rows.length === 0)
     return;
-  const taskPanes = paneIdsByRole(rows, "tasks");
-  await runTmuxSequence(taskPanes.map((pane) => ["resize-pane", "-t", pane, "-x", `${TASKS_PANE_WIDTH}`]));
+  const winW = Number.parseInt(rows[0][3]?.trim() ?? "", 10);
+  const winH = Number.parseInt(rows[0][4]?.trim() ?? "", 10);
+  const sets = [];
+  const tasks = rows.find(([role]) => role?.trim() === "tasks");
+  if (tasks) {
+    const width = Number.parseInt(tasks[1]?.trim() ?? "", 10);
+    if (Number.isFinite(width) && width > 0)
+      sets.push(["set-option", "-s", TASKS_WIDTH_OPTION, `${clampTasksPaneWidth(width)}`]);
+  }
+  const ops = rows.find(([role]) => role?.trim() === "ops");
+  if (ops && Number.isFinite(winW) && winW > 0 && Number.isFinite(winH) && winH > 0) {
+    const opsW = Number.parseInt(ops[1]?.trim() ?? "", 10);
+    const opsH = Number.parseInt(ops[2]?.trim() ?? "", 10);
+    const widthPct = Number.isFinite(opsW) ? clampPanePercent(100 * opsW / winW) : null;
+    const heightPct = Number.isFinite(opsH) ? clampPanePercent(100 * opsH / winH) : null;
+    if (widthPct !== null)
+      sets.push(["set-option", "-s", RIGHT_COLUMN_WIDTH_OPTION, `${widthPct}`]);
+    if (heightPct !== null)
+      sets.push(["set-option", "-s", OPS_HEIGHT_OPTION, `${heightPct}`]);
+  }
+  if (sets.length > 0)
+    await runTmuxSequence(sets);
 }
 async function healKobePaneVersions(session, cwd, taskId, vendor) {
   const rows = await listKobePanes(session);
@@ -10253,6 +10712,7 @@ function kobeStatusRight(keys) {
 }
 async function buildPanesAround(claudePane, args) {
   const envPrefix = inheritedEnvPrefix();
+  const tasksWidth = await globalTasksPaneWidth();
   const opsCmd = keepAlive(args.opsCommand ?? envPrefix + opsPaneCommand({
     cwd: args.cwd,
     taskId: args.taskId,
@@ -10270,7 +10730,7 @@ async function buildPanesAround(claudePane, args) {
       "-t",
       claudePane,
       "-l",
-      `${TASKS_PANE_WIDTH}`,
+      `${tasksWidth}`,
       "-c",
       localSpawnCwd(args.cwd),
       "-P",
@@ -10303,6 +10763,11 @@ async function buildPanesAround(claudePane, args) {
     ...ids.ops ? [["set-option", "-p", "-t", ids.ops, "@kobe_role", "ops"]] : [],
     ...ids.ops ? [["set-option", "-p", "-t", ids.ops, PANE_VERSION_OPTION, CURRENT_VERSION]] : []
   ]);
+  if (ids.ops) {
+    const rcArgs = await globalRightColumnResizeArgs();
+    if (rcArgs.length > 0)
+      await runTmux(["resize-pane", "-t", ids.ops, ...rcArgs]);
+  }
 }
 async function newChatTab(session, vendorOverride) {
   if (!await sessionExists(session))
@@ -10350,6 +10815,16 @@ async function openSettingsTab(session) {
   const command = `${envPrefix}${inv.map(shellQuote).join(" ")} settings`;
   await newWindow(session, { cwd: localSpawnCwd(cwd), command, name: "settings" });
 }
+async function openHelpTab(session) {
+  if (!await sessionExists(session))
+    return;
+  const sessionOptions = await getSessionOptions(session, ["@kobe_worktree"]);
+  const cwd = sessionOptions["@kobe_worktree"] || process.cwd();
+  const inv = kobeCliInvocation();
+  const envPrefix = inheritedEnvPrefix();
+  const command = `${envPrefix}${inv.map(shellQuote).join(" ")} help-page`;
+  await newWindow(session, { cwd: localSpawnCwd(cwd), command, name: "help" });
+}
 async function openNewTaskTab(session, defaultRepo) {
   if (!await sessionExists(session))
     return;
@@ -10422,18 +10897,22 @@ __export(exports_tmux, {
   selectTasksPane: () => selectTasksPane,
   refreshKobeWorkspacePanes: () => refreshKobeWorkspacePanes,
   quickCreate: () => quickCreate,
+  prepareWindowForAttach: () => prepareWindowForAttach,
   openUpdateTab: () => openUpdateTab,
   openSettingsTab: () => openSettingsTab,
   openNewTaskTab: () => openNewTaskTab,
+  openHelpTab: () => openHelpTab,
   newChatTab: () => newChatTab,
   kobeStatusRight: () => kobeStatusRight,
   killSession: () => killSession,
+  healSessionLayout: () => healSessionLayout,
   ensureSession: () => ensureSession,
   currentSessionName: () => currentSessionName,
   chatTabSwitchBindings: () => chatTabSwitchBindings,
   chatTabRenameBinding: () => chatTabRenameBinding,
   chatTabCloseBinding: () => chatTabCloseBinding,
   chatTabChooseEngineBindings: () => chatTabChooseEngineBindings,
+  captureGlobalLayout: () => captureGlobalLayout,
   attachArgv: () => attachArgv,
   PANE_VERSION_OPTION: () => PANE_VERSION_OPTION,
   CHAT_TAB_STATUS_FORMAT: () => CHAT_TAB_STATUS_FORMAT,
@@ -10450,6 +10929,13 @@ function positiveInt(value) {
   const n = typeof value === "number" ? value : typeof value === "string" ? Number.parseInt(value, 10) : Number.NaN;
   return Number.isInteger(n) && n > 0 ? n : undefined;
 }
+async function prepareWindowForAttach(session) {
+  const sizeArgs = tmuxInitialSizeArgs();
+  if (sizeArgs.length > 0)
+    await runTmux(["resize-window", "-t", `=${session}`, ...sizeArgs]);
+  await healTaskPaneWidths(session);
+  await healRightColumn(session);
+}
 async function ensureSession(opts) {
   const inflight = ensureSessionLocks.get(opts.name);
   if (inflight)
@@ -10483,6 +10969,7 @@ async function ensureSessionImpl(opts) {
   const remoteKey = remoteKeyForRepo(opts.repo);
   if (action.kind === "reuse") {
     await healTaskPaneWidths(opts.name);
+    await healRightColumn(opts.name);
     await healKobePaneVersions(opts.name, opts.cwd, opts.taskId, opts.vendor);
     return true;
   }
@@ -10491,6 +10978,7 @@ async function ensureSessionImpl(opts) {
       if (opts.vendor)
         await setSessionOption(opts.name, "@kobe_vendor", opts.vendor);
       await healTaskPaneWidths(opts.name);
+      await healRightColumn(opts.name);
       await healKobePaneVersions(opts.name, opts.cwd, opts.taskId, opts.vendor);
       return true;
     }
@@ -10544,6 +11032,8 @@ async function ensureSessionImpl(opts) {
   const chooseEngineTmuxCommand = `run-shell ${shellQuote(chooseEngineCommand)}`;
   const focusTasksCommand = `${envStr}${invStr} focus-tasks --session '#{session_name}'`;
   const focusTasksTmuxCommand = `run-shell ${shellQuote(focusTasksCommand)}`;
+  const healLayoutCommand = `${envStr}${invStr} heal-layout --session '#{session_name}'`;
+  const healLayoutTmuxCommand = `run-shell -b ${shellQuote(healLayoutCommand)}`;
   const userKeys = resolveUserTmuxKeys();
   const unbinds = [];
   if (userKeys.overridden.has(TMUX_FOCUS_ID)) {
@@ -10585,6 +11075,7 @@ async function ensureSessionImpl(opts) {
       })
     ],
     ["set-option", "-g", "mouse", "on"],
+    ["set-hook", "-g", "window-resized", healLayoutTmuxCommand],
     ...unbinds,
     ...b["tmux.detach"] ? [
       [
@@ -10648,12 +11139,12 @@ __export(exports_repo_init, {
   resolveRepoInit: () => resolveRepoInit
 });
 import { existsSync as existsSync7, readFileSync as readFileSync8 } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 function repoFileScript(worktreePath) {
-  return existsSync7(join6(worktreePath, INIT_SCRIPT_REL)) ? `sh ${INIT_SCRIPT_REL}` : undefined;
+  return existsSync7(join7(worktreePath, INIT_SCRIPT_REL)) ? `sh ${INIT_SCRIPT_REL}` : undefined;
 }
 function repoFilePrompt(worktreePath) {
-  const p = join6(worktreePath, INIT_PROMPT_REL);
+  const p = join7(worktreePath, INIT_PROMPT_REL);
   if (!existsSync7(p))
     return;
   try {
@@ -10675,53 +11166,8 @@ function resolveRepoInit(repoRoot, worktreePath) {
 var INIT_SCRIPT_REL, INIT_PROMPT_REL;
 var init_repo_init = __esm(() => {
   init_repos();
-  INIT_SCRIPT_REL = join6(".kobe", "init.sh");
-  INIT_PROMPT_REL = join6(".kobe", "init-prompt.md");
-});
-
-// src/tui/panes/sidebar/worktree-changes.ts
-var exports_worktree_changes = {};
-__export(exports_worktree_changes, {
-  readWorktreeChanges: () => readWorktreeChanges,
-  parsePorcelain: () => parsePorcelain2
-});
-import { spawnSync as spawnSync8 } from "child_process";
-function readWorktreeChanges(worktreePath) {
-  if (!worktreePath)
-    return ZERO;
-  try {
-    const out = spawnSync8("git", ["status", "--porcelain=v1"], {
-      cwd: worktreePath,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"],
-      env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" }
-    });
-    if (out.status !== 0 || !out.stdout)
-      return ZERO;
-    return parsePorcelain2(out.stdout);
-  } catch {
-    return ZERO;
-  }
-}
-function parsePorcelain2(text) {
-  let added = 0;
-  let deleted = 0;
-  for (const line of text.split(`
-`)) {
-    if (!line || line.startsWith("##"))
-      continue;
-    const x = line.charAt(0);
-    const y = line.charAt(1);
-    if (x === "D" || y === "D")
-      deleted += 1;
-    else
-      added += 1;
-  }
-  return { added, deleted };
-}
-var ZERO;
-var init_worktree_changes = __esm(() => {
-  ZERO = { added: 0, deleted: 0 };
+  INIT_SCRIPT_REL = join7(".kobe", "init.sh");
+  INIT_PROMPT_REL = join7(".kobe", "init-prompt.md");
 });
 
 // src/cli/api-cmd.ts
@@ -11717,8 +12163,8 @@ var exports_theme = {};
 __export(exports_theme, {
   runThemeSubcommand: () => runThemeSubcommand
 });
-import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync9, readdirSync as readdirSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
-import { basename as basename4, join as join7, resolve as resolve5 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync9, readdirSync as readdirSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { basename as basename5, join as join8, resolve as resolve5 } from "path";
 function fail3(message) {
   process.stderr.write(`kobe theme: ${message}
 `);
@@ -11749,7 +12195,7 @@ function listThemes() {
   } else {
     for (const f of userFiles) {
       const name = f.slice(0, -".json".length);
-      const path11 = join7(dir, f);
+      const path11 = join8(dir, f);
       const overridesBundled = BUNDLED_NAMES.includes(name) ? " (overrides built-in)" : "";
       lines.push(`  ${name}${overridesBundled}  ${path11}`);
     }
@@ -11771,7 +12217,7 @@ async function readSource(source) {
     }
     const text2 = await res.text();
     const cleanPath = source.split(/[?#]/)[0] ?? source;
-    const file2 = basename4(cleanPath) || "theme.json";
+    const file2 = basename5(cleanPath) || "theme.json";
     const defaultName2 = file2.endsWith(".json") ? file2.slice(0, -".json".length) : file2;
     return { text: text2, defaultName: defaultName2 };
   }
@@ -11782,7 +12228,7 @@ async function readSource(source) {
   } catch (err) {
     fail3(`failed to read ${abs}: ${err instanceof Error ? err.message : String(err)}`);
   }
-  const file = basename4(abs);
+  const file = basename5(abs);
   const defaultName = file.endsWith(".json") ? file.slice(0, -".json".length) : file;
   return { text, defaultName };
 }
@@ -11838,8 +12284,8 @@ async function addTheme(args) {
     fail3(`invalid theme name "${name}" (use letters, digits, '.', '_', '-')`);
   }
   const dir = userThemesDir();
-  mkdirSync4(dir, { recursive: true });
-  const dest = join7(dir, `${name}.json`);
+  mkdirSync5(dir, { recursive: true });
+  const dest = join8(dir, `${name}.json`);
   if (existsSync8(dest) && !opts.force) {
     fail3(`${dest} already exists (pass --force to overwrite)`);
   }
@@ -11857,7 +12303,7 @@ function removeTheme(args) {
   if (BUNDLED_NAMES.includes(name)) {
     fail3(`"${name}" is a built-in theme and cannot be removed`);
   }
-  const dest = join7(userThemesDir(), `${name}.json`);
+  const dest = join8(userThemesDir(), `${name}.json`);
   if (!existsSync8(dest)) {
     fail3(`no user theme named "${name}" (looked for ${dest})`);
   }
@@ -12018,9 +12464,9 @@ var init_feedback_cmd = __esm(() => {
 });
 
 // src/core/index.ts
-import { homedir as homedir14 } from "os";
+import { homedir as homedir15 } from "os";
 async function createKobeCore(options = {}) {
-  const homeDir2 = options.homeDir ?? process.env.KOBE_HOME_DIR ?? homedir14();
+  const homeDir2 = options.homeDir ?? process.env.KOBE_HOME_DIR ?? homedir15();
   const store = new TaskIndexStore({ homeDir: homeDir2 });
   await store.load();
   const worktrees = new GitWorktreeManager;
@@ -12138,8 +12584,8 @@ var init_daemon_cmd = __esm(() => {
 
 // src/lib/skill-install.ts
 import { existsSync as existsSync9, readFileSync as readFileSync11 } from "fs";
-import { homedir as homedir15 } from "os";
-import { join as join8 } from "path";
+import { homedir as homedir16 } from "os";
+import { join as join9 } from "path";
 function npxSkillsArgv(opts = {}) {
   return ["skills", "add", SKILL_SOURCE_SLUG, "--skill", "kobe", "--agent", opts.agent ?? DEFAULT_SKILL_AGENT];
 }
@@ -12147,9 +12593,9 @@ function npxSkillsCommand(opts = {}) {
   return `npx ${npxSkillsArgv(opts).join(" ")}`;
 }
 function kobeSkillPaths(opts = {}) {
-  const home = opts.home ?? homedir15();
+  const home = opts.home ?? homedir16();
   const cwd = opts.cwd ?? process.cwd();
-  return [join8(home, SKILL_REL_PATH), join8(cwd, SKILL_REL_PATH)];
+  return [join9(home, SKILL_REL_PATH), join9(cwd, SKILL_REL_PATH)];
 }
 function parseSkillVersion(content) {
   const m = content.match(/kobe-skill-version:\s*(\d+)/);
@@ -12210,7 +12656,7 @@ __export(exports_maintenance, {
 });
 import { existsSync as existsSync10, readFileSync as readFileSync12, statSync as statSync5 } from "fs";
 import { unlink as unlink6 } from "fs/promises";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 import { createInterface as createInterface2 } from "readline";
 function isProcessAlive2(pid) {
   try {
@@ -12307,7 +12753,7 @@ async function runDoctorSubcommand(argv = []) {
   const socketPath = defaultDaemonSocketPath();
   const pidPath = defaultDaemonPidPath();
   const logPath = defaultDaemonLogPath();
-  const tasksPath = join9(kobeStateDir(), "tasks.json");
+  const tasksPath = join10(kobeStateDir(), "tasks.json");
   const statePath2 = kvStatePath();
   const out = ["kobe doctor", `  home:   ${homeDir()}`, `  socket: ${socketPath}`, ""];
   const status = await probeDaemonStatus(socketPath);
@@ -12426,7 +12872,7 @@ async function runResetSubcommand(argv) {
   const yes = argv.includes("--yes") || argv.includes("-y");
   const socketPath = defaultDaemonSocketPath();
   const pidPath = defaultDaemonPidPath();
-  const tasksPath = join9(kobeStateDir(), "tasks.json");
+  const tasksPath = join10(kobeStateDir(), "tasks.json");
   const statePath2 = kvStatePath();
   console.log("kobe reset will:");
   console.log("  \u2022 stop the kobe daemon (graceful \u2192 SIGTERM \u2192 SIGKILL)");
@@ -12696,15 +13142,15 @@ var GIT_TIMEOUT_MS = 15000;
 
 // src/web/notes.ts
 import { mkdir as mkdir7, readFile as readFile9, writeFile as writeFile5 } from "fs/promises";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 function notesDir() {
-  return join10(kobeStateDir(), "notes");
+  return join11(kobeStateDir(), "notes");
 }
 function isSafeTaskId(taskId) {
   return typeof taskId === "string" && taskId.length > 0 && /^[A-Za-z0-9_-]+$/.test(taskId);
 }
 function noteFilePath(taskId) {
-  return join10(notesDir(), `${taskId}.md`);
+  return join11(notesDir(), `${taskId}.md`);
 }
 async function handleGet(url) {
   const taskId = url.searchParams.get("taskId");
@@ -12817,16 +13263,21 @@ class DaemonLink {
     const socketPath = allowSpawn ? await ensureDaemonReachable() : defaultDaemonSocketPath();
     const client = new KobeDaemonClient(socketPath);
     await client.connect();
-    const hello = await client.request("hello", {
-      protocolVersion: DAEMON_PROTOCOL_VERSION,
-      minProtocolVersion: MIN_COMPATIBLE_PROTOCOL_VERSION
-    });
-    if (hello.tasks)
-      this.tasks = hello.tasks;
-    this.engineStates = {};
-    client.on("*", (frame) => this.onFrame(frame.name, frame.payload));
-    client.onLifecycle("close", () => this.onDrop(client));
-    await client.subscribe({ role: "gui" });
+    try {
+      const hello = await client.request("hello", {
+        protocolVersion: DAEMON_PROTOCOL_VERSION,
+        minProtocolVersion: MIN_COMPATIBLE_PROTOCOL_VERSION
+      });
+      if (hello.tasks)
+        this.tasks = hello.tasks;
+      this.engineStates = {};
+      client.on("*", (frame) => this.onFrame(frame.name, frame.payload));
+      client.onLifecycle("close", () => this.onDrop(client));
+      await client.subscribe({ role: "gui" });
+    } catch (err) {
+      client.close();
+      throw err;
+    }
     this.client = client;
     this.setConnected(true);
   }
@@ -12950,7 +13401,7 @@ var init_session = __esm(() => {
 
 // ../kobe-web/server/bridge.ts
 import { existsSync as existsSync11 } from "fs";
-import { join as join11, normalize as normalize2 } from "path";
+import { join as join12, normalize as normalize2 } from "path";
 function sseResponse(register) {
   let unregister = null;
   let heartbeat = null;
@@ -13024,10 +13475,10 @@ async function specResponse(url, link, spec) {
 }
 async function staticResponse(pathname, staticDir) {
   const rel = pathname === "/" ? "/index.html" : pathname;
-  const resolved = normalize2(join11(staticDir, rel));
+  const resolved = normalize2(join12(staticDir, rel));
   if (!resolved.startsWith(staticDir))
     return new Response("forbidden", { status: 403 });
-  const file = Bun.file(existsSync11(resolved) ? resolved : join11(staticDir, "index.html"));
+  const file = Bun.file(existsSync11(resolved) ? resolved : join12(staticDir, "index.html"));
   if (!await file.exists()) {
     return new Response("kobe web assets not built \u2014 run `bun --filter kobe-web build`", { status: 503 });
   }
@@ -13424,8 +13875,8 @@ __export(exports_hook_cmd, {
   parseWorktreeAddPath: () => parseWorktreeAddPath,
   ensureGlobalKobeHooks: () => ensureGlobalKobeHooks
 });
-import { homedir as homedir16 } from "os";
-import { join as join12, resolve as resolve7 } from "path";
+import { homedir as homedir17 } from "os";
+import { join as join13, resolve as resolve7 } from "path";
 async function readStdinPayload() {
   try {
     const text = await Promise.race([
@@ -13545,7 +13996,7 @@ function activityHookAdapters() {
   return ALL_VENDORS.map((v) => createEngineHookAdapter(v)).filter((a) => a.supportsHooks());
 }
 function globalSettingsPath() {
-  return join12(homedir16(), ".claude", "settings.json");
+  return join13(homedir17(), ".claude", "settings.json");
 }
 function persistedSyncPath(stored) {
   if (!stored || stored === "off")
@@ -13553,7 +14004,7 @@ function persistedSyncPath(stored) {
   if (stored === "global")
     return globalSettingsPath();
   if (stored.startsWith("repo:"))
-    return join12(resolve7(stored.slice(5)), ".claude", "settings.json");
+    return join13(resolve7(stored.slice(5)), ".claude", "settings.json");
   return stored;
 }
 async function ensureGlobalKobeHooks() {
@@ -14883,6 +15334,30 @@ var init_solid = __esm(() => {
 });
 
 // src/client/remote-orchestrator.ts
+function parseWorktreeChangesPayload(payload) {
+  const changes = payload?.changes;
+  if (!changes || typeof changes !== "object" || Array.isArray(changes))
+    return null;
+  const map = new Map;
+  for (const [path11, value] of Object.entries(changes)) {
+    const counts = value;
+    if (typeof counts?.added !== "number" || typeof counts.deleted !== "number")
+      return null;
+    map.set(path11, { added: counts.added, deleted: counts.deleted });
+  }
+  return map;
+}
+function sameWorktreeChangesMap(a, b) {
+  if (a.size !== b.size)
+    return false;
+  for (const [path11, counts] of a) {
+    const other = b.get(path11);
+    if (!other || !sameWorktreeChanges(counts, other))
+      return false;
+  }
+  return true;
+}
+
 class RemoteOrchestrator {
   client;
   tasksAcc;
@@ -14895,8 +15370,14 @@ class RemoteOrchestrator {
   setDaemonVersionSig;
   engineStateAcc;
   setEngineStateSig;
+  taskJobsAcc;
+  setTaskJobsSig;
+  worktreeChangesAcc;
+  setWorktreeChangesSig;
   uiPrefsAcc;
   setUiPrefsSig;
+  keybindingsRevAcc;
+  setKeybindingsRevSig;
   connectionStateAcc;
   setConnectionState;
   ensureReachable;
@@ -14909,7 +15390,10 @@ class RemoteOrchestrator {
     const [update, setUpdate] = createSignal(null);
     const [daemonVersion, setDaemonVersion] = createSignal(null);
     const [engineState, setEngineState] = createSignal(new Map);
+    const [taskJobs, setTaskJobs] = createSignal(new Map);
+    const [worktreeChanges, setWorktreeChanges] = createSignal(null);
     const [uiPrefs, setUiPrefs] = createSignal(null);
+    const [keybindingsRev, setKeybindingsRev] = createSignal(null);
     const [connectionState, setConnectionState] = createSignal("online");
     this.tasksAcc = tasks;
     this.setTasks = (next) => setTasks(() => next);
@@ -14921,8 +15405,14 @@ class RemoteOrchestrator {
     this.setDaemonVersionSig = (next) => setDaemonVersion(() => next);
     this.engineStateAcc = engineState;
     this.setEngineStateSig = (next) => setEngineState(() => next);
+    this.taskJobsAcc = taskJobs;
+    this.setTaskJobsSig = (next) => setTaskJobs(() => next);
+    this.worktreeChangesAcc = worktreeChanges;
+    this.setWorktreeChangesSig = (next) => setWorktreeChanges(() => next);
     this.uiPrefsAcc = uiPrefs;
     this.setUiPrefsSig = (next) => setUiPrefs(() => next);
+    this.keybindingsRevAcc = keybindingsRev;
+    this.setKeybindingsRevSig = (next) => setKeybindingsRev(() => next);
     this.connectionStateAcc = connectionState;
     this.setConnectionState = (next) => setConnectionState(() => next);
     this.ensureReachable = options.ensureReachable ?? ensureDaemonReachable;
@@ -14979,6 +15469,12 @@ class RemoteOrchestrator {
     if (hello.tasks)
       this.setTasks(hello.tasks.map(deserializeTask));
     await this.client.subscribe({ role: this.role });
+    if (hello.capabilities?.includes("worktree.changes")) {
+      if (this.worktreeChangesAcc() === null)
+        this.setWorktreeChangesSig(new Map);
+    } else {
+      this.setWorktreeChangesSig(null);
+    }
     this.setConnectionState("online");
     logClient("orch", `subscribed as ${this.role} (${this.tasksAcc().length} tasks)`);
   }
@@ -15011,9 +15507,18 @@ class RemoteOrchestrator {
   engineStateSignal() {
     return this.engineStateAcc;
   }
+  taskJobsSignal() {
+    return this.taskJobsAcc;
+  }
+  worktreeChangesSignal() {
+    return this.worktreeChangesAcc;
+  }
   uiPrefsSignal() {
     return this.uiPrefsAcc;
   }
+  keybindingsRevSignal() {
+    return this.keybindingsRevAcc;
+  }
   listTasks() {
     return this.tasksAcc();
   }
@@ -15093,8 +15598,11 @@ class RemoteOrchestrator {
   handleEvent(name, payload) {
     if (name === "task.snapshot") {
       const value = payload?.tasks;
-      if (Array.isArray(value))
+      if (Array.isArray(value)) {
         this.setTasks(value.map(deserializeTask));
+        this.pruneEngineState(value);
+        this.pruneTaskJobs(value);
+      }
       return;
     }
     if (name === "active-task") {
@@ -15119,6 +15627,34 @@ class RemoteOrchestrator {
       this.setEngineStateSig(next);
       return;
     }
+    if (name === "task.jobs") {
+      const p = payload;
+      if (typeof p?.taskId !== "string" || p.kind !== "ensureWorktree")
+        return;
+      const current = this.taskJobsAcc();
+      if (p.phase === "running") {
+        const next = new Map(current);
+        next.set(p.taskId, { kind: p.kind });
+        this.setTaskJobsSig(next);
+        return;
+      }
+      if ((p.phase === "done" || p.phase === "error") && current.has(p.taskId)) {
+        const next = new Map(current);
+        next.delete(p.taskId);
+        this.setTaskJobsSig(next);
+      }
+      return;
+    }
+    if (name === "worktree.changes") {
+      const next = parseWorktreeChangesPayload(payload);
+      if (!next)
+        return;
+      const current = this.worktreeChangesAcc();
+      if (current && sameWorktreeChangesMap(current, next))
+        return;
+      this.setWorktreeChangesSig(next);
+      return;
+    }
     if (name === "ui-prefs") {
       const p = payload;
       if (typeof p?.theme !== "string")
@@ -15126,10 +15662,51 @@ class RemoteOrchestrator {
       this.setUiPrefsSig({
         theme: p.theme,
         transparentBackground: p.transparentBackground === true,
-        focusAccent: typeof p.focusAccent === "string" ? p.focusAccent : null
+        focusAccent: typeof p.focusAccent === "string" ? p.focusAccent : null,
+        sortMode: p.sortMode === "recent" ? "recent" : "default",
+        keysCollapsed: p.keysCollapsed === true
       });
       return;
     }
+    if (name === "keybindings") {
+      const p = payload;
+      if (typeof p?.rev !== "number")
+        return;
+      this.setKeybindingsRevSig(p.rev);
+      return;
+    }
+  }
+  pruneEngineState(tasks) {
+    const current = this.engineStateAcc();
+    if (current.size === 0)
+      return;
+    const live = new Set(tasks.map((t) => t.id));
+    let next = null;
+    for (const key of current.keys()) {
+      if (live.has(key))
+        continue;
+      if (!next)
+        next = new Map(current);
+      next.delete(key);
+    }
+    if (next)
+      this.setEngineStateSig(next);
+  }
+  pruneTaskJobs(tasks) {
+    const current = this.taskJobsAcc();
+    if (current.size === 0)
+      return;
+    const live = new Set(tasks.map((t) => t.id));
+    let next = null;
+    for (const key of current.keys()) {
+      if (live.has(key))
+        continue;
+      if (!next)
+        next = new Map(current);
+      next.delete(key);
+    }
+    if (next)
+      this.setTaskJobsSig(next);
   }
 }
 function deserializeTask(s) {
@@ -15154,6 +15731,7 @@ var init_remote_orchestrator = __esm(() => {
   init_daemon_process();
   init_protocol();
   init_dev();
+  init_worktree_changes();
   init_version();
 });
 
@@ -15523,10 +16101,6 @@ function resolveTheme(theme, mode = "dark") {
     ...out
   };
 }
-function withAlpha(color, alpha) {
-  const [r, g, b] = color.toInts();
-  return RGBA.fromInts(r ?? 0, g ?? 0, b ?? 0, alpha);
-}
 var BUNDLED_THEMES, FOCUS_ACCENT_SLOTS, store, setStore, useTheme, ThemeProvider;
 var init_theme2 = __esm(() => {
   init_solid();
@@ -15598,8 +16172,7 @@ var init_theme2 = __esm(() => {
         return {
           ...v,
           background: transparent,
-          backgroundPanel: transparent,
-          backgroundDialog: withAlpha(v.backgroundDialog, 128)
+          backgroundPanel: transparent
         };
       });
       createEffect(() => {
@@ -15687,7 +16260,7 @@ function dispatchKeyEvent(bindingStack, evt) {
       continue;
     const hit = cfg.bindings.find((b) => candidates.includes(b.key));
     if (hit) {
-      hit.cmd(evt);
+      hit.cmd(evt, hit.slot);
       evt.preventDefault();
       return true;
     }
@@ -16098,7 +16671,7 @@ function joinDrill(typedValue, baseExpanded, name) {
 var init_path_helpers = () => {};
 
 // src/tui/component/new-task-dialog/clone.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import * as fs5 from "fs";
 import * as path11 from "path";
 function deriveFolderName(url) {
@@ -16177,7 +16750,7 @@ function cloneRepo(url, target, onProgress) {
   return new Promise((resolve8) => {
     let stderrBuf = "";
     try {
-      const child = spawn3("git", ["clone", "--progress", url, target], {
+      const child = spawn4("git", ["clone", "--progress", url, target], {
         stdio: ["ignore", "ignore", "pipe"]
       });
       child.stderr?.setEncoding("utf-8");
@@ -17673,6 +18246,19 @@ var init_focus = __esm(() => {
 });
 
 // src/tui/context/keybindings.ts
+function resetKeymapToDefaults() {
+  for (const row of KobeKeymap) {
+    const def = KEYMAP_DEFAULTS.get(row.id);
+    if (!def)
+      continue;
+    const mutable = row;
+    mutable.keys = [...def.keys];
+    mutable.hint = def.hint ? { ...def.hint } : undefined;
+  }
+}
+function bumpKeymapVersion() {
+  setKeymapVersion((v) => v + 1);
+}
 function findBinding(id) {
   return KobeKeymap.find((b) => b.id === id);
 }
@@ -17690,20 +18276,20 @@ function bindByIds(handlers) {
       console.warn(`[kobe/keybindings] bindByIds: id="${id}" has no chords (or doesn't exist in KobeKeymap)`);
       continue;
     }
-    for (const c of chords)
-      out.push({ key: c, cmd });
+    chords.forEach((c, slot) => out.push({ key: c, cmd, slot }));
   }
   return out;
 }
-var KobeKeymap;
+var KobeKeymap, KEYMAP_DEFAULTS, keymapVersion, setKeymapVersion;
 var init_keybindings2 = __esm(() => {
+  init_dev();
   KobeKeymap = [
     {
       id: "help.open",
       scope: "global",
       keys: ["f1"],
       category: "Global",
-      description: "Show this help dialog",
+      description: "Show keybindings help",
       hint: { keys: "F1", label: "help", pin: "right" }
     },
     {
@@ -18154,6 +18740,8 @@ var init_keybindings2 = __esm(() => {
       hint: { keys: "ctrl+[/]", label: "tab" }
     }
   ];
+  KEYMAP_DEFAULTS = new Map(KobeKeymap.map((b) => [b.id, { keys: [...b.keys], hint: b.hint ? { ...b.hint } : undefined }]));
+  [keymapVersion, setKeymapVersion] = createSignal(0);
 });
 
 // src/tui/context/keybindings-user.ts
@@ -18201,6 +18789,15 @@ function applyUserKeybindings() {
 function userKeybindingsReport() {
   return cached3 ?? applyUserKeybindings();
 }
+function reloadUserKeybindings() {
+  cached3 = null;
+  resetKeybindingsFileCache();
+  resetTmuxKeysCache();
+  resetKeymapToDefaults();
+  const report = applyUserKeybindings();
+  bumpKeymapVersion();
+  return report;
+}
 var cached3 = null;
 var init_keybindings_user = __esm(() => {
   init_keybindings_file();
@@ -18299,9 +18896,9 @@ var pulse_default = "../pulse-n3cq1btw.wav";
 var init_pulse = () => {};
 
 // src/tui/lib/sound.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync5 } from "fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync6 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { basename as basename5, isAbsolute, join as join14, resolve as resolve8 } from "path";
+import { basename as basename6, isAbsolute, join as join15, resolve as resolve8 } from "path";
 function args(player, file, volume) {
   if (player === "ffplay")
     return [player, "-autoexit", "-nodisp", "-af", `volume=${volume}`, file];
@@ -18324,13 +18921,13 @@ function pickPlayer() {
     return cachedPlayer;
   const path12 = process.env.PATH ?? "";
   const segments = path12.split(":").filter(Boolean);
-  cachedPlayer = PLAYERS.find((p) => segments.some((dir) => existsSync14(join14(dir, p)))) ?? null;
+  cachedPlayer = PLAYERS.find((p) => segments.some((dir) => existsSync14(join15(dir, p)))) ?? null;
   return cachedPlayer;
 }
 async function ensureAsset() {
   cachedPath ??= (async () => {
-    mkdirSync5(DIR, { recursive: true });
-    const dest = join14(DIR, basename5(pulseAsset));
+    mkdirSync6(DIR, { recursive: true });
+    const dest = join15(DIR, basename6(pulseAsset));
     const out = Bun.file(dest);
     if (await out.exists())
       return dest;
@@ -18360,7 +18957,7 @@ var pulseAsset, DIR, PLAYERS, cachedPlayer, cachedPath;
 var init_sound = __esm(() => {
   init_pulse();
   pulseAsset = isAbsolute(pulse_default) ? pulse_default : resolve8(import.meta.dir, pulse_default);
-  DIR = join14(tmpdir2(), "kobe-sfx");
+  DIR = join15(tmpdir2(), "kobe-sfx");
   PLAYERS = [
     "ffplay",
     "mpv",
@@ -18584,20 +19181,28 @@ function UiPrefsSync(props) {
     focusAccent: props.boot.focusAccent
   });
   const [prefsOrch, setPrefsOrch] = createSignal(null);
+  let disposed = false;
   onMount(() => {
     (async () => {
+      let remote = null;
       try {
         const client = await connectIfRunning();
         if (!client) {
           logClient("ui-prefs", "no daemon \u2014 keeping boot-time visual prefs");
           return;
         }
-        const remote = new RemoteOrchestrator(client);
+        remote = new RemoteOrchestrator(client);
         await remote.init();
-        setPrefsOrch(remote);
       } catch (err) {
         logClientError("ui-prefs", err);
+        remote?.dispose();
+        return;
       }
+      if (disposed) {
+        remote.dispose();
+        return;
+      }
+      setPrefsOrch(remote);
     })();
   });
   createEffect(() => {
@@ -18605,7 +19210,22 @@ function UiPrefsSync(props) {
     if (payload)
       applyUiPrefs(target, payload);
   });
-  onCleanup(() => prefsOrch()?.dispose());
+  let lastKeybindingsRev = null;
+  createEffect(() => {
+    const rev = prefsOrch()?.keybindingsRevSignal()();
+    if (rev == null)
+      return;
+    if (lastKeybindingsRev === null || rev === lastKeybindingsRev) {
+      lastKeybindingsRev = rev;
+      return;
+    }
+    lastKeybindingsRev = rev;
+    reloadUserKeybindings();
+  });
+  onCleanup(() => {
+    disposed = true;
+    prefsOrch()?.dispose();
+  });
   return null;
 }
 async function bootPaneHost(opts) {
@@ -18830,6 +19450,31 @@ function repoBasename(repo) {
 function flattenIds(rows) {
   return rows.map((r) => r.task.id);
 }
+function sameSidebarRowTask(a, b) {
+  return a === b || a.id === b.id && a.kind === b.kind && a.title === b.title && a.repo === b.repo && a.branch === b.branch && a.worktreePath === b.worktreePath && a.status === b.status && a.archived === b.archived && a.pinned === b.pinned && a.vendor === b.vendor;
+}
+function reconcileSidebarRows(prev, next) {
+  if (prev.length === 0)
+    return next;
+  const prevById = new Map;
+  for (const row of prev)
+    prevById.set(row.task.id, row);
+  let allReused = prev.length === next.length;
+  const out = new Array(next.length);
+  for (let i = 0;i < next.length; i++) {
+    const fresh = next[i];
+    const old = prevById.get(fresh.task.id);
+    if (old && old.flatIndex === fresh.flatIndex && sameSidebarRowTask(old.task, fresh.task)) {
+      out[i] = old;
+      if (allReused && prev[i] !== old)
+        allReused = false;
+    } else {
+      out[i] = fresh;
+      allReused = false;
+    }
+  }
+  return allReused ? prev : out;
+}
 var init_groups = () => {};
 
 // src/tui/quick-task/host.tsx
@@ -19107,12 +19752,13 @@ function groupBindings(keymap) {
     rows: groups.get(cat)
   }));
 }
-function HelpDialog() {
+function HelpDialog(props = {}) {
   const dialog = useDialog();
   const {
     theme
   } = useTheme();
   const grouped = () => groupBindings(KobeKeymap);
+  const close = () => props.onClose ? props.onClose() : dialog.clear();
   const [prefixGlyph, setPrefixGlyph] = createSignal("\u2303B");
   onMount(() => {
     runTmuxCapturing(["show-options", "-g", "prefix"]).then(({
@@ -19129,7 +19775,7 @@ function HelpDialog() {
   useBindings(() => ({
     bindings: [{
       key: "?",
-      cmd: () => dialog.clear()
+      cmd: close
     }]
   }));
   return (() => {
@@ -19147,7 +19793,7 @@ function HelpDialog() {
     setProp(_el$2, "flexShrink", 0);
     insertNode(_el$3, createTextNode(`kobe \u2014 keybindings`));
     insertNode(_el$5, createTextNode(`esc`));
-    setProp(_el$5, "onMouseUp", () => dialog.clear());
+    setProp(_el$5, "onMouseUp", close);
     insertNode(_el$7, _el$8);
     setProp(_el$7, "flexShrink", 1);
     setProp(_el$7, "flexGrow", 1);
@@ -19517,7 +20163,7 @@ var init_dialog_confirm = __esm(() => {
 
 // src/tui/component/settings-dialog/actions.ts
 import { unlinkSync as unlinkSync2 } from "fs";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 function hasRestartableDaemon(orchestrator) {
   return orchestrator instanceof RemoteOrchestrator;
 }
@@ -19534,7 +20180,7 @@ async function confirmResetState(dialog, kv, renderer) {
     return;
   kv.clear();
   try {
-    unlinkSync2(join15(homeDir(), ".kobe", "tasks.json"));
+    unlinkSync2(join16(homeDir(), ".kobe", "tasks.json"));
   } catch (err) {
     if (err.code !== "ENOENT") {
       console.error("kobe: failed to delete tasks.json during reset:", err);
@@ -21771,9 +22417,9 @@ var init_task_actions = __esm(() => {
 });
 
 // src/tui/lib/worktree-opener.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 import { existsSync as existsSync15 } from "fs";
-import { basename as basename6, delimiter, isAbsolute as isAbsolute2, join as join16 } from "path";
+import { basename as basename7, delimiter, isAbsolute as isAbsolute2, join as join17 } from "path";
 function executableOnPath(command, env, exists) {
   if (isAbsolute2(command))
     return exists(command);
@@ -21781,13 +22427,13 @@ function executableOnPath(command, env, exists) {
   for (const dir of pathEnv.split(delimiter)) {
     if (!dir)
       continue;
-    if (exists(join16(dir, command)))
+    if (exists(join17(dir, command)))
       return true;
   }
   return false;
 }
 function labelForOverride(command) {
-  const name = basename6(command);
+  const name = basename7(command);
   if (name === "code")
     return "VS Code";
   if (name === "cursor")
@@ -21830,7 +22476,7 @@ function buildOpenWorktreeCommand(worktreePath, opener) {
 function openWorktree(worktreePath, opener, deps = {}) {
   if (!worktreePath)
     return false;
-  const spawnFn = deps.spawn ?? spawn4;
+  const spawnFn = deps.spawn ?? spawn5;
   const [command, args2] = buildOpenWorktreeCommand(worktreePath, opener);
   try {
     const child = spawnFn(command, args2, { detached: true, stdio: "ignore" });
@@ -21879,15 +22525,6 @@ var init_worktree_opener = __esm(() => {
 });
 
 // src/tui/lib/background-poll.ts
-import { spawn as spawn5 } from "child_process";
-function computeNextAllowedAt(startedAt, finishedAt, timedOut, cfg) {
-  if (timedOut)
-    return startedAt + cfg.slowRetryMs;
-  return finishedAt + Math.max(cfg.minIntervalMs, (finishedAt - startedAt) * 5);
-}
-function shouldPoll(state, now) {
-  return !state.inFlight && now >= state.nextAllowedAt;
-}
 function createBackgroundPoller(cfg) {
   const entries = new Map;
   function entryFor(key) {
@@ -21909,58 +22546,17 @@ function createBackgroundPoller(cfg) {
       if (!key)
         return;
       const entry = entryFor(key);
-      const startedAt = Date.now();
-      if (!shouldPoll(entry, startedAt))
-        return;
-      entry.inFlight = true;
-      const controller = new AbortController;
-      const timer = setTimeout(() => controller.abort(), cfg.timeoutMs);
-      (async () => {
-        let value;
-        let ok = false;
-        try {
-          value = await cfg.run(key, controller.signal);
-          ok = true;
-        } catch {}
-        clearTimeout(timer);
-        const timedOut = controller.signal.aborted;
-        entry.nextAllowedAt = computeNextAllowedAt(startedAt, Date.now(), timedOut, cfg);
-        entry.inFlight = false;
-        if (ok && !timedOut)
-          entry.write(value);
-      })();
+      maybeStartScheduledRun(entry, cfg, (signal) => cfg.run(key, signal), (value) => entry.write(value));
     },
     reset() {
       entries.clear();
     }
   };
 }
-function spawnCapture(cmd, args2, opts) {
-  return new Promise((resolve9) => {
-    let out = "";
-    let settled = false;
-    const finish = (status) => {
-      if (settled)
-        return;
-      settled = true;
-      resolve9({ status, stdout: out });
-    };
-    const child = spawn5(cmd, args2.slice(), {
-      cwd: opts.cwd,
-      stdio: ["ignore", "pipe", "ignore"],
-      env: opts.env,
-      signal: opts.signal,
-      killSignal: "SIGKILL"
-    });
-    child.stdout?.on("data", (chunk) => {
-      out += String(chunk);
-    });
-    child.on("error", () => finish(null));
-    child.on("close", (code) => finish(code));
-  });
-}
 var init_background_poll = __esm(() => {
   init_dev();
+  init_poll_scheduling();
+  init_poll_scheduling();
 });
 
 // src/tui/panes/sidebar/git-head.ts
@@ -22098,20 +22694,18 @@ function useSidebarBindings(opts) {
   useBindings(() => ({
     enabled: opts.focused() && !searchModeAccessor(),
     bindings: bindByIds({
-      "sidebar.nav": (evt) => {
+      "sidebar.nav": (_evt, slot) => {
+        const down = (slot ?? 0) % 2 === 0;
         if (moveModeAccessor()) {
           const id = cursorTaskId();
           if (id === undefined)
             return;
-          if (evt.name === "j" || evt.name === "down")
-            opts.onMoveRequest?.(id, 1);
-          else if (evt.name === "k" || evt.name === "up")
-            opts.onMoveRequest?.(id, -1);
+          opts.onMoveRequest?.(id, down ? 1 : -1);
           return;
         }
-        if (evt.name === "j" || evt.name === "down")
+        if (down)
           ctrl.moveDown();
-        else if (evt.name === "k" || evt.name === "up")
+        else
           ctrl.moveUp();
       },
       "sidebar.select": () => {
@@ -22185,21 +22779,18 @@ function useSidebarBindings(opts) {
   useBindings(() => ({
     enabled: opts.focused(),
     bindings: bindByIds({
-      "sidebar.view": (evt) => {
-        if (evt.name === "]")
-          opts.onViewSwitch?.(1);
-        else
-          opts.onViewSwitch?.(-1);
+      "sidebar.view": (_evt, slot) => {
+        opts.onViewSwitch?.((slot ?? 0) % 2 === 0 ? -1 : 1);
       }
     })
   }));
   useBindings(() => ({
     enabled: opts.focused() && searchModeAccessor(),
     bindings: bindByIds({
-      "sidebar.search.nav": (evt) => {
-        if (evt.name === "down")
+      "sidebar.search.nav": (_evt, slot) => {
+        if ((slot ?? 0) % 2 === 0)
           ctrl.moveDown();
-        else if (evt.name === "up")
+        else
           ctrl.moveUp();
       },
       "sidebar.search.submit": () => {
@@ -22255,11 +22846,12 @@ function buildSidebarRowView(opts) {
   const activityBadge = activityBadgeFor(activityState);
   const activityLabel = activityLabelFor(activityState);
   const untrackedCustomEngine = isCustomEngineTask(task) && !hasActivity;
-  const loading = !untrackedCustomEngine && (activityState === "running" || opts.live || !hasActivity && !isMain && task.status === "in_progress");
+  const materializing = opts.job !== undefined;
+  const loading = materializing || !untrackedCustomEngine && (activityState === "running" || opts.live || !hasActivity && !isMain && task.status === "in_progress");
   const spinner = IN_PROGRESS_SPINNER[opts.spinnerFrame] ?? IN_PROGRESS_SPINNER[0];
-  const tone = untrackedCustomEngine ? "textMuted" : activityLabel?.tone ?? (loading ? "primary" : activityBadge?.tone ?? badge.tone);
+  const tone = materializing ? "primary" : untrackedCustomEngine ? "textMuted" : activityLabel?.tone ?? (loading ? "primary" : activityBadge?.tone ?? badge.tone);
   const fallbackSubtitle = untrackedCustomEngine ? NO_TRACKING_SUBTITLE : STATUS_LABEL[task.status];
-  const subtitleText = activityLabel ? opts.truncateBranch(activityLabel.text, opts.subtitleBudget) : branch.length > 0 ? opts.truncateBranch(branch, opts.subtitleBudget) : opts.truncateBranch(fallbackSubtitle, opts.subtitleBudget);
+  const subtitleText = materializing ? opts.truncateBranch(MATERIALIZING_SUBTITLE, opts.subtitleBudget) : activityLabel ? opts.truncateBranch(activityLabel.text, opts.subtitleBudget) : branch.length > 0 ? opts.truncateBranch(branch, opts.subtitleBudget) : opts.truncateBranch(fallbackSubtitle, opts.subtitleBudget);
   const restGlyph = untrackedCustomEngine ? NO_TRACKING_GLYPH : activityBadge?.glyph ?? badge.glyph;
   const restProjectGlyph = untrackedCustomEngine ? NO_TRACKING_GLYPH : activityBadge?.glyph ?? "\u2605";
   return {
@@ -22286,7 +22878,7 @@ function activityBadgeFor(state) {
       return null;
   }
 }
-var STATUS_BADGE, STATUS_LABEL, IN_PROGRESS_SPINNER, SPINNER_FRAME_MS = 100, NO_TRACKING_GLYPH = "\xB7", NO_TRACKING_SUBTITLE = "no activity tracking";
+var STATUS_BADGE, STATUS_LABEL, IN_PROGRESS_SPINNER, SPINNER_FRAME_MS = 100, NO_TRACKING_GLYPH = "\xB7", NO_TRACKING_SUBTITLE = "no activity tracking", MATERIALIZING_SUBTITLE = "materializing";
 var init_row_view = __esm(() => {
   init_vendor();
   init_groups();
@@ -22324,7 +22916,7 @@ var init_worktree_changes_poller = __esm(() => {
   ZERO2 = { added: 0, deleted: 0 };
   poller2 = createBackgroundPoller({
     initial: ZERO2,
-    equals: (a, b) => a.added === b.added && a.deleted === b.deleted,
+    equals: sameWorktreeChanges,
     timeoutMs: POLL_TIMEOUT_MS,
     slowRetryMs: SLOW_REPO_RETRY_MS,
     minIntervalMs: MIN_POLL_INTERVAL_MS,
@@ -22406,12 +22998,13 @@ function Sidebar(props) {
     onCleanup(() => r.keyInput.off("keypress", listener2));
   });
   const [branchTick, setBranchTick] = createSignal(0);
-  setInterval(() => setBranchTick((n) => n + 1), MAIN_BRANCH_POLL_MS);
+  const branchInterval = setInterval(() => setBranchTick((n) => n + 1), MAIN_BRANCH_POLL_MS);
+  onCleanup(() => clearInterval(branchInterval));
   const [spinnerFrame, setSpinnerFrame] = createSignal(0);
   const spinnerInterval = setInterval(() => setSpinnerFrame((n) => (n + 1) % IN_PROGRESS_SPINNER.length), SPINNER_FRAME_MS);
   onCleanup(() => clearInterval(spinnerInterval));
   const sortMode = () => props.sortMode?.() ?? "default";
-  const rows = createMemo(() => buildRows(props.tasks(), view(), searchMode() ? searchQuery() : "", sortMode()));
+  const rows = createMemo((prev) => reconcileSidebarRows(prev, buildRows(props.tasks(), view(), searchMode() ? searchQuery() : "", sortMode())), []);
   const flatIds = createMemo(() => flattenIds(rows()));
   const firstTaskFlatIndex = createMemo(() => {
     const r = rows();
@@ -22760,10 +23353,15 @@ function Sidebar(props) {
           }
         };
         const changes = createMemo(() => {
+          const pushed = pickPushedChanges(props.worktreeChanges?.(), task.worktreePath);
+          if (pushed)
+            return pushed;
           branchTick();
           if (!task.archived)
             pollWorktreeChanges(task.worktreePath);
           return worktreeChanges(task.worktreePath);
+        }, undefined, {
+          equals: sameWorktreeChanges
         });
         const projectBranch = createMemo(() => {
           branchTick();
@@ -22774,6 +23372,7 @@ function Sidebar(props) {
         const rowView = createMemo(() => buildSidebarRowView({
           task,
           activity: props.engineState?.().get(task.id),
+          job: props.taskJobs?.().get(task.id),
           live: isLive(),
           spinnerFrame: spinnerFrame(),
           subtitleBudget: subtitleBudget(),
@@ -23206,6 +23805,7 @@ var init_Sidebar = __esm(() => {
   init_groups();
   init_keys();
   init_row_view();
+  init_worktree_changes();
   init_worktree_changes_poller();
   VIEW_TABS = [{
     view: "active",
@@ -23251,7 +23851,7 @@ function TasksShell(props) {
     });
   }
   const [moveMode, setMoveMode] = createSignal(false);
-  const [sortMode, setSortMode] = createSignal("default");
+  const [sortMode, setSortMode] = createSignal(kv.get("activeSortMode") === "recent" ? "recent" : "default");
   const [updateInfo, setUpdateInfo] = createSignal(null);
   const dimensions = useTerminalDimensions();
   let activeConfirmed = !props.initialTaskId;
@@ -23266,6 +23866,11 @@ function TasksShell(props) {
     }
     setSelectedId(active);
   });
+  createEffect(() => {
+    const payload = props.orch?.uiPrefsSignal()();
+    if (payload && payload.sortMode !== sortMode())
+      setSortMode(payload.sortMode);
+  });
   createEffect(() => {
     const info = props.orch?.updateSignal()();
     if (info)
@@ -23333,6 +23938,14 @@ function TasksShell(props) {
       console.error("[kobe tasks] failed to refresh workspace panes:", err);
     }
   }
+  async function openHelp() {
+    const session = await currentSessionName();
+    if (session) {
+      await openHelpTab(session);
+      return;
+    }
+    HelpDialog.show(dialog);
+  }
   async function openUpdate() {
     const info = updateInfo();
     if (!info?.hasUpdate) {
@@ -23404,13 +24017,21 @@ function TasksShell(props) {
     setSelectedId(id);
     await props.reload();
   }
-  const keysCollapsed = () => kv.get("tasksPane.keysCollapsed", false) === true;
-  const setKeysCollapsed = (next) => kv.set("tasksPane.keysCollapsed", next);
+  const [keysCollapsed, setKeysCollapsedSig] = createSignal(kv.get("tasksPane.keysCollapsed", false) === true);
+  const setKeysCollapsed = (next) => {
+    setKeysCollapsedSig(next);
+    kv.set("tasksPane.keysCollapsed", next);
+  };
+  createEffect(() => {
+    const payload = props.orch?.uiPrefsSignal()();
+    if (payload && payload.keysCollapsed !== keysCollapsed())
+      setKeysCollapsedSig(payload.keysCollapsed);
+  });
   const [searchActive, setSearchActive] = createSignal(false);
   useBindings(() => ({
     enabled: dialog.stack.length === 0 && !searchActive(),
     bindings: bindByIds({
-      "help.open": () => HelpDialog.show(dialog),
+      "help.open": () => void openHelp(),
       "task.new": () => void createTask(),
       "settings.open.sidebar": () => void openSettings(),
       "tasks.update": () => void openUpdate(),
@@ -23435,6 +24056,9 @@ function TasksShell(props) {
   async function switchTo(id) {
     const name = tmuxSessionName(id);
     const task = props.tasks().find((t) => t.id === id);
+    const from = await currentSessionName();
+    if (from && from !== name)
+      await captureGlobalLayout(from);
     const exists = await sessionExists(name);
     if (exists) {
       const cwd2 = await getSessionOption(name, "@kobe_worktree") || task?.worktreePath || "";
@@ -23532,6 +24156,17 @@ function TasksShell(props) {
       get engineState() {
         return memo2(() => !!props.orch)() ? props.orch.engineStateSignal() : undefined;
       },
+      get taskJobs() {
+        return memo2(() => !!props.orch)() ? props.orch.taskJobsSignal() : undefined;
+      },
+      get worktreeChanges() {
+        return props.orch ? () => {
+          const orch = props.orch;
+          if (!orch || orch.connectionStateSignal()() !== "online")
+            return null;
+          return orch.worktreeChangesSignal()();
+        } : undefined;
+      },
       onRenameRequest: (id) => void renameTask(id),
       onDeleteRequest: (id) => void deleteTask(id),
       onArchiveRequest: (id) => void archiveTask(id),
@@ -23546,7 +24181,11 @@ function TasksShell(props) {
       onMoveRequest: (id, delta) => void moveTask(id, delta),
       onMoveModeExit: () => setMoveMode(false),
       sortMode,
-      onSortModeToggle: () => setSortMode((cur) => cur === "default" ? "recent" : "default"),
+      onSortModeToggle: () => {
+        const next = sortMode() === "default" ? "recent" : "default";
+        setSortMode(next);
+        kv.set("activeSortMode", next);
+      },
       focused: () => dialog.stack.length === 0,
       onSearchActiveChange: setSearchActive
     }));
@@ -23578,6 +24217,7 @@ function ShortcutHints(props) {
     });
   });
   const tmuxHints = () => {
+    keymapVersion();
     const res = resolveUserTmuxKeys();
     const b = res.binds;
     const out = [];
@@ -23985,9 +24625,73 @@ var init_host4 = __esm(() => {
   init_dialog();
 });
 
-// src/tui/update/host.tsx
+// src/tui/help/host.tsx
 var exports_host5 = {};
 __export(exports_host5, {
+  startHelpHost: () => startHelpHost
+});
+function HelpPage() {
+  const dialog = useDialog();
+  const {
+    theme
+  } = useTheme();
+  function exit() {
+    process.exit(0);
+  }
+  useBindings(() => ({
+    enabled: dialog.stack.length === 0,
+    bindings: [{
+      key: "escape",
+      cmd: exit
+    }, {
+      key: "q",
+      cmd: exit
+    }, {
+      key: "f1",
+      cmd: exit
+    }, {
+      key: "ctrl+c",
+      cmd: exit
+    }]
+  }));
+  return (() => {
+    var _el$ = createElement("box");
+    setProp(_el$, "flexGrow", 1);
+    setProp(_el$, "paddingTop", 1);
+    insert(_el$, createComponent2(HelpDialog, {
+      onClose: exit
+    }));
+    effect((_$p) => setProp(_el$, "backgroundColor", theme.background, _$p));
+    return _el$;
+  })();
+}
+async function startHelpHost() {
+  await bootPaneHost({
+    providers: {
+      kv: false,
+      focus: false
+    },
+    setup: () => ({
+      root: () => createComponent2(HelpPage, {})
+    })
+  });
+}
+var init_host5 = __esm(() => {
+  init_solid();
+  init_solid();
+  init_solid();
+  init_solid();
+  init_solid();
+  init_help_dialog();
+  init_theme2();
+  init_host_boot();
+  init_keymap();
+  init_dialog();
+});
+
+// src/tui/update/host.tsx
+var exports_host6 = {};
+__export(exports_host6, {
   startUpdateHost: () => startUpdateHost
 });
 import { spawn as spawn6, spawnSync as spawnSync11 } from "child_process";
@@ -24342,7 +25046,7 @@ async function startUpdateHost() {
     })
   });
 }
-var init_host5 = __esm(() => {
+var init_host6 = __esm(() => {
   init_solid();
   init_solid();
   init_solid();
@@ -24666,26 +25370,24 @@ function useFileTreeBindings(opts) {
   useBindings(() => ({
     enabled: opts.focused(),
     bindings: bindByIds({
-      "files.nav": (evt) => {
-        if (evt.name === "j" || evt.name === "down")
+      "files.nav": (_evt, slot) => {
+        if ((slot ?? 0) % 2 === 0)
           opts.moveDown();
-        else if (evt.name === "k" || evt.name === "up")
+        else
           opts.moveUp();
       },
-      "files.hierarchy": (evt) => {
-        if (evt.name === "l" || evt.name === "right")
-          opts.expandOrDescend();
-        else if (evt.name === "h" || evt.name === "left")
+      "files.hierarchy": (_evt, slot) => {
+        if ((slot ?? 0) % 2 === 0)
           opts.collapseOrParent();
+        else
+          opts.expandOrDescend();
       },
-      "files.tab": (evt) => {
+      "files.tab": (_evt, slot) => {
         const cur = opts.currentTab();
         const idx = TAB_ORDER.indexOf(cur);
         if (idx < 0)
           return;
-        const delta = evt.name === "[" ? -1 : evt.name === "]" ? 1 : 0;
-        if (delta === 0)
-          return;
+        const delta = (slot ?? 0) % 2 === 0 ? -1 : 1;
         const next = TAB_ORDER[(idx + delta + TAB_ORDER.length) % TAB_ORDER.length];
         if (next)
           opts.setTab(next);
@@ -24753,8 +25455,109 @@ function spawnDetached(cmd, args2, onError) {
 }
 var init_open_external = () => {};
 
+// src/tui/panes/filetree/rows.ts
+function flattenTree(node, expanded, depth, out) {
+  for (const child of node.children) {
+    if (child.isDir) {
+      const isOpen = expanded.has(child.path);
+      out.push({
+        kind: "dir",
+        path: child.path,
+        name: child.name,
+        depth,
+        expanded: isOpen,
+        hasChildren: child.children.length > 0
+      });
+      if (isOpen)
+        flattenTree(child, expanded, depth + 1, out);
+    } else {
+      out.push({ kind: "file", path: child.path, name: child.name, depth });
+    }
+  }
+}
+function statusRows(entries) {
+  return entries.map((e) => ({
+    kind: "status",
+    path: e.path,
+    status: e.status,
+    added: e.added,
+    deleted: e.deleted
+  }));
+}
+function rowKey(row) {
+  return `${row.kind}\x00${row.path}`;
+}
+function rowEquals(a, b) {
+  if (a.kind !== b.kind || a.path !== b.path)
+    return false;
+  switch (a.kind) {
+    case "file": {
+      const o = b;
+      return a.name === o.name && a.depth === o.depth;
+    }
+    case "dir": {
+      const o = b;
+      return a.name === o.name && a.depth === o.depth && a.expanded === o.expanded && a.hasChildren === o.hasChildren;
+    }
+    case "status": {
+      const o = b;
+      return a.status === o.status && a.added === o.added && a.deleted === o.deleted;
+    }
+  }
+}
+function reconcileRows(prev, next) {
+  if (prev.length === 0)
+    return next;
+  const prevByKey = new Map;
+  for (const row of prev)
+    prevByKey.set(rowKey(row), row);
+  let allReused = prev.length === next.length;
+  const out = new Array(next.length);
+  for (let i = 0;i < next.length; i++) {
+    const fresh = next[i];
+    const old = prevByKey.get(rowKey(fresh));
+    if (old && rowEquals(old, fresh)) {
+      out[i] = old;
+      if (allReused && prev[i] !== old)
+        allReused = false;
+    } else {
+      out[i] = fresh;
+      allReused = false;
+    }
+  }
+  return allReused ? prev : out;
+}
+function sameFileList(a, b) {
+  if (a === b)
+    return true;
+  if (a == null || b == null)
+    return false;
+  if (a.length !== b.length)
+    return false;
+  for (let i = 0;i < a.length; i++) {
+    if (a[i] !== b[i])
+      return false;
+  }
+  return true;
+}
+function sameStatusEntries(a, b) {
+  if (a === b)
+    return true;
+  if (a == null || b == null)
+    return false;
+  if (a.length !== b.length)
+    return false;
+  for (let i = 0;i < a.length; i++) {
+    const x = a[i];
+    const y = b[i];
+    if (x.path !== y.path || x.status !== y.status || x.added !== y.added || x.deleted !== y.deleted)
+      return false;
+  }
+  return true;
+}
+
 // src/tui/panes/filetree/FileTree.tsx
-import { watch as watch2 } from "fs";
+import { watch as watch3 } from "fs";
 import { TextAttributes as TextAttributes14 } from "@opentui/core";
 function statusToken(s) {
   switch (s) {
@@ -24801,8 +25604,12 @@ function FileTree(props) {
   const [tab, setTab] = createSignal("all");
   const [cursorIndex, setCursorIndex] = createSignal(0);
   const [refreshTick, setRefreshTick] = createSignal(0);
-  const [allFiles, setAllFiles] = createSignal(null);
-  const [changes, setChanges] = createSignal(null);
+  const [allFiles, setAllFiles] = createSignal(null, {
+    equals: sameFileList
+  });
+  const [changes, setChanges] = createSignal(null, {
+    equals: sameStatusEntries
+  });
   const [error, setError] = createSignal(null);
   const [expandedDirs, setExpandedDirs] = createSignal(new Set);
   let fetchSeq = 0;
@@ -24849,7 +25656,7 @@ function FileTree(props) {
     let debounceTimer = null;
     let watcher = null;
     try {
-      watcher = watch2(path12, {
+      watcher = watch3(path12, {
         recursive: true
       }, (_event, filename) => {
         if (filename == null)
@@ -24898,53 +25705,19 @@ function FileTree(props) {
       return null;
     return buildTree(files);
   });
-  function flattenTree(node, expanded, depth, out) {
-    for (const child of node.children) {
-      if (child.isDir) {
-        const isOpen = expanded.has(child.path);
-        out.push({
-          kind: "dir",
-          path: child.path,
-          name: child.name,
-          depth,
-          expanded: isOpen,
-          hasChildren: child.children.length > 0
-        });
-        if (isOpen)
-          flattenTree(child, expanded, depth + 1, out);
-      } else {
-        out.push({
-          kind: "file",
-          path: child.path,
-          name: child.name,
-          depth
-        });
-      }
-    }
-  }
-  const rows = createMemo(() => {
+  const rows = createMemo((prev) => {
+    const next = [];
     if (tab() === "all") {
       const root = tree();
-      if (root == null)
-        return [];
-      const out = [];
-      flattenTree(root, expandedDirs(), 0, out);
-      return out;
-    }
-    if (tab() === "changes") {
+      if (root != null)
+        flattenTree(root, expandedDirs(), 0, next);
+    } else if (tab() === "changes") {
       const list2 = changes();
-      if (list2 == null)
-        return [];
-      return list2.map((e) => ({
-        kind: "status",
-        path: e.path,
-        status: e.status,
-        added: e.added,
-        deleted: e.deleted
-      }));
+      if (list2 != null)
+        next.push(...statusRows(list2));
     }
-    return [];
-  });
+    return reconcileRows(prev ?? [], next);
+  }, []);
   const statWidths = createMemo(() => {
     let added = 0;
     let deleted = 0;
@@ -25631,8 +26404,8 @@ var init_pr_prompt = __esm(() => {
 });
 
 // src/tui/ops/host.tsx
-var exports_host6 = {};
-__export(exports_host6, {
+var exports_host7 = {};
+__export(exports_host7, {
   startOpsPreview: () => startOpsPreview,
   startOpsHost: () => startOpsHost
 });
@@ -25738,7 +26511,7 @@ function OpsShell(props) {
         relPath: rel,
         cliInvocation: kobeCliInvocation()
       }),
-      name: basename7(rel)
+      name: basename8(rel)
     });
   }
   function openFile(rel) {
@@ -25781,7 +26554,7 @@ function OpsShell(props) {
     return _el$;
   })();
 }
-function basename7(p) {
+function basename8(p) {
   const i = p.lastIndexOf("/");
   return i >= 0 ? p.slice(i + 1) : p;
 }
@@ -26026,7 +26799,7 @@ async function startOpsPreview(args2) {
   });
 }
 var ACTIVITY_POLL_MS = 2500, TURN_STATUS_POLL_MS = 1500, STABLE_POLLS_FOR_DONE = 2, CHAT_TAB_STATE_OPTION2 = "@kobe_tab_state";
-var init_host6 = __esm(() => {
+var init_host7 = __esm(() => {
   init_solid();
   init_solid();
   init_solid();
@@ -26124,6 +26897,7 @@ async function startDirectTmux() {
     if (!task) {
       const home = await ensureFallbackSession();
       await applyTmuxPaneBorderTheme();
+      await prepareWindowForAttach(home);
       if (await attachTmux(attachArgv(home)) === null) {
         console.error("kobe: failed to attach to the kobe-home session");
         process.exitCode = 1;
@@ -26151,6 +26925,7 @@ async function startDirectTmux() {
       return;
     }
     await applyTmuxPaneBorderTheme();
+    await prepareWindowForAttach(name);
     const exitCode = await attachTmux(attachArgv(name));
     if (exitCode === null) {
       console.error(`kobe: failed to attach to tmux session ${name}`);
@@ -26576,6 +27351,17 @@ async function main() {
     await selectTasksPane2(session);
     return;
   }
+  if (subcommand === "heal-layout") {
+    const flags = parseOpsFlags(rest);
+    const session = flags.session;
+    if (!session) {
+      console.error("kobe heal-layout: --session <name> is required");
+      process.exit(2);
+    }
+    const { healSessionLayout: healSessionLayout2 } = await Promise.resolve().then(() => (init_tmux(), exports_tmux));
+    await healSessionLayout2(session);
+    return;
+  }
   if (subcommand === "quick-task") {
     const flags = parseOpsFlags(rest);
     const { startQuickTaskHost: startQuickTaskHost2 } = await Promise.resolve().then(() => (init_host2(), exports_host2));
@@ -26593,6 +27379,11 @@ async function main() {
     await startSettingsHost2();
     return;
   }
+  if (subcommand === "help-page") {
+    const { startHelpHost: startHelpHost2 } = await Promise.resolve().then(() => (init_host5(), exports_host5));
+    await startHelpHost2();
+    return;
+  }
   if (subcommand === "new-task") {
     const flags = parseOpsFlags(rest);
     const { startNewTaskHost: startNewTaskHost2 } = await Promise.resolve().then(() => (init_host(), exports_host));
@@ -26600,7 +27391,7 @@ async function main() {
     return;
   }
   if (subcommand === "update-page") {
-    const { startUpdateHost: startUpdateHost2 } = await Promise.resolve().then(() => (init_host5(), exports_host5));
+    const { startUpdateHost: startUpdateHost2 } = await Promise.resolve().then(() => (init_host6(), exports_host6));
     await startUpdateHost2();
     return;
   }
@@ -26611,11 +27402,11 @@ async function main() {
       process.exit(2);
     }
     if (flags.preview) {
-      const { startOpsPreview: startOpsPreview2 } = await Promise.resolve().then(() => (init_host6(), exports_host6));
+      const { startOpsPreview: startOpsPreview2 } = await Promise.resolve().then(() => (init_host7(), exports_host7));
       await startOpsPreview2({ worktree: flags.worktree, relPath: flags.preview });
       return;
     }
-    const { startOpsHost: startOpsHost2 } = await Promise.resolve().then(() => (init_host6(), exports_host6));
+    const { startOpsHost: startOpsHost2 } = await Promise.resolve().then(() => (init_host7(), exports_host7));
     await startOpsHost2({
       taskId: flags.taskId ?? "",
       worktree: flags.worktree,