@sma1lboy/kobe 0.7.18 → 0.7.20

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.18",
+    version: "0.7.20",
     description: "TUI orchestrator for Claude Code (codename)",
     type: "module",
     packageManager: "bun@1.3.13",
@@ -123,6 +123,7 @@ var init_package = __esm(() => {
       "test:fast": "vitest run --passWithNoTests",
       "test:socket": "KOBE_INCLUDE_SOCKET=1 vitest run test/daemon --pool forks --minWorkers=1 --maxWorkers=1 --passWithNoTests",
       "test:behavior": "KOBE_INCLUDE_BEHAVIOR=1 vitest run test/behavior --passWithNoTests",
+      bench: "vitest bench --run",
       lint: "biome check .",
       knip: "knip-bun",
       postinstall: "bun run scripts/check-preview-deps.ts || true",
@@ -3919,7 +3920,9 @@ var init_protocol = __esm(() => {
     "update",
     "engine-state",
     "ui-prefs",
-    "keybindings"
+    "keybindings",
+    "task.jobs",
+    "worktree.changes"
   ];
 });
 
@@ -4067,6 +4070,7 @@ class KobeDaemonClient {
     this.disposed = true;
     this.socket?.end();
     this.socket = null;
+    this.failPending();
   }
   forceDisconnect() {
     const socket = this.socket;
@@ -4074,6 +4078,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);
@@ -4148,9 +4161,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) {
@@ -5059,66 +5070,6 @@ var init_history = __esm(() => {
   };
 });
 
-// src/engine/claude-code-local/cost.ts
-import { readFile as readFile3 } from "fs/promises";
-async function summarizeClaudeWorktreeCost(worktree) {
-  const files = await listSessionFilesForWorktree(worktree);
-  const base = {
-    sessionCount: files.length,
-    inputTokens: 0,
-    outputTokens: 0,
-    cacheReadTokens: 0,
-    cacheCreateTokens: 0,
-    lastActivityMs: files[0]?.mtimeMs ?? null
-  };
-  if (files.length === 0)
-    return base;
-  let input = 0;
-  let output = 0;
-  let cacheRead = 0;
-  let cacheCreate = 0;
-  for (const file of files) {
-    let raw;
-    try {
-      raw = await readFile3(file.path, "utf8");
-    } catch {
-      continue;
-    }
-    for (const line of raw.split(`
-`)) {
-      if (line.length === 0)
-        continue;
-      let parsed;
-      try {
-        parsed = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      const usage = parsed.message?.usage;
-      if (!usage)
-        continue;
-      if (typeof usage.input_tokens === "number")
-        input += usage.input_tokens;
-      if (typeof usage.output_tokens === "number")
-        output += usage.output_tokens;
-      if (typeof usage.cache_read_input_tokens === "number")
-        cacheRead += usage.cache_read_input_tokens;
-      if (typeof usage.cache_creation_input_tokens === "number")
-        cacheCreate += usage.cache_creation_input_tokens;
-    }
-  }
-  return {
-    ...base,
-    inputTokens: input,
-    outputTokens: output,
-    cacheReadTokens: cacheRead,
-    cacheCreateTokens: cacheCreate
-  };
-}
-var init_cost = __esm(() => {
-  init_history();
-});
-
 // src/cli/invocation.ts
 import { fileURLToPath } from "url";
 function kobeCliInvocation() {
@@ -5215,7 +5166,7 @@ function opsPaneCommand(args) {
 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";
+import { mkdir as mkdir5, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 import { dirname as dirname4 } from "path";
 function failureFromErrorType(errorType) {
   if (typeof errorType !== "string")
@@ -5231,7 +5182,7 @@ function isObject2(v) {
 }
 async function readJsonObject(path8) {
   try {
-    const parsed = JSON.parse(await readFile4(path8, "utf8"));
+    const parsed = JSON.parse(await readFile3(path8, "utf8"));
     return isObject2(parsed) ? parsed : {};
   } catch {
     return {};
@@ -5445,7 +5396,7 @@ function validPositive(v) {
 }
 
 // src/engine/codex-local/history.ts
-import { readFile as readFile5, readdir as readdir2, stat as stat2, unlink as unlink3 } from "fs/promises";
+import { readFile as readFile4, readdir as readdir2, stat as stat2, unlink as unlink3 } from "fs/promises";
 import { homedir as homedir9 } from "os";
 import path8 from "path";
 async function listRolloutFiles(deps = defaultDeps7) {
@@ -5492,6 +5443,26 @@ function rolloutCwd(raw) {
   }
   return "";
 }
+async function rolloutCwdForFile(file, deps) {
+  let cache = rolloutCwdCaches.get(deps);
+  if (!cache) {
+    cache = new Map;
+    rolloutCwdCaches.set(deps, cache);
+  }
+  const hit = cache.get(file);
+  if (hit !== undefined)
+    return hit;
+  let raw;
+  try {
+    raw = await deps.readFile(file);
+  } catch {
+    return null;
+  }
+  const cwd = rolloutCwd(raw);
+  if (cwd)
+    cache.set(file, cwd);
+  return cwd;
+}
 async function listSessionIdsForWorktree(worktree, deps = defaultDeps7) {
   if (!worktree)
     return [];
@@ -5502,13 +5473,7 @@ async function listSessionIdsForWorktree(worktree, deps = defaultDeps7) {
     if (scanned >= MAX_WORKTREE_SCAN)
       break;
     scanned++;
-    let raw;
-    try {
-      raw = await deps.readFile(file);
-    } catch {
-      continue;
-    }
-    if (rolloutCwd(raw) !== worktree)
+    if (await rolloutCwdForFile(file, deps) !== worktree)
       continue;
     const id = path8.basename(file).match(UUID_AT_END)?.[1];
     if (id)
@@ -5516,30 +5481,25 @@ async function listSessionIdsForWorktree(worktree, deps = defaultDeps7) {
   }
   return matches.reverse();
 }
-async function latestTranscriptMtimeForWorktree2(worktree, deps = defaultDeps7) {
+async function findLatestRolloutForWorktree(worktree, deps = defaultDeps7) {
   if (!worktree)
-    return 0;
+    return null;
   const files = await listRolloutFiles(deps);
   let scanned = 0;
   for (const file of files) {
     if (scanned >= MAX_MTIME_SCAN)
       break;
     scanned++;
-    let raw;
-    try {
-      raw = await deps.readFile(file);
-    } catch {
-      continue;
-    }
-    if (rolloutCwd(raw) !== worktree)
+    if (await rolloutCwdForFile(file, deps) !== worktree)
       continue;
     try {
-      return (await deps.stat(file)).mtimeMs;
-    } catch {
-      return 0;
-    }
+      return { path: file, mtimeMs: (await deps.stat(file)).mtimeMs };
+    } catch {}
   }
-  return 0;
+  return null;
+}
+async function latestTranscriptMtimeForWorktree2(worktree, deps = defaultDeps7) {
+  return (await findLatestRolloutForWorktree(worktree, deps))?.mtimeMs ?? 0;
 }
 async function readHistory2(sessionId, deps = defaultDeps7) {
   return (await readHistoryWithMetrics(sessionId, deps)).messages;
@@ -5772,7 +5732,7 @@ function parseTimestampMs(value) {
 function isObject4(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-var defaultDeps7, UUID_AT_END, MAX_WORKTREE_SCAN = 200, MAX_MTIME_SCAN = 12;
+var defaultDeps7, UUID_AT_END, rolloutCwdCaches, MAX_WORKTREE_SCAN = 200, MAX_MTIME_SCAN = 12;
 var init_history2 = __esm(() => {
   init_synthetic();
   defaultDeps7 = {
@@ -5787,11 +5747,12 @@ var init_history2 = __esm(() => {
       }
     },
     async readFile(p) {
-      return await readFile5(p, "utf8");
+      return await readFile4(p, "utf8");
     },
     stat: stat2
   };
   UUID_AT_END = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i;
+  rolloutCwdCaches = new WeakMap;
 });
 
 // src/engine/copilot-local/usage.ts
@@ -5829,7 +5790,7 @@ function numberOr2(value, fallback) {
 }
 
 // src/engine/copilot-local/history.ts
-import { readFile as readFile6, readdir as readdir3, rm, stat as stat3 } from "fs/promises";
+import { readFile as readFile5, readdir as readdir3, rm, stat as stat3 } from "fs/promises";
 import { homedir as homedir10 } from "os";
 import path9 from "path";
 async function listSessionDirs(deps = defaultDeps8) {
@@ -5941,7 +5902,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;
     }
@@ -6009,7 +5970,7 @@ var init_history3 = __esm(() => {
       }
     },
     async readFile(p) {
-      return await readFile6(p, "utf8");
+      return await readFile5(p, "utf8");
     },
     stat: stat3,
     async rm(p) {
@@ -6048,7 +6009,7 @@ var init_hook_adapter2 = __esm(() => {
 });
 
 // src/engine/turn-detector.ts
-import { readFile as readFile7 } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 
 class EngineTurnDetector {
   supportsCompletionMarkers() {
@@ -6121,42 +6082,71 @@ function timestampFromRecord(record, fallback) {
 function isObject7(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-var ClaudeTurnDetector, CodexTurnDetector, UnknownTurnDetector;
+var defaultClaudeDeps, ClaudeTurnDetector, defaultCodexDeps, CodexTurnDetector, UnknownTurnDetector;
 var init_turn_detector = __esm(() => {
   init_history();
   init_history2();
   init_registry();
+  defaultClaudeDeps = {
+    listSessionFiles: (worktree) => listSessionFilesForWorktree(worktree),
+    readFile: (path10) => readFile6(path10, "utf8")
+  };
   ClaudeTurnDetector = class ClaudeTurnDetector extends EngineTurnDetector {
+    deps;
     vendor = "claude";
+    cache = new Map;
+    constructor(deps = defaultClaudeDeps) {
+      super();
+      this.deps = deps;
+    }
     async latestCompletion(worktree) {
-      const files = await listSessionFilesForWorktree(worktree);
+      const files = await this.deps.listSessionFiles(worktree);
       let latest = null;
+      const next = new Map;
       for (const file of files.slice(0, 4)) {
-        const raw = await readFile7(file.path, "utf8").catch(() => "");
-        const marker = latestClaudeCompletionMarkerFromJsonl(raw, file.path, file.mtimeMs);
+        const hit = this.cache.get(file.path);
+        let marker;
+        if (hit && file.mtimeMs > 0 && hit.mtimeMs === file.mtimeMs) {
+          marker = hit.marker;
+        } else {
+          const raw = await this.deps.readFile(file.path).catch(() => "");
+          marker = latestClaudeCompletionMarkerFromJsonl(raw, file.path, file.mtimeMs);
+        }
+        next.set(file.path, { mtimeMs: file.mtimeMs, marker });
         if (marker && (!latest || marker.timestampMs > latest.timestampMs))
           latest = marker;
       }
+      this.cache = next;
       return latest;
     }
   };
+  defaultCodexDeps = {
+    findLatestRollout: (worktree) => findLatestRolloutForWorktree(worktree),
+    readFile: (path10) => readFile6(path10, "utf8")
+  };
   CodexTurnDetector = class CodexTurnDetector extends EngineTurnDetector {
+    deps;
     vendor = "codex";
+    cache = null;
+    constructor(deps = defaultCodexDeps) {
+      super();
+      this.deps = deps;
+    }
     async latestCompletion(worktree) {
       if (!worktree)
         return null;
-      const files = await listRolloutFiles();
-      let scanned = 0;
-      for (const file of files) {
-        if (scanned >= 12)
-          break;
-        scanned++;
-        const raw = await readFile7(file, "utf8").catch(() => "");
-        if (!raw || rolloutCwd(raw) !== worktree)
-          continue;
-        return latestCodexCompletionMarkerFromJsonl(raw, file);
+      const found = await this.deps.findLatestRollout(worktree);
+      if (!found)
+        return null;
+      if (this.cache && this.cache.path === found.path && found.mtimeMs > 0 && this.cache.mtimeMs === found.mtimeMs) {
+        return this.cache.marker;
       }
-      return null;
+      const raw = await this.deps.readFile(found.path).catch(() => "");
+      if (!raw)
+        return null;
+      const marker = latestCodexCompletionMarkerFromJsonl(raw, found.path);
+      this.cache = { path: found.path, mtimeMs: found.mtimeMs, marker };
+      return marker;
     }
   };
   UnknownTurnDetector = class UnknownTurnDetector extends EngineTurnDetector {
@@ -6182,7 +6172,6 @@ function customEngineEntry(vendor) {
     displayName: vendor,
     defaultCommand: [vendor],
     history: EMPTY_HISTORY,
-    summarizeCost: null,
     detectAccount: async () => ({
       binary: { found: false, error: "custom engine: kobe has no account detector for it" },
       account: { kind: "none" }
@@ -6198,7 +6187,6 @@ var EMPTY_HISTORY, claudeHistoryReader, codexHistoryReader, copilotHistoryReader
 var init_registry = __esm(() => {
   init_vendor();
   init_account_detect();
-  init_cost();
   init_history();
   init_hook_adapter();
   init_history2();
@@ -6241,7 +6229,6 @@ var init_registry = __esm(() => {
       displayName: "Claude",
       defaultCommand: ["claude"],
       history: claudeHistoryReader,
-      summarizeCost: (worktree) => summarizeClaudeWorktreeCost(worktree),
       detectAccount: (deps) => detectClaudeAccount(deps),
       createHookAdapter: () => new ClaudeHookAdapter,
       createTurnDetector: () => new ClaudeTurnDetector
@@ -6252,7 +6239,6 @@ var init_registry = __esm(() => {
       displayName: "Codex",
       defaultCommand: ["codex"],
       history: codexHistoryReader,
-      summarizeCost: null,
       detectAccount: (deps) => detectCodexAccount(deps),
       createHookAdapter: () => new NoopHookAdapter("codex"),
       createTurnDetector: () => new CodexTurnDetector
@@ -6263,7 +6249,6 @@ var init_registry = __esm(() => {
       displayName: "Copilot",
       defaultCommand: ["copilot"],
       history: copilotHistoryReader,
-      summarizeCost: null,
       detectAccount: (deps) => detectCopilotAccount(deps),
       createHookAdapter: () => new NoopHookAdapter("copilot"),
       createTurnDetector: () => new UnknownTurnDetector("copilot")
@@ -6277,7 +6262,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)
@@ -6331,6 +6317,7 @@ __export(exports_client, {
   globalTasksPaneWidth: () => globalTasksPaneWidth,
   getSessionOptions: () => getSessionOptions,
   getSessionOption: () => getSessionOption,
+  getServerOptions: () => getServerOptions,
   getServerOption: () => getServerOption,
   ensureFallbackSession: () => ensureFallbackSession,
   currentSessionName: () => currentSessionName,
@@ -6469,6 +6456,22 @@ async function getServerOption(option) {
   const { code, stdout } = await runTmuxCapturing(["show-options", "-sqv", option]);
   return code === 0 ? stdout.trim() : "";
 }
+async function getServerOptions(options) {
+  const values = Object.fromEntries(options.map((option) => [option, undefined]));
+  const { code, stdout } = await runTmuxSequenceCapturing(options.map((option) => ["show-options", "-sq", option]));
+  if (code !== 0)
+    return values;
+  for (const line of stdout.split(`
+`)) {
+    const idx = line.indexOf(" ");
+    if (idx <= 0)
+      continue;
+    const option = line.slice(0, idx);
+    if (option in values)
+      values[option] = line.slice(idx + 1).trim();
+  }
+  return values;
+}
 async function globalTasksPaneWidth() {
   const raw = await getServerOption(TASKS_WIDTH_OPTION);
   const n = Number.parseInt(raw, 10);
@@ -6626,18 +6629,18 @@ async function listChatTabWindows(session, runner = realRunner) {
     "-t",
     `=${session}`,
     "-F",
-    `#{window_index}	#{${CHAT_TAB_SESSION_ID_OPTION}}`
+    `#{window_index}	#{automatic-rename}	#{${CHAT_TAB_SESSION_ID_OPTION}}`
   ]);
   if (code !== 0)
     return [];
   const out = [];
   for (const line of stdout.split(`
 `)) {
-    const tab = line.indexOf("\t");
-    const index = Number.parseInt((tab >= 0 ? line.slice(0, tab) : line).trim(), 10);
+    const [indexField, autoRename, sessionId] = line.split("\t");
+    const index = Number.parseInt((indexField ?? "").trim(), 10);
     if (!Number.isInteger(index))
       continue;
-    out.push({ index, sessionId: tab >= 0 ? line.slice(tab + 1).trim() : "" });
+    out.push({ index, sessionId: sessionId?.trim() ?? "", autoRename: autoRename?.trim() ?? "" });
   }
   return out;
 }
@@ -6650,11 +6653,27 @@ async function windowNamedManually(session, index, runner) {
   ]);
   return code === 0 && /\boff\b/.test(stdout);
 }
+async function globalAutomaticRenameOff(runner) {
+  const { code, stdout } = await runner.capture(["show-window-options", "-g", "automatic-rename"]);
+  return code === 0 && /\boff\b/.test(stdout);
+}
 async function renameWindow(session, index, title, runner) {
   return await runner.run(["rename-window", "-t", `=${session}:${index}`, "--", title]) === 0;
 }
 async function runChatTabNamingPass(orch, deps = realDeps) {
   let renamed = 0;
+  let globalOff = null;
+  const manuallyNamed = async (session, w) => {
+    if (w.autoRename === "1")
+      return false;
+    if (w.autoRename === "0") {
+      if (globalOff === null)
+        globalOff = await globalAutomaticRenameOff(deps.runner);
+      if (!globalOff)
+        return true;
+    }
+    return windowNamedManually(session, w.index, deps.runner);
+  };
   for (const task of orch.listTasks()) {
     if (task.archived || task.kind === "main" || !task.worktreePath)
       continue;
@@ -6666,7 +6685,7 @@ async function runChatTabNamingPass(orch, deps = realDeps) {
     const vendor = task.vendor ?? DEFAULT_TASK_VENDOR;
     for (const w of windows) {
       try {
-        if (await windowNamedManually(session, w.index, deps.runner))
+        if (await manuallyNamed(session, w))
           continue;
         const title = w.sessionId ? await deps.titleFromSessionId(vendor, w.sessionId) : w.index === originIndex ? await deps.titleFromWorktree(task.worktreePath, vendor) : "";
         if (title && await renameWindow(session, w.index, title, deps.runner))
@@ -7071,8 +7090,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;
+        }
       }
     },
     {
@@ -7333,8 +7364,234 @@ 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 { mkdir as mkdir6, readFile as readFile7, unlink as unlink4, writeFile as writeFile4 } from "fs/promises";
 import { createServer } from "net";
 import { dirname as dirname7 } from "path";
 function resolveIdleGraceMs() {
@@ -7436,6 +7693,7 @@ async function startDaemonServer(orch, options = {}) {
     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,
@@ -7450,6 +7708,7 @@ async function startDaemonServer(orch, options = {}) {
       stopAutoTitlePoller();
       stopUiPrefsWatcher();
       stopKeybindingsWatcher();
+      stopWorktreeChangesCollector();
       activity.close();
       broadcast(clients, { type: "event", name: "daemon.stopping", payload: {} });
       for (const client of Array.from(clients)) {
@@ -7546,7 +7805,7 @@ async function startDaemonServer(orch, options = {}) {
 }
 async function readPidFile(pidPath) {
   try {
-    const raw = await readFile8(pidPath, "utf8");
+    const raw = await readFile7(pidPath, "utf8");
     const pid = Number(raw.trim());
     return Number.isFinite(pid) ? pid : null;
   } catch {
@@ -7557,10 +7816,12 @@ function writeFrame(client, frame) {
   client.socket.write(frameToLine(frame));
 }
 function broadcast(clients, frame) {
+  let line = null;
   for (const client of clients) {
     if (!client.subscribed && frame.type === "event")
       continue;
-    writeFrame(client, frame);
+    line ??= frameToLine(frame);
+    client.socket.write(line);
   }
 }
 var DEFAULT_UPDATE_POLL_MS, DEFAULT_IDLE_GRACE_MS = 3000;
@@ -7573,6 +7834,7 @@ var init_server = __esm(() => {
   init_paths2();
   init_protocol();
   init_ui_prefs_watcher();
+  init_worktree_changes_collector();
   init_handlers();
   DEFAULT_UPDATE_POLL_MS = 6 * 60 * 60 * 1000;
 });
@@ -7641,7 +7903,7 @@ __export(exports_daemon_process, {
   connectOrStartDaemon: () => connectOrStartDaemon,
   connectIfRunning: () => connectIfRunning
 });
-import { spawn as spawn2 } from "child_process";
+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";
@@ -7655,7 +7917,7 @@ function spawnDetachedDaemon(command, args, env, logPath) {
   } 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 {
@@ -7938,7 +8200,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)
@@ -7993,7 +8255,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;
@@ -8132,6 +8394,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)
@@ -8271,6 +8540,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)`);
@@ -8282,6 +8559,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;
@@ -8312,21 +8593,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 = {
@@ -10183,10 +10466,17 @@ function parseKobePaneRows(stdout) {
     const line = raw.trim();
     if (!line)
       continue;
-    const [windowId, paneId, role, version] = line.split("\t");
+    const [windowId, paneId, role, version, paneWidth] = line.split("\t");
     if (!windowId || !paneId || !role)
       continue;
-    rows.push({ windowId: windowId.trim(), paneId: paneId.trim(), role: role.trim(), version: version?.trim() ?? "" });
+    const width = Number.parseInt(paneWidth?.trim() ?? "", 10);
+    rows.push({
+      windowId: windowId.trim(),
+      paneId: paneId.trim(),
+      role: role.trim(),
+      version: version?.trim() ?? "",
+      ...Number.isFinite(width) ? { paneWidth: width } : {}
+    });
   }
   return rows;
 }
@@ -10251,38 +10541,18 @@ async function relaunchEngineInAllWindows(session, cwd, command, remoteKey) {
   if (enginePanes.length === 0)
     return false;
   const cmd = keepAlive(wrapEngineLaunch(shellQuoteArgv(command), remoteKey, cwd));
-  for (const pane of enginePanes) {
-    await runTmux(["respawn-pane", "-k", "-c", localSpawnCwd(cwd), "-t", pane, cmd]);
-  }
+  await runTmuxSequence(enginePanes.map((pane) => ["respawn-pane", "-k", "-c", localSpawnCwd(cwd), "-t", pane, cmd]));
   return true;
 }
-async function healTaskPaneWidths(session) {
-  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))
-  };
+async function globalLayoutPrefs() {
+  const opts = await getServerOptions([TASKS_WIDTH_OPTION, RIGHT_COLUMN_WIDTH_OPTION, OPS_HEIGHT_OPTION]);
+  const rawWidth = Number.parseInt(opts[TASKS_WIDTH_OPTION] ?? "", 10);
+  const tasksWidth = Number.isFinite(rawWidth) && rawWidth > 0 ? clampTasksPaneWidth(rawWidth) : TASKS_PANE_WIDTH;
+  const rcArgs = rightColumnResizeArgs({
+    widthPct: clampPanePercent(Number.parseInt(opts[RIGHT_COLUMN_WIDTH_OPTION] ?? "", 10)),
+    heightPct: clampPanePercent(Number.parseInt(opts[OPS_HEIGHT_OPTION] ?? "", 10))
+  });
+  return { tasksWidth, rcArgs };
 }
 function rightColumnResizeArgs(geom) {
   const args = [];
@@ -10293,33 +10563,35 @@ function rightColumnResizeArgs(geom) {
   return args;
 }
 async function globalRightColumnResizeArgs() {
-  return rightColumnResizeArgs(await rightColumnPercents());
+  return (await globalLayoutPrefs()).rcArgs;
 }
-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)
+async function healWorkspaceLayout(session, versions) {
+  const { tasksWidth, rcArgs } = await globalLayoutPrefs();
+  const rows = await listKobePanes(session);
+  if (!rows)
     return;
-  await runTmuxSequence(opsPanes.map((pane) => ["resize-pane", "-t", pane, ...args]));
+  const commands = [];
+  for (const row of rows) {
+    if (row.role === "tasks" && row.paneWidth !== tasksWidth) {
+      commands.push(["resize-pane", "-t", row.paneId, "-x", `${tasksWidth}`]);
+    }
+  }
+  if (rcArgs.length > 0) {
+    for (const row of rows) {
+      if (row.role === "ops")
+        commands.push(["resize-pane", "-t", row.paneId, ...rcArgs]);
+    }
+  }
+  if (versions) {
+    commands.push(...respawnCommandsFor(planPaneHeals(rows, { currentVersion: CURRENT_VERSION, force: false }), versions));
+  }
+  if (commands.length > 0)
+    await runTmuxSequence(commands);
 }
 async function healSessionLayout(session) {
   if (!await sessionExists(session))
     return;
-  await healTaskPaneWidths(session);
-  await healRightColumn(session);
+  await healWorkspaceLayout(session);
 }
 async function captureGlobalLayout(session) {
   const { code, stdout } = await runTmuxCapturing([
@@ -10358,18 +10630,6 @@ async function captureGlobalLayout(session) {
   if (sets.length > 0)
     await runTmuxSequence(sets);
 }
-async function healKobePaneVersions(session, cwd, taskId, vendor) {
-  const rows = await listKobePanes(session);
-  if (!rows)
-    return;
-  const commands = respawnCommandsFor(planPaneHeals(rows, { currentVersion: CURRENT_VERSION, force: false }), {
-    cwd,
-    taskId,
-    vendor
-  });
-  if (commands.length > 0)
-    await runTmuxSequence(commands);
-}
 async function refreshKobeWorkspacePanes(session) {
   const sessionOptions = await getSessionOptions(session, ["@kobe_worktree", "@kobe_task", "@kobe_vendor"]);
   const cwd = sessionOptions["@kobe_worktree"] || process.cwd();
@@ -10395,7 +10655,7 @@ var init_pane_heal = __esm(() => {
   init_tmux_border_theme();
   init_version();
   init_launch();
-  KOBE_PANE_LIST_FORMAT = `#{window_id}	#{pane_id}	#{@kobe_role}	#{${PANE_VERSION_OPTION}}`;
+  KOBE_PANE_LIST_FORMAT = `#{window_id}	#{pane_id}	#{@kobe_role}	#{${PANE_VERSION_OPTION}}	#{pane_width}`;
 });
 
 // src/tui/panes/terminal/chattab.ts
@@ -10625,6 +10885,7 @@ __export(exports_tmux, {
   refreshKobeWorkspacePanes: () => refreshKobeWorkspacePanes,
   quickCreate: () => quickCreate,
   prepareWindowForAttach: () => prepareWindowForAttach,
+  parseObservedSession: () => parseObservedSession,
   openUpdateTab: () => openUpdateTab,
   openSettingsTab: () => openSettingsTab,
   openNewTaskTab: () => openNewTaskTab,
@@ -10633,6 +10894,7 @@ __export(exports_tmux, {
   kobeStatusRight: () => kobeStatusRight,
   killSession: () => killSession,
   healSessionLayout: () => healSessionLayout,
+  focusBindCommand: () => focusBindCommand,
   ensureSession: () => ensureSession,
   currentSessionName: () => currentSessionName,
   chatTabSwitchBindings: () => chatTabSwitchBindings,
@@ -10660,8 +10922,18 @@ async function prepareWindowForAttach(session) {
   const sizeArgs = tmuxInitialSizeArgs();
   if (sizeArgs.length > 0)
     await runTmux(["resize-window", "-t", `=${session}`, ...sizeArgs]);
-  await healTaskPaneWidths(session);
-  await healRightColumn(session);
+  await healWorkspaceLayout(session);
+}
+function focusBindCommand(key, dir) {
+  return [
+    "bind-key",
+    "-n",
+    key,
+    "if-shell",
+    "-F",
+    `#{?window_zoomed_flag,1,#{?${FOCUS_EDGE_VARS[dir]},,1}}`,
+    `select-pane ${dir}`
+  ];
 }
 async function ensureSession(opts) {
   const inflight = ensureSessionLocks.get(opts.name);
@@ -10675,16 +10947,33 @@ async function ensureSession(opts) {
     ensureSessionLocks.delete(opts.name);
   }
 }
+function parseObservedSession(stdout) {
+  let worktree = "";
+  let vendor = "";
+  let claudePaneAlive = false;
+  const windows = new Set;
+  for (const line of stdout.split(`
+`)) {
+    const [windowId, active, role, wt, vd] = line.split("\t");
+    if (!windowId?.trim())
+      continue;
+    windows.add(windowId.trim());
+    if (!worktree && wt?.trim())
+      worktree = wt.trim();
+    if (!vendor && vd?.trim())
+      vendor = vd.trim();
+    if (active?.trim() === "1" && role?.trim() === "claude")
+      claudePaneAlive = true;
+  }
+  return { worktree, vendor, claudePaneAlive, windowCount: windows.size };
+}
 async function observeSession(name) {
   if (!await sessionExists(name))
     return null;
-  const sessionOptions = await getSessionOptions(name, ["@kobe_worktree", "@kobe_vendor"]);
-  return {
-    worktree: sessionOptions["@kobe_worktree"] ?? "",
-    vendor: sessionOptions["@kobe_vendor"] ?? "",
-    claudePaneAlive: await claudePaneIdStrict(name) !== "",
-    windowCount: await windowCount(name)
-  };
+  const { code, stdout } = await runTmuxCapturing(["list-panes", "-s", "-t", `=${name}`, "-F", OBSERVE_SESSION_FORMAT]);
+  if (code !== 0)
+    return { worktree: "", vendor: "", claudePaneAlive: false, windowCount: 0 };
+  return parseObservedSession(stdout);
 }
 async function ensureSessionImpl(opts) {
   const observed = await observeSession(opts.name);
@@ -10695,18 +10984,14 @@ 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);
+    await healWorkspaceLayout(opts.name, { cwd: opts.cwd, taskId: opts.taskId, vendor: opts.vendor });
     return true;
   }
   if (action.kind === "respawn-engine") {
     if (await relaunchEngineInAllWindows(opts.name, opts.cwd, opts.command, remoteKey)) {
       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);
+      await healWorkspaceLayout(opts.name, { cwd: opts.cwd, taskId: opts.taskId, vendor: opts.vendor });
       return true;
     }
   }
@@ -10781,7 +11066,7 @@ async function ensureSessionImpl(opts) {
   const focusDirections = ["-L", "-D", "-U", "-R"];
   const focusBinds = userKeys.focus.flatMap((bind, i) => {
     const dir = focusDirections[i];
-    return bind && dir ? [["bind-key", "-n", bind.key, "select-pane", dir]] : [];
+    return bind && dir ? [focusBindCommand(bind.key, dir)] : [];
   });
   const b = userKeys.binds;
   await runTmuxSequence([
@@ -10841,7 +11126,7 @@ async function selectTasksPane(session) {
   await runTmux(["select-pane", "-t", tasksPane]);
   return tasksPane;
 }
-var ensureSessionLocks;
+var FOCUS_EDGE_VARS, ensureSessionLocks, OBSERVE_SESSION_FORMAT = "#{window_id}\t#{window_active}\t#{@kobe_role}\t#{@kobe_worktree}\t#{@kobe_vendor}";
 var init_tmux = __esm(() => {
   init_invocation();
   init_interactive_command();
@@ -10857,6 +11142,12 @@ var init_tmux = __esm(() => {
   init_client2();
   init_chattab();
   init_pane_heal();
+  FOCUS_EDGE_VARS = {
+    "-L": "pane_at_left",
+    "-D": "pane_at_bottom",
+    "-U": "pane_at_top",
+    "-R": "pane_at_right"
+  };
   ensureSessionLocks = new Map;
 });
 
@@ -10897,51 +11188,6 @@ var init_repo_init = __esm(() => {
   INIT_PROMPT_REL = join7(".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 };
-});
-
 // src/cli/api-cmd.ts
 var exports_api_cmd = {};
 __export(exports_api_cmd, {
@@ -12913,7 +13159,7 @@ async function handleDiffRequest(req, url) {
 var GIT_TIMEOUT_MS = 15000;
 
 // src/web/notes.ts
-import { mkdir as mkdir7, readFile as readFile9, writeFile as writeFile5 } from "fs/promises";
+import { mkdir as mkdir7, readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
 import { join as join11 } from "path";
 function notesDir() {
   return join11(kobeStateDir(), "notes");
@@ -12932,7 +13178,7 @@ async function handleGet(url) {
   try {
     let markdown = "";
     try {
-      markdown = await readFile9(noteFilePath(taskId), "utf8");
+      markdown = await readFile8(noteFilePath(taskId), "utf8");
     } catch (err) {
       if (err.code !== "ENOENT")
         throw err;
@@ -13035,16 +13281,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);
   }
@@ -15101,6 +15352,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;
@@ -15113,6 +15388,10 @@ class RemoteOrchestrator {
   setDaemonVersionSig;
   engineStateAcc;
   setEngineStateSig;
+  taskJobsAcc;
+  setTaskJobsSig;
+  worktreeChangesAcc;
+  setWorktreeChangesSig;
   uiPrefsAcc;
   setUiPrefsSig;
   keybindingsRevAcc;
@@ -15129,6 +15408,8 @@ 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");
@@ -15142,6 +15423,10 @@ 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;
@@ -15202,6 +15487,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)`);
   }
@@ -15234,6 +15525,12 @@ class RemoteOrchestrator {
   engineStateSignal() {
     return this.engineStateAcc;
   }
+  taskJobsSignal() {
+    return this.taskJobsAcc;
+  }
+  worktreeChangesSignal() {
+    return this.worktreeChangesAcc;
+  }
   uiPrefsSignal() {
     return this.uiPrefsAcc;
   }
@@ -15319,8 +15616,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") {
@@ -15345,6 +15645,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")
@@ -15366,6 +15694,38 @@ class RemoteOrchestrator {
       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) {
   return {
@@ -15389,6 +15749,7 @@ var init_remote_orchestrator = __esm(() => {
   init_daemon_process();
   init_protocol();
   init_dev();
+  init_worktree_changes();
   init_version();
 });
 
@@ -15917,7 +16278,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;
     }
@@ -16328,7 +16689,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) {
@@ -16407,7 +16768,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");
@@ -17917,7 +18278,7 @@ function bumpKeymapVersion() {
   setKeymapVersion((v) => v + 1);
 }
 function findBinding(id) {
-  return KobeKeymap.find((b) => b.id === id);
+  return KEYMAP_BY_ID.get(id);
 }
 function chordsOf(id) {
   return findBinding(id)?.keys ?? [];
@@ -17933,12 +18294,11 @@ 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, KEYMAP_DEFAULTS, keymapVersion, setKeymapVersion;
+var KobeKeymap, KEYMAP_DEFAULTS, keymapVersion, setKeymapVersion, KEYMAP_BY_ID;
 var init_keybindings2 = __esm(() => {
   init_dev();
   KobeKeymap = [
@@ -18151,6 +18511,14 @@ var init_keybindings2 = __esm(() => {
       description: "Open the update page (when a new version is available)",
       hint: { keys: "u", label: "update", status: false }
     },
+    {
+      id: "tasks.focusEngine",
+      scope: "sidebar",
+      keys: ["right"],
+      category: "Tasks pane",
+      description: "Focus the engine pane of the current window",
+      hint: { keys: "\u2192", label: "engine", status: false }
+    },
     {
       id: "tasks.toggleKeys",
       scope: "sidebar",
@@ -18400,6 +18768,7 @@ var init_keybindings2 = __esm(() => {
   ];
   KEYMAP_DEFAULTS = new Map(KobeKeymap.map((b) => [b.id, { keys: [...b.keys], hint: b.hint ? { ...b.hint } : undefined }]));
   [keymapVersion, setKeymapVersion] = createSignal(0);
+  KEYMAP_BY_ID = new Map(KobeKeymap.map((b) => [b.id, b]));
 });
 
 // src/tui/context/keybindings-user.ts
@@ -18839,20 +19208,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(() => {
@@ -18872,7 +19249,10 @@ function UiPrefsSync(props) {
     lastKeybindingsRev = rev;
     reloadUserKeybindings();
   });
-  onCleanup(() => prefsOrch()?.dispose());
+  onCleanup(() => {
+    disposed = true;
+    prefsOrch()?.dispose();
+  });
   return null;
 }
 async function bootPaneHost(opts) {
@@ -19097,6 +19477,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
@@ -22039,7 +22444,7 @@ 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 basename7, delimiter, isAbsolute as isAbsolute2, join as join17 } from "path";
 function executableOnPath(command, env, exists) {
@@ -22098,7 +22503,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" });
@@ -22147,15 +22552,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) {
@@ -22177,95 +22573,75 @@ 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
+import { stat as stat4 } from "fs/promises";
+import { join as join18 } from "path";
+async function headFingerprint(repo) {
+  try {
+    const st = await stat4(join18(repo, ".git", "HEAD"));
+    return `${st.mtimeMs}:${st.size}`;
+  } catch {
+    return null;
+  }
+}
+async function resolveBranchHead(repo, signal, spawn6 = spawnCapture) {
+  const fingerprint = await headFingerprint(repo);
+  if (fingerprint !== null) {
+    const cached4 = headCache.get(repo);
+    if (cached4 && cached4.fingerprint === fingerprint)
+      return cached4.value;
+  }
+  let value = "";
+  const ref = await spawn6("git", ["symbolic-ref", "--short", "HEAD"], {
+    cwd: repo,
+    env: gitEnv(),
+    signal
+  });
+  const name = ref.status === 0 ? ref.stdout.trim() : "";
+  if (name && name !== "HEAD") {
+    value = name;
+  } else {
+    const head = await spawn6("git", ["rev-parse", "--verify", "HEAD"], {
+      cwd: repo,
+      env: gitEnv(),
+      signal
+    });
+    if (head.status === 0)
+      value = "(detached)";
+  }
+  if (fingerprint !== null)
+    headCache.set(repo, { fingerprint, value });
+  return value;
+}
 function currentBranch(repo) {
   return poller.read(repo);
 }
 function pollCurrentBranch(repo) {
   poller.poll(repo);
 }
-var BRANCH_POLL_TIMEOUT_MS = 2000, BRANCH_SLOW_RETRY_MS = 30000, BRANCH_MIN_POLL_INTERVAL_MS = 1500, gitEnv = () => ({ ...process.env, GIT_OPTIONAL_LOCKS: "0" }), poller;
+var BRANCH_POLL_TIMEOUT_MS = 2000, BRANCH_SLOW_RETRY_MS = 30000, BRANCH_MIN_POLL_INTERVAL_MS = 1500, gitEnv = () => ({ ...process.env, GIT_OPTIONAL_LOCKS: "0" }), headCache, poller;
 var init_git_head = __esm(() => {
   init_background_poll();
+  headCache = new Map;
   poller = createBackgroundPoller({
     initial: "",
     timeoutMs: BRANCH_POLL_TIMEOUT_MS,
     slowRetryMs: BRANCH_SLOW_RETRY_MS,
     minIntervalMs: BRANCH_MIN_POLL_INTERVAL_MS,
-    run: async (repo, signal) => {
-      const ref = await spawnCapture("git", ["symbolic-ref", "--short", "HEAD"], {
-        cwd: repo,
-        env: gitEnv(),
-        signal
-      });
-      if (ref.status === 0) {
-        const name = ref.stdout.trim();
-        if (name && name !== "HEAD")
-          return name;
-      }
-      const head = await spawnCapture("git", ["rev-parse", "--verify", "HEAD"], {
-        cwd: repo,
-        env: gitEnv(),
-        signal
-      });
-      if (head.status === 0)
-        return "(detached)";
-      return "";
-    }
+    run: (repo, signal) => resolveBranchHead(repo, signal)
   });
 });
 
@@ -22366,20 +22742,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": () => {
@@ -22453,21 +22827,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": () => {
@@ -22523,11 +22894,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 {
@@ -22540,6 +22912,14 @@ function buildSidebarRowView(opts) {
     tone
   };
 }
+function withSpinnerFrame(view, frame) {
+  if (!view.loading)
+    return view;
+  const spinner = IN_PROGRESS_SPINNER[frame() % IN_PROGRESS_SPINNER.length] ?? "\u280B";
+  if (spinner === view.stateGlyph && spinner === view.projectGlyph)
+    return view;
+  return { ...view, stateGlyph: spinner, projectGlyph: spinner };
+}
 function activityBadgeFor(state) {
   switch (state) {
     case "rate_limited":
@@ -22554,7 +22934,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();
@@ -22592,7 +22972,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,
@@ -22680,7 +23060,7 @@ function Sidebar(props) {
   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();
@@ -23029,10 +23409,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();
@@ -23040,15 +23425,17 @@ function Sidebar(props) {
             pollCurrentBranch(task.repo);
           return isMain ? currentBranch(task.repo) : "";
         });
-        const rowView = createMemo(() => buildSidebarRowView({
+        const baseRowView = createMemo(() => buildSidebarRowView({
           task,
           activity: props.engineState?.().get(task.id),
+          job: props.taskJobs?.().get(task.id),
           live: isLive(),
-          spinnerFrame: spinnerFrame(),
+          spinnerFrame: 0,
           subtitleBudget: subtitleBudget(),
           truncateBranch: truncateBranchLabel,
           mainBranch: projectBranch()
         }));
+        const rowView = createMemo(() => withSpinnerFrame(baseRowView(), spinnerFrame));
         const stateColor = () => isMain && !rowView().loading ? theme.primary : toneColor(rowView().tone);
         const barColor = () => isCursor() ? theme.focusAccent : isSelected() ? theme.primary : undefined;
         const barGlyph = () => isCursor() || isSelected() ? "\u258C" : " ";
@@ -23475,6 +23862,7 @@ var init_Sidebar = __esm(() => {
   init_groups();
   init_keys();
   init_row_view();
+  init_worktree_changes();
   init_worktree_changes_poller();
   VIEW_TABS = [{
     view: "active",
@@ -23491,6 +23879,7 @@ __export(exports_host3, {
   startTasksPane: () => startTasksPane
 });
 import { existsSync as existsSync16 } from "fs";
+import { stat as stat5 } from "fs/promises";
 import { TextAttributes as TextAttributes12 } from "@opentui/core";
 function worktreeCwdUsable(cwd) {
   return !!cwd && worktreeUsable(cwd);
@@ -23672,6 +24061,17 @@ function TasksShell(props) {
       notifyError(`Couldn't open worktree with ${opener.label}`);
     }
   }
+  async function focusEnginePane() {
+    if (!process.env.TMUX_PANE)
+      return;
+    const session = await currentSessionName();
+    if (!session)
+      return;
+    const pane = await claudePaneIdStrict(session);
+    if (!pane)
+      return;
+    await runTmux(["select-pane", "-t", pane]);
+  }
   async function moveTask(id, delta) {
     const task = props.tasks().find((t) => t.id === id);
     if (!task || task.kind === "main" || !props.orch)
@@ -23719,7 +24119,8 @@ function TasksShell(props) {
         if (id)
           cycleVendor(id);
       },
-      "tasks.toggleKeys": () => setKeysCollapsed(!keysCollapsed())
+      "tasks.toggleKeys": () => setKeysCollapsed(!keysCollapsed()),
+      "tasks.focusEngine": () => void focusEnginePane().catch((err) => console.error("[kobe tasks] focus engine pane failed:", err))
     })
   }));
   async function switchTo(id) {
@@ -23825,6 +24226,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),
@@ -23949,6 +24361,10 @@ function ShortcutHints(props) {
       k: "enter",
       label: "open"
     },
+    {
+      k: "right",
+      label: "focus engine"
+    },
     {
       k: "n",
       label: "new task"
@@ -24109,10 +24525,21 @@ async function setupTasksPane(opts) {
     await store2.load();
     setFileTasks(store2.list());
   };
+  let lastTasksFileFingerprint = "";
   const timer = setInterval(() => {
     if (orch && orch.connectionStateSignal()() === "online")
       return;
-    reload();
+    (async () => {
+      let fingerprint = "missing";
+      try {
+        const st = await stat5(store2.filePath);
+        fingerprint = `${st.mtimeMs}:${st.size}`;
+      } catch {}
+      if (fingerprint === lastTasksFileFingerprint)
+        return;
+      lastTasksFileFingerprint = fingerprint;
+      await reload();
+    })().catch(() => {});
   }, RELOAD_MS);
   return {
     root: () => [createComponent2(TasksShell, {
@@ -25028,26 +25455,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);