@sma1lboy/kobe 0.7.23 → 0.7.25

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.23",
+    version: "0.7.25",
     description: "TUI orchestrator for Claude Code (codename)",
     type: "module",
     packageManager: "bun@1.3.13",
@@ -1192,6 +1192,37 @@ class TaskIndexStore {
     this.notifyListeners();
     return next;
   }
+  async reorder(moves) {
+    this.assertLoaded();
+    const resolved = moves.map((move) => {
+      const idx = this.cache.tasks.findIndex((t) => t.id === move.id);
+      const existing = idx >= 0 ? this.cache.tasks[idx] : undefined;
+      if (!existing)
+        throw new Error(`task not found: ${move.id}`);
+      return { idx, position: move.position };
+    });
+    let dirty = false;
+    const before = new Map;
+    for (const { idx, position } of resolved) {
+      const existing = this.cache.tasks[idx];
+      if (!existing || existing.position === position)
+        continue;
+      if (!before.has(idx))
+        before.set(idx, existing);
+      this.cache.tasks[idx] = { ...existing, position };
+      dirty = true;
+    }
+    if (!dirty)
+      return;
+    try {
+      await this.save();
+    } catch (err) {
+      for (const [idx, task] of before)
+        this.cache.tasks[idx] = task;
+      throw err;
+    }
+    this.notifyListeners();
+  }
   async archive(id, status = "done") {
     return this.update(id, { status });
   }
@@ -1291,6 +1322,7 @@ function coerceTask(value) {
     kind,
     vendor: isVendorId(v.vendor) ? v.vendor : DEFAULT_TASK_VENDOR,
     prStatus: coercePRStatus(v.prStatus),
+    ...typeof v.position === "number" && Number.isFinite(v.position) ? { position: v.position } : {},
     createdAt: v.createdAt,
     updatedAt: v.updatedAt
   };
@@ -3770,6 +3802,18 @@ class Orchestrator {
       return;
     await this.store.update(task.id, { archived: next });
   }
+  async reorderTasks(moves) {
+    if (moves.length === 0)
+      return;
+    for (const move of moves) {
+      const task = this.requireTask(move.taskId);
+      if (task.kind === "main")
+        throw new Error(`cannot reorder a main task: ${move.taskId}`);
+      if (!Number.isFinite(move.position))
+        throw new Error(`position must be a finite number: ${move.taskId}`);
+    }
+    await this.store.reorder(moves.map((move) => ({ id: move.taskId, position: move.position })));
+  }
   async setStatus(id, status) {
     const task = this.requireTask(id);
     if (task.status === status)
@@ -3916,6 +3960,7 @@ function serializeTask(task) {
     pinned: task.pinned ?? false,
     vendor: task.vendor,
     prStatus: task.prStatus,
+    position: task.position,
     createdAt: task.createdAt,
     updatedAt: task.updatedAt
   };
@@ -3934,7 +3979,9 @@ var init_protocol = __esm(() => {
     "ui-prefs",
     "keybindings",
     "task.jobs",
-    "worktree.changes"
+    "worktree.changes",
+    "task.conflicts",
+    "session.deliver"
   ];
   CHANNEL_NAME_SET = new Set(CHANNEL_NAMES);
 });
@@ -4217,9 +4264,12 @@ class KobeDaemonClient {
     if (!pending)
       return;
     this.pending.delete(frame.id);
-    if (frame.error)
-      pending.reject(new Error(frame.error.message));
-    else
+    if (frame.error) {
+      const err = new Error(frame.error.message);
+      if (frame.error.name)
+        err.name = frame.error.name;
+      pending.reject(err);
+    } else
       pending.resolve(frame.payload);
   }
   emit(frame) {
@@ -6843,6 +6893,347 @@ var init_auto_title_poller = __esm(() => {
   init_chat_tab_naming();
 });
 
+// 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 = () => {};
+
+// ../kobe-daemon/src/daemon/conflict-collector.ts
+class GitGate {
+  limit;
+  active = 0;
+  waiters = [];
+  constructor(limit = MAX_CONCURRENT_GIT) {
+    this.limit = limit;
+  }
+  async run(fn) {
+    if (this.active >= this.limit) {
+      await new Promise((resolve2) => this.waiters.push(resolve2));
+    }
+    this.active += 1;
+    try {
+      return await fn();
+    } finally {
+      this.active -= 1;
+      this.waiters.shift()?.();
+    }
+  }
+}
+async function git(cwd, args, signal, gate) {
+  return gate.run(() => spawnCapture("git", args, { cwd, env: { ...process.env, ...LOCK_FREE_ENV }, signal }));
+}
+function parsePorcelainPaths(stdout) {
+  const paths = [];
+  for (const line of stdout.split(`
+`)) {
+    if (line.length < 4)
+      continue;
+    const rest = line.slice(3);
+    const arrow = rest.indexOf(" -> ");
+    if (arrow >= 0) {
+      paths.push(rest.slice(0, arrow), rest.slice(arrow + 4));
+    } else {
+      paths.push(rest);
+    }
+  }
+  return paths;
+}
+async function resolveBaseRef(worktree, signal, gate) {
+  for (const ref of BASE_REF_CANDIDATES) {
+    const res = await git(worktree, ["rev-parse", "--verify", "--quiet", ref], signal, gate);
+    if (res.status === 0)
+      return ref;
+  }
+  return null;
+}
+async function collectFootprint(worktree, repo, baseRef, signal, gate) {
+  const head = await git(worktree, ["rev-parse", "HEAD"], signal, gate);
+  if (head.status !== 0)
+    throw new Error("rev-parse HEAD failed");
+  const files = new Set;
+  const status = await git(worktree, ["status", "--porcelain=v1"], signal, gate);
+  if (status.status !== 0)
+    throw new Error("git status failed");
+  for (const p of parsePorcelainPaths(status.stdout))
+    files.add(p);
+  if (baseRef) {
+    const diff = await git(worktree, ["diff", "--name-only", `${baseRef}...HEAD`], signal, gate);
+    if (diff.status === 0) {
+      for (const p of diff.stdout.split(`
+`))
+        if (p)
+          files.add(p);
+    }
+  }
+  return { repo, head: head.stdout.trim(), files };
+}
+function sameFootprint(a, b) {
+  if (a.head !== b.head || a.files.size !== b.files.size)
+    return false;
+  for (const f of a.files)
+    if (!b.files.has(f))
+      return false;
+  return true;
+}
+function trackedConflictTasks(tasks) {
+  return tasks.filter((t) => !t.archived && (t.kind ?? "task") !== "main" && !!t.worktreePath && !isRemoteRepoKey(t.repo) && !isRemoteRepoKey(t.worktreePath));
+}
+function overlapPairs(cards) {
+  const ids = [...cards.keys()].sort();
+  const pairs = [];
+  for (let i = 0;i < ids.length; i++) {
+    for (let j = i + 1;j < ids.length; j++) {
+      const a = cards.get(ids[i]);
+      const b = cards.get(ids[j]);
+      if (a.repo !== b.repo)
+        continue;
+      const files = [...a.files].filter((f) => b.files.has(f)).sort();
+      if (files.length === 0)
+        continue;
+      pairs.push({ a: ids[i], b: ids[j], files, level: "overlap" });
+    }
+  }
+  return pairs;
+}
+function parseMergeTreeNames(stdout) {
+  const lines = stdout.split(`
+`);
+  const names = [];
+  for (const line of lines.slice(1)) {
+    if (!line)
+      break;
+    names.push(line);
+  }
+  return names;
+}
+function samePairs(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+class ConflictCollector {
+  orch;
+  bus;
+  options;
+  entries = new Map;
+  baseRefs = new Map;
+  mergeProbes = new Map;
+  gate = new GitGate;
+  mergeTreeUnsupported = false;
+  lastPublished = [];
+  stopped = false;
+  constructor(orch, bus, options = {}) {
+    this.orch = orch;
+    this.bus = bus;
+    this.options = options;
+  }
+  tick() {
+    if (this.stopped)
+      return;
+    if (this.options.hasSubscribers && !this.options.hasSubscribers())
+      return;
+    try {
+      const tracked = trackedConflictTasks(this.orch.listTasks());
+      const trackedIds = new Set(tracked.map((t) => t.id));
+      let pruned = false;
+      for (const id of this.entries.keys()) {
+        if (trackedIds.has(id))
+          continue;
+        if (this.entries.get(id)?.value)
+          pruned = true;
+        this.entries.delete(id);
+      }
+      if (pruned)
+        this.recompute();
+      for (const task of tracked)
+        this.maybeCollect(task);
+    } catch (err) {
+      logDaemonError("conflict-radar", err);
+    }
+  }
+  stop() {
+    this.stopped = true;
+  }
+  maybeCollect(task) {
+    const id = task.id;
+    let entry = this.entries.get(id);
+    if (!entry) {
+      entry = { inFlight: false, nextAllowedAt: 0 };
+      this.entries.set(id, entry);
+    }
+    const cadence = this.options.cadence ?? {
+      timeoutMs: CONFLICTS_TIMEOUT_MS,
+      slowRetryMs: CONFLICTS_SLOW_RETRY_MS,
+      minIntervalMs: CONFLICTS_MIN_INTERVAL_MS
+    };
+    const run = this.options.footprint ?? (async (t, signal) => {
+      const baseRef = await this.baseRefFor(t.worktreePath, signal);
+      return collectFootprint(t.worktreePath, t.repo, baseRef, signal, this.gate);
+    });
+    maybeStartScheduledRun(entry, cadence, (signal) => run(task, signal), (value) => {
+      if (this.stopped)
+        return;
+      if (this.entries.get(id) !== entry)
+        return;
+      if (entry.value && sameFootprint(entry.value, value))
+        return;
+      entry.value = value;
+      this.recompute();
+    });
+  }
+  baseRefFor(worktree, signal) {
+    const cached = this.baseRefs.get(worktree);
+    if (cached)
+      return cached;
+    const promise = resolveBaseRef(worktree, signal, this.gate).catch(() => null);
+    this.baseRefs.set(worktree, promise);
+    return promise;
+  }
+  recompute() {
+    const cards = new Map;
+    for (const [id, entry] of this.entries) {
+      if (entry.value)
+        cards.set(id, entry.value);
+    }
+    const pairs = overlapPairs(cards);
+    const resolved = [];
+    for (const pair of pairs) {
+      const a = cards.get(pair.a);
+      const b = cards.get(pair.b);
+      const key = [a.repo, ...[a.head, b.head].sort()].join("\x00");
+      const probe2 = this.mergeProbes.get(key);
+      if (probe2?.state === "conflict") {
+        resolved.push({
+          ...pair,
+          level: "conflict",
+          files: probe2.files.length > 0 ? probe2.files : pair.files
+        });
+        continue;
+      }
+      resolved.push(pair);
+      if (!probe2 && !this.mergeTreeUnsupported && a.head !== b.head) {
+        this.scheduleMergeProbe(key, cards, pair);
+      }
+    }
+    if (samePairs(this.lastPublished, resolved))
+      return;
+    this.lastPublished = resolved;
+    const payload = { pairs: resolved };
+    this.bus.publish("task.conflicts", payload);
+  }
+  scheduleMergeProbe(key, cards, pair) {
+    const a = cards.get(pair.a);
+    const b = cards.get(pair.b);
+    this.mergeProbes.set(key, { state: "pending" });
+    const worktree = this.worktreeOf(pair.a);
+    const probe2 = this.options.probeMerge ?? (async (wt, headA, headB) => {
+      const res = await git(wt, ["merge-tree", "--write-tree", "--name-only", headA, headB], AbortSignal.timeout(MERGE_TREE_TIMEOUT_MS), this.gate);
+      if (res.status === 0)
+        return { conflict: false, files: [] };
+      if (res.status === 1)
+        return { conflict: true, files: parseMergeTreeNames(res.stdout) };
+      return null;
+    });
+    if (!worktree) {
+      this.mergeProbes.delete(key);
+      return;
+    }
+    probe2(worktree, a.head, b.head).then((result) => {
+      if (this.stopped)
+        return;
+      if (result === null) {
+        if (!this.mergeTreeUnsupported) {
+          this.mergeTreeUnsupported = true;
+          console.log("[conflict-radar] merge-tree dry-run unavailable (git < 2.38 or no merge base) \u2014 radar degrades to file-overlap only");
+        }
+        this.mergeProbes.delete(key);
+        return;
+      }
+      this.mergeProbes.set(key, result.conflict ? { state: "conflict", files: result.files } : { state: "clean" });
+      this.recompute();
+    }).catch((err) => {
+      this.mergeProbes.delete(key);
+      logDaemonError("conflict-radar", err);
+    });
+  }
+  worktreeOf(taskId) {
+    const task = this.orch.listTasks().find((t) => t.id === taskId);
+    return task?.worktreePath || undefined;
+  }
+}
+function startConflictCollector(orch, bus, tickMs = DEFAULT_CONFLICTS_TICK_MS, hasSubscribers) {
+  if (tickMs <= 0)
+    return () => {};
+  const collector = new ConflictCollector(orch, bus, { hasSubscribers });
+  collector.tick();
+  const timer = setInterval(() => collector.tick(), tickMs);
+  timer.unref?.();
+  return () => {
+    clearInterval(timer);
+    collector.stop();
+  };
+}
+var DEFAULT_CONFLICTS_TICK_MS = 5000, CONFLICTS_TIMEOUT_MS = 5000, CONFLICTS_SLOW_RETRY_MS = 60000, CONFLICTS_MIN_INTERVAL_MS = 1e4, MAX_CONCURRENT_GIT = 3, MERGE_TREE_TIMEOUT_MS = 8000, LOCK_FREE_ENV, BASE_REF_CANDIDATES;
+var init_conflict_collector = __esm(() => {
+  init_poll_scheduling();
+  init_repos();
+  LOCK_FREE_ENV = { GIT_OPTIONAL_LOCKS: "0" };
+  BASE_REF_CANDIDATES = ["origin/HEAD", "origin/main", "origin/master", "main", "master"];
+});
+
 // ../kobe-daemon/src/daemon/event-bus.ts
 class DaemonEventBus {
   last = new Map;
@@ -6864,6 +7255,33 @@ class DaemonEventBus {
   }
 }
 
+// src/state/auto-status.ts
+function autoStatusEnabled() {
+  return loadStateFile()[AUTO_STATUS_KEY] === true;
+}
+var AUTO_STATUS_KEY = "experimental.autoStatus";
+var init_auto_status = __esm(() => {
+  init_store();
+});
+
+// src/monitor/status-rules.ts
+async function maybeAutoStart(orch, taskId, enabled = autoStatusEnabled) {
+  if (!enabled())
+    return "skipped";
+  const task = orch.getTask(taskId);
+  if (!task)
+    return "skipped";
+  if ((task.kind ?? "task") === "main" || task.archived)
+    return "skipped";
+  if (task.status !== "backlog")
+    return "skipped";
+  await orch.setStatus(taskId, "in_progress");
+  return "moved";
+}
+var init_status_rules = __esm(() => {
+  init_auto_status();
+});
+
 // ../kobe-daemon/src/daemon/cwd-task.ts
 import { createHash as createHash4 } from "crypto";
 import { homedir as homedir12 } from "os";
@@ -7128,6 +7546,29 @@ function createDaemonHandlerRegistry() {
         return {};
       }
     },
+    {
+      name: "task.reorder",
+      async handle(payload, ctx) {
+        const moves = payload.moves;
+        if (!Array.isArray(moves) || moves.length === 0)
+          throw new Error("moves must be a non-empty array");
+        if (moves.length > 500)
+          throw new Error("too many moves in one task.reorder batch (max 500)");
+        const parsed = moves.map((move) => {
+          if (typeof move !== "object" || move === null)
+            throw new Error("each move needs taskId and position");
+          const entry = move;
+          const taskId = requireString(entry, "taskId");
+          const position = entry.position;
+          if (typeof position !== "number" || !Number.isFinite(position)) {
+            throw new Error("position must be a finite number");
+          }
+          return { taskId, position };
+        });
+        await ctx.orch.reorderTasks(parsed);
+        return {};
+      }
+    },
     {
       name: "task.ensureMain",
       async handle(payload, ctx) {
@@ -7204,6 +7645,47 @@ function createDaemonHandlerRegistry() {
         return {};
       }
     },
+    {
+      name: "session.deliver",
+      async handle(payload, ctx) {
+        const taskId = requireString(payload, "taskId");
+        const text = requireString(payload, "text");
+        const source = optionalString(payload, "source");
+        if (source !== undefined && source !== "note" && source !== "dispatcher") {
+          throw new Error('source must be "note" or "dispatcher"');
+        }
+        if (!ctx.orch.getTask(taskId))
+          throw new Error(`task not found: ${taskId}`);
+        ctx.bus.publish("session.deliver", {
+          taskId,
+          text,
+          at: Date.now(),
+          source: source ?? "dispatcher"
+        });
+        return { ok: true };
+      }
+    },
+    {
+      name: "note.file",
+      async handle(payload, ctx) {
+        const taskId = requireString(payload, "taskId");
+        const text = requireString(payload, "text");
+        const author = ctx.orch.getTask(taskId);
+        if (!author)
+          throw new Error(`task not found: ${taskId}`);
+        const main = ctx.orch.listTasks().find((t) => (t.kind ?? "task") === "main" && t.repo === author.repo && !t.archived);
+        if (!main || main.id === author.id)
+          return { ok: true, routed: false };
+        const label = author.title || author.branch || taskId;
+        ctx.bus.publish("session.deliver", {
+          taskId: main.id,
+          text: `[KOBE FIELD NOTE] from "${label}" (task ${taskId}): ${text}`,
+          at: Date.now(),
+          source: "note"
+        });
+        return { ok: true, routed: true };
+      }
+    },
     {
       name: "engine.reportEvent",
       async handle(payload, ctx) {
@@ -7227,6 +7709,13 @@ function createDaemonHandlerRegistry() {
           return {};
         const detail = optionalActivityDetail(payload);
         ctx.activity.report(taskId, kind, detail);
+        if (kind === "turn-start") {
+          maybeAutoStart(ctx.orch, taskId).then((result) => {
+            if (result === "moved") {
+              console.log(`[status-rules] task ${taskId} auto-moved backlog \u2192 in_progress`);
+            }
+          }).catch((err) => logDaemonError("status-rules", err));
+        }
         return {};
       }
     }
@@ -7280,6 +7769,7 @@ function optionalActivityDetail(payload) {
 }
 var init_handlers = __esm(() => {
   init_hook_events();
+  init_status_rules();
   init_version();
   init_cwd_task();
   init_protocol();
@@ -7414,65 +7904,6 @@ 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, {
@@ -7753,6 +8184,7 @@ async function startDaemonServer(orch, options = {}) {
     debounceMs: options.keybindingsDebounceMs ?? DEFAULT_KEYBINDINGS_DEBOUNCE_MS
   });
   const stopWorktreeChangesCollector = startWorktreeChangesCollector(orch, bus, options.worktreeChangesTickMs ?? DEFAULT_WORKTREE_CHANGES_TICK_MS, hasSubscribers);
+  const stopConflictCollector = startConflictCollector(orch, bus, options.conflictsTickMs ?? DEFAULT_CONFLICTS_TICK_MS, hasSubscribers);
   const serverApi = {
     socketPath,
     pidPath,
@@ -7768,6 +8200,7 @@ async function startDaemonServer(orch, options = {}) {
       stopUiPrefsWatcher();
       stopKeybindingsWatcher();
       stopWorktreeChangesCollector();
+      stopConflictCollector();
       activity.close();
       broadcast(clients, { type: "event", name: "daemon.stopping", payload: {} });
       for (const client of Array.from(clients)) {
@@ -7898,6 +8331,7 @@ var init_server = __esm(() => {
   init_version();
   init_activity_registry();
   init_auto_title_poller();
+  init_conflict_collector();
   init_handlers();
   init_keybindings_watcher();
   init_paths2();
@@ -8218,6 +8652,15 @@ var init_repo_cmd = __esm(() => {
 `);
 });
 
+// src/state/dispatcher.ts
+function dispatcherEnabled() {
+  return loadStateFile()[DISPATCHER_KEY] === true;
+}
+var DISPATCHER_KEY = "experimental.dispatcher";
+var init_dispatcher = __esm(() => {
+  init_store();
+});
+
 // src/engine/interactive-command.ts
 import { randomUUID } from "crypto";
 function engineCommandKey(vendor) {
@@ -8259,9 +8702,88 @@ function withClaudeSessionId(argv, vendor) {
   const sessionId = randomUUID();
   return { argv: [...argv, "--session-id", sessionId], sessionId };
 }
+function kobeApiInvocation() {
+  const quote = (a) => /^[A-Za-z0-9_/.:=-]+$/.test(a) ? a : `'${a.replace(/'/g, "'\\''")}'`;
+  try {
+    return [...kobeCliInvocation(), "api"].map(quote).join(" ");
+  } catch {
+    return "kobe api";
+  }
+}
+function statusReportProtocol(taskId, api = kobeApiInvocation()) {
+  return [
+    `You are running inside kobe (a local multi-session task manager) as task ${taskId}.`,
+    "kobe tracks a lifecycle status for this task on a board.",
+    "When you have COMPLETED the work requested in this session and verified it, report it by running:",
+    `  ${api} set-status --task-id ${taskId} --status in_review`,
+    "Run it only when the work is genuinely done \u2014 never while you are asking the user a question, waiting for input, or mid-task.",
+    "Never set any other status value; everything beyond in_review is the user's decision."
+  ].join(`
+`);
+}
+function noteFilingProtocol(taskId, api = kobeApiInvocation()) {
+  return [
+    "kobe shares hard-won discoveries between its parallel sessions as one-line field notes.",
+    "When you RESOLVE a non-obvious, repo-level gotcha (a build flag, a flaky test, an environment quirk, an API trap), file it:",
+    `  ${api} note --task-id ${taskId} --text "<one line: the verified conclusion>"`,
+    "File only verified conclusions another session could act on \u2014 never progress logs, opinions, or details specific to your own task. A handful per session at most."
+  ].join(`
+`);
+}
+function worktreeProtocol(taskId, api = kobeApiInvocation(), gates = {}) {
+  const parts = [];
+  if ((gates.status ?? autoStatusEnabled)())
+    parts.push(statusReportProtocol(taskId, api));
+  if ((gates.notes ?? dispatcherEnabled)())
+    parts.push(noteFilingProtocol(taskId, api));
+  return parts.length > 0 ? parts.join(`
+
+`) : null;
+}
+function withWorktreeProtocol(argv, vendor, taskId, gates = {}) {
+  if (!taskId)
+    return argv;
+  if ((vendor ?? "claude") !== "claude")
+    return argv;
+  if (argv.includes("--append-system-prompt") || argv.includes("--append-system-prompt-file")) {
+    return argv;
+  }
+  const text = worktreeProtocol(taskId, kobeApiInvocation(), gates);
+  if (!text)
+    return argv;
+  return [...argv, "--append-system-prompt", text];
+}
+function dispatcherProtocol(taskId, api = kobeApiInvocation()) {
+  return [
+    `You are running inside kobe (a local multi-session task manager) as this repository's DISPATCHER (task ${taskId}, the repo's main session).`,
+    "kobe runs multiple worktree task sessions on this repo in parallel. When one of them resolves a non-obvious gotcha, it files a one-line field note; kobe forwards each note to you as a user message prefixed with [KOBE FIELD NOTE].",
+    "Your job is routing that knowledge, fully autonomously \u2014 never ask the user for permission:",
+    `  - See the fleet: \`${api} collect --repo .\` (status, running, change counts per task), or \`--task-ids id1,id2\` for specific tasks.`,
+    `  - Relay a note to a task that would benefit: \`${api} dispatch --task-id <id> --prompt "[dispatcher] FYI from <author task>: <note verbatim>"\`.`,
+    "  - Relay to the in-flight tasks whose work plausibly touches the same area \u2014 and to nobody else. If no task benefits, do nothing.",
+    "  - Never relay a note back to its author, never relay the same note to the same task twice, and keep relays verbatim with provenance \u2014 no summarizing, no embellishment.",
+    "Use ONLY the dispatch verb to message sessions \u2014 the `send` verb pastes via tmux and would spawn a DUPLICATE engine for web-hosted sessions. If dispatch fails, report the error in your own session and stop; do not fall back.",
+    "Take no action on merge conflicts between tasks \u2014 the board's conflict radar is display-only by design, and resolution timing belongs to the humans and the tasks themselves.",
+    "Never run git commands inside other tasks' worktrees."
+  ].join(`
+`);
+}
+function withDispatcherProtocol(argv, vendor, taskId, enabled = dispatcherEnabled) {
+  if (!taskId || !enabled())
+    return argv;
+  if ((vendor ?? "claude") !== "claude")
+    return argv;
+  if (argv.includes("--append-system-prompt") || argv.includes("--append-system-prompt-file")) {
+    return argv;
+  }
+  return [...argv, "--append-system-prompt", dispatcherProtocol(taskId)];
+}
 var VENDOR_LABEL, CLAUDE_SESSION_CONTROL_FLAGS;
 var init_interactive_command = __esm(() => {
+  init_invocation();
   init_registry();
+  init_auto_status();
+  init_dispatcher();
   init_repos();
   init_vendor();
   VENDOR_LABEL = Object.fromEntries(BUILTIN_VENDORS.map((v) => [v, engineEntry(v).displayName]));
@@ -11062,7 +11584,11 @@ async function ensureSessionImpl(opts) {
   }
   const inv = kobeCliInvocation();
   const launch = withClaudeSessionId(opts.command, opts.vendor);
-  const engineCmd = wrapEngineLaunch(shellQuoteArgv(launch.argv), remoteKey, opts.cwd);
+  const isMainSession = opts.repo !== undefined && opts.cwd === opts.repo;
+  const protocolTaskId = isMainSession || remoteKey ? undefined : opts.taskId;
+  const dispatcherTaskId = isMainSession && !remoteKey ? opts.taskId : undefined;
+  const launchArgv = withDispatcherProtocol(withWorktreeProtocol(launch.argv, opts.vendor, protocolTaskId), opts.vendor, dispatcherTaskId);
+  const engineCmd = wrapEngineLaunch(shellQuoteArgv(launchArgv), remoteKey, opts.cwd);
   const r0 = await runTmuxCapturing([
     "new-session",
     "-d",
@@ -11688,6 +12214,19 @@ async function send(ctx) {
     engineReady: delivered.engineReady
   };
 }
+async function dispatch(ctx) {
+  const daemon = daemonOf(ctx);
+  const taskId = ctx.args.require("task-id");
+  const text = ctx.args.require("prompt");
+  await daemon.request("session.deliver", { taskId, text, source: "dispatcher" });
+  return { ok: true, taskId, routed: "session.deliver" };
+}
+async function note(ctx) {
+  const daemon = daemonOf(ctx);
+  const taskId = ctx.args.require("task-id");
+  const text = ctx.args.require("text");
+  return await daemon.request("note.file", { taskId, text });
+}
 async function getTask(ctx) {
   const daemon = daemonOf(ctx);
   const taskId = ctx.args.require("task-id");
@@ -11936,7 +12475,7 @@ var init_api_cmd = __esm(() => {
     discover: ["schema"],
     read: ["list", "get-task", "collect"],
     create: ["add", "fan-out"],
-    drive: ["send", "set-active"],
+    drive: ["send", "dispatch", "note", "set-active"],
     edit: ["rename", "set-branch", "set-vendor", "set-status"],
     lifecycle: ["archive", "pin", "delete"],
     worktree: ["ensure-worktree", "adopt", "discover-adoptable"],
@@ -12016,6 +12555,27 @@ var init_api_cmd = __esm(() => {
       flags: [F.taskId(false), F.prompt(true, "Text pasted + submitted into the engine pane.")],
       handler: send
     },
+    {
+      name: "dispatch",
+      summary: "Route text into a task's live session via the daemon's session.deliver channel \u2014 the front-end hosting the session pastes it. The dispatcher's messenger (docs/design/dispatcher.md); unlike `send`, it never spawns or touches tmux itself.",
+      flags: [F.taskId(true), F.prompt(true, "Text delivered into the task's engine session.")],
+      handler: dispatch
+    },
+    {
+      name: "note",
+      summary: "File a one-line field note \u2014 a resolved, repo-level gotcha worth sharing. kobe forwards it to the repo's dispatcher session (the main session), which relays it to the in-flight tasks that benefit (docs/design/dispatcher.md).",
+      flags: [
+        F.taskId(true),
+        {
+          name: "text",
+          type: "string",
+          required: true,
+          placeholder: "TEXT",
+          description: "One line: the verified conclusion another session could act on."
+        }
+      ],
+      handler: note
+    },
     {
       name: "feedback",
       summary: "Create a GitHub Discussion in the kobe repo's Feedback category through `gh`.",
@@ -13470,6 +14030,8 @@ var init_spa_channels = __esm(() => {
     "update",
     "task.jobs",
     "worktree.changes",
+    "task.conflicts",
+    "session.deliver",
     "ui-prefs"
   ];
   SPA_CHANNEL_SET = new Set(SPA_CHANNELS);
@@ -13493,6 +14055,8 @@ class DaemonLink {
   update = null;
   jobs = {};
   worktreeChanges = {};
+  conflicts = [];
+  deliver = null;
   uiPrefs = null;
   async start() {
     await this.connectOnce(true);
@@ -13505,6 +14069,8 @@ class DaemonLink {
       update: this.update,
       jobs: this.jobs,
       worktreeChanges: this.worktreeChanges,
+      conflicts: this.conflicts,
+      deliver: this.deliver,
       uiPrefs: this.uiPrefs,
       connected: this.connected
     };
@@ -13615,6 +14181,12 @@ class DaemonLink {
       case "worktree.changes":
         this.worktreeChanges = payload.changes;
         break;
+      case "task.conflicts":
+        this.conflicts = payload.pairs;
+        break;
+      case "session.deliver":
+        this.deliver = payload;
+        break;
       case "ui-prefs":
         this.uiPrefs = payload;
         break;
@@ -13662,6 +14234,7 @@ var init_rpc_allowlist = __esm(() => {
     "task.pin",
     "task.move",
     "task.status",
+    "task.reorder",
     "task.ensureMain",
     "task.ensureWorktree",
     "task.setActive",
@@ -13708,7 +14281,11 @@ function shellQuote2(argv) {
 }
 async function engineSpec(link, taskId) {
   const { task, worktreePath } = await ensureTaskWorktree(link, taskId);
-  const argv = [...interactiveEngineCommand(task.vendor)];
+  const protocolTaskId = task.kind === "main" ? undefined : taskId;
+  const dispatcherTaskId = task.kind === "main" ? taskId : undefined;
+  const argv = [
+    ...withDispatcherProtocol(withWorktreeProtocol(interactiveEngineCommand(task.vendor), task.vendor, protocolTaskId), task.vendor, dispatcherTaskId)
+  ];
   const init = resolveRepoInit(task.repo ?? "", worktreePath);
   const quoted = shellQuote2(argv);
   const script = init.initScript?.trim() ? `${init.initScript}
@@ -13790,7 +14367,8 @@ async function rpcResponse(req, link, tearDown) {
     }
     return Response.json({ result });
   } catch (err) {
-    return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 500 });
+    const name = err instanceof Error && err.name !== "Error" ? err.name : undefined;
+    return Response.json({ error: err instanceof Error ? err.message : String(err), ...name ? { name } : {} }, { status: 500 });
   }
 }
 async function enginesResponse() {
@@ -13848,6 +14426,10 @@ function createRequestHandler(deps) {
       return specResponse(url, link, terminalSpec);
     if (url.pathname === "/api/engines" && req.method === "GET")
       return enginesResponse();
+    if (url.pathname === "/api/quick-prompts" && req.method === "GET")
+      return quickPromptsGet();
+    if (url.pathname === "/api/quick-prompts" && req.method === "PUT")
+      return quickPromptsPut(req);
     const notes = await handleNotesRequest(req, url);
     if (notes)
       return notes;
@@ -13865,6 +14447,24 @@ function createRequestHandler(deps) {
     return new Response("not found", { status: 404 });
   };
 }
+function quickPromptsGet() {
+  return Response.json({
+    review: getPersistedString(QUICK_PROMPT_KEYS.review) ?? null,
+    pr: getPersistedString(QUICK_PROMPT_KEYS.pr) ?? null
+  });
+}
+async function quickPromptsPut(req) {
+  try {
+    const body = await req.json();
+    if (typeof body.review === "string")
+      setPersistedString(QUICK_PROMPT_KEYS.review, body.review);
+    if (typeof body.pr === "string")
+      setPersistedString(QUICK_PROMPT_KEYS.pr, body.pr);
+    return quickPromptsGet();
+  } catch (err) {
+    return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 400 });
+  }
+}
 async function staticResponse(pathname, staticDir) {
   const rel = pathname === "/" ? "/index.html" : pathname;
   const resolved = normalize2(join12(staticDir, rel));
@@ -13942,16 +14542,21 @@ async function createBridgeServer(opts = {}) {
     }
   };
 }
-var WEB_HEALTH_MARKER = "kobe-web", WEB_HEALTH_PATH = "/__kobe_web";
+var WEB_HEALTH_MARKER = "kobe-web", WEB_HEALTH_PATH = "/__kobe_web", QUICK_PROMPT_KEYS;
 var init_bridge = __esm(() => {
   init_account_detect();
   init_interactive_command();
+  init_repos();
   init_history4();
   init_notes();
   init_themes();
   init_daemon_link();
   init_rpc_allowlist();
   init_session();
+  QUICK_PROMPT_KEYS = {
+    review: "boardPrompt.review",
+    pr: "boardPrompt.pr"
+  };
 });
 
 // ../kobe-web/server/index.ts
@@ -17267,7 +17872,7 @@ function clampCursor(cursor, listLength) {
     return 0;
   return Math.max(0, Math.min(listLength - 1, cursor));
 }
-function resolveBaseRef(typed, filteredBranches, cursor) {
+function resolveBaseRef2(typed, filteredBranches, cursor) {
   const picked = filteredBranches[cursor];
   if (picked)
     return picked;
@@ -17841,7 +18446,7 @@ function NewTaskDialogView(props) {
             setBaseRef(stripNewlines(v));
           });
           setProp(_el$28, "onSubmit", () => {
-            setBaseRef(resolveBaseRef(baseRef(), branchFiltered(), branchCursor()));
+            setBaseRef(resolveBaseRef2(baseRef(), branchFiltered(), branchCursor()));
             setBaseRefTouched(true);
             setField("confirm");
           });
@@ -20661,7 +21266,9 @@ function devRows(hasDaemon) {
   return [
     { id: "dev-reset", kind: "devReset" },
     ...hasDaemon ? [{ id: "dev-restart", kind: "devRestartDaemon" }] : [],
-    { id: "remote-projects", kind: "devRemoteProjects" }
+    { id: "remote-projects", kind: "devRemoteProjects" },
+    { id: "auto-status", kind: "devAutoStatus" },
+    { id: "dispatcher", kind: "devDispatcher" }
   ];
 }
 function sectionRows(section, input) {
@@ -21527,8 +22134,12 @@ function DevSettingsSection(props) {
   const restartIsCursor = () => props.level() === "body" && props.bodyRow() === 1;
   const experimentalRow = () => rowIndex(devRows(props.hasDaemon), "remote-projects");
   const remoteIsCursor = () => props.level() === "body" && props.bodyRow() === experimentalRow();
+  const autoStatusRow = () => rowIndex(devRows(props.hasDaemon), "auto-status");
+  const autoStatusIsCursor = () => props.level() === "body" && props.bodyRow() === autoStatusRow();
+  const dispatcherRow = () => rowIndex(devRows(props.hasDaemon), "dispatcher");
+  const dispatcherIsCursor = () => props.level() === "body" && props.bodyRow() === dispatcherRow();
   return (() => {
-    var _el$128 = createElement("box"), _el$129 = createElement("text"), _el$131 = createElement("text"), _el$133 = createElement("box"), _el$134 = createElement("text"), _el$144 = createElement("text"), _el$146 = createElement("box"), _el$147 = createElement("text"), _el$149 = createElement("text"), _el$151 = createElement("box"), _el$152 = createElement("text");
+    var _el$128 = createElement("box"), _el$129 = createElement("text"), _el$131 = createElement("text"), _el$133 = createElement("box"), _el$134 = createElement("text"), _el$144 = createElement("text"), _el$146 = createElement("box"), _el$147 = createElement("text"), _el$149 = createElement("text"), _el$151 = createElement("box"), _el$152 = createElement("text"), _el$153 = createElement("text"), _el$155 = createElement("box"), _el$156 = createElement("text"), _el$157 = createElement("text"), _el$159 = createElement("box"), _el$160 = createElement("text");
     insertNode(_el$128, _el$129);
     insertNode(_el$128, _el$131);
     insertNode(_el$128, _el$133);
@@ -21599,6 +22210,10 @@ function DevSettingsSection(props) {
     insertNode(_el$146, _el$147);
     insertNode(_el$146, _el$149);
     insertNode(_el$146, _el$151);
+    insertNode(_el$146, _el$153);
+    insertNode(_el$146, _el$155);
+    insertNode(_el$146, _el$157);
+    insertNode(_el$146, _el$159);
     setProp(_el$146, "flexDirection", "column");
     setProp(_el$146, "gap", 0);
     setProp(_el$146, "paddingTop", 1);
@@ -21615,8 +22230,32 @@ function DevSettingsSection(props) {
       props.toggleRemoteProjects();
     });
     insert(_el$152, () => props.remoteProjectsEnabled() ? "[x] Remote projects (on)" : "[ ] Remote projects (off)");
+    insertNode(_el$153, createTextNode(`Auto status flow: a backlog task moves to in_progress when its engine starts a turn, and new claude sessions get a system-prompt note telling the agent to set in_review itself when the work is done. Never touches done/canceled.`));
+    setProp(_el$153, "wrapMode", "word");
+    insertNode(_el$155, _el$156);
+    setProp(_el$155, "flexDirection", "row");
+    setProp(_el$155, "paddingLeft", 1);
+    setProp(_el$155, "paddingRight", 1);
+    setProp(_el$155, "onMouseUp", () => {
+      props.setLevel("body");
+      props.setBodyRow(autoStatusRow());
+      props.toggleAutoStatus();
+    });
+    insert(_el$156, () => props.autoStatusEnabled() ? "[x] Auto status flow (on)" : "[ ] Auto status flow (off)");
+    insertNode(_el$157, createTextNode(`Field-notes dispatcher: task sessions file one-line gotchas (\`kobe api note\`), the daemon forwards each to the repo's main session, and that session relays them to the in-flight tasks that benefit (\`kobe api dispatch\`). Web-hosted sessions receive the relays today.`));
+    setProp(_el$157, "wrapMode", "word");
+    insertNode(_el$159, _el$160);
+    setProp(_el$159, "flexDirection", "row");
+    setProp(_el$159, "paddingLeft", 1);
+    setProp(_el$159, "paddingRight", 1);
+    setProp(_el$159, "onMouseUp", () => {
+      props.setLevel("body");
+      props.setBodyRow(dispatcherRow());
+      props.toggleDispatcher();
+    });
+    insert(_el$160, () => props.dispatcherEnabled() ? "[x] Field-notes dispatcher (on)" : "[ ] Field-notes dispatcher (off)");
     effect((_p$) => {
-      var _v$86 = theme.text, _v$87 = TextAttributes7.BOLD, _v$88 = theme.textMuted, _v$89 = resetIsCursor() ? theme.primary : theme.backgroundElement, _v$90 = resetIsCursor() ? theme.selectedListItemText : theme.warning, _v$91 = TextAttributes7.BOLD, _v$92 = theme.textMuted, _v$93 = theme.text, _v$94 = TextAttributes7.BOLD, _v$95 = theme.textMuted, _v$96 = remoteIsCursor() ? theme.primary : theme.backgroundElement, _v$97 = remoteIsCursor() ? theme.selectedListItemText : theme.text, _v$98 = props.remoteProjectsEnabled() ? TextAttributes7.BOLD : undefined;
+      var _v$86 = theme.text, _v$87 = TextAttributes7.BOLD, _v$88 = theme.textMuted, _v$89 = resetIsCursor() ? theme.primary : theme.backgroundElement, _v$90 = resetIsCursor() ? theme.selectedListItemText : theme.warning, _v$91 = TextAttributes7.BOLD, _v$92 = theme.textMuted, _v$93 = theme.text, _v$94 = TextAttributes7.BOLD, _v$95 = theme.textMuted, _v$96 = remoteIsCursor() ? theme.primary : theme.backgroundElement, _v$97 = remoteIsCursor() ? theme.selectedListItemText : theme.text, _v$98 = props.remoteProjectsEnabled() ? TextAttributes7.BOLD : undefined, _v$99 = theme.textMuted, _v$100 = autoStatusIsCursor() ? theme.primary : theme.backgroundElement, _v$101 = autoStatusIsCursor() ? theme.selectedListItemText : theme.text, _v$102 = props.autoStatusEnabled() ? TextAttributes7.BOLD : undefined, _v$103 = theme.textMuted, _v$104 = dispatcherIsCursor() ? theme.primary : theme.backgroundElement, _v$105 = dispatcherIsCursor() ? theme.selectedListItemText : theme.text, _v$106 = props.dispatcherEnabled() ? TextAttributes7.BOLD : undefined;
       _v$86 !== _p$.e && (_p$.e = setProp(_el$129, "fg", _v$86, _p$.e));
       _v$87 !== _p$.t && (_p$.t = setProp(_el$129, "attributes", _v$87, _p$.t));
       _v$88 !== _p$.a && (_p$.a = setProp(_el$131, "fg", _v$88, _p$.a));
@@ -21630,6 +22269,14 @@ function DevSettingsSection(props) {
       _v$96 !== _p$.l && (_p$.l = setProp(_el$151, "backgroundColor", _v$96, _p$.l));
       _v$97 !== _p$.u && (_p$.u = setProp(_el$152, "fg", _v$97, _p$.u));
       _v$98 !== _p$.c && (_p$.c = setProp(_el$152, "attributes", _v$98, _p$.c));
+      _v$99 !== _p$.w && (_p$.w = setProp(_el$153, "fg", _v$99, _p$.w));
+      _v$100 !== _p$.m && (_p$.m = setProp(_el$155, "backgroundColor", _v$100, _p$.m));
+      _v$101 !== _p$.f && (_p$.f = setProp(_el$156, "fg", _v$101, _p$.f));
+      _v$102 !== _p$.y && (_p$.y = setProp(_el$156, "attributes", _v$102, _p$.y));
+      _v$103 !== _p$.g && (_p$.g = setProp(_el$157, "fg", _v$103, _p$.g));
+      _v$104 !== _p$.p && (_p$.p = setProp(_el$159, "backgroundColor", _v$104, _p$.p));
+      _v$105 !== _p$.b && (_p$.b = setProp(_el$160, "fg", _v$105, _p$.b));
+      _v$106 !== _p$.T && (_p$.T = setProp(_el$160, "attributes", _v$106, _p$.T));
       return _p$;
     }, {
       e: undefined,
@@ -21644,7 +22291,15 @@ function DevSettingsSection(props) {
       d: undefined,
       l: undefined,
       u: undefined,
-      c: undefined
+      c: undefined,
+      w: undefined,
+      m: undefined,
+      f: undefined,
+      y: undefined,
+      g: undefined,
+      p: undefined,
+      b: undefined,
+      T: undefined
     });
     return _el$128;
   })();
@@ -21656,63 +22311,63 @@ function KeybindingsSettingsSection() {
   const report = userKeybindingsReport();
   const fixedIds = Object.keys(FIXED_BINDING_IDS).sort();
   return (() => {
-    var _el$153 = createElement("box"), _el$154 = createElement("text"), _el$156 = createElement("text"), _el$158 = createElement("box"), _el$159 = createElement("text"), _el$161 = createElement("text"), _el$189 = createElement("text"), _el$191 = createElement("text");
-    insertNode(_el$153, _el$154);
-    insertNode(_el$153, _el$156);
-    insertNode(_el$153, _el$158);
-    insertNode(_el$153, _el$189);
-    insertNode(_el$153, _el$191);
-    setProp(_el$153, "flexDirection", "column");
-    setProp(_el$153, "gap", 1);
-    insertNode(_el$154, createTextNode(`Keybindings`));
-    insertNode(_el$156, createTextNode(`Rebind chords by editing the YAML below, then restart kobe (or respawn the pane). Press F1 anywhere for the live keymap with every binding id.`));
-    setProp(_el$156, "wrapMode", "word");
-    insertNode(_el$158, _el$159);
-    insertNode(_el$158, _el$161);
-    setProp(_el$158, "flexDirection", "column");
-    setProp(_el$158, "gap", 0);
-    insertNode(_el$159, createTextNode(`Config file`));
-    setProp(_el$161, "wrapMode", "word");
-    insert(_el$161, () => report.path, null);
-    insert(_el$161, () => report.exists ? "" : "  (not created yet)", null);
-    insert(_el$153, createComponent2(Show, {
+    var _el$161 = createElement("box"), _el$162 = createElement("text"), _el$164 = createElement("text"), _el$166 = createElement("box"), _el$167 = createElement("text"), _el$169 = createElement("text"), _el$197 = createElement("text"), _el$199 = createElement("text");
+    insertNode(_el$161, _el$162);
+    insertNode(_el$161, _el$164);
+    insertNode(_el$161, _el$166);
+    insertNode(_el$161, _el$197);
+    insertNode(_el$161, _el$199);
+    setProp(_el$161, "flexDirection", "column");
+    setProp(_el$161, "gap", 1);
+    insertNode(_el$162, createTextNode(`Keybindings`));
+    insertNode(_el$164, createTextNode(`Rebind chords by editing the YAML below, then restart kobe (or respawn the pane). Press F1 anywhere for the live keymap with every binding id.`));
+    setProp(_el$164, "wrapMode", "word");
+    insertNode(_el$166, _el$167);
+    insertNode(_el$166, _el$169);
+    setProp(_el$166, "flexDirection", "column");
+    setProp(_el$166, "gap", 0);
+    insertNode(_el$167, createTextNode(`Config file`));
+    setProp(_el$169, "wrapMode", "word");
+    insert(_el$169, () => report.path, null);
+    insert(_el$169, () => report.exists ? "" : "  (not created yet)", null);
+    insert(_el$161, createComponent2(Show, {
       get when() {
         return !report.exists;
       },
       get children() {
-        var _el$162 = createElement("box"), _el$163 = createElement("text"), _el$165 = createElement("text"), _el$167 = createElement("text"), _el$169 = createElement("text"), _el$171 = createElement("text"), _el$173 = createElement("text"), _el$175 = createElement("text"), _el$177 = createElement("text"), _el$179 = createElement("text");
-        insertNode(_el$162, _el$163);
-        insertNode(_el$162, _el$165);
-        insertNode(_el$162, _el$167);
-        insertNode(_el$162, _el$169);
-        insertNode(_el$162, _el$171);
-        insertNode(_el$162, _el$173);
-        insertNode(_el$162, _el$175);
-        insertNode(_el$162, _el$177);
-        insertNode(_el$162, _el$179);
-        setProp(_el$162, "flexDirection", "column");
-        setProp(_el$162, "gap", 0);
-        insertNode(_el$163, createTextNode(`Example`));
-        insertNode(_el$165, createTextNode(`bindings:`));
-        insertNode(_el$167, createTextNode(`  chat.fork.new: ctrl+g      # string = one chord`));
-        insertNode(_el$169, createTextNode(`  sidebar.select: [enter]    # list = several chords`));
-        insertNode(_el$171, createTextNode(`  files.createPR: null       # null = unbind`));
-        insertNode(_el$173, createTextNode(`  tmux.tab.new: ctrl+y       # tmux session key (see below)`));
-        insertNode(_el$175, createTextNode(`darwin:                      # platform overlay (also: linux)`));
-        insertNode(_el$177, createTextNode(`  bindings:`));
-        insertNode(_el$179, createTextNode(`    palette.open: [cmd+p, ctrl+p]`));
+        var _el$170 = createElement("box"), _el$171 = createElement("text"), _el$173 = createElement("text"), _el$175 = createElement("text"), _el$177 = createElement("text"), _el$179 = createElement("text"), _el$181 = createElement("text"), _el$183 = createElement("text"), _el$185 = createElement("text"), _el$187 = createElement("text");
+        insertNode(_el$170, _el$171);
+        insertNode(_el$170, _el$173);
+        insertNode(_el$170, _el$175);
+        insertNode(_el$170, _el$177);
+        insertNode(_el$170, _el$179);
+        insertNode(_el$170, _el$181);
+        insertNode(_el$170, _el$183);
+        insertNode(_el$170, _el$185);
+        insertNode(_el$170, _el$187);
+        setProp(_el$170, "flexDirection", "column");
+        setProp(_el$170, "gap", 0);
+        insertNode(_el$171, createTextNode(`Example`));
+        insertNode(_el$173, createTextNode(`bindings:`));
+        insertNode(_el$175, createTextNode(`  chat.fork.new: ctrl+g      # string = one chord`));
+        insertNode(_el$177, createTextNode(`  sidebar.select: [enter]    # list = several chords`));
+        insertNode(_el$179, createTextNode(`  files.createPR: null       # null = unbind`));
+        insertNode(_el$181, createTextNode(`  tmux.tab.new: ctrl+y       # tmux session key (see below)`));
+        insertNode(_el$183, createTextNode(`darwin:                      # platform overlay (also: linux)`));
+        insertNode(_el$185, createTextNode(`  bindings:`));
+        insertNode(_el$187, createTextNode(`    palette.open: [cmd+p, ctrl+p]`));
         effect((_p$) => {
-          var _v$99 = theme.text, _v$100 = TextAttributes7.BOLD, _v$101 = theme.textMuted, _v$102 = theme.textMuted, _v$103 = theme.textMuted, _v$104 = theme.textMuted, _v$105 = theme.textMuted, _v$106 = theme.textMuted, _v$107 = theme.textMuted, _v$108 = theme.textMuted;
-          _v$99 !== _p$.e && (_p$.e = setProp(_el$163, "fg", _v$99, _p$.e));
-          _v$100 !== _p$.t && (_p$.t = setProp(_el$163, "attributes", _v$100, _p$.t));
-          _v$101 !== _p$.a && (_p$.a = setProp(_el$165, "fg", _v$101, _p$.a));
-          _v$102 !== _p$.o && (_p$.o = setProp(_el$167, "fg", _v$102, _p$.o));
-          _v$103 !== _p$.i && (_p$.i = setProp(_el$169, "fg", _v$103, _p$.i));
-          _v$104 !== _p$.n && (_p$.n = setProp(_el$171, "fg", _v$104, _p$.n));
-          _v$105 !== _p$.s && (_p$.s = setProp(_el$173, "fg", _v$105, _p$.s));
-          _v$106 !== _p$.h && (_p$.h = setProp(_el$175, "fg", _v$106, _p$.h));
-          _v$107 !== _p$.r && (_p$.r = setProp(_el$177, "fg", _v$107, _p$.r));
-          _v$108 !== _p$.d && (_p$.d = setProp(_el$179, "fg", _v$108, _p$.d));
+          var _v$107 = theme.text, _v$108 = TextAttributes7.BOLD, _v$109 = theme.textMuted, _v$110 = theme.textMuted, _v$111 = theme.textMuted, _v$112 = theme.textMuted, _v$113 = theme.textMuted, _v$114 = theme.textMuted, _v$115 = theme.textMuted, _v$116 = theme.textMuted;
+          _v$107 !== _p$.e && (_p$.e = setProp(_el$171, "fg", _v$107, _p$.e));
+          _v$108 !== _p$.t && (_p$.t = setProp(_el$171, "attributes", _v$108, _p$.t));
+          _v$109 !== _p$.a && (_p$.a = setProp(_el$173, "fg", _v$109, _p$.a));
+          _v$110 !== _p$.o && (_p$.o = setProp(_el$175, "fg", _v$110, _p$.o));
+          _v$111 !== _p$.i && (_p$.i = setProp(_el$177, "fg", _v$111, _p$.i));
+          _v$112 !== _p$.n && (_p$.n = setProp(_el$179, "fg", _v$112, _p$.n));
+          _v$113 !== _p$.s && (_p$.s = setProp(_el$181, "fg", _v$113, _p$.s));
+          _v$114 !== _p$.h && (_p$.h = setProp(_el$183, "fg", _v$114, _p$.h));
+          _v$115 !== _p$.r && (_p$.r = setProp(_el$185, "fg", _v$115, _p$.r));
+          _v$116 !== _p$.d && (_p$.d = setProp(_el$187, "fg", _v$116, _p$.d));
           return _p$;
         }, {
           e: undefined,
@@ -21726,102 +22381,102 @@ function KeybindingsSettingsSection() {
           r: undefined,
           d: undefined
         });
-        return _el$162;
+        return _el$170;
       }
-    }), _el$189);
-    insert(_el$153, createComponent2(Show, {
+    }), _el$197);
+    insert(_el$161, createComponent2(Show, {
       get when() {
         return report.exists;
       },
       get children() {
-        var _el$181 = createElement("box"), _el$182 = createElement("text");
-        insertNode(_el$181, _el$182);
-        setProp(_el$181, "flexDirection", "column");
-        setProp(_el$181, "gap", 0);
-        insertNode(_el$182, createTextNode(`Overrides applied`));
-        insert(_el$181, createComponent2(Show, {
+        var _el$189 = createElement("box"), _el$190 = createElement("text");
+        insertNode(_el$189, _el$190);
+        setProp(_el$189, "flexDirection", "column");
+        setProp(_el$189, "gap", 0);
+        insertNode(_el$190, createTextNode(`Overrides applied`));
+        insert(_el$189, createComponent2(Show, {
           get when() {
             return report.applied.length === 0;
           },
           get children() {
-            var _el$184 = createElement("text");
-            insertNode(_el$184, createTextNode(`none`));
-            effect((_$p) => setProp(_el$184, "fg", theme.textMuted, _$p));
-            return _el$184;
+            var _el$192 = createElement("text");
+            insertNode(_el$192, createTextNode(`none`));
+            effect((_$p) => setProp(_el$192, "fg", theme.textMuted, _$p));
+            return _el$192;
           }
         }), null);
-        insert(_el$181, createComponent2(For, {
+        insert(_el$189, createComponent2(For, {
           get each() {
             return report.applied;
           },
           children: (o) => (() => {
-            var _el$192 = createElement("text");
-            setProp(_el$192, "wrapMode", "word");
-            insert(_el$192, () => `${o.id} \u2192 ${o.keys.length > 0 ? o.keys.join(" / ") : "(unbound)"}  (default: ${o.defaultKeys.join(" / ")})`);
-            effect((_$p) => setProp(_el$192, "fg", theme.text, _$p));
-            return _el$192;
+            var _el$200 = createElement("text");
+            setProp(_el$200, "wrapMode", "word");
+            insert(_el$200, () => `${o.id} \u2192 ${o.keys.length > 0 ? o.keys.join(" / ") : "(unbound)"}  (default: ${o.defaultKeys.join(" / ")})`);
+            effect((_$p) => setProp(_el$200, "fg", theme.text, _$p));
+            return _el$200;
           })()
         }), null);
         effect((_p$) => {
-          var _v$109 = theme.text, _v$110 = TextAttributes7.BOLD;
-          _v$109 !== _p$.e && (_p$.e = setProp(_el$182, "fg", _v$109, _p$.e));
-          _v$110 !== _p$.t && (_p$.t = setProp(_el$182, "attributes", _v$110, _p$.t));
+          var _v$117 = theme.text, _v$118 = TextAttributes7.BOLD;
+          _v$117 !== _p$.e && (_p$.e = setProp(_el$190, "fg", _v$117, _p$.e));
+          _v$118 !== _p$.t && (_p$.t = setProp(_el$190, "attributes", _v$118, _p$.t));
           return _p$;
         }, {
           e: undefined,
           t: undefined
         });
-        return _el$181;
+        return _el$189;
       }
-    }), _el$189);
-    insert(_el$153, createComponent2(Show, {
+    }), _el$197);
+    insert(_el$161, createComponent2(Show, {
       get when() {
         return report.warnings.length > 0;
       },
       get children() {
-        var _el$186 = createElement("box"), _el$187 = createElement("text");
-        insertNode(_el$186, _el$187);
-        setProp(_el$186, "flexDirection", "column");
-        setProp(_el$186, "gap", 0);
-        insertNode(_el$187, createTextNode(`Warnings`));
-        insert(_el$186, createComponent2(For, {
+        var _el$194 = createElement("box"), _el$195 = createElement("text");
+        insertNode(_el$194, _el$195);
+        setProp(_el$194, "flexDirection", "column");
+        setProp(_el$194, "gap", 0);
+        insertNode(_el$195, createTextNode(`Warnings`));
+        insert(_el$194, createComponent2(For, {
           get each() {
             return report.warnings;
           },
           children: (w) => (() => {
-            var _el$193 = createElement("text");
-            setProp(_el$193, "wrapMode", "word");
-            insert(_el$193, `! ${w}`);
-            effect((_$p) => setProp(_el$193, "fg", theme.warning, _$p));
-            return _el$193;
+            var _el$201 = createElement("text");
+            setProp(_el$201, "wrapMode", "word");
+            insert(_el$201, `! ${w}`);
+            effect((_$p) => setProp(_el$201, "fg", theme.warning, _$p));
+            return _el$201;
           })()
         }), null);
         effect((_p$) => {
-          var _v$111 = theme.warning, _v$112 = TextAttributes7.BOLD;
-          _v$111 !== _p$.e && (_p$.e = setProp(_el$187, "fg", _v$111, _p$.e));
-          _v$112 !== _p$.t && (_p$.t = setProp(_el$187, "attributes", _v$112, _p$.t));
+          var _v$119 = theme.warning, _v$120 = TextAttributes7.BOLD;
+          _v$119 !== _p$.e && (_p$.e = setProp(_el$195, "fg", _v$119, _p$.e));
+          _v$120 !== _p$.t && (_p$.t = setProp(_el$195, "attributes", _v$120, _p$.t));
           return _p$;
         }, {
           e: undefined,
           t: undefined
         });
-        return _el$186;
+        return _el$194;
       }
-    }), _el$189);
-    insertNode(_el$189, createTextNode(`tmux session keys use the same file: tmux.tab.new (ctrl+t), tmux.tab.prev/next (ctrl+[/]), tmux.tab.close (ctrl+w), tmux.tab.rename (f2), tmux.tab.chooseEngine (ctrl+shift+t), tmux.detach (ctrl+q), tmux.focus (4 chords, left/down/up/right). They apply when a session is (re)built.`));
-    setProp(_el$189, "wrapMode", "word");
-    setProp(_el$191, "wrapMode", "word");
-    insert(_el$191, () => `Fixed (not rebindable): ${fixedIds.join(", ")}.`);
+    }), _el$197);
+    insertNode(_el$197, createTextNode(`tmux session keys use the same file: tmux.tab.new (ctrl+t), tmux.tab.prev/next (ctrl+[/]), tmux.tab.close (ctrl+w), tmux.tab.rename (f2), tmux.tab.chooseEngine (ctrl+shift+t), tmux.detach (ctrl+q), tmux.focus (4 chords, left/down/up/right). They apply when a session is (re)built.`));
+    setProp(_el$197, "wrapMode", "word");
+    setProp(_el$199, "wrapMode", "word");
+    insert(_el$199, () => `Fixed (not rebindable): ${fixedIds.join(", ")}.`);
     effect((_p$) => {
-      var _v$113 = theme.text, _v$114 = TextAttributes7.BOLD, _v$115 = theme.textMuted, _v$116 = theme.text, _v$117 = TextAttributes7.BOLD, _v$118 = theme.textMuted, _v$119 = theme.textMuted, _v$120 = theme.textMuted;
-      _v$113 !== _p$.e && (_p$.e = setProp(_el$154, "fg", _v$113, _p$.e));
-      _v$114 !== _p$.t && (_p$.t = setProp(_el$154, "attributes", _v$114, _p$.t));
-      _v$115 !== _p$.a && (_p$.a = setProp(_el$156, "fg", _v$115, _p$.a));
-      _v$116 !== _p$.o && (_p$.o = setProp(_el$159, "fg", _v$116, _p$.o));
-      _v$117 !== _p$.i && (_p$.i = setProp(_el$159, "attributes", _v$117, _p$.i));
-      _v$118 !== _p$.n && (_p$.n = setProp(_el$161, "fg", _v$118, _p$.n));
-      _v$119 !== _p$.s && (_p$.s = setProp(_el$189, "fg", _v$119, _p$.s));
-      _v$120 !== _p$.h && (_p$.h = setProp(_el$191, "fg", _v$120, _p$.h));
+      var _v$121 = theme.text, _v$122 = TextAttributes7.BOLD, _v$123 = theme.textMuted, _v$124 = theme.text, _v$125 = TextAttributes7.BOLD, _v$126 = theme.textMuted, _v$127 = theme.textMuted, _v$128 = theme.textMuted;
+      _v$121 !== _p$.e && (_p$.e = setProp(_el$162, "fg", _v$121, _p$.e));
+      _v$122 !== _p$.t && (_p$.t = setProp(_el$162, "attributes", _v$122, _p$.t));
+      _v$123 !== _p$.a && (_p$.a = setProp(_el$164, "fg", _v$123, _p$.a));
+      _v$124 !== _p$.o && (_p$.o = setProp(_el$167, "fg", _v$124, _p$.o));
+      _v$125 !== _p$.i && (_p$.i = setProp(_el$167, "attributes", _v$125, _p$.i));
+      _v$126 !== _p$.n && (_p$.n = setProp(_el$169, "fg", _v$126, _p$.n));
+      _v$127 !== _p$.s && (_p$.s = setProp(_el$197, "fg", _v$127, _p$.s));
+      _v$128 !== _p$.h && (_p$.h = setProp(_el$199, "fg", _v$128, _p$.h));
       return _p$;
     }, {
       e: undefined,
@@ -21833,7 +22488,7 @@ function KeybindingsSettingsSection() {
       s: undefined,
       h: undefined
     });
-    return _el$153;
+    return _el$161;
   })();
 }
 var init_sections = __esm(() => {
@@ -21946,6 +22601,18 @@ function SettingsDialog(props) {
   function toggleRemoteProjects() {
     props.kv.set("experimental.remoteProjects", !remoteProjectsEnabled());
   }
+  function autoStatusOn() {
+    return props.kv.get(AUTO_STATUS_KEY, false) === true;
+  }
+  function toggleAutoStatus() {
+    props.kv.set(AUTO_STATUS_KEY, !autoStatusOn());
+  }
+  function dispatcherOn() {
+    return props.kv.get(DISPATCHER_KEY, false) === true;
+  }
+  function toggleDispatcher() {
+    props.kv.set(DISPATCHER_KEY, !dispatcherOn());
+  }
   function customEngines() {
     const raw = props.kv.get("customEngineIds", []);
     return Array.isArray(raw) ? raw.filter((s) => typeof s === "string" && s.trim().length > 0) : [];
@@ -22163,7 +22830,9 @@ function SettingsDialog(props) {
     feedbackSend: () => void sendFeedback(),
     devReset: () => void confirmResetState(dialog, props.kv, renderer),
     devRestartDaemon: () => void confirmRestartDaemon(dialog, props.orchestrator, renderer),
-    devRemoteProjects: () => toggleRemoteProjects()
+    devRemoteProjects: () => toggleRemoteProjects(),
+    devAutoStatus: () => toggleAutoStatus(),
+    devDispatcher: () => toggleDispatcher()
   };
   function activateBodyRow() {
     const row = rowAt(bodyRows(), bodyRow());
@@ -22369,7 +23038,11 @@ function SettingsDialog(props) {
           confirmReset: () => void confirmResetState(dialog, props.kv, renderer),
           confirmRestartDaemon: () => void confirmRestartDaemon(dialog, props.orchestrator, renderer),
           remoteProjectsEnabled,
-          toggleRemoteProjects
+          toggleRemoteProjects,
+          autoStatusEnabled: autoStatusOn,
+          toggleAutoStatus,
+          dispatcherEnabled: dispatcherOn,
+          toggleDispatcher
         });
       }
     }), null);
@@ -22405,6 +23078,8 @@ var init_settings_dialog = __esm(() => {
   init_account_detect();
   init_interactive_command();
   init_feedback();
+  init_auto_status();
+  init_dispatcher();
   init_repos();
   init_vendor();
   init_theme2();
@@ -26800,7 +27475,7 @@ var init_filetree = __esm(() => {
 // src/tui/ops/pr-prompt.ts
 import { promises as fs6 } from "fs";
 import path12 from "path";
-async function git(cwd, args2) {
+async function git2(cwd, args2) {
   const controller = new AbortController;
   const timer = setTimeout(() => controller.abort(), GIT_TIMEOUT_MS2);
   try {
@@ -26819,20 +27494,20 @@ async function git(cwd, args2) {
   }
 }
 async function currentBranch2(cwd) {
-  return await git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]) || "HEAD";
+  return await git2(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]) || "HEAD";
 }
 async function targetBranch(cwd) {
-  const out = await git(cwd, ["symbolic-ref", "refs/remotes/origin/HEAD", "--short"]);
+  const out = await git2(cwd, ["symbolic-ref", "refs/remotes/origin/HEAD", "--short"]);
   if (!out)
     return "main";
   return out.startsWith("origin/") ? out.slice("origin/".length) : out;
 }
 async function hasUpstream(cwd) {
-  const out = await git(cwd, ["rev-parse", "--abbrev-ref", "@{u}"]);
+  const out = await git2(cwd, ["rev-parse", "--abbrev-ref", "@{u}"]);
   return out !== null && out.length > 0;
 }
 async function dirtyCount(cwd) {
-  const out = await git(cwd, ["status", "--porcelain"]);
+  const out = await git2(cwd, ["status", "--porcelain"]);
   if (!out)
     return 0;
   return out.split(`