@band-app/server 0.27.0 → 0.27.2

package/dist/start-server.mjs

@@ -30394,6 +30394,20 @@ var init_claude_code = __esm({
           args: [prompt]
         };
       }
+      /**
+       * Headless one-shot invocation for automated terminal dispatch (cronjobs,
+       * issue #581). `claude -p "<prompt>"` runs the prompt in print
+       * (non-interactive) mode and exits when the turn completes — unlike
+       * `cliInvocation`'s bare `claude "<prompt>"`, which opens the REPL and
+       * stays parked. The prompt is the value of `-p`, so a leading `-` in it is
+       * consumed as the flag's argument rather than parsed as a flag.
+       */
+      cliHeadlessInvocation(prompt) {
+        return {
+          command: this.executablePath ?? CLAUDE_CODE_DEFAULT_BINARY,
+          args: ["-p", prompt]
+        };
+      }
       /**
        * Resume CLI invocation for the chat tab's "Continue in terminal" action.
        * `claude --resume <session-id>` reopens the interactive REPL with that
@@ -31148,6 +31162,18 @@ var init_cursor_cli = __esm({
           reason: "Cursor CLI has no interactive prompt-loading invocation; falling back to chat."
         };
       }
+      /**
+       * Cursor CLI is SDK-only (JSON over a managed subprocess) with no
+       * non-interactive vendor CLI to run in a pane, so headless terminal
+       * dispatch (cronjobs `via: "terminal"`, issue #581) also returns the
+       * `unsupported` sentinel — the cronjob service then falls back to chat.
+       */
+      cliHeadlessInvocation(_prompt) {
+        return {
+          unsupported: true,
+          reason: "Cursor CLI has no non-interactive CLI invocation; falling back to chat."
+        };
+      }
       /**
        * The chat tab's "Continue in terminal" action has no Cursor equivalent:
        * the agent runs over the SDK's managed JSON subprocess, with no
@@ -32346,6 +32372,18 @@ var init_codex = __esm({
           args: [prompt]
         };
       }
+      /**
+       * Headless one-shot invocation for automated terminal dispatch (cronjobs,
+       * issue #581). `codex exec "<prompt>"` runs the prompt non-interactively
+       * and exits on completion — unlike `cliInvocation`'s bare `codex
+       * "<prompt>"`, which opens the interactive TUI and stays parked.
+       */
+      cliHeadlessInvocation(prompt) {
+        return {
+          command: this.executablePath ?? CODEX_DEFAULT_BINARY,
+          args: ["exec", prompt]
+        };
+      }
       /**
        * Resume CLI invocation for the chat tab's "Continue in terminal" action.
        * `codex resume <session-id>` reopens the interactive Codex TUI with that
@@ -32735,6 +32773,25 @@ var init_gemini_cli = __esm({
           args: ["--", prompt]
         };
       }
+      /**
+       * Headless one-shot invocation for automated terminal dispatch (cronjobs,
+       * issue #581). `gemini --prompt=<prompt>` runs non-interactively and exits
+       * on completion — unlike `cliInvocation`'s `gemini -- "<prompt>"`, which
+       * opens the interactive REPL and stays parked. The `--prompt=<value>`
+       * joined form (rather than `--prompt <value>`) binds the prompt as the
+       * flag's argument even when it starts with `-`, mirroring the leading-dash
+       * safety the interactive `--` guard provides.
+       *
+       * `--output-format` is deliberately omitted (unlike `runSession`, which asks
+       * for NDJSON): a cron terminal shows plain human-readable output in the pane,
+       * not a machine-parsed stream.
+       */
+      cliHeadlessInvocation(prompt) {
+        return {
+          command: this.executablePath,
+          args: [`--prompt=${prompt}`]
+        };
+      }
       /**
        * The chat tab's "Continue in terminal" action has no Gemini equivalent:
        * the Gemini CLI has no session model, so there's no session ID to resume
@@ -33230,6 +33287,21 @@ var init_opencode = __esm({
           args: ["--prompt", prompt]
         };
       }
+      /**
+       * Headless one-shot invocation for automated terminal dispatch (cronjobs,
+       * issue #581). `opencode run "<prompt>"` executes the prompt
+       * non-interactively and exits on completion — unlike `cliInvocation`'s
+       * `opencode --prompt "<prompt>"`, which opens the interactive TUI and stays
+       * parked. `run` takes the prompt as its trailing positional (same shape as
+       * the SDK `runSession` path above, minus the JSON formatting we only need
+       * when parsing programmatically).
+       */
+      cliHeadlessInvocation(prompt) {
+        return {
+          command: this.executablePath,
+          args: ["run", prompt]
+        };
+      }
       /**
        * Resume CLI invocation for the chat tab's "Continue in terminal" action.
        * `opencode --session <id>` launches the interactive TUI on that exact
@@ -101849,10 +101921,19 @@ var cronjobs = sqliteTable("cronjobs", {
   cronExpression: text2("cron_expression").notNull(),
   scope: text2("scope", { enum: ["project", "workspace"] }).notNull(),
   workspaceId: text2("workspace_id"),
+  // Where a fire dispatches the prompt (issue #581): "chat" submits a task to
+  // the workspace's cron chat pane (default, backward-compatible); "terminal"
+  // spawns the agent's vendor CLI in a fresh self-closing PTY pane. Mirrors the
+  // `via` discriminator on `workspaces.create` (#551).
+  via: text2("via", { enum: ["chat", "terminal"] }).notNull().default("chat"),
   enabled: integer2("enabled", { mode: "boolean" }).notNull().default(true),
   createdAt: text2("created_at").notNull(),
   lastRunAt: text2("last_run_at"),
-  lastRunStatus: text2("last_run_status", { enum: ["completed", "failed", "skipped"] })
+  lastRunStatus: text2("last_run_status", { enum: ["completed", "failed", "skipped"] }),
+  // For via="terminal" jobs, the id of the terminal spawned by the most recent
+  // fire. Used as the overlap-check handle: if this PTY is still alive when the
+  // next tick fires, the run is skipped rather than launching a second agent.
+  lastTerminalId: text2("last_terminal_id")
 });
 var usageEvents = sqliteTable(
   "usage_events",
@@ -111498,7 +111579,7 @@ var badgeVariants = cva(
 // ../../packages/ui/src/components/button.tsx
 var import_jsx_runtime20 = __toESM(require_jsx_runtime(), 1);
 var buttonVariants = cva(
-  "inline-flex shrink-0 items-center justify-center gap-2 rounded-md text-sm font-medium whitespace-nowrap transition-all outline-none focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+  "inline-flex shrink-0 items-center justify-center gap-2 rounded-md text-sm font-medium whitespace-nowrap transition-[color,background-color,border-color,box-shadow,opacity,transform] outline-none active:scale-[0.97] focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
   {
     variants: {
       variant: {
@@ -111597,10 +111678,10 @@ function DialogOverlay2({
   );
 }
 var DIALOG_CONTENT_VARIANTS = {
-  default: "fixed top-[50%] left-[50%] z-50 grid w-full max-w-[calc(100%-2rem)] translate-x-[-50%] translate-y-[-50%] gap-4 rounded-lg border bg-background p-6 shadow-lg duration-200 outline-none data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[state=open]:animate-in data-[state=open]:fade-in-0 data-[state=open]:zoom-in-95 sm:max-w-lg",
+  default: "ease-out fixed top-[50%] left-[50%] z-50 grid w-full max-w-[calc(100%-2rem)] translate-x-[-50%] translate-y-[-50%] gap-4 rounded-lg border bg-background p-6 shadow-lg duration-200 outline-none data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[state=open]:animate-in data-[state=open]:fade-in-0 data-[state=open]:zoom-in-95 sm:max-w-lg",
   "bottom-sheet": [
     // Shared
-    "fixed z-50 flex flex-col bg-background shadow-lg duration-200 outline-none",
+    "ease-out fixed z-50 flex flex-col bg-background shadow-lg duration-200 outline-none",
     "data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:animate-in data-[state=open]:fade-in-0",
     // Mobile (< lg): bottom drawer
     "inset-x-0 bottom-0 w-full max-w-none rounded-t-2xl border border-b-0 p-6",
@@ -111612,8 +111693,11 @@ var DIALOG_CONTENT_VARIANTS = {
   ].join(" "),
   "command-palette": [
     // Shared
-    "fixed z-50 flex flex-col bg-background shadow-lg duration-200 outline-none",
-    "data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:animate-in data-[state=open]:fade-in-0",
+    "fixed z-50 flex flex-col bg-background shadow-lg outline-none",
+    // Mobile-only open/close animation: the drawer slide is touch-initiated.
+    // Desktop (lg+) gets NO open/close animation — this is a keyboard-summoned
+    // surface hit dozens of times a day; it must appear instantly.
+    "max-lg:duration-200 max-lg:data-[state=closed]:animate-out max-lg:data-[state=closed]:fade-out-0 max-lg:data-[state=open]:animate-in max-lg:data-[state=open]:fade-in-0",
     // Mobile (< lg): bottom drawer with the input pinned to the bottom. Flip
     // the command's flex direction so the input sits below the results list,
     // and flip the input wrapper's divider to a top border to match. The sheet
@@ -111626,8 +111710,7 @@ var DIALOG_CONTENT_VARIANTS = {
     "max-lg:data-[state=open]:slide-in-from-bottom max-lg:data-[state=closed]:slide-out-to-bottom",
     // Desktop (lg+): anchored in the upper third by its TOP edge — no
     // `translate-y`, so the input never moves as the list grows downward.
-    "lg:inset-x-auto lg:bottom-auto lg:top-[12vh] lg:left-1/2 lg:w-full lg:max-w-lg lg:max-h-[70vh] lg:-translate-x-1/2 lg:rounded-lg lg:border",
-    "lg:data-[state=open]:zoom-in-95 lg:data-[state=closed]:zoom-out-95"
+    "lg:inset-x-auto lg:bottom-auto lg:top-[12vh] lg:left-1/2 lg:w-full lg:max-w-lg lg:max-h-[70vh] lg:-translate-x-1/2 lg:rounded-lg lg:border"
   ].join(" ")
 };
 var keyboardInsetHolders = /* @__PURE__ */ new Set();
@@ -111663,7 +111746,15 @@ function DialogContent2({
 }) {
   useKeyboardInset(variant === "command-palette");
   return /* @__PURE__ */ (0, import_jsx_runtime28.jsxs)(DialogPortal2, { "data-slot": "dialog-portal", children: [
-    /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(DialogOverlay2, { className: overlayClassName }),
+    /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(
+      DialogOverlay2,
+      {
+        className: cn(
+          variant === "command-palette" && "lg:data-[state=open]:animate-none lg:data-[state=closed]:animate-none",
+          overlayClassName
+        )
+      }
+    ),
     /* @__PURE__ */ (0, import_jsx_runtime28.jsxs)(
       dist_exports2.Content,
       {
@@ -111774,7 +111865,7 @@ function ContextMenuContent2({
         if (event.button === 2) event.stopPropagation();
       },
       className: cn(
-        "z-50 max-h-(--radix-context-menu-content-available-height) min-w-[8rem] origin-(--radix-context-menu-content-transform-origin) overflow-x-hidden overflow-y-auto rounded-md border border-border bg-popover p-1 text-popover-foreground shadow-md data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[state=open]:animate-in data-[state=open]:fade-in-0 data-[state=open]:zoom-in-95",
+        "ease-out duration-150 z-50 max-h-(--radix-context-menu-content-available-height) min-w-[8rem] origin-(--radix-context-menu-content-transform-origin) overflow-x-hidden overflow-y-auto rounded-md border border-border bg-popover p-1 text-popover-foreground shadow-md data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[state=open]:animate-in data-[state=open]:fade-in-0 data-[state=open]:zoom-in-95",
         className
       ),
       ...props
@@ -111868,7 +111959,7 @@ function TooltipContent2({
       "data-slot": "tooltip-content",
       sideOffset,
       className: cn(
-        "z-50 w-fit origin-(--radix-tooltip-content-transform-origin) animate-in rounded-md bg-foreground px-3 py-1.5 text-xs text-balance text-background fade-in-0 zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95",
+        "z-50 w-fit origin-(--radix-tooltip-content-transform-origin) animate-in fade-in-0 duration-100 ease-out rounded-md bg-foreground px-3 py-1.5 text-xs text-balance text-background data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:duration-75",
         className
       ),
       ...props,
@@ -120638,7 +120729,7 @@ function mimeTypeFromFilename(filename) {
 init_src();
 init_zod();
 import { execFile as execFile6 } from "node:child_process";
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import { existsSync as existsSync9, mkdirSync as mkdirSync5, unlinkSync as unlinkSync3 } from "node:fs";
 import { rm } from "node:fs/promises";
 import { join as join20 } from "node:path";
@@ -121554,6 +121645,7 @@ setBrowserLookup((browserId) => browserService.get(browserId));
 
 // src/server/services/cronjob-service.ts
 init_src();
+import { randomUUID as randomUUID3 } from "node:crypto";
 
 // ../../node_modules/.pnpm/croner@10.0.1/node_modules/croner/dist/croner.js
 function T(s6) {
@@ -122247,10 +122339,12 @@ var CronjobQueries = class _CronjobQueries {
           cronExpression: job.cronExpression,
           scope: job.scope,
           workspaceId: job.workspaceId ?? null,
+          via: job.via ?? "chat",
           enabled: job.enabled,
           createdAt: job.createdAt,
           lastRunAt: job.lastRunAt ?? null,
-          lastRunStatus: job.lastRunStatus ?? null
+          lastRunStatus: job.lastRunStatus ?? null,
+          lastTerminalId: job.lastTerminalId ?? null
         }).run();
       }
     });
@@ -122282,6 +122376,19 @@ var CronjobQueries = class _CronjobQueries {
     const db2 = getDb();
     db2.update(cronjobs).set({ lastRunAt: (/* @__PURE__ */ new Date()).toISOString(), lastRunStatus: status }).where(eq2(cronjobs.id, jobId)).run();
   }
+  /**
+   * Record (or clear) the terminal a via="terminal" fire spawned.
+   *
+   * Dedicated targeted UPDATE — same rationale as `updateLastRun`: the fire
+   * path shouldn't load + diff + rewrite the whole file just to stamp one
+   * column. The stored id is the handle the scheduler uses on the next tick to
+   * decide whether the previous run is still in flight (skip) or finished
+   * (spawn a fresh pane). Pass `null` to clear it.
+   */
+  updateLastTerminal(jobId, terminalId) {
+    const db2 = getDb();
+    db2.update(cronjobs).set({ lastTerminalId: terminalId }).where(eq2(cronjobs.id, jobId)).run();
+  }
   /**
    * Convert a Drizzle row into the optional-T-shaped `CronjobDefinition`.
    *
@@ -122296,1097 +122403,1242 @@ var CronjobQueries = class _CronjobQueries {
       cronExpression: row.cronExpression,
       scope: row.scope,
       workspaceId: row.workspaceId ?? void 0,
+      via: row.via ?? "chat",
       enabled: row.enabled,
       createdAt: row.createdAt,
       lastRunAt: row.lastRunAt ?? void 0,
-      lastRunStatus: row.lastRunStatus
+      lastRunStatus: row.lastRunStatus,
+      lastTerminalId: row.lastTerminalId ?? void 0
     };
   }
 };
 
-// src/server/services/cronjob-service.ts
-var log20 = createLogger("cronjob-service");
-var SCHEDULER_KEY = Symbol.for("band.cronjob-scheduler");
-var g12 = globalThis;
-if (!g12[SCHEDULER_KEY]) {
-  g12[SCHEDULER_KEY] = {
-    jobs: /* @__PURE__ */ new Map(),
-    started: false
-  };
-}
-function schedulerState() {
-  return g12[SCHEDULER_KEY];
-}
-var cronjobCreateInput = external_exports.object({
-  key: external_exports.string().min(1),
-  name: external_exports.string().min(1),
-  prompt: external_exports.string().min(1),
-  cronExpression: external_exports.string().min(1),
-  scope: external_exports.enum(["project", "workspace"]),
-  workspaceId: external_exports.string().optional(),
-  enabled: external_exports.boolean().default(true)
-});
-var cronjobUpdateInput = external_exports.object({
-  // `.min(1)` rejects the obviously invalid empty-string `key`/`id` at the
-  // validator instead of letting it reach the service, which would
-  // `loadFile("")` an empty result and 404 on `findIndex`. The legacy
-  // router accepted bare `z.string()` here; the migration is the natural
-  // moment to tighten the boundary so the create + update shapes stay
-  // consistent (`cronjobCreateInput.key` already has `.min(1)`).
-  key: external_exports.string().min(1),
-  id: external_exports.string().min(1),
-  name: external_exports.string().min(1).optional(),
-  prompt: external_exports.string().min(1).optional(),
-  cronExpression: external_exports.string().min(1).optional(),
-  enabled: external_exports.boolean().optional()
-});
-var cronjobByIdInput = external_exports.object({
-  key: external_exports.string().min(1),
-  id: external_exports.string().min(1)
-});
-var CronjobNotFoundError = class extends Error {
-  constructor(message = "Cronjob not found") {
-    super(message);
-    this.name = "CronjobNotFoundError";
-  }
-};
-var InvalidCronExpressionError = class extends Error {
-  constructor(message = "Invalid cron expression") {
-    super(message);
-    this.name = "InvalidCronExpressionError";
-  }
-};
-var CronjobWorkspaceMissingError = class extends Error {
-  constructor(message = "workspaceId is required for workspace-scoped cronjobs") {
-    super(message);
-    this.name = "CronjobWorkspaceMissingError";
-  }
-};
-var CronjobProjectNotFoundError = class extends Error {
-  constructor(message = "Project not found") {
-    super(message);
-    this.name = "CronjobProjectNotFoundError";
-  }
-};
-var CronjobService = class {
-  constructor(queries = new CronjobQueries()) {
-    this.queries = queries;
-  }
-  // -------------------------------------------------------------------------
-  // Read operations
-  // -------------------------------------------------------------------------
+// src/server/services/terminal-service.ts
+init_src();
+init_zod();
+
+// src/server/infra/terminals/terminal-pool.ts
+init_src();
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { existsSync as existsSync8, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join19, sep as sep3 } from "node:path";
+var log20 = createLogger("terminal-pool");
+var MAX_SCROLLBACK_SIZE = 1e5;
+var TerminalPool = class {
+  /** terminalId -> session */
+  terminals = /* @__PURE__ */ new Map();
+  /** workspaceId -> Set<terminalId> (reverse index for workspace-level cleanup) */
+  workspaceTerminals = /* @__PURE__ */ new Map();
+  /** terminalId -> Set<listener> for live output streaming */
+  outputListeners = /* @__PURE__ */ new Map();
   /**
-   * List jobs for a key, or — if neither `project` nor `workspaceId` is
-   * provided — every cronjob across every key.
+   * terminalId -> in-flight spawn promise. A single terminal is created via TWO
+   * concurrent paths — the WebSocket handler (spawn-on-`getSession`-miss) and
+   * the tRPC `terminal.create` mutation. Without deduplication both spawn a PTY
+   * and the second `terminals.set` overwrites the first, so the client stays
+   * wired to one PTY while the server's session map (and thus scrollback /
+   * `terminals output` / reconnect-replay) points at the other. That's the
+   * "output on screen but empty server scrollback until reload" bug
+   * (band-app/band#617). This map makes concurrent spawns share ONE PTY.
+   */
+  spawning = /* @__PURE__ */ new Map();
+  /**
+   * Spawn (or return the already-spawning/spawned) PTY for a terminalId.
    *
-   * Mirrors the legacy tRPC `cronjobs.list` shape so the router stays a
-   * straight delegate. The "all" branch returns `fileKey` on each row
-   * because callers (the dashboard's cronjob settings page) need both
-   * pieces to render the project/workspace breadcrumbs.
+   * Idempotent per terminalId: if a session already exists it is returned
+   * as-is, and concurrent spawn calls for the same id share a single in-flight
+   * promise — so the WebSocket and tRPC create paths never create competing
+   * PTYs. `workspaceRoot` is the absolute worktree path; resolving the
+   * workspaceId to a path is the service tier's job so the pool stays oblivious
+   * to the workspace registry.
    */
-  list(filter) {
-    if (filter?.project) {
-      const { project } = filter;
-      const file = this.queries.loadFile(project);
-      return { jobs: file.jobs.map((j) => ({ ...j, fileKey: project })) };
-    }
-    if (filter?.workspaceId) {
-      const { workspaceId } = filter;
-      const file = this.queries.loadFile(workspaceId);
-      return {
-        jobs: file.jobs.map((j) => ({ ...j, fileKey: workspaceId }))
-      };
+  async spawn(workspaceId, terminalId, workspaceRoot, options2, onExit) {
+    const existing = this.terminals.get(terminalId);
+    if (existing) return existing;
+    const inflight = this.spawning.get(terminalId);
+    if (inflight) return inflight;
+    const promise = this.spawnNew(workspaceId, terminalId, workspaceRoot, options2, onExit);
+    this.spawning.set(terminalId, promise);
+    try {
+      return await promise;
+    } finally {
+      this.spawning.delete(terminalId);
     }
-    return { jobs: this.queries.listAll() };
   }
-  /** Get a single job by `key` + `id`. Throws `CronjobNotFoundError` if absent. */
-  get(key, id) {
-    const job = this.findJob(key, id);
-    if (!job) throw new CronjobNotFoundError();
-    return { job };
+  async spawnNew(workspaceId, terminalId, workspaceRoot, options2, onExit) {
+    const shell = defaultShell();
+    const resolvedPath = await shellPath();
+    const env = {};
+    for (const [key, value] of Object.entries(process.env)) {
+      if (value != null) {
+        env[key] = value;
+      }
+    }
+    env.PATH = resolvedPath;
+    env.TERM = "xterm-256color";
+    env.COLORTERM = "truecolor";
+    env.COLORFGBG = "15;0";
+    delete env.PORT;
+    if (options2?.env) {
+      Object.assign(env, options2.env);
+    }
+    env.BAND_DISPATCH = "terminal";
+    let cwd = workspaceRoot;
+    if (options2?.cwd) {
+      const resolved = join19(workspaceRoot, options2.cwd);
+      if (resolved !== workspaceRoot && !resolved.startsWith(workspaceRoot + sep3)) {
+        log20.warn(
+          "Ignoring cwd %s \u2014 resolves outside workspace root %s",
+          options2.cwd,
+          workspaceRoot
+        );
+      } else if (existsSync8(resolved)) {
+        cwd = resolved;
+      } else {
+        log20.warn("Ignoring cwd %s \u2014 directory does not exist", options2.cwd);
+      }
+    }
+    if (!existsSync8(cwd)) {
+      throw new Error(`Workspace directory does not exist: ${cwd}`);
+    }
+    if (!existsSync8(shell)) {
+      throw new Error(`Shell not found: ${shell}`);
+    }
+    log20.debug(
+      "Spawning shell %s in %s for terminal %s (PATH=%s)",
+      shell,
+      cwd,
+      terminalId,
+      resolvedPath.slice(0, 200)
+    );
+    const nodePty = await import("node-pty");
+    let ptyProcess;
+    try {
+      ptyProcess = nodePty.spawn(shell, [], {
+        name: "xterm-256color",
+        cols: 80,
+        rows: 24,
+        cwd,
+        env
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log20.error("pty.spawn failed: %s (shell=%s, cwd=%s)", msg, shell, cwd);
+      throw err;
+    }
+    const session = { pty: ptyProcess, scrollback: "", workspaceId };
+    this.terminals.set(terminalId, session);
+    if (options2?.command) {
+      this.autoRunCommand(session, options2.command);
+    }
+    let ids = this.workspaceTerminals.get(workspaceId);
+    if (!ids) {
+      ids = /* @__PURE__ */ new Set();
+      this.workspaceTerminals.set(workspaceId, ids);
+    }
+    ids.add(terminalId);
+    ptyProcess.onData((data) => {
+      session.scrollback += data;
+      if (session.scrollback.length > MAX_SCROLLBACK_SIZE) {
+        session.scrollback = session.scrollback.slice(-MAX_SCROLLBACK_SIZE);
+      }
+      const listeners3 = this.outputListeners.get(terminalId);
+      if (listeners3) {
+        for (const cb2 of listeners3) {
+          try {
+            cb2(data);
+          } catch {
+          }
+        }
+      }
+    });
+    ptyProcess.onExit(() => {
+      log20.debug("Terminal exited: %s (workspace %s)", terminalId, workspaceId);
+      const explicitlyKilled = !this.terminals.has(terminalId);
+      this.terminals.delete(terminalId);
+      this.outputListeners.delete(terminalId);
+      const set = this.workspaceTerminals.get(workspaceId);
+      if (set) {
+        set.delete(terminalId);
+        if (set.size === 0) {
+          this.workspaceTerminals.delete(workspaceId);
+        }
+      }
+      if (session.autoRunFile) {
+        try {
+          unlinkSync2(session.autoRunFile);
+        } catch {
+        }
+      }
+      if (onExit && !explicitlyKilled) {
+        try {
+          onExit();
+        } catch (err) {
+          log20.warn("onExit callback threw for terminal %s: %s", terminalId, err);
+        }
+      }
+    });
+    return session;
   }
-  // -------------------------------------------------------------------------
-  // Mutations
-  // -------------------------------------------------------------------------
   /**
-   * Create a new cronjob and re-bind the scheduler.
+   * Auto-run the workspace's initial command inside a freshly spawned PTY,
+   * robustly.
    *
-   * Validates the cron expression by attempting to construct a `Cron` with
-   * `maxRuns: 0` (parses without scheduling). Throws
-   * `InvalidCronExpressionError` for a bad expression and
-   * `CronjobWorkspaceMissingError` when a workspace-scoped job is missing
-   * its `workspaceId`.
+   * Writing a long command line straight into a cold PTY is racy on three
+   * fronts, all of which surfaced in production with `via=terminal`
+   * prompt-as-argv launches (`'<agent-binary>' '<entire-prompt>'`):
+   *
+   *   1. **Dropped newline.** The shell may not have finished sourcing its
+   *      rc files, and the tty can still be in its startup canonical-mode
+   *      window. A trailing `\n` written then is swallowed — the command
+   *      is typed at the prompt but never executed.
+   *   2. **Truncation.** A single input line longer than the tty's
+   *      canonical buffer (`MAX_CANON`, ~4 KB) is clipped. Long prompts
+   *      blow past that easily.
+   *   3. **UTF-8 corruption.** A multi-byte sequence split across a tty
+   *      buffer boundary is mangled (the classic em-dash → mojibake).
+   *
+   * Fix both layers: (1) stage the command's bytes in a temp file so they
+   * never traverse the tty's canonical input buffer — sidestepping the
+   * truncation and UTF-8-split failures entirely — and (2) wait for the
+   * shell to emit its first output (its prompt) before writing the
+   * *short* `source <file>` line. The short line is well under the
+   * canonical limit and lands after the cold-start window, so its newline
+   * survives. `source` runs the command in the current interactive shell,
+   * so the user keeps their session afterwards.
    */
-  create(input) {
-    this.assertValidCron(input.cronExpression);
-    if (input.scope === "workspace" && !input.workspaceId) {
-      throw new CronjobWorkspaceMissingError();
+  autoRunCommand(session, command) {
+    const pty = session.pty;
+    let cmdFile;
+    try {
+      cmdFile = join19(tmpdir(), `band-autorun-${randomUUID2()}.sh`);
+      writeFileSync2(cmdFile, `${command}
+`, { encoding: "utf-8", mode: 384, flag: "wx" });
+      session.autoRunFile = cmdFile;
+    } catch (err) {
+      log20.warn(
+        "autoRunCommand: temp-file staging failed (%s); writing command directly",
+        err instanceof Error ? err.message : String(err)
+      );
+      pty.write(`${command}
+`);
+      return;
     }
-    const file = this.queries.loadFile(input.key);
-    const job = {
-      id: generateCronjobId(),
-      name: input.name,
-      prompt: input.prompt,
-      cronExpression: input.cronExpression,
-      scope: input.scope,
-      workspaceId: input.workspaceId,
-      enabled: input.enabled,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    const quotedPath = cmdFile.replace(/'/g, `'\\''`);
+    const sourceLine = `. '${quotedPath}'
+`;
+    let done = false;
+    const inject = () => {
+      if (done) return;
+      done = true;
+      try {
+        pty.write(sourceLine);
+      } catch (err) {
+        log20.warn("autoRunCommand: failed to inject command line (%s)", err);
+      }
     };
-    file.jobs.push(job);
-    this.queries.saveFile(input.key, file);
-    this.reloadSchedules();
-    return { job };
+    let dataDisposed = false;
+    const disposeData = () => {
+      if (dataDisposed) return;
+      dataDisposed = true;
+      dataDisposable.dispose();
+    };
+    const dataDisposable = pty.onData(() => {
+      disposeData();
+      inject();
+    });
+    const timer = setTimeout(inject, 750);
+    timer.unref();
+    let exitDisposed = false;
+    const exitDisposable = pty.onExit(() => {
+      done = true;
+      clearTimeout(timer);
+      disposeData();
+      if (exitDisposed) return;
+      exitDisposed = true;
+      exitDisposable.dispose();
+    });
   }
   /**
-   * Partially update an existing cronjob.
-   *
-   * Each optional field is applied only when present, matching the legacy
-   * router behavior. If `cronExpression` is supplied it's validated before
-   * the write. Throws `CronjobNotFoundError` if no job matches `key`+`id`.
+   * Returns an existing PTY session by terminalId, or undefined.
    */
-  update(input) {
-    if (input.cronExpression !== void 0) {
-      this.assertValidCron(input.cronExpression);
-    }
-    const file = this.queries.loadFile(input.key);
-    const job = file.jobs.find((j) => j.id === input.id);
-    if (!job) throw new CronjobNotFoundError();
-    if (input.name !== void 0) job.name = input.name;
-    if (input.prompt !== void 0) job.prompt = input.prompt;
-    if (input.cronExpression !== void 0) job.cronExpression = input.cronExpression;
-    if (input.enabled !== void 0) job.enabled = input.enabled;
-    this.queries.saveFile(input.key, file);
-    this.reloadSchedules();
-    return { job };
+  get(terminalId) {
+    return this.terminals.get(terminalId);
   }
   /**
-   * Delete a cronjob and re-bind the scheduler.
-   *
-   * Throws `CronjobNotFoundError` if the job is already gone.
+   * Resize the underlying PTY. No-op if the terminal isn't known to the pool.
    */
-  delete(key, id) {
-    const file = this.queries.loadFile(key);
-    const index3 = file.jobs.findIndex((j) => j.id === id);
-    if (index3 === -1) throw new CronjobNotFoundError();
-    file.jobs.splice(index3, 1);
-    this.queries.saveFile(key, file);
-    this.reloadSchedules();
-    return { ok: true };
+  resize(terminalId, cols, rows) {
+    const session = this.terminals.get(terminalId);
+    if (session) {
+      session.pty.resize(cols, rows);
+    }
   }
   /**
-   * Fire a cronjob synchronously (manual "run now" path).
-   *
-   * Uses the same `band:cronId`-labeled chat as the scheduled fire so the
-   * user sees both paths converge on a single dedicated conversation
-   * (issue #520). `submitTask` may throw `TaskConflictError`, which the API
-   * tier translates into a 409 Conflict response.
+   * List metadata for every PTY session bound to the given workspace.
    *
-   * Atomicity caveat: `getOrCreateCronjobChat` and `submitTask` are not run
-   * inside a single transaction. If `createChat` succeeds but `submitTask`
-   * later throws an unexpected (non-`TaskConflictError`) error, the
-   * freshly-created chat remains in the workspace as an orphan with no
-   * task ever attached. The next manual `trigger` (or scheduled fire)
-   * reuses that chat via its `band:cronId` label, so the orphan
-   * self-heals — but the user may briefly see an empty chat pane. The
-   * legacy implementation had the same gap; preserved here to match
-   * existing behavior. If this ever needs to be tightened, the fix is
-   * either (a) wrap both calls in a try/catch that deletes the chat on
-   * unexpected failure, or (b) defer `createChat` until `submitTask`
-   * succeeds (which would require buffering the chat name/labels on the
-   * task row).
+   * The returned `title` is the foreground process name reported by the
+   * PTY; reading `pty.process` can throw if the process has already exited
+   * between the reverse-index lookup and the read, so the read is wrapped.
    */
-  trigger(key, id) {
-    const job = this.findJob(key, id);
-    if (!job) throw new CronjobNotFoundError();
-    const workspaceId = this.resolveWorkspaceId(job, key);
-    if (!workspaceId) throw new CronjobProjectNotFoundError();
-    const cronChat = this.getOrCreateCronjobChat(workspaceId, job);
-    const task = taskService.submitTask({ workspaceId, chatId: cronChat.id, prompt: job.prompt });
-    return { taskId: task.id, workspaceId, chatId: cronChat.id };
+  list(workspaceId) {
+    const ids = this.workspaceTerminals.get(workspaceId);
+    if (!ids) return [];
+    const result = [];
+    for (const terminalId of ids) {
+      const session = this.terminals.get(terminalId);
+      if (session) {
+        let title = "";
+        try {
+          title = session.pty.process;
+        } catch {
+        }
+        result.push({
+          terminalId,
+          workspaceId,
+          pid: session.pty.pid,
+          scrollbackLength: session.scrollback.length,
+          title
+        });
+      }
+    }
+    return result;
   }
-  // -------------------------------------------------------------------------
-  // Lifecycle hooks for workspace/project removal
-  // -------------------------------------------------------------------------
   /**
-   * Stop all timers for jobs in `key` and remove the file rows.
-   *
-   * Called when a workspace or project is removed. Order matters: stop
-   * timers first so no further fires queue up between the timer-stop and
-   * the row-delete. An in-flight fire is already safe in either order
-   * because `executeCronjob` operates on closed-over `job`/`fileKey` (it
-   * never re-reads the row) and `safeUpdateLastRun` swallows the
-   * row-missing case. The two steps were previously two separate calls
-   * (`stopJobsForKey` + `deleteCronjobFile`) at every call site — the
-   * legacy callers always invoked them in pairs, so they're collapsed
-   * here to make the contract harder to misuse.
-   *
-   * Partial-failure recovery: if `deleteFile` throws (e.g. a transient DB
-   * lock), the timers are already stopped but the rows remain in the DB.
-   * The next `reloadSchedules()` call — triggered by any subsequent
-   * cronjob mutation, or by a server restart — re-reads the rows from the
-   * DB and re-registers the timers, so the orphaned rows self-heal
-   * without manual intervention. We do NOT roll back the `stop()` calls
-   * because re-binding timers for a workspace that's mid-deletion is
-   * worse than leaving them stopped: the workspace path is about to be
-   * removed and any fire that races the removal would target a
-   * non-existent worktree. Re-registration on the next reload is the
-   * intentional recovery strategy; operators encountering a partial
-   * failure on this path should expect the next reload to be a no-op
-   * once the workspace removal completes and the rows are re-attempted.
+   * Returns the scrollback buffer for a terminal, optionally limited to the
+   * last N lines. Returns `null` if the terminal is not found.
    */
-  removeForKey(key) {
-    this.stopJobsForKey(key);
-    this.queries.deleteFile(key);
-  }
-  // -------------------------------------------------------------------------
-  // Scheduler lifecycle
-  // -------------------------------------------------------------------------
-  /** Start the cronjob scheduler. Called once on server boot. */
-  start() {
-    const state = schedulerState();
-    if (state.started) return;
-    state.started = true;
-    this.loadAndScheduleAll();
-    log20.info("cronjob scheduler started");
+  getScrollback(terminalId, lines) {
+    const session = this.terminals.get(terminalId);
+    if (!session) return null;
+    if (lines == null) return session.scrollback;
+    const allLines = session.scrollback.split("\n");
+    return allLines.slice(-lines).join("\n");
   }
-  /** Stop the cronjob scheduler. Called on graceful shutdown. */
-  stop() {
-    const state = schedulerState();
-    for (const [, cron] of state.jobs) {
-      cron.stop();
+  /**
+   * Writes data to a terminal's PTY stdin.
+   * Returns false if the terminal is not found.
+   */
+  write(terminalId, data) {
+    const session = this.terminals.get(terminalId);
+    if (!session) return false;
+    session.pty.write(data);
+    return true;
+  }
+  /**
+   * Subscribe to live output from a terminal's PTY.
+   * Returns an unsubscribe function.
+   */
+  subscribeOutput(terminalId, callback) {
+    let listeners3 = this.outputListeners.get(terminalId);
+    if (!listeners3) {
+      listeners3 = /* @__PURE__ */ new Set();
+      this.outputListeners.set(terminalId, listeners3);
     }
-    state.jobs.clear();
-    state.started = false;
-    log20.info("cronjob scheduler stopped");
+    listeners3.add(callback);
+    return () => {
+      listeners3.delete(callback);
+      if (listeners3.size === 0) {
+        this.outputListeners.delete(terminalId);
+      }
+    };
   }
-  /** Reload all schedules from the database. Call after cronjob mutations. */
-  reloadSchedules() {
-    if (!schedulerState().started) return;
-    this.loadAndScheduleAll();
+  /**
+   * Kill a single terminal by terminalId.
+   */
+  kill(terminalId) {
+    const session = this.terminals.get(terminalId);
+    if (session) {
+      session.pty.kill();
+      this.terminals.delete(terminalId);
+      const set = this.workspaceTerminals.get(session.workspaceId);
+      if (set) {
+        set.delete(terminalId);
+        if (set.size === 0) {
+          this.workspaceTerminals.delete(session.workspaceId);
+        }
+      }
+    }
   }
   /**
-   * Stop all scheduled jobs for a key (e.g. when a workspace is removed).
-   *
-   * Private because the only correct call site is `removeForKey` above:
-   * stopping the timers without also dropping the rows would re-schedule
-   * the same jobs on the next `reloadSchedules()` tick. Keeping it
-   * accessible only through `removeForKey` prevents future callers from
-   * accidentally invoking just one half of the pair.
+   * Kill all terminals for a workspace.
    */
-  stopJobsForKey(key) {
-    const state = schedulerState();
-    const file = this.queries.loadFile(key);
-    for (const job of file.jobs) {
-      const cron = state.jobs.get(job.id);
-      if (cron) {
-        cron.stop();
-        state.jobs.delete(job.id);
-        log20.info({ jobId: job.id, key }, "stopped cronjob");
+  killWorkspace(workspaceId) {
+    const ids = this.workspaceTerminals.get(workspaceId);
+    if (!ids) return;
+    for (const terminalId of ids) {
+      const session = this.terminals.get(terminalId);
+      if (session) {
+        session.pty.kill();
+        this.terminals.delete(terminalId);
       }
     }
+    this.workspaceTerminals.delete(workspaceId);
+  }
+  /**
+   * Kill every tracked PTY (server shutdown path).
+   */
+  killAll() {
+    for (const [, session] of this.terminals) {
+      session.pty.kill();
+    }
+    this.terminals.clear();
+    this.workspaceTerminals.clear();
+  }
+};
+var terminalPool = new TerminalPool();
+
+// src/server/services/_utils/terminal-layout-manager.ts
+var manager = new DockviewLayoutManager("terminal_layout");
+var getTerminalLayout = (workspaceId) => manager.get(workspaceId);
+var saveTerminalLayout = (workspaceId, tree) => manager.save(workspaceId, tree);
+var deleteTerminalLayout = (workspaceId) => manager.delete(workspaceId);
+function addTerminalToLayout(workspaceId, terminalId, opts) {
+  manager.addPanel(workspaceId, {
+    id: terminalId,
+    contentComponent: "terminalTab",
+    tabComponent: "terminalTab",
+    title: opts?.title ?? "Terminal",
+    params: {
+      workspaceId,
+      terminalId,
+      ...opts?.command ? { command: opts.command } : {},
+      ...opts?.cwd ? { cwd: opts.cwd } : {},
+      ...opts?.env ? { env: opts.env } : {}
+    }
+  });
+}
+function removeTerminalFromLayout(workspaceId, terminalId) {
+  manager.removePanel(workspaceId, terminalId);
+}
+
+// src/server/services/terminal-service.ts
+var log21 = createLogger("terminal-service");
+var TerminalPaneConfigSchema = external_exports.object({
+  name: external_exports.string().optional(),
+  command: external_exports.string().optional(),
+  cwd: external_exports.string().optional(),
+  env: external_exports.record(external_exports.string()).optional(),
+  focus: external_exports.boolean().optional()
+});
+var PaneNodeSchema = external_exports.object({
+  pane: TerminalPaneConfigSchema
+});
+var TerminalLayoutNodeSchema = external_exports.lazy(
+  () => external_exports.union([
+    PaneNodeSchema,
+    external_exports.object({
+      direction: external_exports.enum(["horizontal", "vertical"]),
+      split: external_exports.number().min(0.1).max(0.9).optional().default(0.5),
+      children: external_exports.tuple([TerminalLayoutNodeSchema, TerminalLayoutNodeSchema])
+    })
+  ])
+);
+var WorkspaceTerminalConfigSchema = external_exports.object({
+  layout: TerminalLayoutNodeSchema
+});
+var TerminalService = class {
+  constructor(pool2 = terminalPool) {
+    this.pool = pool2;
   }
   // -------------------------------------------------------------------------
-  // Shared resolution helpers (used by both the API + the scheduled fire path)
+  // PTY lifecycle
   // -------------------------------------------------------------------------
   /**
-   * Find — or create — the dedicated chat this cronjob writes into.
+   * Spawn a new PTY for the given workspace + terminalId.
    *
-   * Issue #520: each cronjob owns its own chat in the workspace, looked up
-   * by the canonical `band:cronId` label. First call creates the chat;
-   * subsequent calls reuse it. If the user deletes the chat, the next call
-   * recreates it (intentional soft reset). This replaces the old
-   * `getOrCreateDefaultChat` dispatch, which silently latched onto whatever
-   * chat the user happened to be focused on. Shared between the scheduled
-   * fire path (`executeCronjob` below) and the manual `trigger` route so
-   * both stay aligned.
+   * Resolves `workspaceId` to a worktree path before delegating to the
+   * pool, and registers the new terminal in the saved dockview layout so it
+   * survives a server restart (mirrors `chatService.create` /
+   * `browserService.create`). Does NOT emit a `terminal-created` event —
+   * the API entry points decide whether to broadcast (the WebSocket handler
+   * stays silent; the tRPC `create` mutation emits explicitly).
    */
-  getOrCreateCronjobChat(workspaceId, job) {
-    const labelMatch = { [BAND_CRON_ID_LABEL]: job.id };
-    const existing = chatService.findByLabels(workspaceId, labelMatch);
-    if (existing) return existing;
-    return chatService.create(workspaceId, {
-      name: job.name,
-      labels: labelMatch,
-      // Cronjob scheduler is a trusted server-side caller — it's allowed
-      // to write the reserved `band:` prefix that user-facing surfaces
-      // are blocked from touching.
-      allowReservedLabels: true
+  async spawn(workspaceId, terminalId, options2, opts) {
+    const workspace = workspaceService.resolve(workspaceId);
+    if (!workspace) {
+      throw new Error(`Workspace not found: ${workspaceId}`);
+    }
+    const session = await this.pool.spawn(
+      workspaceId,
+      terminalId,
+      workspace.worktree.path,
+      options2,
+      opts?.cleanupOnExit ? () => this.emitRemoved(workspaceId, terminalId) : void 0
+    );
+    addTerminalToLayout(workspaceId, terminalId, {
+      command: options2?.command,
+      cwd: options2?.cwd,
+      env: options2?.env
     });
+    return session;
   }
   /**
-   * Resolve the workspace the cronjob fires into.
-   *
-   * Returns `null` for project-scoped jobs whose project no longer exists
-   * (which the scheduled fire path treats as a soft failure — see
-   * `executeCronjob`). The manual trigger route maps the same condition to
-   * a `CronjobProjectNotFoundError`.
-   *
-   * Workspace-scoped jobs return `null` rather than falling through to the
-   * project-resolution branch when `workspaceId` is somehow missing. The
-   * `create` path already rejects this via `CronjobWorkspaceMissingError`,
-   * but a workspace-scoped row written by an older server version could
-   * theoretically reach here with a null `workspaceId`. Falling through
-   * would silently misfire into the project's default branch; returning
-   * `null` makes the failure explicit (logged + `lastRunStatus = "failed"`
-   * for the scheduler; `CronjobProjectNotFoundError` for the manual
-   * trigger path).
+   * Kill a single terminal. Removes it from the saved dockview layout and
+   * emits `terminal-killed` so the dashboard's status stream prunes the
+   * panel. Safe to call with an unknown terminalId — no-op.
    */
-  resolveWorkspaceId(job, fileKey) {
-    if (job.scope === "workspace") {
-      return job.workspaceId ?? null;
+  kill(terminalId) {
+    const session = this.pool.get(terminalId);
+    const workspaceId = session?.workspaceId;
+    this.pool.kill(terminalId);
+    if (workspaceId) {
+      this.emitRemoved(workspaceId, terminalId);
     }
-    const appState = loadState();
-    const project = appState.projects.find((p6) => p6.name === fileKey);
-    if (!project) return null;
-    return toWorkspaceId(project.name, project.defaultBranch);
+  }
+  /**
+   * Drop a terminal from the saved dockview layout and broadcast
+   * `terminal-killed` so an open dashboard prunes the panel. Shared by the
+   * explicit {@link kill} path and the `cleanupOnExit` natural-exit hook wired
+   * up in {@link spawn}. Idempotent: `removeTerminalFromLayout` is a no-op when
+   * the panel is already gone, and a duplicate `terminal-killed` is harmless.
+   */
+  emitRemoved(workspaceId, terminalId) {
+    removeTerminalFromLayout(workspaceId, terminalId);
+    emit({ kind: "terminal-killed", workspaceId, terminalId });
+  }
+  /**
+   * Kill every PTY associated with a workspace. Used by the workspace
+   * deletion path — the caller is responsible for tearing down the layout
+   * tree via {@link deleteLayout} as well.
+   */
+  killWorkspace(workspaceId) {
+    this.pool.killWorkspace(workspaceId);
+  }
+  /**
+   * Kill every tracked PTY across all workspaces. Used by the server
+   * shutdown path in `start-server.ts`.
+   */
+  killAll() {
+    this.pool.killAll();
   }
   // -------------------------------------------------------------------------
-  // Internals
+  // Per-terminal accessors
   // -------------------------------------------------------------------------
-  findJob(key, id) {
-    const file = this.queries.loadFile(key);
-    return file.jobs.find((j) => j.id === id);
+  list(workspaceId) {
+    return this.pool.list(workspaceId);
   }
-  assertValidCron(expression) {
-    try {
-      const options2 = { maxRuns: 0 };
-      void new E2(expression, options2);
-    } catch {
-      throw new InvalidCronExpressionError();
-    }
+  getSession(terminalId) {
+    return this.pool.get(terminalId);
   }
-  scheduleJob(job, fileKey) {
-    const state = schedulerState();
-    const existing = state.jobs.get(job.id);
-    if (existing) {
-      existing.stop();
-      state.jobs.delete(job.id);
-    }
-    if (!job.enabled) return;
-    try {
-      const cronInstance = new E2(job.cronExpression, () => {
-        this.executeCronjob(job, fileKey).catch((err) => {
-          log20.error({ jobId: job.id, err }, "unhandled error in cronjob execution");
-        });
-      });
-      state.jobs.set(job.id, cronInstance);
-      log20.info(
-        { jobId: job.id, name: job.name, cron: job.cronExpression, scope: job.scope },
-        "scheduled cronjob"
-      );
-    } catch (err) {
-      log20.error(
-        { jobId: job.id, cronExpression: job.cronExpression, err },
-        "invalid cron expression, skipping job"
-      );
-    }
+  getScrollback(terminalId, lines) {
+    return this.pool.getScrollback(terminalId, lines);
   }
-  async executeCronjob(job, fileKey) {
-    const workspaceId = this.resolveWorkspaceId(job, fileKey);
-    if (!workspaceId) {
-      log20.warn({ jobId: job.id, fileKey }, "project not found for cronjob, skipping");
-      this.safeUpdateLastRun(job.id, "failed");
-      return;
-    }
-    log20.info({ jobId: job.id, name: job.name, workspaceId }, "executing cronjob");
-    try {
-      const chat = this.getOrCreateCronjobChat(workspaceId, job);
-      const task = taskService.submitTask({ workspaceId, chatId: chat.id, prompt: job.prompt });
-      log20.info(
-        { jobId: job.id, taskId: task.id, workspaceId, chatId: chat.id },
-        "cronjob task submitted"
-      );
-      this.safeUpdateLastRun(job.id, "completed");
-    } catch (err) {
-      if (err instanceof TaskConflictError) {
-        log20.info(
-          { jobId: job.id, workspaceId },
-          "task already running, skipping cronjob execution"
-        );
-        this.safeUpdateLastRun(job.id, "skipped");
-        return;
-      }
-      log20.error({ jobId: job.id, err }, "cronjob execution failed");
-      this.safeUpdateLastRun(job.id, "failed");
-    }
+  write(terminalId, data) {
+    return this.pool.write(terminalId, data);
+  }
+  resize(terminalId, cols, rows) {
+    this.pool.resize(terminalId, cols, rows);
+  }
+  subscribeOutput(terminalId, callback) {
+    return this.pool.subscribeOutput(terminalId, callback);
+  }
+  // -------------------------------------------------------------------------
+  // Layout persistence (dockview tree)
+  //
+  // Thin pass-throughs to `lib/terminal-layout-manager` so the API tier
+  // doesn't reach across into `lib/` directly. The layout helpers will be
+  // folded into a dedicated infra adapter in a follow-up phase (when the
+  // chats/browsers domains get their own infra adapters); leaving them in
+  // `lib/` for now is the minimum-disruption shape during the phased
+  // migration.
+  // -------------------------------------------------------------------------
+  getLayout(workspaceId) {
+    return getTerminalLayout(workspaceId);
   }
+  saveLayout(workspaceId, tree) {
+    saveTerminalLayout(workspaceId, tree);
+  }
+  deleteLayout(workspaceId) {
+    deleteTerminalLayout(workspaceId);
+  }
+  // -------------------------------------------------------------------------
+  // Workspace `.band/config.json` `workspace.terminal` block
+  // -------------------------------------------------------------------------
   /**
-   * Update `lastRunAt`/`lastRunStatus`, swallowing DB errors.
+   * Load and validate the `workspace.terminal` block from
+   * `.band/config.json`. Returns `null` when the workspace can't be
+   * resolved, the config file is absent, the block is missing, or the
+   * payload fails validation.
    *
-   * Errors here are diagnostic noise during the fire path — the cronjob
-   * already executed (or failed/skipped), and we don't want a transient
-   * DB lock to mask the real outcome by re-raising. The legacy
-   * implementation logged at `warn` and moved on; preserved here.
+   * Absorbed from the old `lib/terminal-config.ts:loadWorkspaceTerminalConfig`
+   * — same parsing semantics, but the lookup now goes through the service
+   * tier so callers (currently the workspace router's `getTerminalConfig`
+   * query) reach it via `terminalService` instead of a stand-alone helper.
    */
-  safeUpdateLastRun(jobId, status) {
-    try {
-      this.queries.updateLastRun(jobId, status);
-    } catch (err) {
-      log20.warn({ jobId, err }, "failed to update lastRun on cronjob");
-    }
+  getWorkspaceConfig(workspaceId) {
+    const workspace = workspaceService.resolve(workspaceId);
+    if (!workspace) return null;
+    return this.loadWorkspaceConfigFromPaths(workspace.worktree.path, workspace.project.path);
   }
-  loadAndScheduleAll() {
-    const state = schedulerState();
-    for (const [, cron] of state.jobs) {
-      cron.stop();
-    }
-    state.jobs.clear();
-    for (const job of this.queries.listAll()) {
-      this.scheduleJob(job, job.fileKey);
+  /**
+   * Internal: the path-driven parse so tests / future non-tRPC entry
+   * points can plug raw paths in without going through `resolveWorkspace`.
+   */
+  loadWorkspaceConfigFromPaths(worktreePath, projectPath) {
+    const raw = loadProjectConfig(worktreePath, projectPath);
+    if (!raw) return null;
+    const terminalBlock = raw.workspace && typeof raw.workspace === "object" ? raw.workspace.terminal : void 0;
+    if (!terminalBlock) return null;
+    const result = WorkspaceTerminalConfigSchema.safeParse(terminalBlock);
+    if (!result.success) {
+      log21.warn(
+        "Invalid workspace.terminal config: %s",
+        result.error.issues.map((i2) => `${i2.path.join(".")}: ${i2.message}`).join("; ")
+      );
+      return null;
     }
-    log20.info({ count: state.jobs.size }, "loaded cronjob schedules");
+    return result.data;
   }
 };
-var cronjobService = new CronjobService();
+var terminalService = new TerminalService();
 
-// src/server/services/panel-focus-service.ts
-init_src();
-var log21 = createLogger("panel-focus-service");
-var PANEL_FOCUS_TYPE = "panel_focus";
-function focusRowId(workspaceId) {
-  return `${PANEL_FOCUS_TYPE}:${workspaceId}`;
+// src/server/services/cronjob-service.ts
+var log22 = createLogger("cronjob-service");
+var SCHEDULER_KEY = Symbol.for("band.cronjob-scheduler");
+var g12 = globalThis;
+if (!g12[SCHEDULER_KEY]) {
+  g12[SCHEDULER_KEY] = {
+    jobs: /* @__PURE__ */ new Map(),
+    started: false,
+    spawningTerminals: /* @__PURE__ */ new Set()
+  };
 }
-var PanelFocusService = class {
-  /** workspaceId → last-focused panel ids. */
-  focus = /* @__PURE__ */ new Map();
-  /**
-   * Workspaces whose focus row has been loaded from the DB into `focus`.
-   * Separate from the map's own key presence because a workspace can have a
-   * loaded-but-empty record (row absent) — we still don't want to re-hit the
-   * DB on every read.
-   */
-  hydrated = /* @__PURE__ */ new Set();
-  /** Workspaces that already have a `panel_states` row (drives insert vs update). */
-  persisted = /* @__PURE__ */ new Set();
+function schedulerState() {
+  return g12[SCHEDULER_KEY];
+}
+var cronjobVia = external_exports.enum(["chat", "terminal"]);
+var cronjobCreateInput = external_exports.object({
+  key: external_exports.string().min(1),
+  name: external_exports.string().min(1),
+  prompt: external_exports.string().min(1),
+  cronExpression: external_exports.string().min(1),
+  scope: external_exports.enum(["project", "workspace"]),
+  workspaceId: external_exports.string().optional(),
+  // Dispatch target for scheduled + manual fires. Optional — absent defaults to
+  // "chat" in `create()` so existing callers (the web UI) keep their behavior.
+  via: cronjobVia.optional(),
+  enabled: external_exports.boolean().default(true)
+});
+var cronjobUpdateInput = external_exports.object({
+  // `.min(1)` rejects the obviously invalid empty-string `key`/`id` at the
+  // validator instead of letting it reach the service, which would
+  // `loadFile("")` an empty result and 404 on `findIndex`. The legacy
+  // router accepted bare `z.string()` here; the migration is the natural
+  // moment to tighten the boundary so the create + update shapes stay
+  // consistent (`cronjobCreateInput.key` already has `.min(1)`).
+  key: external_exports.string().min(1),
+  id: external_exports.string().min(1),
+  name: external_exports.string().min(1).optional(),
+  prompt: external_exports.string().min(1).optional(),
+  cronExpression: external_exports.string().min(1).optional(),
+  enabled: external_exports.boolean().optional()
+});
+var cronjobByIdInput = external_exports.object({
+  key: external_exports.string().min(1),
+  id: external_exports.string().min(1)
+});
+var CronjobNotFoundError = class extends Error {
+  constructor(message = "Cronjob not found") {
+    super(message);
+    this.name = "CronjobNotFoundError";
+  }
+};
+var InvalidCronExpressionError = class extends Error {
+  constructor(message = "Invalid cron expression") {
+    super(message);
+    this.name = "InvalidCronExpressionError";
+  }
+};
+var CronjobWorkspaceMissingError = class extends Error {
+  constructor(message = "workspaceId is required for workspace-scoped cronjobs") {
+    super(message);
+    this.name = "CronjobWorkspaceMissingError";
+  }
+};
+var CronjobProjectNotFoundError = class extends Error {
+  constructor(message = "Project not found") {
+    super(message);
+    this.name = "CronjobProjectNotFoundError";
+  }
+};
+var CronjobService = class {
+  constructor(queries = new CronjobQueries()) {
+    this.queries = queries;
+  }
+  // -------------------------------------------------------------------------
+  // Read operations
+  // -------------------------------------------------------------------------
   /**
-   * Load a workspace's focus row from the DB on first access. Cheap and
-   * idempotent — subsequent calls short-circuit on the `hydrated` set.
+   * List jobs for a key, or — if neither `project` nor `workspaceId` is
+   * provided — every cronjob across every key.
+   *
+   * Mirrors the legacy tRPC `cronjobs.list` shape so the router stays a
+   * straight delegate. The "all" branch returns `fileKey` on each row
+   * because callers (the dashboard's cronjob settings page) need both
+   * pieces to render the project/workspace breadcrumbs.
    */
-  ensureHydrated(workspaceId) {
-    if (this.hydrated.has(workspaceId)) return;
-    this.hydrated.add(workspaceId);
-    const rows = listPanelStatesForWorkspace(workspaceId, PANEL_FOCUS_TYPE);
-    const row = rows[0];
-    if (!row) return;
-    this.persisted.add(workspaceId);
-    try {
-      const parsed = JSON.parse(row.state);
-      this.focus.set(workspaceId, {
-        chat: parsed.chat,
-        terminal: parsed.terminal,
-        browser: parsed.browser
-      });
-    } catch (err) {
-      log21.warn({ workspaceId, err }, "failed to parse persisted panel focus; ignoring");
+  list(filter) {
+    if (filter?.project) {
+      const { project } = filter;
+      const file = this.queries.loadFile(project);
+      return { jobs: file.jobs.map((j) => ({ ...j, fileKey: project })) };
     }
+    if (filter?.workspaceId) {
+      const { workspaceId } = filter;
+      const file = this.queries.loadFile(workspaceId);
+      return {
+        jobs: file.jobs.map((j) => ({ ...j, fileKey: workspaceId }))
+      };
+    }
+    return { jobs: this.queries.listAll() };
   }
-  /** Get the last-focused panel ids for a workspace. */
-  get(workspaceId) {
-    this.ensureHydrated(workspaceId);
-    return { ...this.focus.get(workspaceId) ?? {} };
+  /** Get a single job by `key` + `id`. Throws `CronjobNotFoundError` if absent. */
+  get(key, id) {
+    const job = this.findJob(key, id);
+    if (!job) throw new CronjobNotFoundError();
+    return { job };
   }
+  // -------------------------------------------------------------------------
+  // Mutations
+  // -------------------------------------------------------------------------
   /**
-   * Record that `panelId` is the last-focused panel of `panelType` in
-   * `workspaceId`. Write-through: updates the in-memory map and upserts the
-   * backing `panel_states` row.
+   * Create a new cronjob and re-bind the scheduler.
+   *
+   * Validates the cron expression by attempting to construct a `Cron` with
+   * `maxRuns: 0` (parses without scheduling). Throws
+   * `InvalidCronExpressionError` for a bad expression and
+   * `CronjobWorkspaceMissingError` when a workspace-scoped job is missing
+   * its `workspaceId`.
    */
-  set(workspaceId, panelType, panelId) {
-    this.ensureHydrated(workspaceId);
-    const current2 = this.focus.get(workspaceId) ?? {};
-    if (current2[panelType] === panelId) return;
-    const next = { ...current2, [panelType]: panelId };
-    this.focus.set(workspaceId, next);
-    const now = Date.now();
-    const state = JSON.stringify(next);
-    if (this.persisted.has(workspaceId)) {
-      updatePanelState(focusRowId(workspaceId), { state, updatedAt: now });
-    } else {
-      insertPanelState({
-        id: focusRowId(workspaceId),
-        workspaceId,
-        panelType: PANEL_FOCUS_TYPE,
-        state,
-        createdAt: now,
-        updatedAt: now
-      });
-      this.persisted.add(workspaceId);
+  create(input) {
+    this.assertValidCron(input.cronExpression);
+    if (input.scope === "workspace" && !input.workspaceId) {
+      throw new CronjobWorkspaceMissingError();
     }
+    const file = this.queries.loadFile(input.key);
+    const job = {
+      id: generateCronjobId(),
+      name: input.name,
+      prompt: input.prompt,
+      cronExpression: input.cronExpression,
+      scope: input.scope,
+      workspaceId: input.workspaceId,
+      // Absent `via` means the web UI (or a pre-#581 caller) — default to chat
+      // so existing cronjobs keep dispatching exactly as before.
+      via: input.via ?? "chat",
+      enabled: input.enabled,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    file.jobs.push(job);
+    this.queries.saveFile(input.key, file);
+    this.reloadSchedules();
+    return { job };
   }
   /**
-   * Drop all focus tracking for a workspace. Called from the workspace delete
-   * path so the row doesn't outlive the workspace.
+   * Partially update an existing cronjob.
+   *
+   * Each optional field is applied only when present, matching the legacy
+   * router behavior. If `cronExpression` is supplied it's validated before
+   * the write. Throws `CronjobNotFoundError` if no job matches `key`+`id`.
    */
-  remove(workspaceId) {
-    this.focus.delete(workspaceId);
-    this.hydrated.delete(workspaceId);
-    this.persisted.delete(workspaceId);
-    deletePanelState(focusRowId(workspaceId));
+  update(input) {
+    if (input.cronExpression !== void 0) {
+      this.assertValidCron(input.cronExpression);
+    }
+    const file = this.queries.loadFile(input.key);
+    const job = file.jobs.find((j) => j.id === input.id);
+    if (!job) throw new CronjobNotFoundError();
+    if (input.name !== void 0) job.name = input.name;
+    if (input.prompt !== void 0) job.prompt = input.prompt;
+    if (input.cronExpression !== void 0) job.cronExpression = input.cronExpression;
+    if (input.enabled !== void 0) job.enabled = input.enabled;
+    this.queries.saveFile(input.key, file);
+    this.reloadSchedules();
+    return { job };
   }
-};
-var panelFocusService = new PanelFocusService();
-
-// src/server/services/terminal-service.ts
-init_src();
-init_zod();
-
-// src/server/infra/terminals/terminal-pool.ts
-init_src();
-import { randomUUID as randomUUID2 } from "node:crypto";
-import { existsSync as existsSync8, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { tmpdir } from "node:os";
-import { join as join19, sep as sep3 } from "node:path";
-var log22 = createLogger("terminal-pool");
-var MAX_SCROLLBACK_SIZE = 1e5;
-var TerminalPool = class {
-  /** terminalId -> session */
-  terminals = /* @__PURE__ */ new Map();
-  /** workspaceId -> Set<terminalId> (reverse index for workspace-level cleanup) */
-  workspaceTerminals = /* @__PURE__ */ new Map();
-  /** terminalId -> Set<listener> for live output streaming */
-  outputListeners = /* @__PURE__ */ new Map();
-  /**
-   * terminalId -> in-flight spawn promise. A single terminal is created via TWO
-   * concurrent paths — the WebSocket handler (spawn-on-`getSession`-miss) and
-   * the tRPC `terminal.create` mutation. Without deduplication both spawn a PTY
-   * and the second `terminals.set` overwrites the first, so the client stays
-   * wired to one PTY while the server's session map (and thus scrollback /
-   * `terminals output` / reconnect-replay) points at the other. That's the
-   * "output on screen but empty server scrollback until reload" bug
-   * (band-app/band#617). This map makes concurrent spawns share ONE PTY.
-   */
-  spawning = /* @__PURE__ */ new Map();
   /**
-   * Spawn (or return the already-spawning/spawned) PTY for a terminalId.
+   * Delete a cronjob and re-bind the scheduler.
    *
-   * Idempotent per terminalId: if a session already exists it is returned
-   * as-is, and concurrent spawn calls for the same id share a single in-flight
-   * promise — so the WebSocket and tRPC create paths never create competing
-   * PTYs. `workspaceRoot` is the absolute worktree path; resolving the
-   * workspaceId to a path is the service tier's job so the pool stays oblivious
-   * to the workspace registry.
+   * Throws `CronjobNotFoundError` if the job is already gone.
    */
-  async spawn(workspaceId, terminalId, workspaceRoot, options2) {
-    const existing = this.terminals.get(terminalId);
-    if (existing) return existing;
-    const inflight = this.spawning.get(terminalId);
-    if (inflight) return inflight;
-    const promise = this.spawnNew(workspaceId, terminalId, workspaceRoot, options2);
-    this.spawning.set(terminalId, promise);
-    try {
-      return await promise;
-    } finally {
-      this.spawning.delete(terminalId);
-    }
-  }
-  async spawnNew(workspaceId, terminalId, workspaceRoot, options2) {
-    const shell = defaultShell();
-    const resolvedPath = await shellPath();
-    const env = {};
-    for (const [key, value] of Object.entries(process.env)) {
-      if (value != null) {
-        env[key] = value;
-      }
-    }
-    env.PATH = resolvedPath;
-    env.TERM = "xterm-256color";
-    env.COLORTERM = "truecolor";
-    env.COLORFGBG = "15;0";
-    delete env.PORT;
-    if (options2?.env) {
-      Object.assign(env, options2.env);
-    }
-    env.BAND_DISPATCH = "terminal";
-    let cwd = workspaceRoot;
-    if (options2?.cwd) {
-      const resolved = join19(workspaceRoot, options2.cwd);
-      if (resolved !== workspaceRoot && !resolved.startsWith(workspaceRoot + sep3)) {
-        log22.warn(
-          "Ignoring cwd %s \u2014 resolves outside workspace root %s",
-          options2.cwd,
-          workspaceRoot
-        );
-      } else if (existsSync8(resolved)) {
-        cwd = resolved;
-      } else {
-        log22.warn("Ignoring cwd %s \u2014 directory does not exist", options2.cwd);
-      }
-    }
-    if (!existsSync8(cwd)) {
-      throw new Error(`Workspace directory does not exist: ${cwd}`);
-    }
-    if (!existsSync8(shell)) {
-      throw new Error(`Shell not found: ${shell}`);
-    }
-    log22.debug(
-      "Spawning shell %s in %s for terminal %s (PATH=%s)",
-      shell,
-      cwd,
-      terminalId,
-      resolvedPath.slice(0, 200)
-    );
-    const nodePty = await import("node-pty");
-    let ptyProcess;
-    try {
-      ptyProcess = nodePty.spawn(shell, [], {
-        name: "xterm-256color",
-        cols: 80,
-        rows: 24,
-        cwd,
-        env
-      });
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      log22.error("pty.spawn failed: %s (shell=%s, cwd=%s)", msg, shell, cwd);
-      throw err;
-    }
-    const session = { pty: ptyProcess, scrollback: "", workspaceId };
-    this.terminals.set(terminalId, session);
-    if (options2?.command) {
-      this.autoRunCommand(session, options2.command);
-    }
-    let ids = this.workspaceTerminals.get(workspaceId);
-    if (!ids) {
-      ids = /* @__PURE__ */ new Set();
-      this.workspaceTerminals.set(workspaceId, ids);
+  delete(key, id) {
+    const file = this.queries.loadFile(key);
+    const index3 = file.jobs.findIndex((j) => j.id === id);
+    if (index3 === -1) throw new CronjobNotFoundError();
+    const [removed] = file.jobs.splice(index3, 1);
+    this.queries.saveFile(key, file);
+    if (removed?.lastTerminalId) {
+      terminalService.kill(removed.lastTerminalId);
     }
-    ids.add(terminalId);
-    ptyProcess.onData((data) => {
-      session.scrollback += data;
-      if (session.scrollback.length > MAX_SCROLLBACK_SIZE) {
-        session.scrollback = session.scrollback.slice(-MAX_SCROLLBACK_SIZE);
-      }
-      const listeners3 = this.outputListeners.get(terminalId);
-      if (listeners3) {
-        for (const cb2 of listeners3) {
-          try {
-            cb2(data);
-          } catch {
-          }
-        }
-      }
-    });
-    ptyProcess.onExit(() => {
-      log22.debug("Terminal exited: %s (workspace %s)", terminalId, workspaceId);
-      this.terminals.delete(terminalId);
-      this.outputListeners.delete(terminalId);
-      const set = this.workspaceTerminals.get(workspaceId);
-      if (set) {
-        set.delete(terminalId);
-        if (set.size === 0) {
-          this.workspaceTerminals.delete(workspaceId);
-        }
-      }
-      if (session.autoRunFile) {
-        try {
-          unlinkSync2(session.autoRunFile);
-        } catch {
-        }
-      }
-    });
-    return session;
+    this.reloadSchedules();
+    return { ok: true };
   }
   /**
-   * Auto-run the workspace's initial command inside a freshly spawned PTY,
-   * robustly.
-   *
-   * Writing a long command line straight into a cold PTY is racy on three
-   * fronts, all of which surfaced in production with `via=terminal`
-   * prompt-as-argv launches (`'<agent-binary>' '<entire-prompt>'`):
+   * Fire a cronjob synchronously (manual "run now" path).
    *
-   *   1. **Dropped newline.** The shell may not have finished sourcing its
-   *      rc files, and the tty can still be in its startup canonical-mode
-   *      window. A trailing `\n` written then is swallowed — the command
-   *      is typed at the prompt but never executed.
-   *   2. **Truncation.** A single input line longer than the tty's
-   *      canonical buffer (`MAX_CANON`, ~4 KB) is clipped. Long prompts
-   *      blow past that easily.
-   *   3. **UTF-8 corruption.** A multi-byte sequence split across a tty
-   *      buffer boundary is mangled (the classic em-dash → mojibake).
+   * Uses the same `band:cronId`-labeled chat as the scheduled fire so the
+   * user sees both paths converge on a single dedicated conversation
+   * (issue #520). `submitTask` may throw `TaskConflictError`, which the API
+   * tier translates into a 409 Conflict response.
    *
-   * Fix both layers: (1) stage the command's bytes in a temp file so they
-   * never traverse the tty's canonical input buffer — sidestepping the
-   * truncation and UTF-8-split failures entirely — and (2) wait for the
-   * shell to emit its first output (its prompt) before writing the
-   * *short* `source <file>` line. The short line is well under the
-   * canonical limit and lands after the cold-start window, so its newline
-   * survives. `source` runs the command in the current interactive shell,
-   * so the user keeps their session afterwards.
+   * Atomicity caveat: `getOrCreateCronjobChat` and `submitTask` are not run
+   * inside a single transaction. If `createChat` succeeds but `submitTask`
+   * later throws an unexpected (non-`TaskConflictError`) error, the
+   * freshly-created chat remains in the workspace as an orphan with no
+   * task ever attached. The next manual `trigger` (or scheduled fire)
+   * reuses that chat via its `band:cronId` label, so the orphan
+   * self-heals — but the user may briefly see an empty chat pane. The
+   * legacy implementation had the same gap; preserved here to match
+   * existing behavior. If this ever needs to be tightened, the fix is
+   * either (a) wrap both calls in a try/catch that deletes the chat on
+   * unexpected failure, or (b) defer `createChat` until `submitTask`
+   * succeeds (which would require buffering the chat name/labels on the
+   * task row).
    */
-  autoRunCommand(session, command) {
-    const pty = session.pty;
-    let cmdFile;
-    try {
-      cmdFile = join19(tmpdir(), `band-autorun-${randomUUID2()}.sh`);
-      writeFileSync2(cmdFile, `${command}
-`, { encoding: "utf-8", mode: 384, flag: "wx" });
-      session.autoRunFile = cmdFile;
-    } catch (err) {
-      log22.warn(
-        "autoRunCommand: temp-file staging failed (%s); writing command directly",
-        err instanceof Error ? err.message : String(err)
-      );
-      pty.write(`${command}
-`);
-      return;
-    }
-    const quotedPath = cmdFile.replace(/'/g, `'\\''`);
-    const sourceLine = `. '${quotedPath}'
-`;
-    let done = false;
-    const inject = () => {
-      if (done) return;
-      done = true;
-      try {
-        pty.write(sourceLine);
-      } catch (err) {
-        log22.warn("autoRunCommand: failed to inject command line (%s)", err);
+  async trigger(key, id) {
+    const job = this.findJob(key, id);
+    if (!job) throw new CronjobNotFoundError();
+    const workspaceId = this.resolveWorkspaceId(job, key);
+    if (!workspaceId) throw new CronjobProjectNotFoundError();
+    if (job.via === "terminal") {
+      const { terminalId } = await this.spawnCronTerminal(job, workspaceId, key);
+      if (terminalId) {
+        return { via: "terminal", terminalId, workspaceId };
       }
-    };
-    let dataDisposed = false;
-    const disposeData = () => {
-      if (dataDisposed) return;
-      dataDisposed = true;
-      dataDisposable.dispose();
-    };
-    const dataDisposable = pty.onData(() => {
-      disposeData();
-      inject();
-    });
-    const timer = setTimeout(inject, 750);
-    timer.unref();
-    let exitDisposed = false;
-    const exitDisposable = pty.onExit(() => {
-      done = true;
-      clearTimeout(timer);
-      disposeData();
-      if (exitDisposed) return;
-      exitDisposed = true;
-      exitDisposable.dispose();
-    });
+    }
+    const cronChat = this.getOrCreateCronjobChat(workspaceId, job);
+    const task = taskService.submitTask({ workspaceId, chatId: cronChat.id, prompt: job.prompt });
+    return { via: "chat", taskId: task.id, workspaceId, chatId: cronChat.id };
   }
+  // -------------------------------------------------------------------------
+  // Lifecycle hooks for workspace/project removal
+  // -------------------------------------------------------------------------
   /**
-   * Returns an existing PTY session by terminalId, or undefined.
+   * Stop all timers for jobs in `key` and remove the file rows.
+   *
+   * Called when a workspace or project is removed. Order matters: stop
+   * timers first so no further fires queue up between the timer-stop and
+   * the row-delete. An in-flight fire is already safe in either order
+   * because `executeCronjob` operates on closed-over `job`/`fileKey` (it
+   * never re-reads the row) and `safeUpdateLastRun` swallows the
+   * row-missing case. The two steps were previously two separate calls
+   * (`stopJobsForKey` + `deleteCronjobFile`) at every call site — the
+   * legacy callers always invoked them in pairs, so they're collapsed
+   * here to make the contract harder to misuse.
+   *
+   * Partial-failure recovery: if `deleteFile` throws (e.g. a transient DB
+   * lock), the timers are already stopped but the rows remain in the DB.
+   * The next `reloadSchedules()` call — triggered by any subsequent
+   * cronjob mutation, or by a server restart — re-reads the rows from the
+   * DB and re-registers the timers, so the orphaned rows self-heal
+   * without manual intervention. We do NOT roll back the `stop()` calls
+   * because re-binding timers for a workspace that's mid-deletion is
+   * worse than leaving them stopped: the workspace path is about to be
+   * removed and any fire that races the removal would target a
+   * non-existent worktree. Re-registration on the next reload is the
+   * intentional recovery strategy; operators encountering a partial
+   * failure on this path should expect the next reload to be a no-op
+   * once the workspace removal completes and the rows are re-attempted.
    */
-  get(terminalId) {
-    return this.terminals.get(terminalId);
+  removeForKey(key) {
+    this.stopJobsForKey(key);
+    this.queries.deleteFile(key);
   }
-  /**
-   * Resize the underlying PTY. No-op if the terminal isn't known to the pool.
-   */
-  resize(terminalId, cols, rows) {
-    const session = this.terminals.get(terminalId);
-    if (session) {
-      session.pty.resize(cols, rows);
+  // -------------------------------------------------------------------------
+  // Scheduler lifecycle
+  // -------------------------------------------------------------------------
+  /** Start the cronjob scheduler. Called once on server boot. */
+  start() {
+    const state = schedulerState();
+    if (state.started) return;
+    state.started = true;
+    this.loadAndScheduleAll();
+    log22.info("cronjob scheduler started");
+  }
+  /** Stop the cronjob scheduler. Called on graceful shutdown. */
+  stop() {
+    const state = schedulerState();
+    for (const [, cron] of state.jobs) {
+      cron.stop();
     }
+    state.jobs.clear();
+    state.started = false;
+    log22.info("cronjob scheduler stopped");
+  }
+  /** Reload all schedules from the database. Call after cronjob mutations. */
+  reloadSchedules() {
+    if (!schedulerState().started) return;
+    this.loadAndScheduleAll();
   }
   /**
-   * List metadata for every PTY session bound to the given workspace.
+   * Stop all scheduled jobs for a key (e.g. when a workspace is removed).
    *
-   * The returned `title` is the foreground process name reported by the
-   * PTY; reading `pty.process` can throw if the process has already exited
-   * between the reverse-index lookup and the read, so the read is wrapped.
+   * Private because the only correct call site is `removeForKey` above:
+   * stopping the timers without also dropping the rows would re-schedule
+   * the same jobs on the next `reloadSchedules()` tick. Keeping it
+   * accessible only through `removeForKey` prevents future callers from
+   * accidentally invoking just one half of the pair.
    */
-  list(workspaceId) {
-    const ids = this.workspaceTerminals.get(workspaceId);
-    if (!ids) return [];
-    const result = [];
-    for (const terminalId of ids) {
-      const session = this.terminals.get(terminalId);
-      if (session) {
-        let title = "";
-        try {
-          title = session.pty.process;
-        } catch {
-        }
-        result.push({
-          terminalId,
-          workspaceId,
-          pid: session.pty.pid,
-          scrollbackLength: session.scrollback.length,
-          title
-        });
+  stopJobsForKey(key) {
+    const state = schedulerState();
+    const file = this.queries.loadFile(key);
+    for (const job of file.jobs) {
+      const cron = state.jobs.get(job.id);
+      if (cron) {
+        cron.stop();
+        state.jobs.delete(job.id);
+        log22.info({ jobId: job.id, key }, "stopped cronjob");
       }
     }
-    return result;
-  }
-  /**
-   * Returns the scrollback buffer for a terminal, optionally limited to the
-   * last N lines. Returns `null` if the terminal is not found.
-   */
-  getScrollback(terminalId, lines) {
-    const session = this.terminals.get(terminalId);
-    if (!session) return null;
-    if (lines == null) return session.scrollback;
-    const allLines = session.scrollback.split("\n");
-    return allLines.slice(-lines).join("\n");
   }
+  // -------------------------------------------------------------------------
+  // Shared resolution helpers (used by both the API + the scheduled fire path)
+  // -------------------------------------------------------------------------
   /**
-   * Writes data to a terminal's PTY stdin.
-   * Returns false if the terminal is not found.
+   * Find — or create — the dedicated chat this cronjob writes into.
+   *
+   * Issue #520: each cronjob owns its own chat in the workspace, looked up
+   * by the canonical `band:cronId` label. First call creates the chat;
+   * subsequent calls reuse it. If the user deletes the chat, the next call
+   * recreates it (intentional soft reset). This replaces the old
+   * `getOrCreateDefaultChat` dispatch, which silently latched onto whatever
+   * chat the user happened to be focused on. Shared between the scheduled
+   * fire path (`executeCronjob` below) and the manual `trigger` route so
+   * both stay aligned.
    */
-  write(terminalId, data) {
-    const session = this.terminals.get(terminalId);
-    if (!session) return false;
-    session.pty.write(data);
-    return true;
+  getOrCreateCronjobChat(workspaceId, job) {
+    const labelMatch = { [BAND_CRON_ID_LABEL]: job.id };
+    const existing = chatService.findByLabels(workspaceId, labelMatch);
+    if (existing) return existing;
+    return chatService.create(workspaceId, {
+      name: job.name,
+      labels: labelMatch,
+      // Cronjob scheduler is a trusted server-side caller — it's allowed
+      // to write the reserved `band:` prefix that user-facing surfaces
+      // are blocked from touching.
+      allowReservedLabels: true
+    });
   }
   /**
-   * Subscribe to live output from a terminal's PTY.
-   * Returns an unsubscribe function.
+   * Dispatch a `via="terminal"` fire: spawn the agent's *headless* vendor CLI
+   * in a fresh, self-closing PTY pane. Mirrors the `via=terminal` branch of
+   * `WorkspaceService.create` (#551), but adapted for a recurring cron in two
+   * important ways:
+   *
+   *   - **Headless, not interactive.** We use `adapter.cliHeadlessInvocation`
+   *     (`claude -p`, `codex exec`, …), NOT the interactive `cliInvocation`
+   *     that workspace-create uses. The interactive REPL never exits on its
+   *     own, so the pane would stay parked after the turn — the shell's `exit`
+   *     would never run and the overlap guard below would treat "idle at the
+   *     REPL" as "still running", blocking every subsequent tick (issue #581
+   *     follow-up). The headless form runs the prompt and exits, which is what
+   *     makes both the self-close and the overlap guard actually work.
+   *   - **Overlap guard.** If the terminal spawned by this job's previous fire
+   *     is still alive, throw `TaskConflictError` instead of launching a second
+   *     agent — the caller records "skipped" (scheduled) or surfaces 409
+   *     (manual trigger), exactly like the chat running-task conflict. Because
+   *     the headless process exits when the turn completes, a live PTY reliably
+   *     means the previous run is genuinely still working.
+   *   - **Self-closing pane.** The command is `<headless-cli>\nexit`, staged
+   *     and sourced by the pool via `.`, so the shell exits the moment the
+   *     headless CLI returns. Combined with `cleanupOnExit`, the finished pane
+   *     removes itself from the layout and emits `terminal-killed` — bounding a
+   *     frequent cron to ~1 pane and keeping the next tick's liveness check
+   *     accurate.
+   *
+   * Returns `{ terminalId: null }` when the agent exposes no headless CLI (or
+   * the workspace can't be resolved), signalling the caller to fall back to
+   * chat. Spawn failures propagate (recorded as "failed").
+   *
+   * Edge case: if `terminalService.spawn` throws *after* the PTY is forked but
+   * before `updateLastTerminal` runs, `lastTerminalId` stays unset for this
+   * fire, so the next tick's overlap guard won't see that (now likely dead)
+   * PTY. This is acceptable — a spawn that rejects has almost certainly failed
+   * to produce a usable pane, and the synchronous in-process lock above still
+   * prevents a *concurrent* double-spawn; only a subsequent, well-separated
+   * tick could add a second pane, which is the same at-most-transient
+   * duplication the self-close bound already tolerates.
    */
-  subscribeOutput(terminalId, callback) {
-    let listeners3 = this.outputListeners.get(terminalId);
-    if (!listeners3) {
-      listeners3 = /* @__PURE__ */ new Set();
-      this.outputListeners.set(terminalId, listeners3);
+  async spawnCronTerminal(job, workspaceId, fileKey) {
+    const state = schedulerState();
+    if (state.spawningTerminals.has(job.id)) {
+      throw new TaskConflictError(`Cronjob ${job.id} terminal run is already being spawned`);
     }
-    listeners3.add(callback);
-    return () => {
-      listeners3.delete(callback);
-      if (listeners3.size === 0) {
-        this.outputListeners.delete(terminalId);
+    state.spawningTerminals.add(job.id);
+    try {
+      const workspace = workspaceService.resolve(workspaceId);
+      if (!workspace) {
+        log22.warn(
+          { jobId: job.id, workspaceId },
+          "workspace not resolvable for via=terminal cronjob; falling back to chat"
+        );
+        return { terminalId: null };
       }
-    };
-  }
-  /**
-   * Kill a single terminal by terminalId.
-   */
-  kill(terminalId) {
-    const session = this.terminals.get(terminalId);
-    if (session) {
-      session.pty.kill();
-      this.terminals.delete(terminalId);
-      const set = this.workspaceTerminals.get(session.workspaceId);
-      if (set) {
-        set.delete(terminalId);
-        if (set.size === 0) {
-          this.workspaceTerminals.delete(session.workspaceId);
-        }
+      const prevTerminalId = this.findJob(fileKey, job.id)?.lastTerminalId;
+      if (prevTerminalId && terminalService.getSession(prevTerminalId)) {
+        throw new TaskConflictError(`Cronjob ${job.id} terminal run is still in progress`);
       }
+      const adapter = await agentService.createWorkspaceAgent(workspace.worktree.path);
+      const invocation = adapter.cliHeadlessInvocation?.(job.prompt);
+      adapter.abort?.();
+      if (!invocation || invocation.unsupported) {
+        const reason = invocation?.reason ?? "adapter does not expose cliHeadlessInvocation";
+        log22.warn(
+          { jobId: job.id, workspaceId, reason },
+          "via=terminal requested but agent has no headless CLI; falling back to chat"
+        );
+        return { terminalId: null };
+      }
+      const command = `${formatShellCommand(invocation.command, invocation.args)}
+exit`;
+      const terminalId = randomUUID3();
+      await terminalService.spawn(workspaceId, terminalId, { command }, { cleanupOnExit: true });
+      this.queries.updateLastTerminal(job.id, terminalId);
+      emit({ kind: "terminal-created", workspaceId, terminalId });
+      return { terminalId };
+    } finally {
+      state.spawningTerminals.delete(job.id);
     }
   }
   /**
-   * Kill all terminals for a workspace.
+   * Resolve the workspace the cronjob fires into.
+   *
+   * Returns `null` for project-scoped jobs whose project no longer exists
+   * (which the scheduled fire path treats as a soft failure — see
+   * `executeCronjob`). The manual trigger route maps the same condition to
+   * a `CronjobProjectNotFoundError`.
+   *
+   * Workspace-scoped jobs return `null` rather than falling through to the
+   * project-resolution branch when `workspaceId` is somehow missing. The
+   * `create` path already rejects this via `CronjobWorkspaceMissingError`,
+   * but a workspace-scoped row written by an older server version could
+   * theoretically reach here with a null `workspaceId`. Falling through
+   * would silently misfire into the project's default branch; returning
+   * `null` makes the failure explicit (logged + `lastRunStatus = "failed"`
+   * for the scheduler; `CronjobProjectNotFoundError` for the manual
+   * trigger path).
    */
-  killWorkspace(workspaceId) {
-    const ids = this.workspaceTerminals.get(workspaceId);
-    if (!ids) return;
-    for (const terminalId of ids) {
-      const session = this.terminals.get(terminalId);
-      if (session) {
-        session.pty.kill();
-        this.terminals.delete(terminalId);
-      }
+  resolveWorkspaceId(job, fileKey) {
+    if (job.scope === "workspace") {
+      return job.workspaceId ?? null;
     }
-    this.workspaceTerminals.delete(workspaceId);
+    const appState = loadState();
+    const project = appState.projects.find((p6) => p6.name === fileKey);
+    if (!project) return null;
+    return toWorkspaceId(project.name, project.defaultBranch);
   }
-  /**
-   * Kill every tracked PTY (server shutdown path).
-   */
-  killAll() {
-    for (const [, session] of this.terminals) {
-      session.pty.kill();
+  // -------------------------------------------------------------------------
+  // Internals
+  // -------------------------------------------------------------------------
+  findJob(key, id) {
+    const file = this.queries.loadFile(key);
+    return file.jobs.find((j) => j.id === id);
+  }
+  assertValidCron(expression) {
+    try {
+      const options2 = { maxRuns: 0 };
+      void new E2(expression, options2);
+    } catch {
+      throw new InvalidCronExpressionError();
     }
-    this.terminals.clear();
-    this.workspaceTerminals.clear();
   }
-};
-var terminalPool = new TerminalPool();
-
-// src/server/services/_utils/terminal-layout-manager.ts
-var manager = new DockviewLayoutManager("terminal_layout");
-var getTerminalLayout = (workspaceId) => manager.get(workspaceId);
-var saveTerminalLayout = (workspaceId, tree) => manager.save(workspaceId, tree);
-var deleteTerminalLayout = (workspaceId) => manager.delete(workspaceId);
-function addTerminalToLayout(workspaceId, terminalId, opts) {
-  manager.addPanel(workspaceId, {
-    id: terminalId,
-    contentComponent: "terminalTab",
-    tabComponent: "terminalTab",
-    title: opts?.title ?? "Terminal",
-    params: {
-      workspaceId,
-      terminalId,
-      ...opts?.command ? { command: opts.command } : {},
-      ...opts?.cwd ? { cwd: opts.cwd } : {},
-      ...opts?.env ? { env: opts.env } : {}
+  scheduleJob(job, fileKey) {
+    const state = schedulerState();
+    const existing = state.jobs.get(job.id);
+    if (existing) {
+      existing.stop();
+      state.jobs.delete(job.id);
+    }
+    if (!job.enabled) return;
+    try {
+      const cronInstance = new E2(job.cronExpression, () => {
+        this.executeCronjob(job, fileKey).catch((err) => {
+          log22.error({ jobId: job.id, err }, "unhandled error in cronjob execution");
+        });
+      });
+      state.jobs.set(job.id, cronInstance);
+      log22.info(
+        { jobId: job.id, name: job.name, cron: job.cronExpression, scope: job.scope },
+        "scheduled cronjob"
+      );
+    } catch (err) {
+      log22.error(
+        { jobId: job.id, cronExpression: job.cronExpression, err },
+        "invalid cron expression, skipping job"
+      );
+    }
+  }
+  async executeCronjob(job, fileKey) {
+    const workspaceId = this.resolveWorkspaceId(job, fileKey);
+    if (!workspaceId) {
+      log22.warn({ jobId: job.id, fileKey }, "project not found for cronjob, skipping");
+      this.safeUpdateLastRun(job.id, "failed");
+      return;
+    }
+    log22.info({ jobId: job.id, name: job.name, workspaceId }, "executing cronjob");
+    if (job.via === "terminal") {
+      try {
+        const { terminalId } = await this.spawnCronTerminal(job, workspaceId, fileKey);
+        if (terminalId) {
+          log22.info({ jobId: job.id, terminalId, workspaceId }, "cronjob terminal spawned");
+          this.safeUpdateLastRun(job.id, "completed");
+          return;
+        }
+        log22.info(
+          { jobId: job.id, workspaceId },
+          "via=terminal not supported by agent; falling back to chat dispatch"
+        );
+      } catch (err) {
+        if (err instanceof TaskConflictError) {
+          log22.info(
+            { jobId: job.id, workspaceId },
+            "previous terminal run still active, skipping cronjob execution"
+          );
+          this.safeUpdateLastRun(job.id, "skipped");
+          return;
+        }
+        log22.error({ jobId: job.id, err }, "cronjob terminal dispatch failed");
+        this.safeUpdateLastRun(job.id, "failed");
+        return;
+      }
+    }
+    try {
+      const chat = this.getOrCreateCronjobChat(workspaceId, job);
+      const task = taskService.submitTask({ workspaceId, chatId: chat.id, prompt: job.prompt });
+      log22.info(
+        { jobId: job.id, taskId: task.id, workspaceId, chatId: chat.id },
+        "cronjob task submitted"
+      );
+      this.safeUpdateLastRun(job.id, "completed");
+    } catch (err) {
+      if (err instanceof TaskConflictError) {
+        log22.info(
+          { jobId: job.id, workspaceId },
+          "task already running, skipping cronjob execution"
+        );
+        this.safeUpdateLastRun(job.id, "skipped");
+        return;
+      }
+      log22.error({ jobId: job.id, err }, "cronjob execution failed");
+      this.safeUpdateLastRun(job.id, "failed");
     }
-  });
-}
-function removeTerminalFromLayout(workspaceId, terminalId) {
-  manager.removePanel(workspaceId, terminalId);
-}
-
-// src/server/services/terminal-service.ts
-var log23 = createLogger("terminal-service");
-var TerminalPaneConfigSchema = external_exports.object({
-  name: external_exports.string().optional(),
-  command: external_exports.string().optional(),
-  cwd: external_exports.string().optional(),
-  env: external_exports.record(external_exports.string()).optional(),
-  focus: external_exports.boolean().optional()
-});
-var PaneNodeSchema = external_exports.object({
-  pane: TerminalPaneConfigSchema
-});
-var TerminalLayoutNodeSchema = external_exports.lazy(
-  () => external_exports.union([
-    PaneNodeSchema,
-    external_exports.object({
-      direction: external_exports.enum(["horizontal", "vertical"]),
-      split: external_exports.number().min(0.1).max(0.9).optional().default(0.5),
-      children: external_exports.tuple([TerminalLayoutNodeSchema, TerminalLayoutNodeSchema])
-    })
-  ])
-);
-var WorkspaceTerminalConfigSchema = external_exports.object({
-  layout: TerminalLayoutNodeSchema
-});
-var TerminalService = class {
-  constructor(pool2 = terminalPool) {
-    this.pool = pool2;
   }
-  // -------------------------------------------------------------------------
-  // PTY lifecycle
-  // -------------------------------------------------------------------------
   /**
-   * Spawn a new PTY for the given workspace + terminalId.
+   * Update `lastRunAt`/`lastRunStatus`, swallowing DB errors.
    *
-   * Resolves `workspaceId` to a worktree path before delegating to the
-   * pool, and registers the new terminal in the saved dockview layout so it
-   * survives a server restart (mirrors `chatService.create` /
-   * `browserService.create`). Does NOT emit a `terminal-created` event —
-   * the API entry points decide whether to broadcast (the WebSocket handler
-   * stays silent; the tRPC `create` mutation emits explicitly).
+   * Errors here are diagnostic noise during the fire path — the cronjob
+   * already executed (or failed/skipped), and we don't want a transient
+   * DB lock to mask the real outcome by re-raising. The legacy
+   * implementation logged at `warn` and moved on; preserved here.
    */
-  async spawn(workspaceId, terminalId, options2) {
-    const workspace = workspaceService.resolve(workspaceId);
-    if (!workspace) {
-      throw new Error(`Workspace not found: ${workspaceId}`);
+  safeUpdateLastRun(jobId, status) {
+    try {
+      this.queries.updateLastRun(jobId, status);
+    } catch (err) {
+      log22.warn({ jobId, err }, "failed to update lastRun on cronjob");
     }
-    const session = await this.pool.spawn(
-      workspaceId,
-      terminalId,
-      workspace.worktree.path,
-      options2
-    );
-    addTerminalToLayout(workspaceId, terminalId, {
-      command: options2?.command,
-      cwd: options2?.cwd,
-      env: options2?.env
-    });
-    return session;
   }
-  /**
-   * Kill a single terminal. Removes it from the saved dockview layout and
-   * emits `terminal-killed` so the dashboard's status stream prunes the
-   * panel. Safe to call with an unknown terminalId — no-op.
-   */
-  kill(terminalId) {
-    const session = this.pool.get(terminalId);
-    const workspaceId = session?.workspaceId;
-    this.pool.kill(terminalId);
-    if (workspaceId) {
-      removeTerminalFromLayout(workspaceId, terminalId);
-      emit({ kind: "terminal-killed", workspaceId, terminalId });
+  loadAndScheduleAll() {
+    const state = schedulerState();
+    for (const [, cron] of state.jobs) {
+      cron.stop();
+    }
+    state.jobs.clear();
+    for (const job of this.queries.listAll()) {
+      this.scheduleJob(job, job.fileKey);
     }
+    log22.info({ count: state.jobs.size }, "loaded cronjob schedules");
   }
+};
+var cronjobService = new CronjobService();
+
+// src/server/services/panel-focus-service.ts
+init_src();
+var log23 = createLogger("panel-focus-service");
+var PANEL_FOCUS_TYPE = "panel_focus";
+function focusRowId(workspaceId) {
+  return `${PANEL_FOCUS_TYPE}:${workspaceId}`;
+}
+var PanelFocusService = class {
+  /** workspaceId → last-focused panel ids. */
+  focus = /* @__PURE__ */ new Map();
   /**
-   * Kill every PTY associated with a workspace. Used by the workspace
-   * deletion path — the caller is responsible for tearing down the layout
-   * tree via {@link deleteLayout} as well.
+   * Workspaces whose focus row has been loaded from the DB into `focus`.
+   * Separate from the map's own key presence because a workspace can have a
+   * loaded-but-empty record (row absent) — we still don't want to re-hit the
+   * DB on every read.
    */
-  killWorkspace(workspaceId) {
-    this.pool.killWorkspace(workspaceId);
-  }
+  hydrated = /* @__PURE__ */ new Set();
+  /** Workspaces that already have a `panel_states` row (drives insert vs update). */
+  persisted = /* @__PURE__ */ new Set();
   /**
-   * Kill every tracked PTY across all workspaces. Used by the server
-   * shutdown path in `start-server.ts`.
+   * Load a workspace's focus row from the DB on first access. Cheap and
+   * idempotent — subsequent calls short-circuit on the `hydrated` set.
    */
-  killAll() {
-    this.pool.killAll();
-  }
-  // -------------------------------------------------------------------------
-  // Per-terminal accessors
-  // -------------------------------------------------------------------------
-  list(workspaceId) {
-    return this.pool.list(workspaceId);
-  }
-  getSession(terminalId) {
-    return this.pool.get(terminalId);
-  }
-  getScrollback(terminalId, lines) {
-    return this.pool.getScrollback(terminalId, lines);
-  }
-  write(terminalId, data) {
-    return this.pool.write(terminalId, data);
-  }
-  resize(terminalId, cols, rows) {
-    this.pool.resize(terminalId, cols, rows);
-  }
-  subscribeOutput(terminalId, callback) {
-    return this.pool.subscribeOutput(terminalId, callback);
-  }
-  // -------------------------------------------------------------------------
-  // Layout persistence (dockview tree)
-  //
-  // Thin pass-throughs to `lib/terminal-layout-manager` so the API tier
-  // doesn't reach across into `lib/` directly. The layout helpers will be
-  // folded into a dedicated infra adapter in a follow-up phase (when the
-  // chats/browsers domains get their own infra adapters); leaving them in
-  // `lib/` for now is the minimum-disruption shape during the phased
-  // migration.
-  // -------------------------------------------------------------------------
-  getLayout(workspaceId) {
-    return getTerminalLayout(workspaceId);
-  }
-  saveLayout(workspaceId, tree) {
-    saveTerminalLayout(workspaceId, tree);
+  ensureHydrated(workspaceId) {
+    if (this.hydrated.has(workspaceId)) return;
+    this.hydrated.add(workspaceId);
+    const rows = listPanelStatesForWorkspace(workspaceId, PANEL_FOCUS_TYPE);
+    const row = rows[0];
+    if (!row) return;
+    this.persisted.add(workspaceId);
+    try {
+      const parsed = JSON.parse(row.state);
+      this.focus.set(workspaceId, {
+        chat: parsed.chat,
+        terminal: parsed.terminal,
+        browser: parsed.browser
+      });
+    } catch (err) {
+      log23.warn({ workspaceId, err }, "failed to parse persisted panel focus; ignoring");
+    }
   }
-  deleteLayout(workspaceId) {
-    deleteTerminalLayout(workspaceId);
+  /** Get the last-focused panel ids for a workspace. */
+  get(workspaceId) {
+    this.ensureHydrated(workspaceId);
+    return { ...this.focus.get(workspaceId) ?? {} };
   }
-  // -------------------------------------------------------------------------
-  // Workspace `.band/config.json` `workspace.terminal` block
-  // -------------------------------------------------------------------------
   /**
-   * Load and validate the `workspace.terminal` block from
-   * `.band/config.json`. Returns `null` when the workspace can't be
-   * resolved, the config file is absent, the block is missing, or the
-   * payload fails validation.
-   *
-   * Absorbed from the old `lib/terminal-config.ts:loadWorkspaceTerminalConfig`
-   * — same parsing semantics, but the lookup now goes through the service
-   * tier so callers (currently the workspace router's `getTerminalConfig`
-   * query) reach it via `terminalService` instead of a stand-alone helper.
+   * Record that `panelId` is the last-focused panel of `panelType` in
+   * `workspaceId`. Write-through: updates the in-memory map and upserts the
+   * backing `panel_states` row.
    */
-  getWorkspaceConfig(workspaceId) {
-    const workspace = workspaceService.resolve(workspaceId);
-    if (!workspace) return null;
-    return this.loadWorkspaceConfigFromPaths(workspace.worktree.path, workspace.project.path);
+  set(workspaceId, panelType, panelId) {
+    this.ensureHydrated(workspaceId);
+    const current2 = this.focus.get(workspaceId) ?? {};
+    if (current2[panelType] === panelId) return;
+    const next = { ...current2, [panelType]: panelId };
+    this.focus.set(workspaceId, next);
+    const now = Date.now();
+    const state = JSON.stringify(next);
+    if (this.persisted.has(workspaceId)) {
+      updatePanelState(focusRowId(workspaceId), { state, updatedAt: now });
+    } else {
+      insertPanelState({
+        id: focusRowId(workspaceId),
+        workspaceId,
+        panelType: PANEL_FOCUS_TYPE,
+        state,
+        createdAt: now,
+        updatedAt: now
+      });
+      this.persisted.add(workspaceId);
+    }
   }
   /**
-   * Internal: the path-driven parse so tests / future non-tRPC entry
-   * points can plug raw paths in without going through `resolveWorkspace`.
+   * Drop all focus tracking for a workspace. Called from the workspace delete
+   * path so the row doesn't outlive the workspace.
    */
-  loadWorkspaceConfigFromPaths(worktreePath, projectPath) {
-    const raw = loadProjectConfig(worktreePath, projectPath);
-    if (!raw) return null;
-    const terminalBlock = raw.workspace && typeof raw.workspace === "object" ? raw.workspace.terminal : void 0;
-    if (!terminalBlock) return null;
-    const result = WorkspaceTerminalConfigSchema.safeParse(terminalBlock);
-    if (!result.success) {
-      log23.warn(
-        "Invalid workspace.terminal config: %s",
-        result.error.issues.map((i2) => `${i2.path.join(".")}: ${i2.message}`).join("; ")
-      );
-      return null;
-    }
-    return result.data;
+  remove(workspaceId) {
+    this.focus.delete(workspaceId);
+    this.hydrated.delete(workspaceId);
+    this.persisted.delete(workspaceId);
+    deletePanelState(focusRowId(workspaceId));
   }
 };
-var terminalService = new TerminalService();
+var panelFocusService = new PanelFocusService();
 
 // src/server/services/workspace-service.ts
 var execFileAsync2 = promisify2(execFile6);
@@ -123608,7 +123860,7 @@ var WorkspaceService = class {
           via = "chat";
         } else {
           terminalCommand = formatShellCommand(invocation.command, invocation.args);
-          terminalId = randomUUID3();
+          terminalId = randomUUID4();
         }
       } catch (err) {
         log24.warn(
@@ -123697,7 +123949,7 @@ var WorkspaceService = class {
       };
     }
     const command = formatShellCommand(invocation.command, invocation.args);
-    const terminalId = randomUUID3();
+    const terminalId = randomUUID4();
     await terminalService.spawn(chat.workspaceId, terminalId, { command });
     emit({ kind: "terminal-created", workspaceId: chat.workspaceId, terminalId });
     log24.info(
@@ -137690,9 +137942,9 @@ var cronjobsRouter = t2.router({
       throwAsTRPCError(err);
     }
   }),
-  trigger: publicProcedure.input(cronjobByIdInput).mutation(({ input }) => {
+  trigger: publicProcedure.input(cronjobByIdInput).mutation(async ({ input }) => {
     try {
-      return cronjobService.trigger(input.key, input.id);
+      return await cronjobService.trigger(input.key, input.id);
     } catch (err) {
       throwAsTRPCError(err);
     }
@@ -137706,10 +137958,7 @@ function throwAsTRPCError(err) {
     throw new TRPCError({ code: "BAD_REQUEST", message: err.message });
   }
   if (err instanceof TaskConflictError) {
-    throw new TRPCError({
-      code: "CONFLICT",
-      message: "Task already running for this chat pane"
-    });
+    throw new TRPCError({ code: "CONFLICT", message: err.message });
   }
   throw err;
 }
@@ -140479,7 +140728,7 @@ function throwAsTrpcError2(err) {
 }
 
 // src/server/api/terminals/router.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 init_zod();
 
 // src/server/api/terminals/strip-queries.ts
@@ -140505,7 +140754,7 @@ var terminalRouter = t2.router({
       env: external_exports.record(external_exports.string()).optional()
     })
   ).mutation(async ({ input }) => {
-    const terminalId = input.id ?? randomUUID4();
+    const terminalId = input.id ?? randomUUID5();
     const session = await terminalService.spawn(input.workspaceId, terminalId, {
       command: input.command,
       cwd: input.cwd,