@sma1lboy/kobe 0.7.32 → 0.7.33

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.32",
+    version: "0.7.33",
     description: "TUI orchestrator for Claude Code (codename)",
     type: "module",
     packageManager: "bun@1.3.13",
@@ -5259,6 +5259,14 @@ function kobeCliInvocation() {
 var init_invocation = () => {};
 
 // src/tmux/session-layout.ts
+function hiddenTerminalSessionName(session) {
+  const safe = session.replace(/[^A-Za-z0-9_-]/g, "");
+  return `kobe-hidden-${safe || "session"}`;
+}
+function hiddenTerminalWindowIndex(windowId) {
+  const n = Number.parseInt(windowId.replace(/^@/, ""), 10);
+  return Number.isFinite(n) && n >= 0 ? 1000 + n : 1000;
+}
 function clampTasksPaneWidth(width) {
   if (!Number.isFinite(width))
     return TASKS_PANE_WIDTH;
@@ -5339,7 +5347,7 @@ function opsPaneCommand(args) {
   }
   return fallbackOpsScript(args.cwd);
 }
-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;
+var TASKS_PANE_WIDTH = 32, TASKS_PANE_ROLE = "tasks", ENGINE_PANE_ROLE = "claude", OPS_PANE_ROLE = "ops", SHELL_PANE_ROLE = "shell", WORKSPACE_AUX_PANE_ROLE = "workspace_aux", WORKSPACE_SPLIT_MAX_PANES = 4, HIDDEN_TERMINAL_PANE_OPTION = "@kobe_hidden_shell_pane", HIDDEN_TASKS_PANE_OPTION = "@kobe_hidden_tasks_pane", 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 readFile3, writeFile as writeFile3 } from "fs/promises";
@@ -6751,6 +6759,11 @@ async function currentSessionName() {
   return code === 0 && name.length > 0 ? name : null;
 }
 async function killSession(name) {
+  if (!name.startsWith("kobe-hidden-")) {
+    const hidden = hiddenTerminalSessionName(name);
+    if (await sessionExists(hidden))
+      await runTmux(["kill-session", "-t", `=${hidden}`]);
+  }
   if (await sessionExists(name))
     await runTmux(["kill-session", "-t", `=${name}`]);
 }
@@ -9407,7 +9420,10 @@ var init_keymap_overrides = __esm(() => {
 });
 
 // src/tmux/keybindings.ts
-function chordToTmuxKey(chord) {
+function isTmuxPrefixBindingId(id) {
+  return id in TMUX_PREFIX_BINDING_DEFAULTS;
+}
+function chordToTmuxKey(chord, opts) {
   const parts = chord.split("+");
   let key = parts.pop() ?? "";
   if (key === "" && parts.length > 0) {
@@ -9429,7 +9445,7 @@ function chordToTmuxKey(chord) {
     tmuxKey = named;
   }
   const isFKey = /^f\d+$/.test(key);
-  if (mods.size === 0 && !isFKey) {
+  if (mods.size === 0 && !isFKey && !opts?.allowBare) {
     return {
       error: `"${chord}": tmux session keys are no-prefix root bindings live in every pane \u2014 a bare key would shadow typing (add a modifier, or use an F-key)`
     };
@@ -9446,7 +9462,7 @@ function chordToTmuxKey(chord) {
 function defaultResolution() {
   const binds = {};
   for (const [id, chord] of Object.entries(TMUX_SINGLE_BINDING_DEFAULTS)) {
-    const t = chordToTmuxKey(chord);
+    const t = chordToTmuxKey(chord, { allowBare: isTmuxPrefixBindingId(id) });
     if ("error" in t)
       throw new Error(`default tmux chord for ${id} failed to translate: ${t.error}`);
     binds[id] = { chord, key: t.key };
@@ -9506,7 +9522,7 @@ function resolveTmuxKeyEntries(entries) {
       res.warnings.push(`${id}: tmux bindings take ONE chord \u2014 using "${entry.keys[0]}", ignoring the rest`);
     }
     const chord = entry.keys[0];
-    const t = chordToTmuxKey(chord);
+    const t = chordToTmuxKey(chord, { allowBare: isTmuxPrefixBindingId(id) });
     if ("error" in t) {
       res.warnings.push(`${id}: ${t.error} \u2014 keeping the default`);
       continue;
@@ -9541,11 +9557,11 @@ function resolveUserTmuxKeys() {
   cached2 = res;
   return cached2;
 }
-var TMUX_SINGLE_BINDING_DEFAULTS, TMUX_FOCUS_ID = "tmux.focus", TMUX_FOCUS_DEFAULTS, TMUX_NAMED_KEYS, cached2 = null;
+var TMUX_ROOT_BINDING_DEFAULTS, TMUX_PREFIX_BINDING_DEFAULTS, TMUX_LEGACY_LAYOUT_ROOT_KEYS, TMUX_SINGLE_BINDING_DEFAULTS, TMUX_FOCUS_ID = "tmux.focus", TMUX_FOCUS_DEFAULTS, TMUX_NAMED_KEYS, cached2 = null;
 var init_keybindings = __esm(() => {
   init_keybindings_file();
   init_keymap_overrides();
-  TMUX_SINGLE_BINDING_DEFAULTS = {
+  TMUX_ROOT_BINDING_DEFAULTS = {
     "tmux.detach": "ctrl+q",
     "tmux.tab.new": "ctrl+t",
     "tmux.tab.chooseEngine": "ctrl+shift+t",
@@ -9554,6 +9570,19 @@ var init_keybindings = __esm(() => {
     "tmux.tab.close": "ctrl+w",
     "tmux.tab.rename": "f2"
   };
+  TMUX_PREFIX_BINDING_DEFAULTS = {
+    "tmux.layout.workspaceSplit": "s",
+    "tmux.layout.workspaceClose": "x",
+    "tmux.layout.workspaceReset": "r",
+    "tmux.layout.tasksToggle": "a",
+    "tmux.layout.opsToggle": "o",
+    "tmux.layout.terminalToggle": "z"
+  };
+  TMUX_LEGACY_LAYOUT_ROOT_KEYS = ["F6", "F7", "F8", "F9", "F10", "F11"];
+  TMUX_SINGLE_BINDING_DEFAULTS = {
+    ...TMUX_ROOT_BINDING_DEFAULTS,
+    ...TMUX_PREFIX_BINDING_DEFAULTS
+  };
   TMUX_FOCUS_DEFAULTS = ["ctrl+h", "ctrl+j", "ctrl+k", "ctrl+l"];
   TMUX_NAMED_KEYS = {
     up: "Up",
@@ -11400,7 +11429,7 @@ async function captureGlobalLayout(session) {
     "-t",
     `=${session}`,
     "-F",
-    "#{@kobe_role}\t#{pane_width}\t#{pane_height}\t#{window_width}\t#{window_height}\t#{window_zoomed_flag}"
+    `#{@kobe_role}	#{pane_width}	#{pane_height}	#{window_width}	#{window_height}	#{window_zoomed_flag}	#{${HIDDEN_TERMINAL_PANE_OPTION}}	#{${HIDDEN_TASKS_PANE_OPTION}}`
   ]);
   if (code !== 0)
     return;
@@ -11410,6 +11439,10 @@ async function captureGlobalLayout(session) {
     return;
   if (rows.some((cols) => cols[5]?.trim() === "1"))
     return;
+  if (rows.some((cols) => (cols[6]?.trim() ?? "") !== ""))
+    return;
+  if (rows.some((cols) => (cols[7]?.trim() ?? "") !== ""))
+    return;
   const winW = Number.parseInt(rows[0][3]?.trim() ?? "", 10);
   const winH = Number.parseInt(rows[0][4]?.trim() ?? "", 10);
   const sets = [];
@@ -11440,6 +11473,10 @@ function shouldCaptureDrag(stdout) {
     return false;
   if (rows.some((cols) => cols[1]?.trim() === "1"))
     return false;
+  if (rows.some((cols) => (cols[2]?.trim() ?? "") !== ""))
+    return false;
+  if (rows.some((cols) => (cols[3]?.trim() ?? "") !== ""))
+    return false;
   const roles = new Set(rows.map((cols) => cols[0]?.trim()));
   return roles.has("tasks") && roles.has("ops");
 }
@@ -11449,7 +11486,7 @@ async function captureGlobalLayoutOnDrag(session) {
     "-t",
     `=${session}`,
     "-F",
-    "#{@kobe_role}\t#{window_zoomed_flag}"
+    `#{@kobe_role}	#{window_zoomed_flag}	#{${HIDDEN_TERMINAL_PANE_OPTION}}	#{${HIDDEN_TASKS_PANE_OPTION}}`
   ]);
   if (code !== 0 || !shouldCaptureDrag(stdout))
     return;
@@ -11492,7 +11529,7 @@ function chatTabSwitchBindings(prevKey, nextKey) {
     ["bind-key", "-n", nextKey, "next-window"]
   ];
 }
-function chatTabCloseBinding(key) {
+function chatTabCloseBinding(key, closeCommand = "kill-window") {
   return [
     "bind-key",
     "-n",
@@ -11500,7 +11537,7 @@ function chatTabCloseBinding(key) {
     "if-shell",
     "-F",
     "#{>:#{session_windows},1}",
-    "kill-window",
+    closeCommand,
     "display-message 'Cannot close the only ChatTab'"
   ];
 }
@@ -11520,7 +11557,9 @@ function kobeStatusRight(keys) {
   const segments = [
     keys.focusLeft ? `${tmuxKeyCap(keys.focusLeft)} tasks` : null,
     keys.detach ? `${tmuxKeyCap(keys.detach)} detach` : null,
-    keys.newTab ? `${tmuxKeyCap(keys.newTab)} tab` : null
+    keys.newTab ? `${tmuxKeyCap(keys.newTab)} tab` : null,
+    keys.layoutSplits ? `prefix ${keys.layoutSplits} splits` : null,
+    keys.layoutPanes ? `prefix ${keys.layoutPanes} panes` : null
   ].filter((s) => s !== null);
   return `#[fg=brightblack]${segments.join("  ")} `;
 }
@@ -11566,16 +11605,27 @@ async function buildPanesAround(claudePane, args) {
       "ops=#{pane_id}",
       opsCmd
     ],
-    ["split-window", "-v", "-l", `${100 - OPS_PANE_PERCENT}%`, "-c", localSpawnCwd(args.cwd)],
+    [
+      "split-window",
+      "-v",
+      "-l",
+      `${100 - OPS_PANE_PERCENT}%`,
+      "-c",
+      localSpawnCwd(args.cwd),
+      "-P",
+      "-F",
+      "shell=#{pane_id}"
+    ],
     ["select-pane", "-t", claudePane]
   ]);
   const ids = Object.fromEntries(stdout.split(`
 `).map((line) => line.trim()).filter(Boolean).map((line) => line.split("=", 2)));
   await runTmuxSequence([
-    ...ids.tasks ? [["set-option", "-p", "-t", ids.tasks, "@kobe_role", "tasks"]] : [],
+    ...ids.tasks ? [["set-option", "-p", "-t", ids.tasks, "@kobe_role", TASKS_PANE_ROLE]] : [],
     ...ids.tasks ? [["set-option", "-p", "-t", ids.tasks, PANE_VERSION_OPTION, CURRENT_VERSION]] : [],
-    ...ids.ops ? [["set-option", "-p", "-t", ids.ops, "@kobe_role", "ops"]] : [],
-    ...ids.ops ? [["set-option", "-p", "-t", ids.ops, PANE_VERSION_OPTION, CURRENT_VERSION]] : []
+    ...ids.ops ? [["set-option", "-p", "-t", ids.ops, "@kobe_role", OPS_PANE_ROLE]] : [],
+    ...ids.ops ? [["set-option", "-p", "-t", ids.ops, PANE_VERSION_OPTION, CURRENT_VERSION]] : [],
+    ...ids.shell ? [["set-option", "-p", "-t", ids.shell, "@kobe_role", SHELL_PANE_ROLE]] : []
   ]);
   if (ids.ops) {
     const rcArgs = await globalRightColumnResizeArgs();
@@ -11700,6 +11750,644 @@ var init_chattab = __esm(() => {
   CHAT_TAB_STATUS_CURRENT_FORMAT = CHAT_TAB_STATUS_FORMAT;
 });
 
+// src/tui/panes/terminal/layout-actions.ts
+function parseLayoutPaneRows(stdout) {
+  const rows = [];
+  for (const raw of stdout.split(`
+`)) {
+    const line = raw.trim();
+    if (!line)
+      continue;
+    const [paneId, role, active, paneWidth, paneHeight, windowWidth, windowHeight] = line.split("\t");
+    if (!paneId)
+      continue;
+    const width = Number.parseInt(paneWidth ?? "", 10);
+    const height = Number.parseInt(paneHeight ?? "", 10);
+    const winW = Number.parseInt(windowWidth ?? "", 10);
+    const winH = Number.parseInt(windowHeight ?? "", 10);
+    rows.push({
+      paneId: paneId.trim(),
+      role: role?.trim() ?? "",
+      active: active?.trim() === "1",
+      paneWidth: Number.isFinite(width) ? width : 0,
+      paneHeight: Number.isFinite(height) ? height : 0,
+      windowWidth: Number.isFinite(winW) ? winW : 0,
+      windowHeight: Number.isFinite(winH) ? winH : 0
+    });
+  }
+  return rows;
+}
+function planWorkspaceSplit(rows) {
+  const engine = rows.find((row) => row.role === ENGINE_PANE_ROLE);
+  if (!engine)
+    return { kind: "missing-engine" };
+  const aux = rows.filter((row) => row.role === WORKSPACE_AUX_PANE_ROLE);
+  if (aux.length + 1 >= WORKSPACE_SPLIT_MAX_PANES)
+    return { kind: "maxed" };
+  if (aux.length === 0)
+    return { kind: "split", targetPane: engine.paneId, direction: "-h" };
+  if (aux.length === 1)
+    return { kind: "split", targetPane: aux[0]?.paneId ?? engine.paneId, direction: "-v" };
+  return { kind: "split", targetPane: engine.paneId, direction: "-v" };
+}
+function resolveShellPane(rows) {
+  return rows.find((row) => row.role === SHELL_PANE_ROLE) ?? rows.find((row) => row.role === "");
+}
+function expandedTerminalHeightPercent(rawOpsHeightPercent) {
+  const opsPct = clampPanePercent(rawOpsHeightPercent ?? Number.NaN) ?? OPS_PANE_PERCENT;
+  return 100 - opsPct;
+}
+function parsePositiveInt(raw) {
+  const n = Number.parseInt(raw ?? "", 10);
+  return Number.isFinite(n) && n > 0 ? n : undefined;
+}
+async function windowPanes(session, windowId) {
+  const target = windowId?.trim() || `=${session}`;
+  const { code, stdout } = await runTmuxCapturing(["list-panes", "-t", target, "-F", ACTIVE_WINDOW_LAYOUT_FORMAT]);
+  return code === 0 ? parseLayoutPaneRows(stdout) : null;
+}
+async function activeWindowId(session) {
+  const { code, stdout } = await runTmuxCapturing([
+    "list-windows",
+    "-t",
+    `=${session}`,
+    "-F",
+    "#{window_active}\t#{window_id}"
+  ]);
+  if (code !== 0)
+    return "";
+  for (const line of stdout.split(`
+`)) {
+    const [active, windowId] = line.split("\t");
+    if (active?.trim() === "1" && windowId?.trim())
+      return windowId.trim();
+  }
+  return "";
+}
+async function windowOption(target, option) {
+  const { code, stdout } = await runTmuxCapturing(["show-options", "-wqv", "-t", target, option]);
+  return code === 0 ? stdout.trim() : "";
+}
+async function setActiveWindowOption(windowId, option, value) {
+  await runTmux(["set-window-option", "-t", windowId, option, value]);
+}
+async function clearActiveWindowOption(windowId, option) {
+  await runTmux(["set-window-option", "-u", "-t", windowId, option]);
+}
+async function paneExists(paneId) {
+  const { code, stdout } = await runTmuxCapturing(["display-message", "-p", "-t", paneId, "#{pane_id}"]);
+  return code === 0 && stdout.trim() === paneId;
+}
+async function display(session, message) {
+  await runTmux(["display-message", "-t", session, message]);
+}
+async function sessionWorktree(session) {
+  const opts = await getSessionOptions(session, ["@kobe_worktree", "@kobe_task", "@kobe_vendor"]);
+  return {
+    cwd: opts["@kobe_worktree"] || process.cwd(),
+    taskId: opts["@kobe_task"] || undefined,
+    vendor: opts["@kobe_vendor"] || undefined
+  };
+}
+function opsPaneLaunchCommand(args) {
+  const inv = kobeCliInvocation();
+  const envPrefix = inheritedEnvPrefix();
+  return keepAlive(envPrefix + opsPaneCommand({
+    cwd: args.cwd,
+    taskId: args.taskId,
+    claudePaneId: args.enginePaneId,
+    cliInvocation: inv,
+    vendor: args.vendor
+  }));
+}
+async function resolveActionWindowId(session, windowId) {
+  return windowId?.trim() || await activeWindowId(session);
+}
+async function addWorkspaceSplit(session, windowId) {
+  const rows = await windowPanes(session, windowId);
+  if (!rows)
+    return;
+  const plan = planWorkspaceSplit(rows);
+  if (plan.kind === "missing-engine") {
+    await display(windowId, "kobe: no engine pane in this window");
+    return;
+  }
+  if (plan.kind === "maxed") {
+    await display(windowId, `kobe: workspace split limit is ${WORKSPACE_SPLIT_MAX_PANES} panes`);
+    return;
+  }
+  const { cwd } = await sessionWorktree(session);
+  const { code, stdout } = await runTmuxCapturing([
+    "split-window",
+    plan.direction,
+    "-t",
+    plan.targetPane,
+    "-l",
+    "50%",
+    "-c",
+    localSpawnCwd(cwd),
+    "-P",
+    "-F",
+    "#{pane_id}",
+    keepAlive("true")
+  ]);
+  const paneId = stdout.trim();
+  if (code !== 0 || !paneId)
+    return;
+  await runTmuxSequence([
+    ["set-option", "-p", "-t", paneId, "@kobe_role", WORKSPACE_AUX_PANE_ROLE],
+    ["select-pane", "-t", paneId]
+  ]);
+}
+async function closeWorkspaceSplit(session, windowId) {
+  const rows = await windowPanes(session, windowId);
+  if (!rows)
+    return;
+  const aux = rows.filter((row) => row.role === WORKSPACE_AUX_PANE_ROLE);
+  if (aux.length === 0) {
+    await display(windowId, "kobe: no workspace split to close");
+    return;
+  }
+  const activeAux = aux.find((row) => row.active);
+  const target = activeAux ?? aux[aux.length - 1];
+  if (!target)
+    return;
+  await runTmux(["kill-pane", "-t", target.paneId]);
+}
+async function resetWorkspaceSplits(session, windowId) {
+  const rows = await windowPanes(session, windowId);
+  if (!rows)
+    return;
+  const aux = rows.filter((row) => row.role === WORKSPACE_AUX_PANE_ROLE);
+  if (aux.length === 0) {
+    await display(windowId, "kobe: no workspace splits to reset");
+    return;
+  }
+  await runTmuxSequence(aux.map((row) => ["kill-pane", "-t", row.paneId]));
+}
+async function preferredTasksWidth() {
+  const opts = await getServerOptions([TASKS_WIDTH_OPTION]);
+  return clampTasksPaneWidth(parsePositiveInt(opts[TASKS_WIDTH_OPTION]) ?? TASKS_PANE_WIDTH);
+}
+async function tasksPaneLaunchCommand(session) {
+  const { cwd, taskId } = await sessionWorktree(session);
+  const inv = kobeCliInvocation();
+  const envPrefix = inheritedEnvPrefix();
+  return {
+    cwd,
+    command: keepAlive(envPrefix + tasksPaneCommand(inv, { initialTaskId: taskId }))
+  };
+}
+async function toggleOpsPane(session, windowId) {
+  const rows = await windowPanes(session, windowId);
+  if (!rows)
+    return;
+  const ops = rows.find((row) => row.role === OPS_PANE_ROLE);
+  if (ops) {
+    await runTmux(["kill-pane", "-t", ops.paneId]);
+    return;
+  }
+  const shell = resolveShellPane(rows);
+  const engine = rows.find((row) => row.role === ENGINE_PANE_ROLE);
+  if (!engine) {
+    await display(windowId, "kobe: cannot restore file pane in this layout");
+    return;
+  }
+  const { cwd, taskId, vendor } = await sessionWorktree(session);
+  const opsCmd = opsPaneLaunchCommand({ cwd, taskId, vendor, enginePaneId: engine.paneId });
+  const splitArgs = shell ? [
+    "split-window",
+    "-v",
+    "-b",
+    "-t",
+    shell.paneId,
+    "-l",
+    `${await preferredOpsHeightPercent()}%`,
+    "-c",
+    localSpawnCwd(cwd),
+    "-P",
+    "-F",
+    "#{pane_id}",
+    opsCmd
+  ] : [
+    "split-window",
+    "-h",
+    "-t",
+    engine.paneId,
+    "-l",
+    `${await preferredRightColumnWidthPercent()}%`,
+    "-c",
+    localSpawnCwd(cwd),
+    "-P",
+    "-F",
+    "#{pane_id}",
+    opsCmd
+  ];
+  const { code, stdout } = await runTmuxCapturing(splitArgs);
+  const paneId = stdout.trim();
+  if (code !== 0 || !paneId)
+    return;
+  const commands = [
+    ["set-option", "-p", "-t", paneId, "@kobe_role", OPS_PANE_ROLE],
+    ["set-option", "-p", "-t", paneId, PANE_VERSION_OPTION, CURRENT_VERSION]
+  ];
+  if (shell?.role === "")
+    commands.push(["set-option", "-p", "-t", shell.paneId, "@kobe_role", SHELL_PANE_ROLE]);
+  await runTmuxSequence(commands);
+}
+async function preferredOpsHeightPercent() {
+  const opts = await getServerOptions([OPS_HEIGHT_OPTION]);
+  return clampPanePercent(Number.parseInt(opts[OPS_HEIGHT_OPTION] ?? "", 10)) ?? OPS_PANE_PERCENT;
+}
+async function preferredRightColumnWidthPercent() {
+  const opts = await getServerOptions([RIGHT_COLUMN_WIDTH_OPTION]);
+  return clampPanePercent(Number.parseInt(opts[RIGHT_COLUMN_WIDTH_OPTION] ?? "", 10)) ?? 100 - CLAUDE_PANE_PERCENT;
+}
+async function preferredTerminalHeightPercent() {
+  const opts = await getServerOptions([OPS_HEIGHT_OPTION]);
+  return expandedTerminalHeightPercent(Number.parseInt(opts[OPS_HEIGHT_OPTION] ?? "", 10));
+}
+async function hiddenWindowIndices(hiddenSession) {
+  const { code, stdout } = await runTmuxCapturing(["list-windows", "-t", `=${hiddenSession}`, "-F", "#{window_index}"]);
+  if (code !== 0)
+    return new Set;
+  return new Set(stdout.split(`
+`).map((line) => Number.parseInt(line.trim(), 10)).filter((n) => Number.isFinite(n)));
+}
+async function nextHiddenWindowIndex(hiddenSession, windowId) {
+  const used = await hiddenWindowIndices(hiddenSession);
+  let idx = hiddenTerminalWindowIndex(windowId);
+  while (used.has(idx))
+    idx++;
+  return idx;
+}
+async function ensureHiddenPaneSession(session) {
+  const hidden = hiddenTerminalSessionName(session);
+  if (await sessionExists(hidden))
+    return hidden;
+  await runTmux([
+    "new-session",
+    "-d",
+    "-s",
+    hidden,
+    "-n",
+    "hidden-panes",
+    "-c",
+    localSpawnCwd(process.cwd()),
+    "while :; do sleep 3600; done"
+  ]);
+  return hidden;
+}
+async function cleanupHiddenPaneSessionIfEmpty(session) {
+  const hidden = hiddenTerminalSessionName(session);
+  if (!await sessionExists(hidden))
+    return;
+  const { code, stdout } = await runTmuxCapturing(["list-panes", "-s", "-t", `=${hidden}`, "-F", "#{@kobe_role}"]);
+  if (code !== 0)
+    return;
+  const hasHiddenPane = stdout.split(`
+`).some((line) => {
+    const role = line.trim();
+    return role === SHELL_PANE_ROLE || role === TASKS_PANE_ROLE;
+  });
+  if (!hasHiddenPane)
+    await runTmux(["kill-session", "-t", `=${hidden}`]);
+}
+async function cleanupHiddenTerminalForWindow(session, windowId) {
+  await cleanupHiddenPaneForWindow(session, windowId, HIDDEN_TERMINAL_PANE_OPTION);
+}
+async function cleanupHiddenTasksForWindow(session, windowId) {
+  await cleanupHiddenPaneForWindow(session, windowId, HIDDEN_TASKS_PANE_OPTION);
+}
+async function cleanupHiddenPaneForWindow(session, windowId, option) {
+  const hiddenPane = await windowOption(windowId, option);
+  if (!hiddenPane)
+    return;
+  if (await paneExists(hiddenPane)) {
+    await runTmux(["kill-pane", "-t", hiddenPane]);
+  }
+  await clearActiveWindowOption(windowId, option);
+}
+async function cleanupHiddenPanesForWindow(session, windowId) {
+  await cleanupHiddenTerminalForWindow(session, windowId);
+  await cleanupHiddenTasksForWindow(session, windowId);
+  await cleanupHiddenPaneSessionIfEmpty(session);
+}
+function restoreTasksTarget(rows) {
+  return rows.find((row) => row.role === ENGINE_PANE_ROLE) ?? rows[0];
+}
+async function createTasksPane(session, windowId, rows) {
+  const target = restoreTasksTarget(rows);
+  if (!target) {
+    await display(windowId, "kobe: cannot restore Tasks pane in this layout");
+    return false;
+  }
+  const width = await preferredTasksWidth();
+  const { cwd, command } = await tasksPaneLaunchCommand(session);
+  const { code, stdout } = await runTmuxCapturing([
+    "split-window",
+    "-h",
+    "-b",
+    "-t",
+    target.paneId,
+    "-l",
+    `${width}`,
+    "-c",
+    localSpawnCwd(cwd),
+    "-P",
+    "-F",
+    "#{pane_id}",
+    command
+  ]);
+  const paneId = stdout.trim();
+  if (code !== 0 || !paneId)
+    return false;
+  await runTmuxSequence([
+    ["set-option", "-p", "-t", paneId, "@kobe_role", TASKS_PANE_ROLE],
+    ["set-option", "-p", "-t", paneId, PANE_VERSION_OPTION, CURRENT_VERSION],
+    ["select-pane", "-t", paneId]
+  ]);
+  await clearActiveWindowOption(windowId, HIDDEN_TASKS_PANE_OPTION);
+  await display(windowId, "kobe: Tasks pane restored");
+  return true;
+}
+async function hideTasksPane(session, windowId, tasks) {
+  const hidden = await ensureHiddenPaneSession(session);
+  const hiddenIndex = await nextHiddenWindowIndex(hidden, windowId);
+  const { code, stdout } = await runTmuxCapturing([
+    "break-pane",
+    "-d",
+    "-s",
+    tasks.paneId,
+    "-t",
+    `${hidden}:${hiddenIndex}`,
+    "-P",
+    "-F",
+    "#{pane_id}"
+  ]);
+  const hiddenPane = stdout.trim() || tasks.paneId;
+  if (code !== 0 || !hiddenPane) {
+    await display(windowId, "kobe: could not hide Tasks pane");
+    return;
+  }
+  await setActiveWindowOption(windowId, HIDDEN_TASKS_PANE_OPTION, hiddenPane);
+  await display(windowId, "kobe: Tasks pane hidden");
+}
+async function restoreHiddenTasksPane(session, windowId, hiddenPane) {
+  const rows = await windowPanes(session, windowId);
+  if (!rows)
+    return;
+  if (!await paneExists(hiddenPane)) {
+    await clearActiveWindowOption(windowId, HIDDEN_TASKS_PANE_OPTION);
+    const visibleTasks = rows.find((row) => row.role === TASKS_PANE_ROLE);
+    if (visibleTasks) {
+      await runTmux(["select-pane", "-t", visibleTasks.paneId]);
+      return;
+    }
+    await createTasksPane(session, windowId, rows);
+    return;
+  }
+  const target = restoreTasksTarget(rows);
+  if (!target) {
+    await display(windowId, "kobe: cannot restore Tasks pane in this layout");
+    return;
+  }
+  const code = await runTmux([
+    "join-pane",
+    "-h",
+    "-b",
+    "-s",
+    hiddenPane,
+    "-t",
+    target.paneId,
+    "-l",
+    `${await preferredTasksWidth()}`
+  ]);
+  if (code !== 0) {
+    await display(windowId, "kobe: could not restore Tasks pane");
+    return;
+  }
+  await runTmuxSequence([
+    ["set-option", "-p", "-t", hiddenPane, "@kobe_role", TASKS_PANE_ROLE],
+    ["set-option", "-p", "-t", hiddenPane, PANE_VERSION_OPTION, CURRENT_VERSION],
+    ["select-pane", "-t", hiddenPane]
+  ]);
+  await clearActiveWindowOption(windowId, HIDDEN_TASKS_PANE_OPTION);
+  await cleanupHiddenPaneSessionIfEmpty(session);
+  await display(windowId, "kobe: Tasks pane restored");
+}
+async function toggleTasksPane(session, windowId) {
+  const hiddenPane = await windowOption(windowId, HIDDEN_TASKS_PANE_OPTION);
+  if (hiddenPane) {
+    await restoreHiddenTasksPane(session, windowId, hiddenPane);
+    return;
+  }
+  const rows = await windowPanes(session, windowId);
+  if (!rows)
+    return;
+  const tasks = rows.find((row) => row.role === TASKS_PANE_ROLE);
+  if (tasks) {
+    await hideTasksPane(session, windowId, tasks);
+    return;
+  }
+  await createTasksPane(session, windowId, rows);
+}
+async function restoreTasksPane(session, windowId) {
+  const hiddenPane = await windowOption(windowId, HIDDEN_TASKS_PANE_OPTION);
+  if (hiddenPane) {
+    await restoreHiddenTasksPane(session, windowId, hiddenPane);
+    return;
+  }
+  const rows = await windowPanes(session, windowId);
+  if (!rows)
+    return;
+  const tasks = rows.find((row) => row.role === TASKS_PANE_ROLE);
+  if (tasks) {
+    await runTmux(["select-pane", "-t", tasks.paneId]);
+    return;
+  }
+  await createTasksPane(session, windowId, rows);
+}
+async function hideTerminalPane(session, windowId, shell) {
+  if (shell.role === "") {
+    await runTmux(["set-option", "-p", "-t", shell.paneId, "@kobe_role", SHELL_PANE_ROLE]);
+  }
+  const hidden = await ensureHiddenPaneSession(session);
+  const hiddenIndex = await nextHiddenWindowIndex(hidden, windowId);
+  const { code, stdout } = await runTmuxCapturing([
+    "break-pane",
+    "-d",
+    "-s",
+    shell.paneId,
+    "-t",
+    `${hidden}:${hiddenIndex}`,
+    "-P",
+    "-F",
+    "#{pane_id}"
+  ]);
+  const hiddenPane = stdout.trim() || shell.paneId;
+  if (code !== 0 || !hiddenPane) {
+    await display(windowId, "kobe: could not hide terminal pane");
+    return;
+  }
+  await setActiveWindowOption(windowId, HIDDEN_TERMINAL_PANE_OPTION, hiddenPane);
+  await display(windowId, "kobe: Terminal pane hidden");
+}
+async function createTerminalPane(session, windowId, rows) {
+  const ops = rows.find((row) => row.role === OPS_PANE_ROLE);
+  const engine = rows.find((row) => row.role === ENGINE_PANE_ROLE);
+  if (!ops && !engine) {
+    await display(windowId, "kobe: cannot restore terminal pane in this layout");
+    return false;
+  }
+  const { cwd } = await sessionWorktree(session);
+  const splitArgs = ops ? [
+    "split-window",
+    "-v",
+    "-t",
+    ops.paneId,
+    "-l",
+    `${await preferredTerminalHeightPercent()}%`,
+    "-c",
+    localSpawnCwd(cwd),
+    "-P",
+    "-F",
+    "#{pane_id}"
+  ] : [
+    "split-window",
+    "-h",
+    "-t",
+    engine?.paneId ?? "",
+    "-l",
+    `${await preferredRightColumnWidthPercent()}%`,
+    "-c",
+    localSpawnCwd(cwd),
+    "-P",
+    "-F",
+    "#{pane_id}"
+  ];
+  const { code, stdout } = await runTmuxCapturing(splitArgs);
+  const paneId = stdout.trim();
+  if (code !== 0 || !paneId)
+    return false;
+  await runTmux(["set-option", "-p", "-t", paneId, "@kobe_role", SHELL_PANE_ROLE]);
+  await clearActiveWindowOption(windowId, HIDDEN_TERMINAL_PANE_OPTION);
+  await display(windowId, "kobe: Terminal pane restored");
+  return true;
+}
+async function restoreHiddenTerminalPane(session, windowId, hiddenPane) {
+  let rows = await windowPanes(session, windowId);
+  if (!rows)
+    return;
+  if (!await paneExists(hiddenPane)) {
+    await clearActiveWindowOption(windowId, HIDDEN_TERMINAL_PANE_OPTION);
+    await createTerminalPane(session, windowId, rows);
+    return;
+  }
+  const ops = rows.find((row) => row.role === OPS_PANE_ROLE);
+  const engine = rows.find((row) => row.role === ENGINE_PANE_ROLE);
+  if (!ops && !engine) {
+    await display(windowId, "kobe: cannot restore terminal pane in this layout");
+    return;
+  }
+  const joinArgs = ops ? ["join-pane", "-v", "-s", hiddenPane, "-t", ops.paneId, "-l", `${await preferredTerminalHeightPercent()}%`] : [
+    "join-pane",
+    "-h",
+    "-s",
+    hiddenPane,
+    "-t",
+    engine?.paneId ?? "",
+    "-l",
+    `${await preferredRightColumnWidthPercent()}%`
+  ];
+  const code = await runTmux(joinArgs);
+  if (code !== 0) {
+    await display(windowId, "kobe: could not restore terminal pane");
+    return;
+  }
+  await runTmux(["set-option", "-p", "-t", hiddenPane, "@kobe_role", SHELL_PANE_ROLE]);
+  await clearActiveWindowOption(windowId, HIDDEN_TERMINAL_PANE_OPTION);
+  await cleanupHiddenPaneSessionIfEmpty(session);
+  rows = await windowPanes(session, windowId);
+  const restored = rows?.find((row) => row.paneId === hiddenPane);
+  if (restored)
+    await runTmux(["select-pane", "-t", restored.paneId]);
+  await display(windowId, "kobe: Terminal pane restored");
+}
+async function toggleTerminalPane(session, windowId) {
+  const hiddenPane = await windowOption(windowId, HIDDEN_TERMINAL_PANE_OPTION);
+  if (hiddenPane) {
+    await restoreHiddenTerminalPane(session, windowId, hiddenPane);
+    return;
+  }
+  const rows = await windowPanes(session, windowId);
+  if (!rows)
+    return;
+  const shell = resolveShellPane(rows);
+  if (shell) {
+    await hideTerminalPane(session, windowId, shell);
+    return;
+  }
+  await createTerminalPane(session, windowId, rows);
+}
+async function activeSessionWindowCount(session) {
+  const { code, stdout } = await runTmuxCapturing(["list-windows", "-t", `=${session}`, "-F", "#{window_id}"]);
+  if (code !== 0)
+    return 0;
+  return stdout.split(`
+`).filter((line) => line.trim().length > 0).length;
+}
+async function closeChatTab(session, windowId) {
+  if (await activeSessionWindowCount(session) <= 1) {
+    await display(windowId, "Cannot close the only ChatTab");
+    return;
+  }
+  await cleanupHiddenPanesForWindow(session, windowId);
+  await runTmux(["kill-window", "-t", windowId]);
+}
+async function runLayoutAction(session, action, opts = {}) {
+  if (!await sessionExists(session))
+    return;
+  const windowId = await resolveActionWindowId(session, opts.windowId);
+  if (!windowId)
+    return;
+  switch (action) {
+    case "workspace-split":
+      await addWorkspaceSplit(session, windowId);
+      return;
+    case "workspace-close":
+      await closeWorkspaceSplit(session, windowId);
+      return;
+    case "workspace-reset":
+      await resetWorkspaceSplits(session, windowId);
+      return;
+    case "tasks-toggle":
+      await toggleTasksPane(session, windowId);
+      return;
+    case "tasks-restore":
+      await restoreTasksPane(session, windowId);
+      return;
+    case "ops-toggle":
+      await toggleOpsPane(session, windowId);
+      return;
+    case "terminal-toggle":
+      await toggleTerminalPane(session, windowId);
+      return;
+    case "chat-tab-close":
+      await closeChatTab(session, windowId);
+      return;
+  }
+}
+var ACTIVE_WINDOW_LAYOUT_FORMAT = "#{pane_id}\t#{@kobe_role}\t#{pane_active}\t#{pane_width}\t#{pane_height}\t#{window_width}\t#{window_height}";
+var init_layout_actions = __esm(() => {
+  init_invocation();
+  init_resolve();
+  init_client2();
+  init_version();
+  init_launch();
+  init_pane_heal();
+});
+
 // src/tui/panes/terminal/tmux.ts
 var exports_tmux = {};
 __export(exports_tmux, {
@@ -11709,6 +12397,7 @@ __export(exports_tmux, {
   switchClientBeforeKill: () => switchClientBeforeKill,
   sessionExists: () => sessionExists,
   selectTasksPane: () => selectTasksPane,
+  runLayoutAction: () => runLayoutAction,
   refreshKobeWorkspacePanes: () => refreshKobeWorkspacePanes,
   quickCreate: () => quickCreate,
   prepareWindowForSwitch: () => prepareWindowForSwitch,
@@ -11768,16 +12457,12 @@ async function prepareWindowForSwitch(session) {
     await runTmux(["resize-window", "-t", `=${session}`, ...sizeArgs]);
   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}`
-  ];
+function focusBindCommand(key, dir, edgeCommand) {
+  const condition = `#{?window_zoomed_flag,1,#{?${FOCUS_EDGE_VARS[dir]},,1}}`;
+  if (edgeCommand) {
+    return ["bind-key", "-n", key, "if-shell", "-F", condition, `select-pane ${dir}`, edgeCommand];
+  }
+  return ["bind-key", "-n", key, "if-shell", "-F", condition, `select-pane ${dir}`];
 }
 async function ensureSession(opts) {
   const inflight = ensureSessionLocks.get(opts.name);
@@ -11845,7 +12530,7 @@ async function ensureSessionImpl(opts) {
     }
   }
   if (action.kind === "rebuild" || action.kind === "respawn-engine") {
-    await runTmux(["kill-session", "-t", `=${opts.name}`]);
+    await killSession(opts.name);
   }
   const inv = kobeCliInvocation();
   const launch = withClaudeSessionId(opts.command, opts.vendor);
@@ -11895,14 +12580,19 @@ async function ensureSessionImpl(opts) {
   const newChatTabCommand = `${envStr}${invStr} new-chattab --session '#{session_name}'`;
   const chooseEngineCommand = `${newChatTabCommand} --vendor '%%'`;
   const chooseEngineTmuxCommand = `run-shell ${shellQuote(chooseEngineCommand)}`;
-  const focusTasksCommand = `${envStr}${invStr} focus-tasks --session '#{session_name}'`;
+  const focusTasksCommand = `${envStr}${invStr} focus-tasks --session '#{session_name}' --window '#{window_id}'`;
   const focusTasksTmuxCommand = `run-shell ${shellQuote(focusTasksCommand)}`;
+  const layoutCommand = (action2) => `${envStr}${invStr} layout --session '#{session_name}' --window '#{window_id}' --action ${action2}`;
+  const restoreTasksCommand = layoutCommand("tasks-restore");
+  const restoreTasksTmuxCommand = `run-shell ${shellQuote(restoreTasksCommand)}`;
+  const closeChatTabCommand = layoutCommand("chat-tab-close");
+  const closeChatTabTmuxCommand = `run-shell ${shellQuote(closeChatTabCommand)}`;
   const healLayoutCommand = `${envStr}${invStr} heal-layout --session '#{session_name}'`;
   const healLayoutTmuxCommand = `run-shell -b ${shellQuote(healLayoutCommand)}`;
   const captureLayoutCommand = `${envStr}${invStr} capture-layout --session '#{session_name}'`;
   const captureLayoutTmuxCommand = `run-shell -b ${shellQuote(captureLayoutCommand)}`;
   const userKeys = resolveUserTmuxKeys();
-  const unbinds = [];
+  const unbinds = TMUX_LEGACY_LAYOUT_ROOT_KEYS.map((key) => ["unbind-key", "-n", key]);
   if (userKeys.overridden.has(TMUX_FOCUS_ID)) {
     for (const chord of TMUX_FOCUS_DEFAULTS) {
       const t = chordToTmuxKey(chord);
@@ -11914,16 +12604,26 @@ async function ensureSessionImpl(opts) {
     if (id === TMUX_FOCUS_ID)
       continue;
     const def = TMUX_SINGLE_BINDING_DEFAULTS[id];
-    const t = chordToTmuxKey(def);
+    const isPrefix = isTmuxPrefixBindingId(id);
+    const t = chordToTmuxKey(def, { allowBare: isPrefix });
     if ("key" in t)
-      unbinds.push(["unbind-key", "-n", t.key]);
+      unbinds.push(isPrefix ? ["unbind-key", t.key] : ["unbind-key", "-n", t.key]);
   }
   const focusDirections = ["-L", "-D", "-U", "-R"];
   const focusBinds = userKeys.focus.flatMap((bind, i) => {
     const dir = focusDirections[i];
-    return bind && dir ? [focusBindCommand(bind.key, dir)] : [];
+    const edgeCommand = dir === "-L" ? restoreTasksTmuxCommand : undefined;
+    return bind && dir ? [focusBindCommand(bind.key, dir, edgeCommand)] : [];
   });
   const b = userKeys.binds;
+  const layoutBind = (id, action2) => {
+    const bind = b[id];
+    return bind ? [["bind-key", bind.key, "run-shell", layoutCommand(action2)]] : [];
+  };
+  const layoutChordGroup = (...ids) => {
+    const chords = ids.map((id) => b[id]?.chord).filter((chord) => !!chord);
+    return chords.length > 0 ? chords.join("/") : null;
+  };
   await runTmuxSequence([
     ["set-option", "-g", "status", "on"],
     ["set-window-option", "-g", "aggressive-resize", "on"],
@@ -11938,7 +12638,9 @@ async function ensureSessionImpl(opts) {
       kobeStatusRight({
         focusLeft: userKeys.focus[0]?.key ?? null,
         detach: b["tmux.detach"]?.key ?? null,
-        newTab: b["tmux.tab.new"]?.key ?? null
+        newTab: b["tmux.tab.new"]?.key ?? null,
+        layoutSplits: layoutChordGroup("tmux.layout.workspaceSplit", "tmux.layout.workspaceClose", "tmux.layout.workspaceReset"),
+        layoutPanes: layoutChordGroup("tmux.layout.tasksToggle", "tmux.layout.opsToggle", "tmux.layout.terminalToggle")
       })
     ],
     ["set-option", "-g", "mouse", "on"],
@@ -11952,7 +12654,7 @@ async function ensureSessionImpl(opts) {
         b["tmux.detach"].key,
         "if-shell",
         "-F",
-        "#{==:#{@kobe_role},tasks}",
+        `#{?#{${HIDDEN_TASKS_PANE_OPTION}},1,#{==:#{@kobe_role},tasks}}`,
         "detach-client",
         focusTasksTmuxCommand
       ]
@@ -11961,8 +12663,14 @@ async function ensureSessionImpl(opts) {
     ...b["tmux.tab.new"] ? [["bind-key", "-n", b["tmux.tab.new"].key, "run-shell", newChatTabCommand]] : [],
     ...b["tmux.tab.chooseEngine"] ? chatTabChooseEngineBindings(b["tmux.tab.chooseEngine"].key).map((binding) => [...binding, chooseEngineTmuxCommand]) : [],
     ...b["tmux.tab.prev"] && b["tmux.tab.next"] ? chatTabSwitchBindings(b["tmux.tab.prev"].key, b["tmux.tab.next"].key) : b["tmux.tab.prev"] ? [["bind-key", "-n", b["tmux.tab.prev"].key, "previous-window"]] : b["tmux.tab.next"] ? [["bind-key", "-n", b["tmux.tab.next"].key, "next-window"]] : [],
-    ...b["tmux.tab.close"] ? [chatTabCloseBinding(b["tmux.tab.close"].key)] : [],
+    ...b["tmux.tab.close"] ? [chatTabCloseBinding(b["tmux.tab.close"].key, closeChatTabTmuxCommand)] : [],
     ...b["tmux.tab.rename"] ? [chatTabRenameBinding(b["tmux.tab.rename"].key)] : [],
+    ...layoutBind("tmux.layout.workspaceSplit", "workspace-split"),
+    ...layoutBind("tmux.layout.workspaceClose", "workspace-close"),
+    ...layoutBind("tmux.layout.workspaceReset", "workspace-reset"),
+    ...layoutBind("tmux.layout.tasksToggle", "tasks-toggle"),
+    ...layoutBind("tmux.layout.opsToggle", "ops-toggle"),
+    ...layoutBind("tmux.layout.terminalToggle", "terminal-toggle"),
     ["bind-key", "f", "run-shell", `${envStr}${invStr} quick-create --session '#{session_name}'`]
   ]);
   await applyTmuxPaneBorderTheme();
@@ -11973,10 +12681,27 @@ async function ensureSessionImpl(opts) {
   }
   return true;
 }
-async function selectTasksPane(session) {
+async function paneIdByRoleInWindow(session, role, windowId) {
+  const target = windowId?.trim() || `=${session}`;
+  const { code, stdout } = await runTmuxCapturing(["list-panes", "-t", target, "-F", "#{pane_id}\t#{@kobe_role}"]);
+  if (code !== 0)
+    return "";
+  for (const line of stdout.split(`
+`)) {
+    const [paneId, paneRole] = line.split("\t");
+    if (paneId?.trim() && paneRole?.trim() === role)
+      return paneId.trim();
+  }
+  return "";
+}
+async function selectTasksPane(session, opts = {}) {
   if (!await sessionExists(session))
     return "";
-  const tasksPane = await paneIdByRole(session, "tasks");
+  let tasksPane = await paneIdByRoleInWindow(session, "tasks", opts.windowId);
+  if (!tasksPane) {
+    await runLayoutAction(session, "tasks-restore", { windowId: opts.windowId });
+    tasksPane = await paneIdByRoleInWindow(session, "tasks", opts.windowId);
+  }
   if (!tasksPane)
     return "";
   await runTmux(["select-pane", "-t", tasksPane]);
@@ -11994,11 +12719,13 @@ var init_tmux = __esm(() => {
   init_tmux_border_theme();
   init_chattab();
   init_launch();
+  init_layout_actions();
   init_layout_coord();
   init_pane_heal();
   init_client2();
   init_chattab();
   init_pane_heal();
+  init_layout_actions();
   FOCUS_EDGE_VARS = {
     "-L": "pane_at_left",
     "-D": "pane_at_bottom",
@@ -20263,6 +20990,54 @@ var init_keybindings2 = __esm(() => {
       description: "Open the engine in a new tab (tmux prefix, then t)",
       hint: { keys: "prefix t", label: "engine tab", status: false }
     },
+    {
+      id: "tmux.layout.workspaceSplit",
+      scope: "global",
+      keys: [],
+      category: "Workspace (tmux)",
+      description: "Add a temporary workspace split (tmux prefix, then s)",
+      hint: { keys: "prefix s", label: "split", status: false }
+    },
+    {
+      id: "tmux.layout.workspaceClose",
+      scope: "global",
+      keys: [],
+      category: "Workspace (tmux)",
+      description: "Close the focused temporary workspace split (tmux prefix, then x)",
+      hint: { keys: "prefix x", label: "close split", status: false }
+    },
+    {
+      id: "tmux.layout.workspaceReset",
+      scope: "global",
+      keys: [],
+      category: "Workspace (tmux)",
+      description: "Close all temporary workspace splits (tmux prefix, then r)",
+      hint: { keys: "prefix r", label: "reset splits", status: false }
+    },
+    {
+      id: "tmux.layout.tasksToggle",
+      scope: "global",
+      keys: [],
+      category: "Workspace (tmux)",
+      description: "Hide / restore the Tasks pane (tmux prefix, then a)",
+      hint: { keys: "prefix a", label: "tasks pane", status: false }
+    },
+    {
+      id: "tmux.layout.opsToggle",
+      scope: "global",
+      keys: [],
+      category: "Workspace (tmux)",
+      description: "Toggle the file/Ops pane (tmux prefix, then o)",
+      hint: { keys: "prefix o", label: "file pane", status: false }
+    },
+    {
+      id: "tmux.layout.terminalToggle",
+      scope: "global",
+      keys: [],
+      category: "Workspace (tmux)",
+      description: "Hide / restore the terminal pane (tmux prefix, then z)",
+      hint: { keys: "prefix z", label: "terminal", status: false }
+    },
     {
       id: "chat.send",
       scope: "workspace",
@@ -20526,6 +21301,10 @@ function applyUserKeybindings() {
         keys: bind ? [bind.chord] : [],
         defaultKeys: [TMUX_SINGLE_BINDING_DEFAULTS[id]]
       });
+      const displayRow = KobeKeymap.find((row) => row.id === id);
+      if (displayRow?.hint) {
+        displayRow.hint.keys = bind ? `${isTmuxPrefixBindingId(id) ? "prefix " : ""}${bind.chord}` : "\u2014";
+      }
     }
   }
   for (const w of warnings)
@@ -21007,6 +21786,45 @@ var init_host_boot = __esm(() => {
   init_persisted_ui_prefs();
 });
 
+// src/tui/lib/task-enter.ts
+async function ensureTaskSession2(orch, task, repo, vendor, opts = {}) {
+  const session = tmuxSessionName(task.id);
+  if (await sessionExists(session))
+    return true;
+  let worktree = task.worktreePath;
+  if (!worktree)
+    worktree = await orch.ensureWorktree(task.id);
+  if (!worktree)
+    throw new Error(`task ${task.id} has no worktree`);
+  const { ensureSession: ensureSession2 } = await Promise.resolve().then(() => (init_tmux(), exports_tmux));
+  const { resolveRepoInit: resolveRepoInit2 } = await Promise.resolve().then(() => (init_repo_init(), exports_repo_init));
+  const init2 = resolveRepoInit2(repo, worktree);
+  const ok = await ensureSession2({
+    name: session,
+    cwd: worktree,
+    command: interactiveEngineCommand(vendor),
+    taskId: task.id,
+    vendor,
+    repo,
+    initScript: init2.initScript,
+    initPrompt: opts.includeInitPrompt ? init2.initPrompt : undefined
+  });
+  if (!ok)
+    throw new Error(`failed to start tmux session for ${task.id}`);
+  return false;
+}
+async function jumpToTask(orch, task, repo, vendor, opts = {}) {
+  await ensureTaskSession2(orch, task, repo, vendor, opts);
+  await orch.setActiveTask(task.id).catch(() => {});
+  const { prepareWindowForSwitch: prepareWindowForSwitch2 } = await Promise.resolve().then(() => (init_tmux(), exports_tmux));
+  await prepareWindowForSwitch2(tmuxSessionName(task.id));
+  await runTmux(["switch-client", "-t", `=${tmuxSessionName(task.id)}`]);
+}
+var init_task_enter = __esm(() => {
+  init_interactive_command();
+  init_client2();
+});
+
 // src/tui/new-task/host.tsx
 var exports_host = {};
 __export(exports_host, {
@@ -21041,10 +21859,11 @@ function NewTaskPage(props) {
       console.error("[kobe new-task] no daemon; cannot create task");
       process.exit(1);
     }
+    let entered;
     try {
       if (result.mode === "adopt") {
         for (const w of result.adopt) {
-          await orch.adoptWorktree({
+          entered = await orch.adoptWorktree({
             repo: result.repo,
             worktreePath: w.worktreePath,
             branch: w.branch,
@@ -21052,7 +21871,7 @@ function NewTaskPage(props) {
           });
         }
       } else {
-        await orch.createTask({
+        entered = await orch.createTask({
           repo: result.repo,
           baseRef: result.baseRef,
           vendor: result.vendor
@@ -21062,6 +21881,15 @@ function NewTaskPage(props) {
       console.error("[kobe new-task] task.create/adopt failed:", err);
       process.exit(1);
     }
+    if (entered) {
+      try {
+        await jumpToTask(orch, entered, result.repo, result.vendor, {
+          includeInitPrompt: result.mode !== "adopt"
+        });
+      } catch (err) {
+        console.error("[kobe new-task] auto-enter failed:", err);
+      }
+    }
     process.exit(0);
   }
   return (() => {
@@ -21112,6 +21940,7 @@ var init_host = __esm(() => {
   init_new_task_dialog();
   init_theme2();
   init_host_boot();
+  init_task_enter();
   init_dialog();
 });
 
@@ -21249,35 +22078,6 @@ async function resolveQuickTaskContext(orch, session) {
     fallbackRepo
   };
 }
-async function ensureTaskSession2(orch, task, repo, vendor) {
-  const session = tmuxSessionName(task.id);
-  if (await sessionExists(session))
-    return true;
-  let worktree = task.worktreePath;
-  if (!worktree)
-    worktree = await orch.ensureWorktree(task.id);
-  if (!worktree)
-    throw new Error(`task ${task.id} has no worktree`);
-  const {
-    ensureSession: ensureSession2
-  } = await Promise.resolve().then(() => (init_tmux(), exports_tmux));
-  const {
-    resolveRepoInit: resolveRepoInit2
-  } = await Promise.resolve().then(() => (init_repo_init(), exports_repo_init));
-  const init2 = resolveRepoInit2(repo, worktree);
-  const ok = await ensureSession2({
-    name: session,
-    cwd: worktree,
-    command: interactiveEngineCommand(vendor),
-    taskId: task.id,
-    vendor,
-    repo,
-    initScript: init2.initScript
-  });
-  if (!ok)
-    throw new Error(`failed to start tmux session for ${task.id}`);
-  return false;
-}
 async function deliverFirstPromptToTask(orch, task, repo, vendor, prompt) {
   const existed = await ensureTaskSession2(orch, task, repo, vendor);
   const session = tmuxSessionName(task.id);
@@ -21287,15 +22087,6 @@ async function deliverFirstPromptToTask(orch, task, repo, vendor, prompt) {
   if (pane)
     await pasteAndSubmit(pane, prompt);
 }
-async function jumpToTask(orch, task, repo, vendor) {
-  await ensureTaskSession2(orch, task, repo, vendor);
-  await orch.setActiveTask(task.id).catch(() => {});
-  const {
-    prepareWindowForSwitch: prepareWindowForSwitch2
-  } = await Promise.resolve().then(() => (init_tmux(), exports_tmux));
-  await prepareWindowForSwitch2(tmuxSessionName(task.id));
-  await runTmux(["switch-client", "-t", `=${tmuxSessionName(task.id)}`]);
-}
 function QuickTaskPage(props) {
   const {
     theme
@@ -21394,6 +22185,7 @@ var init_host2 = __esm(() => {
   init_git_snapshot();
   init_host_boot();
   init_path_helpers();
+  init_task_enter();
   init_host();
   init_groups();
   init_dialog();
@@ -21432,8 +22224,10 @@ function formatChord(chord, prefixGlyph = "\u2303B") {
   if (!s)
     return s;
   const pm = /^prefix\s+(.+)$/i.exec(s);
-  if (pm)
-    return `${prefixGlyph} ${formatKey(pm[1] ?? "", true)}`;
+  if (pm) {
+    const suffix = pm[1] ?? "";
+    return `${prefixGlyph} ${suffix.includes("+") ? formatChord(suffix, prefixGlyph) : formatKey(suffix, true)}`;
+  }
   const parts = s.split("+");
   if (parts.length === 1)
     return formatKey(parts[0] ?? "", false);
@@ -23022,12 +23816,12 @@ function KeybindingsSettingsSection() {
   const report = userKeybindingsReport();
   const fixedIds = Object.keys(FIXED_BINDING_IDS).sort();
   return (() => {
-    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");
+    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$199 = createElement("text"), _el$201 = 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);
+    insertNode(_el$161, _el$201);
     setProp(_el$161, "flexDirection", "column");
     setProp(_el$161, "gap", 1);
     insertNode(_el$162, createTextNode(`Keybindings`));
@@ -23046,7 +23840,7 @@ function KeybindingsSettingsSection() {
         return !report.exists;
       },
       get children() {
-        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");
+        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"), _el$189 = createElement("text");
         insertNode(_el$170, _el$171);
         insertNode(_el$170, _el$173);
         insertNode(_el$170, _el$175);
@@ -23056,6 +23850,7 @@ function KeybindingsSettingsSection() {
         insertNode(_el$170, _el$183);
         insertNode(_el$170, _el$185);
         insertNode(_el$170, _el$187);
+        insertNode(_el$170, _el$189);
         setProp(_el$170, "flexDirection", "column");
         setProp(_el$170, "gap", 0);
         insertNode(_el$171, createTextNode(`Example`));
@@ -23064,11 +23859,12 @@ function KeybindingsSettingsSection() {
         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]`));
+        insertNode(_el$183, createTextNode(`  tmux.layout.workspaceSplit: g  # prefix g`));
+        insertNode(_el$185, createTextNode(`darwin:                      # platform overlay (also: linux)`));
+        insertNode(_el$187, createTextNode(`  bindings:`));
+        insertNode(_el$189, createTextNode(`    palette.open: [cmd+p, ctrl+p]`));
         effect((_p$) => {
-          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;
+          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$117 = 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));
@@ -23079,6 +23875,7 @@ function KeybindingsSettingsSection() {
           _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));
+          _v$117 !== _p$.l && (_p$.l = setProp(_el$189, "fg", _v$117, _p$.l));
           return _p$;
         }, {
           e: undefined,
@@ -23090,104 +23887,105 @@ function KeybindingsSettingsSection() {
           s: undefined,
           h: undefined,
           r: undefined,
-          d: undefined
+          d: undefined,
+          l: undefined
         });
         return _el$170;
       }
-    }), _el$197);
+    }), _el$199);
     insert(_el$161, createComponent2(Show, {
       get when() {
         return report.exists;
       },
       get children() {
-        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, {
+        var _el$191 = createElement("box"), _el$192 = createElement("text");
+        insertNode(_el$191, _el$192);
+        setProp(_el$191, "flexDirection", "column");
+        setProp(_el$191, "gap", 0);
+        insertNode(_el$192, createTextNode(`Overrides applied`));
+        insert(_el$191, createComponent2(Show, {
           get when() {
             return report.applied.length === 0;
           },
           get children() {
-            var _el$192 = createElement("text");
-            insertNode(_el$192, createTextNode(`none`));
-            effect((_$p) => setProp(_el$192, "fg", theme.textMuted, _$p));
-            return _el$192;
+            var _el$194 = createElement("text");
+            insertNode(_el$194, createTextNode(`none`));
+            effect((_$p) => setProp(_el$194, "fg", theme.textMuted, _$p));
+            return _el$194;
           }
         }), null);
-        insert(_el$189, createComponent2(For, {
+        insert(_el$191, createComponent2(For, {
           get each() {
             return report.applied;
           },
           children: (o) => (() => {
-            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;
+            var _el$202 = createElement("text");
+            setProp(_el$202, "wrapMode", "word");
+            insert(_el$202, () => `${o.id} \u2192 ${o.keys.length > 0 ? o.keys.join(" / ") : "(unbound)"}  (default: ${o.defaultKeys.join(" / ")})`);
+            effect((_$p) => setProp(_el$202, "fg", theme.text, _$p));
+            return _el$202;
           })()
         }), null);
         effect((_p$) => {
-          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));
+          var _v$118 = theme.text, _v$119 = TextAttributes7.BOLD;
+          _v$118 !== _p$.e && (_p$.e = setProp(_el$192, "fg", _v$118, _p$.e));
+          _v$119 !== _p$.t && (_p$.t = setProp(_el$192, "attributes", _v$119, _p$.t));
           return _p$;
         }, {
           e: undefined,
           t: undefined
         });
-        return _el$189;
+        return _el$191;
       }
-    }), _el$197);
+    }), _el$199);
     insert(_el$161, createComponent2(Show, {
       get when() {
         return report.warnings.length > 0;
       },
       get children() {
-        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, {
+        var _el$196 = createElement("box"), _el$197 = createElement("text");
+        insertNode(_el$196, _el$197);
+        setProp(_el$196, "flexDirection", "column");
+        setProp(_el$196, "gap", 0);
+        insertNode(_el$197, createTextNode(`Warnings`));
+        insert(_el$196, createComponent2(For, {
           get each() {
             return report.warnings;
           },
           children: (w) => (() => {
-            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;
+            var _el$203 = createElement("text");
+            setProp(_el$203, "wrapMode", "word");
+            insert(_el$203, `! ${w}`);
+            effect((_$p) => setProp(_el$203, "fg", theme.warning, _$p));
+            return _el$203;
           })()
         }), null);
         effect((_p$) => {
-          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));
+          var _v$120 = theme.warning, _v$121 = TextAttributes7.BOLD;
+          _v$120 !== _p$.e && (_p$.e = setProp(_el$197, "fg", _v$120, _p$.e));
+          _v$121 !== _p$.t && (_p$.t = setProp(_el$197, "attributes", _v$121, _p$.t));
           return _p$;
         }, {
           e: undefined,
           t: undefined
         });
-        return _el$194;
+        return _el$196;
       }
-    }), _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");
+    }), _el$199);
+    insertNode(_el$199, 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), and prefix layout keys: workspaceSplit (s), workspaceClose (x), workspaceReset (r), tasksToggle (a), opsToggle (o), terminalToggle (z). They apply when a session is (re)built.`));
     setProp(_el$199, "wrapMode", "word");
-    insert(_el$199, () => `Fixed (not rebindable): ${fixedIds.join(", ")}.`);
+    setProp(_el$201, "wrapMode", "word");
+    insert(_el$201, () => `Fixed (not rebindable): ${fixedIds.join(", ")}.`);
     effect((_p$) => {
-      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));
+      var _v$122 = theme.text, _v$123 = TextAttributes7.BOLD, _v$124 = theme.textMuted, _v$125 = theme.text, _v$126 = TextAttributes7.BOLD, _v$127 = theme.textMuted, _v$128 = theme.textMuted, _v$129 = theme.textMuted;
+      _v$122 !== _p$.e && (_p$.e = setProp(_el$162, "fg", _v$122, _p$.e));
+      _v$123 !== _p$.t && (_p$.t = setProp(_el$162, "attributes", _v$123, _p$.t));
+      _v$124 !== _p$.a && (_p$.a = setProp(_el$164, "fg", _v$124, _p$.a));
+      _v$125 !== _p$.o && (_p$.o = setProp(_el$167, "fg", _v$125, _p$.o));
+      _v$126 !== _p$.i && (_p$.i = setProp(_el$167, "attributes", _v$126, _p$.i));
+      _v$127 !== _p$.n && (_p$.n = setProp(_el$169, "fg", _v$127, _p$.n));
+      _v$128 !== _p$.s && (_p$.s = setProp(_el$199, "fg", _v$128, _p$.s));
+      _v$129 !== _p$.h && (_p$.h = setProp(_el$201, "fg", _v$129, _p$.h));
       return _p$;
     }, {
       e: undefined,
@@ -24201,8 +24999,10 @@ async function createTaskFlow(ctx3) {
     return;
   }
   await ctx3.reload?.();
-  if (createdId)
+  if (createdId) {
     ctx3.selectTask?.(createdId);
+    await ctx3.enterTask?.(createdId);
+  }
 }
 var init_task_actions = __esm(() => {
   init_account_detect();
@@ -25783,7 +26583,8 @@ function TasksShell(props) {
       await openNewTaskTab(session, defaultRepo);
       return true;
     },
-    selectTask: (id) => setSelectedId(id)
+    selectTask: (id) => setSelectedId(id),
+    enterTask: (id) => switchTo(id)
   };
   async function createTask() {
     await createTaskFlow(taskActions);
@@ -26132,11 +26933,21 @@ function ShortcutHints(props) {
         label: "move panes"
       });
     }
+    const layoutGroup = (label, ids) => {
+      const chords = ids.map((id) => b[id]?.chord).filter((chord) => !!chord);
+      if (chords.length > 0)
+        out.push({
+          k: `prefix ${chords.join("/")}`,
+          label
+        });
+    };
     if (b["tmux.detach"])
       out.push({
         k: b["tmux.detach"].chord,
         label: "tasks\u2192detach"
       });
+    layoutGroup("splits", ["tmux.layout.workspaceSplit", "tmux.layout.workspaceClose", "tmux.layout.workspaceReset"]);
+    layoutGroup("panes", ["tmux.layout.tasksToggle", "tmux.layout.opsToggle", "tmux.layout.terminalToggle"]);
     return out;
   };
   const defaultHints = () => {
@@ -29139,6 +29950,12 @@ function parseOpsFlags(argv) {
     } else if (flag === "--initial-task-id") {
       flags.initialTaskId = value;
       i++;
+    } else if (flag === "--action") {
+      flags.action = value;
+      i++;
+    } else if (flag === "--window") {
+      flags.windowId = value;
+      i++;
     }
   }
   return flags;
@@ -29277,7 +30094,7 @@ async function main() {
       process.exit(2);
     }
     const { selectTasksPane: selectTasksPane2 } = await Promise.resolve().then(() => (init_tmux(), exports_tmux));
-    await selectTasksPane2(session);
+    await selectTasksPane2(session, { windowId: flags.windowId });
     return;
   }
   if (subcommand === "heal-layout") {
@@ -29308,6 +30125,34 @@ async function main() {
     });
     return;
   }
+  if (subcommand === "layout") {
+    const flags = parseOpsFlags(rest);
+    const session = flags.session;
+    if (!session) {
+      console.error("kobe layout: --session <name> is required");
+      process.exit(2);
+    }
+    const action = flags.action;
+    const valid = new Set([
+      "workspace-split",
+      "workspace-close",
+      "workspace-reset",
+      "tasks-toggle",
+      "tasks-restore",
+      "ops-toggle",
+      "terminal-toggle",
+      "chat-tab-close"
+    ]);
+    if (!action || !valid.has(action)) {
+      console.error("kobe layout: --action must be one of workspace-split, workspace-close, workspace-reset, tasks-toggle, tasks-restore, ops-toggle, terminal-toggle, chat-tab-close");
+      process.exit(2);
+    }
+    const { runLayoutAction: runLayoutAction2 } = await Promise.resolve().then(() => (init_tmux(), exports_tmux));
+    await runLayoutAction2(session, action, {
+      windowId: flags.windowId
+    });
+    return;
+  }
   if (subcommand === "quick-task") {
     const flags = parseOpsFlags(rest);
     const { startQuickTaskHost: startQuickTaskHost2 } = await Promise.resolve().then(() => (init_host2(), exports_host2));