operatr 0.12.0

package/server/runner.js

@@ -0,0 +1,3799 @@
+import { createRequire as __cr } from 'module'; const require = __cr(import.meta.url);
+
+// apps/server/src/runner/main.ts
+import net from "node:net";
+import { promises as fs6, readFileSync } from "node:fs";
+
+// packages/shared/src/types.ts
+import { z } from "zod";
+var LANE_IDS = [
+  "backlog",
+  "discovery",
+  "architecture",
+  "implementation",
+  "local-testing",
+  "pr-review",
+  "ci",
+  "prod-testing",
+  "done"
+];
+var TASK_ENTRY_LANES = ["backlog", "discovery", "architecture", "implementation"];
+var LANES = [
+  { id: "backlog", title: "Backlog", blurb: "Ideas and to-do. No agent yet.", automated: false },
+  { id: "discovery", title: "Design", blurb: "Product discovery for larger features: clarifying questions, draft descriptions, rough wireframes, approach trade-offs.", automated: true },
+  { id: "architecture", title: "Arch", blurb: "Agent proposes an implementation design.", automated: true },
+  { id: "implementation", title: "Build", blurb: "Agent implements in an isolated worktree.", automated: true },
+  { id: "local-testing", title: "Test", blurb: "Extensive local testing and polish.", automated: true },
+  { id: "pr-review", title: "Review", blurb: "Independent agent reviews, then opens a PR.", automated: true },
+  { id: "ci", title: "Merge", blurb: "Merge and babysit the pipeline to green.", automated: true },
+  { id: "prod-testing", title: "Verify", blurb: "Verify the feature live; nothing broke.", automated: true },
+  { id: "done", title: "Done", blurb: "Complete.", automated: false }
+];
+var EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
+var TASK_SIZES = ["xs", "s", "m", "l", "xl"];
+function effortToSize(effort) {
+  switch (effort) {
+    case "low":
+      return "s";
+    case "medium":
+      return "m";
+    case "high":
+      return "l";
+    case "xhigh":
+    case "max":
+      return "xl";
+  }
+}
+function taskScopeSize(t) {
+  return t.size ?? (t.effort ? effortToSize(t.effort) : "m");
+}
+var STEP_GATES = ["ask", "policy", "auto"];
+var LEGACY_STEP_GATES = {
+  never: "ask",
+  decide: "policy",
+  always: "auto"
+};
+var DEFAULT_STEP_GATES = {
+  backlog: "policy",
+  discovery: "policy",
+  architecture: "policy",
+  implementation: "policy",
+  "local-testing": "policy",
+  "pr-review": "policy",
+  ci: "policy",
+  "prod-testing": "policy",
+  done: "policy"
+};
+var PERMISSION_MODES = [
+  "default",
+  "acceptEdits",
+  "auto",
+  "plan",
+  "dontAsk",
+  "bypassPermissions"
+];
+var DEV_SPEEDS = ["startup", "company", "enterprise"];
+var IFRAME_CACHING = ["none", "last-open", "eager", "all-active"];
+var DEFAULT_IFRAME_CACHING = "eager";
+var FORK_KEY_SEP = "::fork::";
+function parentTaskId(key) {
+  const i = key.indexOf(FORK_KEY_SEP);
+  return i >= 0 ? key.slice(0, i) : key;
+}
+var ForkTabSchema = z.object({
+  key: z.string(),
+  sessionId: z.string().catch(""),
+  label: z.string().catch(""),
+  createdAt: z.string().catch(""),
+  model: z.string().optional().catch(void 0),
+  effort: z.enum(EFFORT_LEVELS).optional().catch(void 0),
+  permissionMode: z.enum(PERMISSION_MODES).optional().catch(void 0),
+  autonomous: z.boolean().optional().catch(void 0)
+});
+var TaskFrontmatterSchema = z.object({
+  id: z.string().optional().catch(void 0),
+  title: z.string().optional().catch(void 0),
+  shortDescription: z.string().optional().catch(void 0),
+  order: z.number().optional().catch(void 0),
+  status: z.enum(LANE_IDS).optional().catch(void 0),
+  sessionId: z.string().optional().catch(void 0),
+  worktree: z.string().optional().catch(void 0),
+  branch: z.string().optional().catch(void 0),
+  model: z.string().optional().catch(void 0),
+  effort: z.enum(EFFORT_LEVELS).optional().catch(void 0),
+  size: z.enum(TASK_SIZES).optional().catch(void 0),
+  permissionMode: z.enum(PERMISSION_MODES).optional().catch(void 0),
+  autonomous: z.boolean().optional().catch(void 0),
+  forks: z.array(ForkTabSchema).optional().catch(void 0),
+  prUrl: z.string().optional().catch(void 0),
+  prNumber: z.number().optional().catch(void 0),
+  createdAt: z.string().optional().catch(void 0),
+  /** ISO timestamp of when the task first moved to the done lane. */
+  doneAt: z.string().optional().catch(void 0),
+  /** ISO timestamp of when the task first left backlog into any swimlane. */
+  workflowEnteredAt: z.string().optional().catch(void 0),
+  /** ISO timestamp of the last orchestrator update_task groom call. */
+  lastGroomedAt: z.string().optional().catch(void 0),
+  /** ISO timestamp of the last update_task_doc append (phase agent changed the spec). */
+  lastDocUpdatedAt: z.string().optional().catch(void 0),
+  /** User-drag crash-safety marker — see `Task.pendingKickoff`. */
+  pendingKickoff: z.enum(LANE_IDS).optional().catch(void 0),
+  /** Last lane whose phase prompt reached the runner — see `Task.kickedLane`. */
+  kickedLane: z.enum(LANE_IDS).optional().catch(void 0),
+  /** Groomer-proposed first swimlane — see `Task.proposedLane`. */
+  proposedLane: z.enum(LANE_IDS).optional().catch(void 0),
+  /** Orchestrator is grooming/routing this idea — see `Task.grooming`. */
+  grooming: z.boolean().optional().catch(void 0)
+}).passthrough();
+var StepGatesFrontmatterSchema = z.record(z.string(), z.unknown()).transform((raw) => {
+  const out = {};
+  for (const [k, v] of Object.entries(raw)) {
+    const gate = LEGACY_STEP_GATES[v] ?? v;
+    if (LANE_IDS.includes(k) && STEP_GATES.includes(gate)) out[k] = gate;
+  }
+  return out;
+}).catch({});
+var PhaseHooksFrontmatterSchema = z.record(z.string(), z.unknown()).transform((raw) => {
+  const out = {};
+  for (const [k, v] of Object.entries(raw)) {
+    if (LANE_IDS.includes(k) && typeof v === "string" && v.trim()) {
+      out[k] = v.trim();
+    }
+  }
+  return out;
+}).catch({});
+var BoardFrontmatterSchema = z.object({
+  trunk: z.string().optional().catch(void 0),
+  reviewMode: z.enum(["local", "remote"]).catch("local"),
+  autoExpand: z.boolean().catch(true),
+  devSpeed: z.enum(DEV_SPEEDS).catch("enterprise"),
+  iframeCaching: z.enum(IFRAME_CACHING).catch(DEFAULT_IFRAME_CACHING),
+  orchestratorSessionId: z.string().optional().catch(void 0),
+  orchestratorModel: z.string().optional().catch(void 0),
+  orchestratorEffort: z.enum(EFFORT_LEVELS).optional().catch(void 0),
+  orchestratorPermissionMode: z.enum(PERMISSION_MODES).optional().catch(void 0),
+  orchestratorForks: z.array(ForkTabSchema).optional().catch(void 0),
+  stepGates: StepGatesFrontmatterSchema.default({}),
+  phaseHooks: PhaseHooksFrontmatterSchema.default({}),
+  /** One-time command run in a JUST-CREATED task worktree (deps install etc.),
+   *  before the first phase prompt. See Project.worktreeSetup. */
+  worktreeSetup: z.string().optional().catch(void 0),
+  devCommand: z.string().optional().catch(void 0)
+}).passthrough();
+var isOrchestratorKey = (key) => key.startsWith("orch:");
+var ClientMessageSchema = z.discriminatedUnion("kind", [
+  // `afterSeq`: the stream's last seen seq cursor — the server replays only
+  // events after it (gap-free reconnect); omitted → full snapshot replay.
+  z.object({
+    kind: z.literal("subscribe_agent"),
+    taskId: z.string(),
+    afterSeq: z.number().int().nonnegative().optional()
+  }),
+  // Run logs: stream one run's output to the open panel (one at a time).
+  z.object({ kind: z.literal("subscribe_run"), taskId: z.string(), runId: z.string() }),
+  z.object({ kind: z.literal("unsubscribe_run"), taskId: z.string(), runId: z.string() }),
+  // Scope this tab's board stream to one project, so a tab governing project A
+  // doesn't receive (and clobber its view with) project B's board broadcasts.
+  // Re-sent after reconnect so the scoping survives a server restart.
+  z.object({ kind: z.literal("subscribe_project"), projectId: z.string() }),
+  // Run an ad-hoc shell command in the task's worktree (one at a time), or kill it.
+  z.object({ kind: z.literal("run_command"), taskId: z.string(), command: z.string() }),
+  z.object({ kind: z.literal("kill_command"), taskId: z.string() }),
+  // Dictation: open the upstream relay, stream base64 PCM16 chunks, then stop.
+  z.object({ kind: z.literal("dictation_start") }),
+  z.object({ kind: z.literal("dictation_audio"), audio: z.string() }),
+  z.object({ kind: z.literal("dictation_stop") }),
+  // Result of a devtools_command, echoed back with its commandId.
+  z.object({
+    kind: z.literal("devtools_result"),
+    taskId: z.string(),
+    commandId: z.string(),
+    ok: z.boolean(),
+    result: z.unknown().optional(),
+    error: z.string().optional()
+  })
+]);
+var OpenProjectBody = z.object({
+  path: z.string().min(1),
+  trunk: z.string().optional()
+}).strict();
+var UpdateProjectBody = z.object({
+  name: z.string().min(1).optional(),
+  trunk: z.string().min(1).optional()
+}).strict();
+var ProjectSettingsBody = z.object({
+  reviewMode: z.enum(["local", "remote"]).optional(),
+  trunk: z.string().optional(),
+  autoExpand: z.boolean().optional(),
+  devSpeed: z.enum(DEV_SPEEDS).optional(),
+  iframeCaching: z.enum(IFRAME_CACHING).optional(),
+  stepGates: z.record(z.enum(LANE_IDS), z.enum(STEP_GATES)).optional(),
+  // Per-lane harness command. Empty string clears the hook for that lane.
+  phaseHooks: z.record(z.enum(LANE_IDS), z.string()).optional(),
+  // One-time worktree-creation hook. Empty string clears it.
+  worktreeSetup: z.string().optional()
+}).strict();
+var AGENT_PROMPT_IDS = ["groom", "orchestrator"];
+var CustomizePromptBody = z.object({
+  scope: z.enum(["project", "user"]),
+  lane: z.enum(LANE_IDS).optional(),
+  agent: z.enum(AGENT_PROMPT_IDS).optional()
+}).strict().refine((b) => b.lane === void 0 !== (b.agent === void 0), {
+  message: "Provide exactly one of `lane` or `agent`."
+});
+var CreateTaskBody = z.object({
+  // Often empty at creation: the user's text goes into the description/body and a
+  // short title is derived during grooming. Kept for the orchestrator/agent to set.
+  title: z.string().default(""),
+  shortDescription: z.string().default(""),
+  /** Lane to create the task in. Defaults to backlog; an in-progress lane starts that phase immediately. */
+  toLane: z.enum(TASK_ENTRY_LANES).optional(),
+  /**
+   * Kick off immediately: create in the backlog, then have the orchestrator
+   * estimate the task's scope and start it at the first phase that scope needs
+   * (skipping e.g. discovery/architecture for small tasks). Only meaningful for
+   * backlog creation — an explicit in-progress `toLane` already starts at once.
+   */
+  kickoff: z.boolean().optional()
+}).strict();
+var MoveTaskBody = z.object({
+  toLane: z.enum(LANE_IDS),
+  toOrder: z.number().int().nonnegative().optional(),
+  /** Optional drag-time instruction from the user, injected into the rerun
+   *  phase's prompt as part of `{{userMoveContext}}`. */
+  userNote: z.string().max(4e3).optional()
+}).strict();
+var SendMessageBody = z.object({
+  text: z.string().min(1)
+}).strict();
+var SetControlsBody = z.object({
+  model: z.string().optional(),
+  effort: z.enum(EFFORT_LEVELS).optional(),
+  size: z.enum(TASK_SIZES).optional(),
+  permissionMode: z.enum(PERMISSION_MODES).optional(),
+  /** Target a fork session (its stream key) instead of the main task session.
+   *  Omitted/equal to the task id → the main session. `size` is task-level and
+   *  ignores this. */
+  streamKey: z.string().optional()
+}).strict();
+var PermissionDecisionBody = z.object({
+  requestId: z.string(),
+  decision: z.enum(["allow", "deny"]),
+  message: z.string().optional()
+}).strict();
+var ClarificationAnswerBody = z.object({
+  requestId: z.string(),
+  answer: z.string()
+}).strict();
+var AskQuestionAnswerBody = z.object({
+  requestId: z.string(),
+  // Map of question text -> chosen answer (multi-select answers comma-joined).
+  // Omitted entirely when the user cancels/dismisses the prompt (the tool is denied).
+  answers: z.record(z.string()).optional()
+}).strict();
+var AdvanceDecisionBody = z.object({
+  requestId: z.string(),
+  accept: z.boolean(),
+  toLane: z.enum(LANE_IDS).optional()
+}).strict();
+var GlobalSettingsBody = z.object({
+  /** ElevenLabs API key for dictation. Empty string clears it. */
+  elevenLabsApiKey: z.string().optional(),
+  /**
+   * When true, pass `settingSources: ["user","project","local"]` to agent sessions
+   * so they inherit the user's ~/.claude settings (model defaults, hooks, autoCompact…).
+   * When false (default), only project/local sources are used and autoCompact is
+   * enabled unconditionally so agents self-manage their context window.
+   */
+  passthroughUserSettings: z.boolean().optional(),
+  /** Comma-separated spoken keywords that submit the current dictation buffer. Default: "shazam". */
+  dictationSubmitKeywords: z.string().optional()
+}).strict();
+var AddAccountBody = z.object({
+  label: z.string().min(1),
+  token: z.string().min(1)
+}).strict();
+var ComposerPutBody = z.object({
+  key: z.string().min(1),
+  draft: z.string().default(""),
+  queue: z.array(z.string()).default([]),
+  pending: z.array(z.string()).default([])
+}).strict();
+var ClaimPendingBody = z.object({ key: z.string().min(1) }).strict();
+var ForkBody = z.object({
+  /** Stream key being forked (taskId for the main session, or a fork key). */
+  sourceKey: z.string().optional(),
+  /** First turn sent to the fork (spawns its runner). */
+  message: z.string().optional(),
+  /** Start a fresh session (no copied transcript/feed) instead of a fork. The
+   *  new tab still inherits the source session's model/effort/permission and the
+   *  same cwd (task worktree / project root). */
+  blank: z.boolean().optional()
+}).strict();
+var RenameBody = z.object({ name: z.string().trim().min(1) }).strict();
+var RewindBody = z.object({
+  toUuid: z.string().min(1),
+  preview: z.string().optional(),
+  index: z.number().int().nonnegative().optional()
+}).strict();
+
+// packages/shared/src/fastTrack.ts
+var AUTOMATED_LANES = LANES.filter((l) => l.automated).map((l) => l.id);
+function sizeOf(size) {
+  return size ?? "m";
+}
+function skippableLanes(devSpeed, size) {
+  const s = sizeOf(size);
+  if (devSpeed === "enterprise") {
+    return /* @__PURE__ */ new Set();
+  }
+  if (devSpeed === "company") {
+    if (s === "xs" || s === "s")
+      return /* @__PURE__ */ new Set(["discovery", "architecture", "local-testing", "prod-testing"]);
+    if (s === "m") return /* @__PURE__ */ new Set(["discovery", "architecture", "prod-testing"]);
+    return /* @__PURE__ */ new Set(["prod-testing"]);
+  }
+  if (s === "xs" || s === "s" || s === "m")
+    return /* @__PURE__ */ new Set([
+      "discovery",
+      "architecture",
+      "local-testing",
+      "pr-review",
+      "prod-testing"
+    ]);
+  if (s === "l") return /* @__PURE__ */ new Set(["discovery", "prod-testing"]);
+  return /* @__PURE__ */ new Set(["prod-testing"]);
+}
+function plannedLanes(devSpeed, size) {
+  const skip = skippableLanes(devSpeed, size);
+  return AUTOMATED_LANES.filter((l) => !skip.has(l));
+}
+function firstPlannedLane(devSpeed, size) {
+  const first = plannedLanes(devSpeed, size)[0];
+  if (!first)
+    throw new Error(
+      `firstPlannedLane: empty planned path for devSpeed=${devSpeed} size=${size ?? "m"}`
+    );
+  return first;
+}
+
+// packages/shared/src/taskOrdering.ts
+function laneSortKey(task, lane) {
+  if (lane === "backlog") return task.createdAt;
+  if (lane === "done") return task.doneAt ?? task.createdAt;
+  return task.workflowEnteredAt ?? task.createdAt;
+}
+function compareTasksInLane(lane, a, b) {
+  return laneSortKey(b, lane).localeCompare(laneSortKey(a, lane)) || b.id.localeCompare(a.id);
+}
+
+// packages/shared/src/taskFields.ts
+var TASK_BODY_FIELDS = [
+  { key: "problem", heading: "Problem" },
+  { key: "context", heading: "Context" },
+  { key: "acceptance", heading: "Acceptance criteria" },
+  /** The independent-test brief — what the test phase verifies, with NO
+   *  implementation detail. `expectedResult` defaults to the grooming-set
+   *  acceptance criteria and may be refined at end of build; `affectedAreas` is
+   *  the high-level "which areas changed" (not how) the build agent records via
+   *  `set_test_brief` before handing off to the fresh tester session. */
+  { key: "expectedResult", heading: "Expected result" },
+  { key: "affectedAreas", heading: "Affected areas" },
+  { key: "clarifications", heading: "Clarifications" },
+  /** Per-phase work log — discovery/architecture/impl findings (update_task_doc
+   *  appends here). Kept structured so phase output never hand-edits the
+   *  definition fields above it. */
+  { key: "notes", heading: "Notes" }
+];
+var APPEND_FIELDS = ["clarifications", "notes"];
+var HEADING_TO_KEY = new Map(
+  TASK_BODY_FIELDS.map((f) => [f.heading.toLowerCase(), f.key])
+);
+function parseTaskBody(body) {
+  const fields = {};
+  let curKey = null;
+  let unknownHeading = null;
+  let buf = [];
+  const flush = () => {
+    const text = buf.join("\n").trim();
+    buf = [];
+    if (curKey) {
+      if (text) fields[curKey] = fields[curKey] ? `${fields[curKey]}
+
+${text}` : text;
+    } else if (unknownHeading) {
+      const chunk = text ? `## ${unknownHeading}
+
+${text}` : `## ${unknownHeading}`;
+      fields.notes = fields.notes ? `${fields.notes}
+
+${chunk}` : chunk;
+    }
+  };
+  for (const line of body.split("\n")) {
+    const m = /^#{2,6}\s+(.+?)\s*$/.exec(line);
+    if (m) {
+      flush();
+      const key = HEADING_TO_KEY.get(m[1].toLowerCase());
+      curKey = key ?? null;
+      unknownHeading = key ? null : m[1];
+    } else {
+      buf.push(line);
+    }
+  }
+  flush();
+  return fields;
+}
+function serializeTaskBody(fields) {
+  const parts = [];
+  for (const { key, heading } of TASK_BODY_FIELDS) {
+    const v = fields[key]?.trim();
+    if (v) parts.push(`## ${heading}
+
+${v}`);
+  }
+  return parts.length ? parts.join("\n\n") + "\n" : "";
+}
+function patchTaskBody(body, patch, append = APPEND_FIELDS) {
+  const fields = parseTaskBody(body);
+  const appendSet = new Set(append);
+  for (const { key } of TASK_BODY_FIELDS) {
+    const v = patch[key];
+    if (v === void 0) continue;
+    const val = v.trim();
+    if (appendSet.has(key) && fields[key] && val) fields[key] = `${fields[key]}
+
+${val}`;
+    else fields[key] = val;
+  }
+  return serializeTaskBody(fields);
+}
+
+// packages/shared/src/feed/identity.ts
+var enc = new TextEncoder();
+
+// apps/server/src/runner/main.ts
+import { nanoid as nanoid2 } from "nanoid";
+
+// apps/server/src/agent/runtime.ts
+import {
+  query,
+  forkSession
+} from "@anthropic-ai/claude-agent-sdk";
+import { nanoid } from "nanoid";
+
+// apps/server/src/agent/toolPolicy.ts
+import path from "node:path";
+var SELF_SCHEDULE_TOOLS = /* @__PURE__ */ new Set(["ScheduleWakeup", "CronCreate", "CronDelete", "CronList", "RemoteTrigger"]);
+var SELF_SCHEDULE_MESSAGE = "Refused: don't self-schedule or poll on a timer in an Operator task. When you start a tracked run (run_tests / start_run), just END YOUR TURN \u2014 Operator sends you the run's PASS/FAIL verdict as a message and re-invokes you automatically. If you're blocked on something else, call mcp__operator__propose_advance or mcp__operator__request_clarification and stop; the harness wakes you when there's work. ScheduleWakeup/Cron do not fire reliably in this runtime and only strand the task.";
+var BACKGROUND_BASH_MESSAGE = "Refused: don't run Bash with run_in_background. Operator doesn't own a backgrounded shell, so it can't deliver the command's result back to you \u2014 your turn would end and the session would hang waiting forever. Run it in the FOREGROUND and wait this turn (up to 10m). For a test suite use mcp__operator__run_tests; for a long-lived process (dev server / preview) use mcp__operator__start_run \u2014 both are tracked and Operator sends you their verdict/exit as a message, so you can safely end your turn.";
+var DANGEROUS_BASH = [
+  /\bpkill\b/,
+  /\bkillall\b/,
+  /\b(kill|lsof|fuser)\b[^\n]*\b(4317|5173)\b/,
+  /\b(4317|5173)\b[^\n]*\b(kill|lsof|fuser)\b/,
+  /\brm\s+-rf\s+(\/|~|\$HOME)(\s|$|\/)/,
+  /\b(shutdown|reboot|halt)\b/
+];
+var DANGER_MESSAGE = "Refused. Do not kill processes or ports you did not start: no pkill/killall, and never touch ports 4317/5173 or the Operator manager. Run the app on $OPERATOR_PORT and stop only the exact PID you started.";
+var GIT_READONLY_SUBCMDS = /* @__PURE__ */ new Set([
+  "log",
+  "show",
+  "diff",
+  "status",
+  "rev-parse",
+  "cat-file",
+  "ls-files",
+  "ls-tree",
+  "blame",
+  "describe",
+  "for-each-ref",
+  "rev-list",
+  "shortlog",
+  "show-ref",
+  "name-rev",
+  "diff-tree",
+  "merge-base",
+  "grep",
+  "whatchanged",
+  "cherry",
+  "count-objects",
+  "reflog"
+]);
+var ESCAPE_MESSAGE = "Refused: that git command would WRITE to a checkout other than your worktree. You may READ another checkout (git -C <path> log/show/diff/status \u2026), but never check out, commit, merge, reset, push, or otherwise mutate outside your worktree \u2014 make changes in your worktree and let the harness merge them.";
+function matchBash(input, patterns) {
+  const cmd = typeof input?.command === "string" ? input.command : "";
+  for (const re of patterns) if (re.test(cmd)) return cmd;
+  return null;
+}
+function dangerousCommand(input) {
+  return matchBash(input, DANGEROUS_BASH);
+}
+var BRANCH_MUTATING_LONG = /^--(delete|force|move|copy|set-upstream-to|unset-upstream|edit-description|create-reflog|track)(=|$)/;
+var BRANCH_MUTATING_SHORT = /^-[a-zA-Z]*[dDmMcCft]/;
+function isReadonlyBranchInvocation(args) {
+  const tokens = args.trim().split(/\s+/).filter(Boolean);
+  if (tokens.length === 0) return true;
+  if (tokens.some((t) => BRANCH_MUTATING_LONG.test(t) || BRANCH_MUTATING_SHORT.test(t))) return false;
+  if (!tokens.every((t) => t.startsWith("-"))) return false;
+  return tokens.some((t) => t === "--show-current" || t === "--list" || t === "-l" || t === "-a" || t === "-r" || t === "-v" || t === "-vv");
+}
+function unquote(s) {
+  if (s.startsWith("'") && s.endsWith("'") || s.startsWith('"') && s.endsWith('"')) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+function targetsOwnWorktree(rawTarget, cwd) {
+  const target = unquote(rawTarget);
+  if (!target || /[$`]/.test(target)) return false;
+  const rel = path.relative(cwd, path.resolve(cwd, target));
+  return rel === "" || rel !== ".." && !rel.startsWith(".." + path.sep) && !path.isAbsolute(rel);
+}
+function worktreeEscapeCommand(input, cwd) {
+  const cmd = typeof input?.command === "string" ? input.command : "";
+  if (!cmd) return null;
+  if (/--git-dir\b/.test(cmd) || /--work-tree\b/.test(cmd)) return cmd;
+  if (!/\bgit\s+-C\b/.test(cmd)) return null;
+  const re = /\bgit\s+-C\s+('[^']*'|"[^"]*"|\S+)\s+([a-z][a-z-]*)[ \t]*([^;|&\n]*)/g;
+  let matched = false;
+  for (const m of cmd.matchAll(re)) {
+    matched = true;
+    if (targetsOwnWorktree(m[1], cwd)) continue;
+    if (GIT_READONLY_SUBCMDS.has(m[2])) continue;
+    if (m[2] === "branch" && isReadonlyBranchInvocation(m[3] ?? "")) continue;
+    return cmd;
+  }
+  return matched ? null : cmd;
+}
+var FILE_WRITE_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+function outOfWorktreeWrite(toolName, input, cwd) {
+  if (!FILE_WRITE_TOOLS.has(toolName)) return null;
+  const fp = input?.file_path ?? input?.notebook_path;
+  if (typeof fp !== "string" || fp === "") return null;
+  const abs = path.resolve(cwd, fp);
+  const rel = path.relative(cwd, abs);
+  const outside = rel === ".." || rel.startsWith(".." + path.sep) || path.isAbsolute(rel);
+  return outside ? abs : null;
+}
+var OUT_OF_WORKTREE_MESSAGE = (cwd, target) => `Refused: \`${target}\` is outside your worktree. You may only create or edit files inside \`${cwd}\` \u2014 your own isolated worktree. That path is in the user's live main checkout; editing it corrupts the running app. Make the change at the matching path inside your worktree instead, and never pass a file-writing tool an absolute path that points outside it. If you genuinely need to touch something outside the worktree, call mcp__operator__request_clarification.`;
+function evaluateToolPolicy(toolName, input, cwd, opts) {
+  if (SELF_SCHEDULE_TOOLS.has(toolName)) {
+    return { message: SELF_SCHEDULE_MESSAGE, log: `Blocked self-scheduling tool: ${toolName}` };
+  }
+  if (toolName === "Bash" && input?.run_in_background === true) {
+    return { message: BACKGROUND_BASH_MESSAGE, log: "Blocked backgrounded Bash (run_in_background)" };
+  }
+  const escapee = outOfWorktreeWrite(toolName, input, cwd);
+  if (escapee) {
+    return { message: OUT_OF_WORKTREE_MESSAGE(cwd, escapee), log: `Blocked out-of-worktree write: ${escapee}` };
+  }
+  if (opts.autonomous && toolName === "Bash") {
+    const danger = dangerousCommand(input);
+    if (danger) return { message: DANGER_MESSAGE, log: `Blocked dangerous command: ${danger}` };
+    const escape = worktreeEscapeCommand(input, cwd);
+    if (escape) return { message: ESCAPE_MESSAGE, log: `Blocked worktree-escape command: ${escape}` };
+  }
+  return null;
+}
+
+// apps/server/src/agent/runtime.ts
+var DEFAULT_AUTO_ALLOW = [
+  "Read",
+  "Grep",
+  "Glob",
+  "LS",
+  "WebFetch",
+  "WebSearch",
+  "TodoWrite",
+  "NotebookRead",
+  "BashOutput"
+];
+var BASH_INLINE_ENV = {
+  BASH_DEFAULT_TIMEOUT_MS: "600000",
+  BASH_MAX_TIMEOUT_MS: "600000",
+  CLAUDE_CODE_DISABLE_BACKGROUND_TASKS: "1"
+};
+var InputQueue = class {
+  buf = [];
+  waiters = [];
+  ended = false;
+  push(msg) {
+    const w = this.waiters.shift();
+    if (w) w({ value: msg, done: false });
+    else this.buf.push(msg);
+  }
+  end() {
+    this.ended = true;
+    let w;
+    while (w = this.waiters.shift()) w({ value: void 0, done: true });
+  }
+  async *[Symbol.asyncIterator]() {
+    for (; ; ) {
+      if (this.buf.length) {
+        yield this.buf.shift();
+        continue;
+      }
+      if (this.ended) return;
+      const r = await new Promise((res) => this.waiters.push(res));
+      if (r.done) return;
+      yield r.value;
+    }
+  }
+};
+function userMessage(text) {
+  return {
+    type: "user",
+    parent_tool_use_id: null,
+    message: { role: "user", content: text }
+  };
+}
+var RATE_LIMIT_RE = /(?:\b(?:status|code|http)\b[^0-9]{0,12})(?:429|529)\b|\b(?:429|529)\b(?:\s+(?:too many requests|overloaded|server error|service unavailable))|overloaded|rate[ _-]?limit|temporarily limiting|too many requests/i;
+function isRateLimitError(err) {
+  if (err == null) return false;
+  const status = err.status ?? err.statusCode;
+  if (status === 429 || status === 529) return true;
+  let text;
+  try {
+    text = typeof err === "string" ? err : [err.message, err.error?.message, err.subtype, JSON.stringify(err)].filter(Boolean).join(" ");
+  } catch {
+    text = String(err.message ?? "");
+  }
+  return RATE_LIMIT_RE.test(text);
+}
+var CONTEXT_OVERFLOW_RE = /prompt is too long|input is too long|too many (?:input )?tokens|maximum context length|context (?:window |length )?(?:exceeded|too long|limit exceeded)/i;
+function isContextOverflowError(err) {
+  if (err == null) return false;
+  let text;
+  try {
+    text = typeof err === "string" ? err : [err.message, err.error?.message, err.subtype, JSON.stringify(err)].filter(Boolean).join(" ");
+  } catch {
+    text = String(err.message ?? "");
+  }
+  return CONTEXT_OVERFLOW_RE.test(text);
+}
+var SESSION_NOT_FOUND_RE = /no conversation found|conversation not found|session (?:id |with id )?not found|could not find (?:the )?(?:conversation|session)|no session with (?:the )?id|unknown session id/i;
+function isSessionNotFoundError(err) {
+  if (err == null) return false;
+  let text;
+  try {
+    text = typeof err === "string" ? err : [err.message, err.error?.message, err.subtype, JSON.stringify(err)].filter(Boolean).join(" ");
+  } catch {
+    text = String(err.message ?? "");
+  }
+  return SESSION_NOT_FOUND_RE.test(text);
+}
+var TRANSIENT_RE = (
+  // `ede_diagnostic` is the CLI's internal "stream ended in an impossible state"
+  // marker (e.g. result_type=user stop_reason=tool_use — the turn died mid-tool).
+  // It recurs sporadically under load and a bounded replay resumes the turn; left
+  // fatal it stranded tasks in error for a hiccup.
+  /socket connection.*closed|closed unexpectedly|ECONNRESET|ETIMEDOUT|EPIPE|socket hang ?up|fetch failed|network error|premature close|ede_diagnostic/i
+);
+function isTransientConnectionError(err) {
+  if (err == null) return false;
+  const status = err.status ?? err.statusCode;
+  if (status === 502 || status === 503 || status === 504) return true;
+  let text;
+  try {
+    text = typeof err === "string" ? err : [err.message, err.error?.message, err.code, JSON.stringify(err)].filter(Boolean).join(" ");
+  } catch {
+    text = String(err.message ?? "");
+  }
+  return TRANSIENT_RE.test(text);
+}
+function classifyAgentError(err, opts = {}) {
+  if (isContextOverflowError(err)) return "overflow";
+  if (opts.trustRateLimitText && isRateLimitError(err) || opts.pendingLimit) return "throttle";
+  if (isSessionNotFoundError(err)) return "stale_session";
+  if (isTransientConnectionError(err)) return "transient";
+  return "fatal";
+}
+var AgentSession = class _AgentSession {
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.sessionId = cfg.resumeSessionId;
+    this.autoAllow = /* @__PURE__ */ new Set([...cfg.autoAllowTools ?? DEFAULT_AUTO_ALLOW]);
+  }
+  q;
+  input;
+  loop;
+  sessionId;
+  needsRestart = false;
+  /** Transient-connection retries for the CURRENT turn (reset on a fresh send). Bounds
+   *  auto-recovery from dropped sockets so a persistent outage can't replay forever. */
+  transientRetries = 0;
+  /** Last assistant text block of the in-flight turn. The CLI sometimes reports a
+   *  dropped socket by PRINTING it as assistant text + an `is_error` result rather
+   *  than throwing — we inspect this at turn end to retry such a stall. */
+  lastAssistantText = "";
+  autoAllow;
+  /** Text of the in-flight turn, kept so a throttled turn can be replayed on retry. */
+  lastTurnText;
+  /** Set while a turn is held after a rate-limit, awaiting a coordinated retry. */
+  throttled = false;
+  /** A deliberate interrupt() is in flight — the next result's error subtype is
+   *  bookkeeping (our own teardown), not a failure. Cleared on the next send. */
+  interrupting = false;
+  /** How many times the current turn has been throttled (reset on a fresh send). */
+  throttleAttempt = 0;
+  /**
+   * Captured from the SDK's structured `rate_limit_event` (status "rejected"): a
+   * known usage-cap reset window. When set at turn-end the throttle carries it so
+   * the orchestrator waits until the reset instead of using adaptive backoff.
+   */
+  pendingLimit;
+  /**
+   * Set once a context-overflow ("Prompt is too long") has triggered an automatic
+   * compaction retry for the CURRENT turn. Bounds recovery to a single attempt so
+   * an over-limit turn that compaction can't shrink enough fails terminally instead
+   * of looping. Reset on a fresh user `send` (a new turn starts clean).
+   */
+  compactRecoveryTried = false;
+  /**
+   * Set once a stale/invalid resume target ("No conversation found") has triggered
+   * a fresh-session retry for the CURRENT turn. Bounds recovery to a single attempt
+   * so a turn that still can't run after dropping the resume id fails terminally
+   * instead of looping. Reset on a fresh user `send`.
+   */
+  staleSessionRecoveryTried = false;
+  /**
+   * Set once a persistent context-overflow (compaction already tried) has triggered
+   * a fresh-session retry for the CURRENT turn. Bounds the last-resort recovery to a
+   * single attempt — a turn that overflows even a fresh session (a gigantic prompt)
+   * fails terminally instead of looping. Reset on a fresh user `send`.
+   */
+  overflowFreshSessionTried = false;
+  /**
+   * Once a session has overflowed, auto-compaction is forced on for every later
+   * (re)built query so it self-manages the window from then on (see buildOptions).
+   * Never reset within a session.
+   */
+  autoCompactForced = false;
+  get currentSessionId() {
+    return this.sessionId;
+  }
+  /** Send a user turn, (re)creating the underlying query if needed. */
+  async send(text) {
+    this.lastTurnText = text;
+    this.throttled = false;
+    this.throttleAttempt = 0;
+    this.transientRetries = 0;
+    this.lastAssistantText = "";
+    this.pendingLimit = void 0;
+    this.compactRecoveryTried = false;
+    this.staleSessionRecoveryTried = false;
+    this.overflowFreshSessionTried = false;
+    await this.pushTurn(text);
+  }
+  /** Whether a turn is currently held awaiting a coordinated retry. */
+  get isThrottled() {
+    return this.throttled;
+  }
+  /**
+   * Replay the throttled turn after the central orchestrator grants a retry.
+   * No-op if nothing is held (e.g. the user already sent a new turn).
+   */
+  async retry() {
+    if (!this.throttled || this.lastTurnText === void 0) return;
+    this.throttled = false;
+    await this.pushTurn(this.lastTurnText);
+  }
+  async pushTurn(text) {
+    if (this.needsRestart) await this.teardownQuery();
+    if (!this.q) {
+      this.startQuery();
+    } else {
+      this.cfg.onEvent({ type: "status", state: "running" });
+    }
+    this.interrupting = false;
+    this.input.push(userMessage(text));
+  }
+  async interrupt() {
+    if (this.throttled) {
+      this.throttled = false;
+      this.cfg.onEvent({ type: "status", state: "idle" });
+      return;
+    }
+    this.interrupting = true;
+    try {
+      await this.q?.interrupt();
+    } catch (err) {
+      this.cfg.onEvent({ type: "error", message: `interrupt failed: ${String(err)}` });
+    }
+  }
+  async setModel(model) {
+    this.cfg.model = model;
+    if (this.q) await this.q.setModel(model).catch(() => {
+    });
+  }
+  /** Emit the current session's slash commands (best-effort; inert on failure). */
+  async emitSlashCommands() {
+    try {
+      const list = await this.q?.supportedCommands?.();
+      if (list) this.cfg.onEvent({ type: "slash_commands", commands: mapSlashCommands(list) });
+    } catch {
+    }
+  }
+  async setPermissionMode(mode) {
+    this.cfg.permissionMode = mode;
+    if (this.q) await this.q.setPermissionMode(mode).catch(() => {
+    });
+  }
+  /** Effort is a query-construction option; apply it on the next turn. */
+  setEffort(effort) {
+    this.cfg.effort = effort;
+    this.needsRestart = true;
+  }
+  /** Update unattended-mode (read live by canUseTool) when the phase changes. */
+  setAutonomous(autonomous) {
+    this.cfg.autonomous = autonomous;
+  }
+  /**
+   * Swap the Claude Code OAuth token used for auth (account switch on limit).
+   * Auth is read at query construction, so this takes effect on the next turn;
+   * force a restart so a turn stalled on a limit re-authenticates cleanly.
+   */
+  setAuthToken(token) {
+    this.cfg.env = { ...this.cfg.env ?? {}, CLAUDE_CODE_OAUTH_TOKEN: token };
+    this.needsRestart = true;
+  }
+  async stop() {
+    await this.teardownQuery();
+  }
+  async teardownQuery() {
+    this.input?.end();
+    if (this.loop) await this.loop.catch(() => {
+    });
+    this.q = void 0;
+    this.input = void 0;
+    this.loop = void 0;
+    this.needsRestart = false;
+  }
+  /**
+   * Rewind the conversation to a prior user message (a checkpoint): restore the
+   * worktree files to that point (if file checkpointing was on for this session),
+   * fork the transcript truncated at it, and resume from the fork so the next turn
+   * continues with the earlier context. Emits a `rewound` divider + idle.
+   */
+  async rewind(toUuid, preview) {
+    try {
+      await this.q?.rewindFiles(toUuid);
+    } catch (err) {
+      this.cfg.onEvent({ type: "error", message: `File rewind failed: ${String(err)}` });
+    }
+    let forkedId;
+    try {
+      const res = await forkSession(this.sessionId ?? "", { upToMessageId: toUuid, dir: this.cfg.cwd });
+      forkedId = res.sessionId;
+    } catch (err) {
+      this.cfg.onEvent({ type: "error", message: `Rewind failed: ${String(err)}` });
+      return;
+    }
+    await this.teardownQuery();
+    this.sessionId = forkedId;
+    this.cfg.onSessionId?.(forkedId);
+    this.cfg.onEvent({ type: "rewound", toUuid, ...preview ? { preview } : {} });
+    this.cfg.onEvent({ type: "status", state: "idle" });
+  }
+  buildOptions() {
+    return {
+      cwd: this.cfg.cwd,
+      resume: this.sessionId,
+      enableFileCheckpointing: true,
+      model: this.cfg.model,
+      effort: this.cfg.effort,
+      permissionMode: this.cfg.permissionMode ?? "default",
+      mcpServers: this.cfg.mcpServers,
+      canUseTool: this.canUseTool,
+      onUserDialog: this.onUserDialog,
+      includePartialMessages: false,
+      // settingSources: when passthrough is off (default), skip the user tier so
+      // the agent doesn't inherit ~/.claude settings (hooks, model overrides, etc.).
+      // When on, load all three tiers so the agent mirrors the user's interactive env.
+      settingSources: this.cfg.passthroughUserSettings ? ["user", "project", "local"] : ["project", "local"],
+      // When passthrough is off, force autoCompact on so agents self-manage their
+      // context window without relying on the user's setting. Also force it on after
+      // a context overflow (autoCompactForced) regardless of the passthrough mode.
+      ...this.autoCompactForced || !this.cfg.passthroughUserSettings ? { settings: { autoCompactEnabled: true } } : {},
+      // Plugins are also loaded explicitly so the agent picks them up regardless of
+      // whether the operator's settings enable them.
+      ...this.cfg.plugins?.length ? { plugins: this.cfg.plugins } : {},
+      // BASH_INLINE_ENV defaults win over process.env (builds must run inline even
+      // if the user's shell sets a low Bash timeout) but the per-task injected env
+      // still overrides, so an explicit per-task value stays authoritative.
+      env: { ...process.env, ...BASH_INLINE_ENV, ...this.cfg.env ?? {} },
+      systemPrompt: {
+        type: "preset",
+        preset: "claude_code",
+        ...this.cfg.appendSystemPrompt ? { append: this.cfg.appendSystemPrompt } : {}
+      },
+      stderr: () => {
+      }
+    };
+  }
+  /**
+   * React to a context-window overflow ("Prompt is too long"). NOT routed through
+   * throttle/RetryOrchestrator — that machinery blindly replays the same turn,
+   * which for an over-limit prompt just fails again forever. Instead, bounded to a
+   * SINGLE attempt per turn: the first overflow forces auto-compaction on, tears
+   * down the dead query, and replays the turn so the rebuilt+resumed session
+   * compacts the transcript before re-sending. A second overflow on the same turn
+   * means compaction couldn't free enough room → surface a terminal error, no loop.
+   */
+  /**
+   * Replay the current turn after a transient connection blip (dropped socket, reset,
+   * fetch failure), bounded to a few attempts with a short backoff. The agent runs in a
+   * detached runner, so the setTimeout survives a server reload. After the cap, surface
+   * a terminal error rather than replaying forever against a real outage.
+   */
+  /**
+   * Replay the current turn, but ONLY if there is one. A recovery can fire on a
+   * session reconnected this lifetime with no prior `send` — then `lastTurnText` is
+   * empty, and pushing it replays an EMPTY turn, which makes the agent idle asking
+   * "anything needed?" (a confusing pseudo-stall that looked like it needed input).
+   * With nothing to replay, go idle so the harness re-engages with a real phase prompt.
+   */
+  replayCurrentTurn(label) {
+    if (!this.lastTurnText) {
+      this.cfg.onEvent({ type: "status", state: "idle" });
+      return;
+    }
+    void this.pushTurn(this.lastTurnText).catch((e) => {
+      this.cfg.onEvent({ type: "error", message: `${label} failed: ${String(e)}` });
+      this.cfg.onEvent({ type: "status", state: "error" });
+    });
+  }
+  static MAX_TRANSIENT_RETRIES = 3;
+  recoverFromTransient(err) {
+    if (this.transientRetries >= _AgentSession.MAX_TRANSIENT_RETRIES) {
+      this.cfg.onEvent({
+        type: "error",
+        message: `Connection error (${String(err)}) \u2014 gave up after ${this.transientRetries} retries. Send a new message to retry.`
+      });
+      this.cfg.onEvent({ type: "status", state: "error" });
+      return;
+    }
+    this.transientRetries++;
+    this.needsRestart = true;
+    this.cfg.onEvent({ type: "status", state: "running" });
+    const delayMs = 1e3 * this.transientRetries;
+    setTimeout(() => this.replayCurrentTurn("Connection retry"), delayMs);
+  }
+  recoverFromOverflow(err) {
+    if (!this.compactRecoveryTried) {
+      this.compactRecoveryTried = true;
+      this.autoCompactForced = true;
+      this.needsRestart = true;
+      this.cfg.onEvent({ type: "status", state: "running" });
+      this.replayCurrentTurn("Compaction retry");
+      return;
+    }
+    if (!this.overflowFreshSessionTried) {
+      this.overflowFreshSessionTried = true;
+      const stale = this.sessionId;
+      this.sessionId = void 0;
+      this.needsRestart = true;
+      console.error(`[runtime] context overflow persisted after compaction \u2014 dropping session ${stale ?? "(none)"} and replaying in a fresh session`);
+      this.cfg.onEvent({
+        type: "error",
+        message: `Context window exceeded (${String(err)}) and compaction could not recover it. Restarting in a fresh session and replaying the current phase prompt \u2014 earlier in-session context is dropped.`
+      });
+      this.cfg.onEvent({ type: "status", state: "running" });
+      this.replayCurrentTurn("Fresh-session overflow retry");
+      return;
+    }
+    this.cfg.onEvent({
+      type: "error",
+      message: `Context window exceeded (${String(err)}). Neither compaction nor a fresh session recovered it \u2014 reduce the task's scope or its prompt; retrying as-is will keep failing.`
+    });
+    this.cfg.onEvent({ type: "status", state: "error" });
+  }
+  /**
+   * React to a stale/invalid resume target ("No conversation found with session
+   * ID"). The persisted id is dead, so resuming it can only re-fail — and left
+   * unhandled it silently bricks the project orchestrator (every grooming/move/
+   * start turn dies here). Bounded to a SINGLE attempt per turn: drop the dead id,
+   * tear down the query, and replay the turn so a FRESH session is created. The
+   * fresh session's `init` persists a new id via onSessionId, auto-correcting the
+   * stored stale id (board.md for the orchestrator, frontmatter for a task). A
+   * second session-not-found on the same turn — not expected once resume is
+   * cleared, but guarded — surfaces a terminal error rather than looping.
+   */
+  recoverFromStaleSession(err) {
+    if (this.staleSessionRecoveryTried) {
+      this.cfg.onEvent({
+        type: "error",
+        message: `Could not resume the session (${String(err)}), and starting a fresh one also failed. The session is unrecoverable \u2014 send a new message to start over.`
+      });
+      this.cfg.onEvent({ type: "status", state: "error" });
+      return;
+    }
+    this.staleSessionRecoveryTried = true;
+    const stale = this.sessionId;
+    this.sessionId = void 0;
+    this.needsRestart = true;
+    console.error(`[runtime] resume target ${stale ?? "(none)"} is gone \u2014 starting a fresh session`);
+    this.cfg.onEvent({ type: "status", state: "running" });
+    this.replayCurrentTurn("Fresh-session retry");
+  }
+  /**
+   * Park the current turn after a rate-limit/overload instead of failing it. The
+   * dead query is flagged for rebuild (needsRestart) so retry() starts a fresh
+   * one and resumes the session. Emits a `throttled` event for the central
+   * orchestrator plus a `throttled` run-state for the card badge.
+   */
+  throttle(err) {
+    if (this.throttled) return;
+    this.throttled = true;
+    this.throttleAttempt += 1;
+    this.needsRestart = true;
+    const limit = this.pendingLimit;
+    this.pendingLimit = void 0;
+    this.cfg.onEvent({
+      type: "throttled",
+      attempt: this.throttleAttempt,
+      lastError: String(err),
+      ...limit?.resetsAt ? { resetsAt: limit.resetsAt } : {},
+      ...limit?.limitType ? { limitType: limit.limitType } : {}
+    });
+    this.cfg.onEvent({ type: "status", state: "throttled" });
+  }
+  startQuery() {
+    this.input = new InputQueue();
+    this.q = query({ prompt: this.input, options: this.buildOptions() });
+    const q = this.q;
+    this.loop = (async () => {
+      try {
+        for await (const msg of q) await this.handle(msg);
+      } catch (err) {
+        switch (classifyAgentError(err, { pendingLimit: !!this.pendingLimit, trustRateLimitText: true })) {
+          case "overflow":
+            this.recoverFromOverflow(err);
+            break;
+          case "throttle":
+            this.throttle(err);
+            break;
+          case "stale_session":
+            this.recoverFromStaleSession(err);
+            break;
+          case "transient":
+            this.recoverFromTransient(err);
+            break;
+          case "fatal":
+            this.cfg.onEvent({ type: "error", message: String(err) });
+            this.cfg.onEvent({ type: "status", state: "error" });
+            break;
+        }
+      }
+    })();
+  }
+  canUseTool = async (toolName, input) => {
+    if (toolName === "AskUserQuestion" && this.cfg.onAskUserQuestion) {
+      const inp = input ?? {};
+      const questions = normalizeQuestions(Array.isArray(inp.questions) ? inp.questions : []);
+      if (questions.length > 0) {
+        const id2 = nanoid(10);
+        this.cfg.onEvent({ type: "ask_user_question", id: id2, questions });
+        const answers = await this.cfg.onAskUserQuestion({ id: id2, questions });
+        if (!answers) return { behavior: "deny", message: "User dismissed the question." };
+        return { behavior: "allow", updatedInput: { ...inp, answers } };
+      }
+    }
+    const denial = evaluateToolPolicy(toolName, input ?? {}, this.cfg.cwd, {
+      autonomous: !!this.cfg.autonomous
+    });
+    if (denial) {
+      this.cfg.onEvent({ type: "error", message: denial.log });
+      return { behavior: "deny", message: denial.message };
+    }
+    if (this.cfg.autonomous) {
+      return { behavior: "allow", updatedInput: input };
+    }
+    if (this.autoAllow.has(toolName) || toolName.startsWith("mcp__operator__")) {
+      return { behavior: "allow", updatedInput: input };
+    }
+    const id = nanoid(10);
+    this.cfg.onEvent({ type: "permission_request", id, toolName, input });
+    const decision = await this.cfg.onPermissionRequest({ id, toolName, input });
+    if (decision.allow) return { behavior: "allow", updatedInput: input };
+    return { behavior: "deny", message: decision.message ?? "Denied by user" };
+  };
+  /**
+   * The CLI renders blocking dialogs by asking the host (us) to handle them. The
+   * only one we surface is `AskUserQuestion` (dialogKind `permission_ask_user_question`):
+   * we emit an `ask_user_question` event, wait for the user, then return the answers
+   * merged into the tool input. Without this handler the SDK auto-cancels the dialog
+   * and the CLI falls back to "the user did not answer" — i.e. the tool is skipped.
+   * Unrecognized kinds MUST be answered `cancelled` (per the SDK contract).
+   */
+  onUserDialog = async (request) => {
+    if (!this.cfg.onAskUserQuestion) return { behavior: "cancelled" };
+    const payload = request.payload ?? {};
+    const rawQuestions = findQuestionsArray(payload) ?? findQuestionsArray(request);
+    const questions = normalizeQuestions(rawQuestions);
+    if (questions.length === 0) {
+      if (request.dialogKind === "permission_ask_user_question") {
+        this.cfg.onEvent({
+          type: "error",
+          message: `Could not read the agent's question (dialog "${request.dialogKind}") \u2014 it was skipped.`
+        });
+      }
+      return { behavior: "cancelled" };
+    }
+    const id = nanoid(10);
+    this.cfg.onEvent({ type: "ask_user_question", id, questions });
+    const answers = await this.cfg.onAskUserQuestion({ id, questions });
+    if (!answers) {
+      return { behavior: "completed", result: { behavior: "deny", message: "User dismissed the question." } };
+    }
+    const input = payload.input && typeof payload.input === "object" ? payload.input : {};
+    return { behavior: "completed", result: { behavior: "allow", updatedInput: { ...input, answers } } };
+  };
+  async handle(msg) {
+    const emit2 = this.cfg.onEvent;
+    switch (msg.type) {
+      case "system": {
+        if (msg.subtype === "init") {
+          this.sessionId = msg.session_id;
+          this.cfg.onSessionId?.(msg.session_id);
+          emit2({ type: "session_init", sessionId: msg.session_id });
+          emit2({ type: "status", state: "running" });
+          void this.emitSlashCommands();
+        }
+        if (msg.subtype === "commands_changed") {
+          emit2({ type: "slash_commands", commands: mapSlashCommands(msg.commands) });
+        }
+        return;
+      }
+      case "assistant": {
+        const content = msg.message?.content;
+        if (!Array.isArray(content)) return;
+        for (const block of content) {
+          if (block.type === "text" && block.text) {
+            this.lastAssistantText = block.text;
+            emit2({ type: "assistant_text", text: block.text });
+          } else if (block.type === "thinking" && block.thinking) {
+            emit2({ type: "thinking", text: block.thinking });
+          } else if (block.type === "tool_use") {
+            if (block.name === "TodoWrite") {
+              const items = (block.input?.todos ?? []).map((t) => ({
+                content: t.content ?? t.activeForm ?? "",
+                status: t.status ?? "pending"
+              }));
+              emit2({ type: "todos", items });
+            } else {
+              emit2({ type: "tool_use", id: block.id, name: block.name, input: block.input });
+            }
+          }
+        }
+        return;
+      }
+      case "user": {
+        const content = msg.message?.content;
+        if (!Array.isArray(content)) return;
+        for (const block of content) {
+          if (block.type === "tool_result") {
+            const images = await this.collectImages(block.content);
+            emit2({
+              type: "tool_result",
+              id: block.tool_use_id,
+              isError: block.is_error,
+              summary: summarize(block.content),
+              ...images.length ? { images } : {}
+            });
+          }
+        }
+        return;
+      }
+      case "rate_limit_event": {
+        const info = msg.rate_limit_info;
+        if (info?.status) {
+          emit2({
+            type: "rate_limit",
+            limit: {
+              status: info.status,
+              utilization: info.utilization,
+              rateLimitType: info.rateLimitType,
+              resetsAt: info.resetsAt
+            }
+          });
+        }
+        this.pendingLimit = info?.status === "rejected" ? { resetsAt: normalizeResetsAt(info.resetsAt), limitType: info.rateLimitType } : void 0;
+        return;
+      }
+      case "result": {
+        const m = msg;
+        emit2({
+          type: "usage",
+          inputTokens: m.usage?.input_tokens,
+          outputTokens: m.usage?.output_tokens,
+          cacheReadTokens: m.usage?.cache_read_input_tokens,
+          cacheCreationTokens: m.usage?.cache_creation_input_tokens
+        });
+        emit2({
+          type: "result",
+          subtype: m.subtype,
+          isError: !!m.is_error,
+          ...this.interrupting ? { deliberate: true } : {}
+        });
+        this.interrupting = false;
+        if (m.is_error) {
+          const ctx = [m.subtype, m.result, this.lastAssistantText].filter(Boolean).join(" ");
+          switch (classifyAgentError(ctx, { pendingLimit: !!this.pendingLimit, trustRateLimitText: false })) {
+            case "overflow":
+              this.pendingLimit = void 0;
+              this.recoverFromOverflow(new Error(this.lastAssistantText || "Prompt is too long"));
+              return;
+            case "throttle":
+              this.throttle(new Error(`usage limit${this.pendingLimit?.limitType ? ` (${this.pendingLimit.limitType})` : ""}`));
+              return;
+            case "stale_session":
+              this.recoverFromStaleSession(new Error(`turn ended on a stale session: ${this.lastAssistantText.slice(0, 160)}`));
+              return;
+            case "transient":
+              this.recoverFromTransient(new Error(`turn ended on a connection error: ${this.lastAssistantText.slice(0, 160)}`));
+              return;
+            case "fatal":
+              break;
+          }
+        } else {
+          this.pendingLimit = void 0;
+        }
+        emit2({ type: "status", state: "idle" });
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  /** Persist any base64 image blocks in a tool result; returns asset refs. */
+  async collectImages(content) {
+    if (!this.cfg.saveImage) return [];
+    const out = [];
+    for (const { data, mediaType } of base64ImageBlocks(content)) {
+      const file = await this.cfg.saveImage(data, mediaType);
+      if (file) out.push({ file });
+    }
+    return out;
+  }
+};
+function mapSlashCommands(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const c of raw) {
+    if (!c || typeof c.name !== "string" || c.name === "") continue;
+    if (seen.has(c.name)) continue;
+    seen.add(c.name);
+    out.push({
+      name: c.name,
+      description: typeof c.description === "string" ? c.description : "",
+      ...typeof c.argumentHint === "string" && c.argumentHint ? { argumentHint: c.argumentHint } : {},
+      ...Array.isArray(c.aliases) ? { aliases: c.aliases.filter((a) => typeof a === "string") } : {}
+    });
+  }
+  return out;
+}
+var QUESTION_TEXT_KEYS = ["question", "prompt", "text", "title"];
+var OPTION_LABEL_KEYS = ["label", "value", "text", "title", "name"];
+function firstString(o, keys) {
+  for (const k of keys) {
+    const v = o[k];
+    if (typeof v === "string" && v) return v;
+  }
+  return void 0;
+}
+function normalizeQuestions(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const q of raw) {
+    if (!q || typeof q !== "object") continue;
+    const text = firstString(q, QUESTION_TEXT_KEYS);
+    if (!text) continue;
+    const rawOptions = q.options ?? q.choices;
+    const options = Array.isArray(rawOptions) ? rawOptions.map((o) => {
+      if (typeof o === "string") return { label: o, description: "" };
+      if (o && typeof o === "object") {
+        const label = firstString(o, OPTION_LABEL_KEYS);
+        return label ? { label, description: typeof o.description === "string" ? o.description : "" } : null;
+      }
+      return null;
+    }).filter((o) => !!o) : [];
+    out.push({
+      question: text,
+      header: typeof q.header === "string" ? q.header : "",
+      multiSelect: q.multiSelect === true || q.allowMultiple === true,
+      options
+    });
+  }
+  return out;
+}
+function findQuestionsArray(value, depth = 0) {
+  if (depth > 5 || !value || typeof value !== "object") return null;
+  if (Array.isArray(value)) {
+    const looksLikeQuestions = value.length > 0 && value.every(
+      (it) => it && typeof it === "object" && firstString(it, QUESTION_TEXT_KEYS)
+    );
+    if (looksLikeQuestions) return value;
+    for (const it of value) {
+      const found = findQuestionsArray(it, depth + 1);
+      if (found) return found;
+    }
+    return null;
+  }
+  const obj = value;
+  if (Array.isArray(obj.questions)) {
+    const found = findQuestionsArray(obj.questions, depth + 1);
+    if (found) return found;
+  }
+  for (const v of Object.values(obj)) {
+    const found = findQuestionsArray(v, depth + 1);
+    if (found) return found;
+  }
+  return null;
+}
+function base64ImageBlocks(content) {
+  if (!Array.isArray(content)) return [];
+  const out = [];
+  for (const block of content) {
+    if (block?.type !== "image" || block.source?.type !== "base64") continue;
+    if (typeof block.source.data !== "string" || !block.source.data) continue;
+    out.push({ data: block.source.data, mediaType: block.source.media_type ?? "image/png" });
+  }
+  return out;
+}
+function normalizeResetsAt(v) {
+  if (typeof v !== "number" || !Number.isFinite(v) || v <= 0) return void 0;
+  return v < 1e12 ? Math.round(v * 1e3) : Math.round(v);
+}
+function summarize(content) {
+  if (typeof content === "string") return content.slice(0, 240);
+  if (Array.isArray(content)) {
+    return content.map((b) => typeof b === "string" ? b : b?.text ?? "").join(" ").slice(0, 240);
+  }
+  return "";
+}
+
+// apps/server/src/mcp/operatorServer.ts
+import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
+import { z as z2 } from "zod";
+
+// apps/server/src/prompts/templates.ts
+var TITLE_GUIDANCE = 'Titles are 2\u20135 words max \u2014 a glanceable label, not a sentence (e.g. "Persist agent status", "Shorten task titles"). Drop filler and articles; keep every what/why/how in the summary/body, never the title.';
+var SIZE_GUIDANCE = "Estimate the task's scope as a size: 'xs' a trivial string/copy/constant tweak or one-line fix; 's' a small, localized change; 'm' a normal feature; 'l' a large, multi-part or architecturally significant change; 'xl' a gigantic, architecturally-fundamental change. Be honest \u2014 undersizing skips needed review/testing, oversizing wastes tokens.";
+var ORCH_SYSTEM_TEMPLATE = `You are the project orchestrator for "<%= projectName %>" in Operator, a kanban-style agent manager. You help the user manage this project's task board and answer questions about its codebase. Tools: create_task, update_task, list_tasks, move_task (advance a task into a lane, which starts that phase). ${TITLE_GUIDANCE} A task's body is structured FIELDS \u2014 set \`problem\`, \`context\`, \`acceptance\` (and \`clarification\` to append) via the tools; you never write the assembled body by hand. When asked to refine a raw todo, populate those fields faithfully without inventing scope. Keep chat answers concise.`;
+var GROOM_TEMPLATE = `<%= context %>
+
+Groom it fully: call update_task("<%= taskId %>", ...) with a short title, a one-line summary, the \`problem\` / \`context\` / \`acceptance\` fields (each free markdown \u2014 storage renders the body from them; you never write the body yourself), and a size. ${TITLE_GUIDANCE} ${SIZE_GUIDANCE} Be faithful to the user's intent; do not invent scope (a raw dictated paragraph still gets the full structure \u2014 dedupe repeated phrases). <%= directive %> Just call the tools; no chat reply needed.`;
+var ROUTE_TEMPLATE = `<%= context %>
+
+Before treating this as a new task, decide whether the idea actually belongs to an existing one. Call list_tasks and consider ONLY backlog tasks (status "backlog") \u2014 never fold into a task already in progress. For any whose summary looks related, call get_task to read its full body.
+
+Every idea MUST end as a definite task operation \u2014 refine, fold, or delete. Never leave the placeholder half-groomed (no title/size) or as a raw idea; the board must never hold a task in an in-between state. Choose exactly one:
+- FOLD \u2014 the idea DUPLICATES or refines/expands one or more backlog tasks (it can be several): for each, call update_task(that id, clarification: "<just the new requirement this idea adds>") \u2014 clarification is appended under the ## Clarifications field, so pass ONLY the added requirement (the rest of the task is left untouched). Then call fold_task("<%= taskId %>", [the task id(s) you expanded]) to dissolve this placeholder into them.
+- REFINE \u2014 it is genuinely NEW: groom the placeholder in place \u2014 call update_task("<%= taskId %>", ...) with a short title, a one-line summary, the \`problem\` / \`context\` / \`acceptance\` fields (storage renders the body from them), and a size. <%= directive %>
+- DELETE \u2014 the idea shouldn't exist as a task at all (it's a no-op, noise, or asks to discard it): call delete_task("<%= taskId %>"). Removal is a legitimate grooming outcome.
+
+The placeholder you were given is id <%= taskId %> \u2014 never match it against itself. ${TITLE_GUIDANCE} ${SIZE_GUIDANCE} Be faithful to the user's intent; do not invent scope (a raw dictated paragraph still gets the full structure \u2014 dedupe repeated phrases). When genuinely unsure whether it's a duplicate, prefer refining it into a new task over folding. Just call the tools; no chat reply needed.`;
+var TURN_PROMPTS = {
+  /** Vars: <%= feedback %>. Resolves a parked propose_advance when the user answered
+   *  the proposal with a MESSAGE instead of accepting — the agent's blocked turn
+   *  continues with the feedback in hand (no empty "not approved" + extra turn). */
+  advanceFeedback: `The user did not accept this advance and responded instead:
+
+<user-note>
+<%= feedback %>
+</user-note>
+
+Address their message, then call mcp__operator__propose_advance again when the phase is truly ready.`,
+  /** Vars: <%= trunk %>, <%= error %>. Sent as a TURN so an idle agent re-engages. */
+  mergeConflictReengage: `The harness squash-merge of your branch into <%= trunk %> hit a conflict:
+<%= error %>
+
+Integrate <%= trunk %> into your branch now (\`git merge <%= trunk %>\`), resolve the conflicts, commit, confirm typecheck + tests pass, then call mcp__operator__propose_advance again to re-queue the merge. Don't stop until you've re-proposed (or call request_clarification if a conflict is genuinely ambiguous).`,
+  /** Vars: <%= trunk %>, <%= error %>. Durable fallback when the runner is unreachable. */
+  mergeConflictError: `Merge into <%= trunk %> failed: <%= error %>. Integrate <%= trunk %> into the branch and advance again.`,
+  /** Vars: <%= trunk %>. A corrupt queue entry was dropped — re-engage the card. */
+  lostMergeReengage: `The harness lost your queued merge into <%= trunk %> (the queue entry was corrupted) \u2014 nothing was merged. Re-confirm your branch is ready (typecheck + tests pass), then call mcp__operator__propose_advance again to re-queue the merge.`,
+  /** Vars: <%= trunk %>. Durable fallback when the runner is unreachable. */
+  lostMergeError: `A queued merge into <%= trunk %> was lost (corrupt queue entry). The card is still in ci \u2014 advance again to re-queue.`,
+  /** No vars. Frames a forked session's first message; the user's text follows. */
+  forkKickoff: `[Operator] This session was just forked from its parent. You still have the full prior transcript as context, but you are now an independent branch shown in your own tab alongside the original. Call the operator \`rename_session\` tool to give this tab a short descriptive name for what this branch is about. The user's message for this new branch follows.`
+};
+var FACTS = `Project **<%= project %>** \xB7 trunk \`<%= trunk %>\`<% if (noRemote) { %> \xB7 local-only repo (no \`origin\` remote \u2014 never fetch/push one)<% } %> \xB7 size **<%= size %>** \xB7 dev speed <%= devSpeed %> \xB7 planned path: <%= plannedPath %>`;
+var BG_DETACHED = [
+  "**Verification checkout (read-only).** `<%= worktree %>` is a detached checkout of merged trunk `<%= trunk %>` \u2014 run and inspect it, but never commit, branch, merge, or `cd` out (and never run git against another path, least of all the live checkout at `<%= projectPath %>`). A regression needing code changes goes back to implementation via `propose_advance`, not fixed here."
+].join("\n");
+var BG_NON_ISOLATED = [
+  "**Live checkout (no isolation).** This repo can't host a worktree yet, so you are working directly in the user's checkout at `<%= projectPath %>` on trunk `<%= trunk %>`. Smallest possible footprint: only this task's changes, and never push, merge, or switch branches."
+].join("\n");
+var BG_ISOLATED = [
+  "**Worktree.** Work only in `<%= worktree %>` on branch `<%= branch %>` \u2014 the harness refuses writes outside it. Never `cd` out, switch branches, or touch trunk `<%= trunk %>` / the live checkout at `<%= projectPath %>` (reads are fine; mutations never).",
+  "Before every commit, confirm `git branch --show-current` prints `<%= branch %>` \u2014 anything else: stop and call `request_clarification`."
+].join("\n");
+var branchGuard = `<% if (detached) { %>${BG_DETACHED}<% } else if (isolated) { %>${BG_ISOLATED}<% } else { %>${BG_NON_ISOLATED}<% } %>`;
+var isolatedLabel = `<% if (isolated) { %>yes<% } else { %>no \u2014 running in the project dir<% } %>`;
+var EXIT_GATE = `<% if (exitGate === "auto") { %>This lane's gate is **auto**: the proposal advances immediately and \`confident\` has no effect \u2014 propose once and move on; no confirmation is coming.<% } else if (exitGate === "ask") { %>This lane's gate is **ask**: the user confirms every exit. Propose, end your turn, and wait \u2014 \`confident\` has no effect here.<% } else if (exitGate === "checkpoint") { %>Set \`confident: true\` when you're certain \u2014 though a task this size still pauses for a human check when leaving this lane.<% } else { %>Set \`confident: true\` when you're certain and the task advances without waiting; leave it false and the user confirms.<% } %>`;
+var FORCED_NOTE = `<% if (forcedPhase) { %>
+
+The planned path for this size would skip this phase, but the user moved the card here deliberately \u2014 do this phase's work in full (never skip-advance out of it), and leave \`confident\` false on exit so the user steers what comes next.<% } %>`;
+var VR_TINY = `This is a very small change. Keep verification minimal and proportional \u2014 a full build, type-check, or test run is usually overkill for a change this size; do only the quick check (if any) that gives you genuine confidence, and add no tests or polish beyond it.`;
+var VR_MEDIUM = `Run a quick, targeted sanity check (a type-check or the most relevant fast test) \u2014 don't over-test.`;
+var VR_LARGE = `Run the relevant sanity checks (type-check / build / fast tests) proportional to the change.`;
+var VR_TAIL_TESTS = `A dedicated testing phase follows \u2014 leave deep/end-to-end testing for it; just keep the branch buildable.`;
+var VR_TAIL_NONE = `No separate testing phase runs for a task this size, so there's no later safety net \u2014 but don't gold-plate either: verify only what this change actually warrants.`;
+var verification = `<% if (tinyChange) { %>${VR_TINY}<% } else if (mediumChange) { %>${VR_MEDIUM}<% } else { %>${VR_LARGE}<% } %> <% if (testingFollows) { %>${VR_TAIL_TESTS}<% } else { %>${VR_TAIL_NONE}<% } %>`;
+var INDEPENDENT_TESTER = "You are a **fresh, independent tester**. You did not design or build this change and you have none of its implementation context \u2014 that is deliberate. Judge it the way a user would: confirm it actually does what was **requested**, against the expected result below and nothing else. Do **not** read the task's design notes / work log, the git diff, or the commit messages, and don't reverse-engineer how it was built \u2014 testing to the implementation defeats the point. You don't fix or extend the code here; if something is wrong it goes back to the build agent.";
+var TEST_BRIEF = "## What you are verifying\n\n**Expected result** \u2014 what the change must do, from the user's point of view:\n\n<expected-result>\n<%= expectedResult %>\n</expected-result>\n\n**Affected areas** \u2014 roughly where it lives, so you know where to look (this is the only hint about the implementation you get):\n\n<affected-areas>\n<%= affectedAreas %>\n</affected-areas>";
+var UO_MOVE = `## User override \u2014 this phase was (re)started by hand
+
+The user manually moved this card from **<%= fromLane %>** to **<%= toLane %>**<% if (interrupted) { %>, interrupting <%= interrupted %><% } %>. Their intent overrides any prior plan or in-flight phase work \u2014 run this phase fresh from the task's current state (your session context is still valid history, but this instruction supersedes it).`;
+var UO_RESTART = `## Phase restarted after a server reload
+
+This card moved to **<%= toLane %>**, but the server restarted before the phase prompt could be delivered. Start (or restart) this phase now from the task's current state.`;
+var UO_NOTE = `## The user's instruction for this phase
+
+<user-note>
+<%= userNote %>
+</user-note>`;
+var userOverride = `<% if (userMoved) { %>
+
+${UO_MOVE}<% } %><% if (phaseRestarted) { %>
+
+${UO_RESTART}<% } %><% if (userNote) { %>
+
+${UO_NOTE}<% } %>`;
+var STATE = `<% if (filesChanged || lastGreen) { %>
+
+## Branch state (computed)
+<% if (filesChanged) { %>Files this branch has already changed vs \`<%= trunk %>\` (\`git diff --name-status\` \u2014 current; no need to re-derive it):
+<files-changed>
+<%= filesChanged %>
+</files-changed><% } %><% if (filesChanged && lastGreen) { %>
+
+<% } %><% if (lastGreen) { %>Already green on this exact worktree content (cached verdict \u2014 re-running proves nothing new): <%= lastGreen %>.<% } %><% } %>`;
+var taskDoc = `<% if (body) { %>
+
+The task's full card \u2014 groomed fields plus the work log earlier phases recorded (\`update_task_doc\` appends to it; no need to locate or read the file yourself):
+<task-document>
+<%= body %>
+</task-document><% } %>`;
+var PHASE_PROMPTS = {
+  "discovery.md": `You are the **Discovery** agent for an Operator task.
+${FACTS}
+
+## Task
+**<%= title %>**
+
+<task-description>
+<%= description %>
+</task-description>${taskDoc}${userOverride}
+
+## Your job (Discovery)
+Product discovery \u2014 pin down *what* should be built and how it should feel before anyone designs the implementation: the problem and who it's for, the interaction flow, the states and edge cases a user would hit, and the trade-offs between viable approaches. Deep code research belongs to the Architecture phase \u2014 but a quick peek at the code to **validate a feasibility assumption** is allowed and encouraged: a design resting on an unchecked assumption fails in production.
+
+If this task is small and already clear, skip discovery: propose the next phase with a one-line note that it isn't needed.
+
+Record your output with \`mcp__operator__update_task_doc\` \u2014 clarifying questions, a refined description, interaction sketches (text/ASCII or \`render_mockup\`), and/or approach trade-offs. A product decision you can't make yourself \u2192 \`mcp__operator__ask_form\` (discrete options) or \`mcp__operator__request_clarification\`, then wait.${FORCED_NOTE}
+
+## Exit
+When the feature and approach are understood, call \`mcp__operator__propose_advance\` with \`to_lane: "<%= nextLane %>"\` and a one-paragraph scope summary. ${EXIT_GATE}`,
+  "architecture.md": `You are the **Architecture** agent for an Operator task. Working at \`<%= worktree %>\` on branch \`<%= branch %>\` (isolated worktree: ${isolatedLabel}).
+${FACTS}
+
+${branchGuard}
+
+## Task
+**<%= title %>**
+
+<task-description>
+<%= description %>
+</task-description>${taskDoc}${userOverride}
+
+## Your job (Architecture)
+Research the implementation this change touches (earlier findings are in the task card above; prefer reusing existing modules/patterns) and record a concrete **design** with \`mcp__operator__update_task_doc\`: Design, Files to change, Test plan, Risks \u2014 proportional to the size. Genuinely different viable approaches \u2192 \`mcp__operator__ask_form\` / \`mcp__operator__request_clarification\` and let the user pick; otherwise choose sensible defaults and note them.
+
+Re-estimate scope: now that the design is concrete, the intake size (**<%= size %>**) may be wrong \u2014 if so call \`mcp__operator__set_size\`; it right-sizes every remaining phase (which run, model/effort, review depth).
+
+Design only \u2014 do not write code in this phase.${FORCED_NOTE}
+
+## Exit
+When the design is settled, call \`mcp__operator__propose_advance\` with \`to_lane: "<%= nextLane %>"\` and a one-paragraph rationale. ${EXIT_GATE}`,
+  "implementation.md": `You are the **Implementation** agent for an Operator task. Working at \`<%= worktree %>\` on branch \`<%= branch %>\` (isolated worktree: ${isolatedLabel}).
+${FACTS}
+
+${branchGuard}
+
+## Task
+**<%= title %>**
+
+<task-description>
+<%= description %>
+</task-description>${taskDoc}${STATE}${userOverride}
+
+## Your job (Implementation)
+Implement the task \u2014 follow the design in the card above when one exists. Match the existing code style, naming, and patterns; reuse existing utilities. Build exactly what the task asks \u2014 no extra features, abstractions, or defensive code beyond it.
+
+Commit to this branch in small, clearly-messaged commits as you go.
+
+Verification \u2014 scaled to this task (size **<%= size %>**): ${verification}
+
+## Before advancing
+- User-visible change (UI / rendered output / runnable surface) \u2192 start a preview with \`mcp__operator__start_run\` (bind \`$OPERATOR_WEB_PORT\` or \`$OPERATOR_DEV_PORT_BASE\`+n; pass \`url\` so the card gets a clickable link). Pure backend/refactor/config \u2192 skip it. A failed \`start_run\` is a note, not a blocker.
+<% if (testingFollows) { %>- Hand the independent tester its brief with \`mcp__operator__set_test_brief\`: \`expectedResult\` (what the change must DO from the user's point of view \u2014 start from the acceptance criteria, refreshed if scope drifted) and \`affectedAreas\` (which surfaces changed, so the tester knows where to look). The tester is a FRESH session that sees only this brief \u2014 WHAT changed, never HOW, or the independent check is worthless.
+<% } %>- Record notable decisions or deviations from the design with \`mcp__operator__update_task_doc\`; a real product/architecture ambiguity \u2192 \`mcp__operator__request_clarification\` and wait.${FORCED_NOTE}
+
+## Exit
+When the feature is implemented and the branch builds, call \`mcp__operator__propose_advance\` with \`to_lane: "<%= nextLane %>"\`. Rationale optional. ${EXIT_GATE}
+
+Stay within this task's scope. No PR, no pushing, never modify trunk \u2014 later phases own those.`,
+  "local-testing.md": `You are the **Independent Test** agent for an Operator task. Worktree \`<%= worktree %>\`, branch \`<%= branch %>\` (isolated worktree: ${isolatedLabel}).
+${FACTS}
+
+${branchGuard}
+
+## You are an independent tester
+${INDEPENDENT_TESTER}
+
+## Task
+**<%= title %>**${userOverride}
+
+${TEST_BRIEF}
+
+## Your job (Independent Test)
+From the expected result alone, work out how a user would exercise this change \u2014 then actually do it: run the app / the relevant commands and drive the real behaviour end-to-end, including the obvious edge cases a user would hit. Run the suite via \`mcp__operator__run_tests\` (never a bare \`Bash\` test command \u2014 it's memory-gated, owns the process, and delivers the verdict back to you; an identical command on unchanged content answers instantly from the green cache). Builds/typechecks may use \`Bash\`, foreground only. A green suite is necessary but not sufficient \u2014 judge the user-facing behaviour.
+
+You verify; you never fix or commit.${FORCED_NOTE}
+
+## Verdict
+- **Works as requested** \u2192 \`mcp__operator__propose_advance\` with \`to_lane: "<%= nextLane %>"\` and a one-line note of what you exercised. ${EXIT_GATE}
+- **Does not work** \u2192 record a concrete bug list with \`mcp__operator__update_task_doc\` (what you did / expected per the brief / actually happened), then \`mcp__operator__propose_advance\` with \`to_lane: "implementation"\` and \`confident: true\` \u2014 the build agent fixes on this branch and you re-test fresh.
+- **Brief too ambiguous to judge** \u2192 \`mcp__operator__request_clarification\` and wait.`,
+  "pr-review.local.md": `You are the **Review** agent (local review mode) for an Operator task. Worktree \`<%= worktree %>\`, branch \`<%= branch %>\`. This project reviews and merges **locally** \u2014 there is no pull request.
+${FACTS}
+
+## Task
+**<%= title %>**
+
+<task-description>
+<%= description %>
+</task-description>${taskDoc}${STATE}${userOverride}
+
+## Your job (Local Review)
+1. Get **<%= reviewers %>** independent review(s) of the branch diff vs \`<%= trunk %>\` by spawning reviewer subagent(s) with the **Agent** tool. With more than one, split focus (correctness/bugs/edge cases vs design/simplicity/reuse); with one, it covers both. Act on their findings \u2014 don't duplicate their reading yourself.
+2. Fix the real findings; commit to this branch.
+3. Confirm still green via \`mcp__operator__run_tests\` (an unchanged tree answers instantly from the green cache).
+
+Summarize findings + resolutions with \`mcp__operator__update_task_doc\`. \`.operator/\` diff churn is board noise, never a review finding.${FORCED_NOTE}
+
+## Exit
+When reviewed and green, call \`mcp__operator__propose_advance\` with \`to_lane: "<%= nextLane %>"\` and a short rationale. ${EXIT_GATE}
+
+No PR and no merging here \u2014 the next phase owns the merge.`,
+  "pr-review.remote.md": `You are the **PR Review** agent for an Operator task. Worktree \`<%= worktree %>\`, branch \`<%= branch %>\`.
+${FACTS}
+
+## Task
+**<%= title %>**
+
+<task-description>
+<%= description %>
+</task-description>${taskDoc}${STATE}${userOverride}
+
+## Your job (PR Review)
+1. Get **<%= reviewers %>** independent review(s) of the branch diff vs \`<%= trunk %>\` by spawning reviewer subagent(s) with the **Agent** tool. With more than one, split focus (correctness/bugs/edge cases vs design/simplicity/reuse). Address the real findings; commit fixes to this branch.
+2. Push the branch and open a PR to \`<%= trunk %>\` with \`gh pr create\` \u2014 clear title, body summarizing the change, design, and test results. Keep \`.operator/\` out of the PR (its churn is board noise).
+3. Register it with \`mcp__operator__report_pr\` (URL + number).
+
+Summarize findings + resolutions with \`mcp__operator__update_task_doc\`. \`gh\` missing or unauthenticated \u2192 \`mcp__operator__request_clarification\`.${FORCED_NOTE}
+
+## Exit
+When the PR is open and reviews are addressed, call \`mcp__operator__propose_advance\` with \`to_lane: "<%= nextLane %>"\` and a short rationale. ${EXIT_GATE}
+
+Do not merge in this phase \u2014 merging happens when the card moves forward.`,
+  "ci.local.md": `You are the **Merge** agent (local review mode) for an Operator task. Task branch \`<%= branch %>\`, worktree \`<%= worktree %>\`.
+${FACTS}
+
+${branchGuard}
+
+## Task
+**<%= title %>**
+
+<task-description>
+<%= description %>
+</task-description>${taskDoc}${STATE}${userOverride}
+
+## Your job: ready the branch \u2014 the harness merges
+Operator performs the squash-merge into \`<%= trunk %>\` and moves this card atomically the moment you signal ready. You never touch \`<%= trunk %>\`, run the squash, or commit to trunk yourself.
+
+1. **Green.** The pre-flight verdict (when Operator ran one) is above this prompt. PASSED \u2192 it stands; don't re-pay the battery. FAILED \u2192 fix exactly what it reports, then re-check via \`mcp__operator__run_tests\` (a gated run \u2014 end your turn and wait for the verdict; unchanged content answers instantly from cache).
+2. **Integrate trunk into the branch:** \`git merge <%= trunk %>\`. Trunk has moved since you branched, and squash-merges mean it may hold newer versions of the very files you touched:
+   - On every conflict take trunk's side: \`git checkout --theirs -- <path> && git add <path>\` (board noise wholesale: \`git checkout --theirs -- .operator && git add .operator\`).
+   - Then \`git diff <%= trunk %>...HEAD\` and confirm THIS task's change is still present. If trunk's version clobbered it, re-implement it on top of trunk's CURRENT code \u2014 adapt to trunk's refactors; never paste your branch's older copy of a file back over trunk's (that silently reverts sibling features; it destroyed a merged feature once).
+   - Integration genuinely ambiguous \u2192 \`git merge --abort\`, then \`mcp__operator__request_clarification\`.
+   - Commit the integration. A clean merge changes nothing about the pre-flight verdict; conflicts that touched a package \u2192 re-check just that package via \`mcp__operator__run_tests\`.
+3. **Hand off:** record what you did with \`mcp__operator__update_task_doc\`, then call \`mcp__operator__propose_advance\` with \`to_lane: "<%= nextLane %>"\` \u2014 that is the merge signal. ${EXIT_GATE}
+
+Never \`git checkout <%= trunk %>\`, squash, push, or remove this worktree \u2014 the harness owns those. If it reports a merge conflict back, repeat step 2 and re-propose.`,
+  "ci.remote.md": `You are the **CI / Merge** agent for an Operator task. Worktree \`<%= worktree %>\`, branch \`<%= branch %>\`. The user moved this task here to merge it and get the pipeline green.
+${FACTS}
+
+## Task
+**<%= title %>**
+
+<task-description>
+<%= description %>
+</task-description>${taskDoc}${STATE}${userOverride}
+
+## Your job (CI / Merge)
+1. Merge this task's PR into \`<%= trunk %>\` once mergeable (\`gh pr merge --squash --delete-branch\` or the repo's convention). Only this task's PR \u2014 never unrelated branches, never force-push \`<%= trunk %>\`. The PR should carry no \`.operator/\` changes \u2014 drop them if it does.
+2. Babysit the pipeline to completion (\`gh pr checks\`, \`gh run watch\`). Failures \u2192 diagnose from the logs and push a fix.
+3. Record the merge commit + final CI status with \`mcp__operator__update_task_doc\`. Blocked (conflicts, required reviews, checks you can't fix) \u2192 \`mcp__operator__request_clarification\` and wait.${FORCED_NOTE}
+
+Merging to \`<%= trunk %>\` is outward-facing and hard to reverse \u2014 confirm the PR is the right one before merging, and stop to ask if anything looks off.
+
+## Exit
+When merged and CI is green, call \`mcp__operator__propose_advance\` with \`to_lane: "<%= nextLane %>"\` and a short rationale. ${EXIT_GATE}`,
+  "prod-testing.local.md": `You are the **Verify** agent (local review mode) for an Operator task. The change is already merged into trunk \`<%= trunk %>\`; your job is to confirm the *integrated* result works and nothing regressed.
+${FACTS}
+
+${branchGuard}
+
+## You are an independent tester
+${INDEPENDENT_TESTER}
+
+## Task
+**<%= title %>**${userOverride}
+
+${TEST_BRIEF}
+
+## Your job (Verify)
+1. Run the suite via \`mcp__operator__run_tests\` (unchanged content answers instantly from the green cache) and exercise the feature the way a user would \u2014 actually drive the behaviour, don't just read code. If the feature can only be judged by a human (voice, feel, hardware), say so and ask for a manual check via \`mcp__operator__request_clarification\` instead of simulating one.
+2. **Reproduce-then-confirm (assumption-based bugfixes only).** If this is a bug fix whose root cause was *inferred* rather than proven, a green suite proves nothing \u2014 drive the user's actual failing path: confirm the original symptom reproduces on the **pre-fix** code (scratch checkout at the merge commit's first parent \u2014 never mutate this one), then prove it's **gone** here. Record both observations. Features, refactors, and obvious mechanical fixes skip this.
+3. Non-destructive only \u2014 never commit, branch, or change code here.
+
+## Verdict
+- **Verified, all good** \u2192 \`mcp__operator__propose_advance\` with \`to_lane: "<%= nextLane %>"\`. ${EXIT_GATE}
+- **Regression needing a code change** \u2192 record the specifics (what broke, how to reproduce, logs) with \`mcp__operator__update_task_doc\`, then \`mcp__operator__propose_advance\` with \`to_lane: "implementation"\` \u2014 Operator reopens a fresh worktree; don't fix it in this detached checkout.
+- **Unsure or blocked** \u2192 \`mcp__operator__request_clarification\`.`,
+  "prod-testing.remote.md": `You are the **Production Testing** agent for an Operator task. The change has been merged and deployed (or is deploying).
+${FACTS}
+
+## You are an independent tester
+${INDEPENDENT_TESTER}
+
+## Task
+**<%= title %>**${userOverride}
+
+${TEST_BRIEF}
+
+## Your job (Prod Testing)
+1. Verify the shipped feature works in the deployed environment and nothing obvious regressed \u2014 non-destructive means only: health endpoints, read-only \`curl\`, smoke checks, or a browser pass against the live URL.
+2. **Assumption-based bugfixes:** if the fix's cause was *inferred* rather than mechanical, a passing smoke check isn't enough \u2014 drive the user's actual failing path live and confirm the specific original symptom is gone. Features/refactors/mechanical fixes skip this.
+3. Deployment URL/environment unknown \u2192 \`mcp__operator__request_clarification\`.
+
+Record what you verified + evidence (status codes, observed behaviour) with \`mcp__operator__update_task_doc\`. A regression \u2192 report it clearly and \`mcp__operator__request_clarification\` rather than guessing.
+
+Keep everything against production read-only and reversible.
+
+## Verdict
+When verified live, call \`mcp__operator__propose_advance\` with \`to_lane: "<%= nextLane %>"\` and a short rationale. ${EXIT_GATE}`
+};
+
+// apps/server/src/prompts/render.ts
+import { Eta } from "eta";
+var DELIMITER_TAGS = /<\s*\/?\s*(?:user-request|user-note|task-description|task-document)\s*>/gi;
+var cc = (n) => String.fromCharCode(n);
+var CONTROL_CHARS = new RegExp(`[${cc(0)}-${cc(8)}${cc(11)}${cc(12)}${cc(14)}-${cc(31)}${cc(127)}]`, "g");
+function sanitizeBlock(s, max = 8e3) {
+  const out = s.replace(CONTROL_CHARS, "").replace(DELIMITER_TAGS, "").trim();
+  return out.length > max ? `${out.slice(0, max)}
+\u2026(truncated)` : out;
+}
+var eta = new Eta({ autoEscape: false, useWith: true, autoTrim: false });
+function renderTemplate(tpl, vars) {
+  return eta.renderString(tpl, vars).replace(/^\n+/, "");
+}
+var advanceFeedback = (text) => renderTemplate(TURN_PROMPTS.advanceFeedback, { feedback: sanitizeBlock(text, 4e3) });
+
+// apps/server/src/mcp/operatorServer.ts
+var ok = (text) => ({ content: [{ type: "text", text }] });
+function buildOperatorMcp(ctx) {
+  return createSdkMcpServer({
+    name: "operator",
+    version: "0.1.0",
+    // Phase prompts MANDATE these tools (propose_advance, run_tests, …) — without
+    // this every session's first call failed ("No such tool available") and paid a
+    // ToolSearch round-trip to load schemas the prompt already promised existed.
+    alwaysLoad: true,
+    instructions: "Operator task-management callbacks. Use request_clarification to ask the user a question, propose_advance to move this task to the most appropriate lane when a phase is done (see that tool's description), update_task_doc to record findings/spec in the task's document, and attach_artifact to surface mockups or screenshots. Render rich content inline with render_mockup (sandboxed HTML/CSS UI mockups), render_diagram (Mermaid diagrams), and ask_form (an interactive multiple-choice question form with custom-reply support that returns the user's selections).",
+    tools: [
+      tool(
+        "request_clarification",
+        "Ask the user a clarifying question and wait for their answer. Optionally provide choices.",
+        { question: z2.string(), options: z2.array(z2.string()).optional() },
+        async (args) => {
+          const answer = await ctx.requestClarification(args.question, args.options);
+          return ok(`User answered: ${answer}`);
+        }
+      ),
+      tool(
+        "propose_advance",
+        "Call when this phase is done to move the task to the next lane. Pick the right target lane (skip phases this task doesn't need; go back if testing found a design flaw). Set `confident: true` to auto-advance without waiting for the user (fast-track dev-speed only; enterprise and large tasks leaving implementation always pause). Leave it false or omit to let the user confirm. `rationale` is optional \u2014 a short note is fine; skip it entirely if there's nothing non-obvious to say. If the user queued messages while you worked, the advance is BLOCKED and the result tells you so \u2014 address them, then re-propose.",
+        {
+          to_lane: z2.enum(LANE_IDS),
+          rationale: z2.string().optional(),
+          confident: z2.boolean().optional()
+        },
+        async (args) => {
+          const result = await ctx.proposeAdvance(
+            args.to_lane,
+            args.rationale,
+            args.confident ?? false
+          );
+          if (result === true) return ok(`Accepted \u2014 task moved to ${args.to_lane}.`);
+          if (result === false) return ok("User declined the advance.");
+          return ok(result);
+        }
+      ),
+      tool(
+        "update_task_doc",
+        "Append markdown (findings, spec, decisions) to this task's detail document.",
+        { markdown: z2.string() },
+        async (args) => {
+          await ctx.appendDoc(args.markdown);
+          return ok("Task document updated.");
+        }
+      ),
+      tool(
+        "set_size",
+        `Re-estimate this task's scope (size) when you understand it better than at intake \u2014 e.g. after architecture. ${SIZE_GUIDANCE} Size right-sizes the remaining phases (which run, the per-step model/effort, review depth), so correcting it saves tokens downstream.`,
+        { size: z2.enum(TASK_SIZES) },
+        async (args) => {
+          await ctx.setSize(args.size);
+          return ok(`Task size set to ${args.size}.`);
+        }
+      ),
+      tool(
+        "set_test_brief",
+        'Record the brief the INDEPENDENT test phase will verify against. The tester runs in a fresh session with NO implementation context \u2014 it sees only this brief, not the design, diff, or work log. Call it at the end of build, before advancing to testing. `expectedResult`: what the feature should DO from the user\'s point of view (the intended outcome / acceptance criteria, refreshed if they drifted during build) \u2014 NO implementation detail. `affectedAreas`: a high-level note of which areas/surfaces changed (e.g. "the task card header and its API route"), so the tester knows where to look \u2014 again, WHAT changed, not HOW. Either field may be omitted to leave it as-is.',
+        { expectedResult: z2.string().optional(), affectedAreas: z2.string().optional() },
+        async (args) => {
+          await ctx.setTestBrief({ expectedResult: args.expectedResult, affectedAreas: args.affectedAreas });
+          return ok("Test brief updated.");
+        }
+      ),
+      tool(
+        "rename_session",
+        "Rename THIS session's tab in the Operator UI. Use it right after a fork: give the forked branch a short, descriptive name (a few words) reflecting what this branch is exploring, so it's distinguishable from its sibling tabs. Only affects forked sessions; a no-op for a task's main session.",
+        { name: z2.string() },
+        async (args) => {
+          const renamed = await ctx.renameSession(args.name);
+          return ok(
+            renamed ? `Session renamed to "${args.name}".` : "Not renamed \u2014 this is the task's main session (only a forked session's tab can be renamed)."
+          );
+        }
+      ),
+      tool(
+        "report_pr",
+        "Register the pull request opened for this task. The URL is shown on the task card.",
+        { url: z2.string(), number: z2.number().optional() },
+        async (args) => {
+          await ctx.setPr(args.url, args.number);
+          await ctx.appendDoc(`**PR:** ${args.url}`);
+          return ok("PR recorded.");
+        }
+      ),
+      tool(
+        "start_run",
+        "Start a long-lived process (dev server, watcher, preview) as a TRACKED run. Prefer this over `Bash` with run_in_background for anything you want the user to see, open, or try: Operator surfaces its status, logs and served URL in the task panel, and automatically stops it when the task reaches Done \u2014 so it never orphans. Bind servers to the per-task ports in the env ($OPERATOR_WEB_PORT / $OPERATOR_PORT). The UI's Open link auto-detects the served URL (the web port, then any URL the process prints); pass `url` to pin it explicitly (e.g. the web UI when the command starts both a UI and a backend). Returns a run id; the command runs in the task's worktree. If the process exits on its own (crash or completion) or fails to start, you will RECEIVE A MESSAGE with its exit status \u2014 no need to poll.",
+        { name: z2.string(), command: z2.string(), url: z2.string().optional() },
+        async (args) => {
+          const runId = ctx.startRun(args.name, args.command, args.url);
+          return ok(`Started run "${args.name}" (id ${runId}). Tracked in the Operator UI; it will be stopped automatically when the task is done.`);
+        }
+      ),
+      tool(
+        "run_tests",
+        "Run a test suite as a memory-GATED run. ALWAYS use this (never a bare `Bash` `pnpm test` / vitest / jest) to execute tests: Operator tracks system memory and QUEUES test runs behind free RAM, so parallel testing tasks wait their turn instead of all running at once and OOM-ing the box. The run may sit `queued` briefly before it starts. When it finishes you will RECEIVE A MESSAGE with the verdict \u2014 PASSED, or FAILED with the failing tests + log tail \u2014 so END YOUR TURN and wait for it (or keep working); never poll. Pass the full test command (e.g. `pnpm -r test`); to scope a run, pass test FILE paths (a `-t` name filter still loads every file). Verdicts are cached: the same command on a worktree whose content hasn't changed answers instantly from the previous green run \u2014 so never re-run a suite just to be sure. Returns a run id.",
+        { name: z2.string(), command: z2.string() },
+        async (args) => {
+          const runId = ctx.runTests(args.name, args.command);
+          return ok(
+            `Queued test run "${args.name}" (id ${runId}) \u2014 command: ${args.command}
+It starts when system memory allows; you'll receive the pass/fail verdict as a message (instantly, if this exact command already passed on the current worktree content).`
+          );
+        }
+      ),
+      tool(
+        "stop_run",
+        "Request a stop of a tracked run you started earlier with start_run, by its run id. Applied asynchronously; stopping an unknown or already-finished run is a silent no-op (no confirmation message is sent either way).",
+        { runId: z2.string() },
+        async (args) => {
+          ctx.stopRun(args.runId);
+          return ok(`Stop requested for run ${args.runId} (a no-op if it already finished or the id is unknown).`);
+        }
+      ),
+      tool(
+        "attach_artifact",
+        "Surface an artifact (mockup, screenshot, link, proposal) in the task panel.",
+        {
+          kind: z2.string(),
+          title: z2.string(),
+          path: z2.string().optional(),
+          data: z2.unknown().optional()
+        },
+        async (args) => {
+          ctx.emitArtifact(args.kind, args.title, args.path, args.data);
+          await ctx.appendDoc(`**Artifact (${args.kind}):** ${args.title}${args.path ? ` \u2014 \`${args.path}\`` : ""}`);
+          return ok("Artifact attached.");
+        }
+      ),
+      tool(
+        "render_mockup",
+        "Render a UI mockup inline in the chat as a visual preview. Supply static HTML (and optional CSS); it is shown in a sandboxed iframe (no scripts, no network) so the user can see the proposed layout. Use for wireframes and UI proposals \u2014 not for runnable code.",
+        {
+          title: z2.string().describe("Short label shown above the mockup."),
+          html: z2.string().describe("The mockup body HTML."),
+          css: z2.string().optional().describe("Optional CSS applied to the mockup.")
+        },
+        async (args) => {
+          ctx.renderMockup(args.title, args.html, args.css);
+          return ok("Mockup rendered.");
+        }
+      ),
+      tool(
+        "render_diagram",
+        "Render a Mermaid diagram inline in the chat (flowchart, sequence, ER, etc.). Supply Mermaid source; the user sees the rendered graph.",
+        {
+          source: z2.string().describe("Mermaid diagram source."),
+          title: z2.string().optional().describe("Optional label shown above the diagram.")
+        },
+        async (args) => {
+          ctx.renderDiagram(args.source, args.title);
+          return ok("Diagram rendered.");
+        }
+      ),
+      tool(
+        "ask_form",
+        "Pose one or more multiple-choice questions as an interactive form and wait for the user's answers. Each question can be single- or multi-select, and the user can always type a custom 'Other' reply. Returns the chosen answers. Use this over request_clarification when the decision has discrete options.",
+        {
+          questions: z2.array(
+            z2.object({
+              question: z2.string().describe("The full question text."),
+              header: z2.string().describe("Short \u226412-char chip label for the question."),
+              multiSelect: z2.boolean().optional().describe("Allow picking more than one option (default false)."),
+              options: z2.array(
+                z2.object({
+                  label: z2.string().min(1),
+                  description: z2.string().optional()
+                })
+              ).min(1)
+            })
+          ).min(1)
+        },
+        async (args) => {
+          const questions = args.questions.map((q) => ({
+            question: q.question,
+            header: q.header,
+            multiSelect: q.multiSelect ?? false,
+            options: q.options.map((o) => ({ label: o.label, description: o.description ?? "" }))
+          }));
+          const answers = await ctx.askForm(questions);
+          if (!answers) return ok("User dismissed the form without answering.");
+          const formatted = Object.entries(answers).map(([q, a]) => `- ${q}: ${a}`).join("\n");
+          return ok(`User submitted:
+${formatted}`);
+        }
+      ),
+      tool(
+        "page_eval",
+        "Run JavaScript in the live preview page (the open browser tab carrying the Operator DevTools overlay) and return the result \u2014 no Playwright needed. The code runs inside an async function, so you can `await`; use `return <value>` to return a result (a returned DOM node comes back as its outerHTML). Use it to inspect or test the running app: read app state, query/measure the DOM, call page functions, check computed styles, etc. Requires the previewed page to be open in a browser; errors if none is connected.",
+        { code: z2.string().describe("JavaScript to evaluate. `return <value>` to return a result.") },
+        async (args) => {
+          const r = await ctx.pageCommand("eval", { code: args.code });
+          if (!r.ok) return ok(`\u26A0 ${r.error ?? "eval failed"}`);
+          return ok(typeof r.result === "string" ? r.result : JSON.stringify(r.result ?? null, null, 2));
+        }
+      ),
+      tool(
+        "page_snapshot",
+        "Return the rendered HTML of the live preview page (or a CSS-selector subtree) so you can read/navigate the actual DOM without Playwright. Long output is truncated.",
+        { selector: z2.string().optional().describe("CSS selector to snapshot; omit for the whole page.") },
+        async (args) => {
+          const r = await ctx.pageCommand("snapshot", { selector: args.selector });
+          return r.ok ? ok(String(r.result ?? "")) : ok(`\u26A0 ${r.error ?? "snapshot failed"}`);
+        }
+      ),
+      tool(
+        "page_click",
+        "Click an element in the live preview page by CSS selector \u2014 simulates a real click to navigate / toggle / submit. No Playwright needed.",
+        { selector: z2.string() },
+        async (args) => {
+          const r = await ctx.pageCommand("click", { selector: args.selector });
+          if (!r.ok) return ok(`\u26A0 ${r.error ?? "click failed"}`);
+          return ok(typeof r.result === "string" ? r.result : "Clicked.");
+        }
+      ),
+      tool(
+        "page_info",
+        "Get the live preview page's URL + title (confirms a preview is connected).",
+        {},
+        async () => {
+          const r = await ctx.pageCommand("info", {});
+          return r.ok ? ok(JSON.stringify(r.result ?? {}, null, 2)) : ok(`\u26A0 ${r.error ?? "no preview connected"}`);
+        }
+      )
+    ]
+  });
+}
+
+// apps/server/src/mcp/orchestratorServer.ts
+import { createSdkMcpServer as createSdkMcpServer2, tool as tool2 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z3 } from "zod";
+var FIELD_PARAMS = {
+  problem: z3.string().optional(),
+  context: z3.string().optional(),
+  acceptance: z3.string().optional(),
+  clarification: z3.string().optional()
+};
+function fieldsFromArgs(a) {
+  const f = {};
+  if (a.problem !== void 0) f.problem = a.problem;
+  if (a.context !== void 0) f.context = a.context;
+  if (a.acceptance !== void 0) f.acceptance = a.acceptance;
+  if (a.clarification !== void 0) f.clarifications = a.clarification;
+  return f;
+}
+var ok2 = (text) => ({ content: [{ type: "text", text }] });
+function buildOrchestratorMcp(ctx) {
+  return createSdkMcpServer2({
+    name: "operator",
+    version: "0.1.0",
+    // The orchestrator's whole job is these tools — never defer them behind
+    // ToolSearch (the groom/route nudges mandate specific calls).
+    alwaysLoad: true,
+    instructions: "Project board tools. create_task adds a backlog task; update_task patches a task's fields in place (title/summary/size + problem/context/acceptance/clarification \u2014 you never write the raw body); list_tasks shows the board (with summaries); get_task reads one task's full body; fold_task dissolves an idea's placeholder into existing backlog task(s) (smart idea routing); delete_task removes a task (a valid groom outcome); move_task advances a task to a lane (which runs that phase); start_task begins a backlog task at the first phase its scope needs.",
+    tools: [
+      tool2(
+        "create_task",
+        `Add a new task to the backlog. ${TITLE_GUIDANCE} Also give a one-line summary, and the structured body as separate FIELDS \u2014 \`problem\`, \`context\`, \`acceptance\` (each free markdown). The body is assembled from these fields (## Problem / ## Context / ## Acceptance criteria); never write the assembled body yourself.`,
+        {
+          title: z3.string(),
+          summary: z3.string().optional(),
+          ...FIELD_PARAMS
+        },
+        async (args) => {
+          const fields = fieldsFromArgs(args);
+          const id = await ctx.createTask(args.title, args.summary ?? "", fields);
+          return ok2(`Created task ${id}: ${args.title}`);
+        }
+      ),
+      tool2(
+        "update_task",
+        `Patch a task in place \u2014 set any subset of its fields (or all of them); unspecified fields are left untouched. Frontmatter: \`title\`, \`summary\`, \`size\`. ${SIZE_GUIDANCE} Size drives which phases the task runs and how diligently (model, reasoning effort, review depth) under the project's dev-speed. ${TITLE_GUIDANCE} Body fields (free markdown each, replacing that section): \`problem\`, \`context\`, \`acceptance\`. To EXPAND a task with a folded-in idea, pass \`clarification\` (the new requirement only) \u2014 it is APPENDED under ## Clarifications, leaving the rest intact. You never write the assembled body; storage renders it from fields.`,
+        {
+          task_id: z3.string(),
+          title: z3.string().optional(),
+          summary: z3.string().optional(),
+          ...FIELD_PARAMS,
+          size: z3.enum(TASK_SIZES).optional()
+        },
+        async (args) => {
+          const fields = fieldsFromArgs(args);
+          const okd = await ctx.updateTask(args.task_id, {
+            title: args.title,
+            shortDescription: args.summary,
+            fields: Object.keys(fields).length ? fields : void 0,
+            size: args.size
+          });
+          return ok2(okd ? `Updated task ${args.task_id}.` : `Task ${args.task_id} not found.`);
+        }
+      ),
+      tool2(
+        "list_tasks",
+        "List all tasks on the board with their lane and one-line summary (the summary is the matching signal for smart idea routing \u2014 titles alone are too thin).",
+        {},
+        async () => {
+          const tasks = await ctx.listTasks();
+          return ok2(JSON.stringify(tasks));
+        }
+      ),
+      tool2(
+        "get_task",
+        "Read one task's full detail \u2014 title, summary, body, size, lane. Use before folding an idea into a backlog task so you can append to (not overwrite) its existing body.",
+        { task_id: z3.string() },
+        async (args) => {
+          const t = await ctx.getTask(args.task_id);
+          return ok2(t ? JSON.stringify(t) : `Task ${args.task_id} not found.`);
+        }
+      ),
+      tool2(
+        "fold_task",
+        "Smart idea routing: dissolve an idea's placeholder task into the existing backlog task(s) you just expanded with update_task. Deletes the placeholder and animates it merging into the target(s). Only call AFTER you have folded the idea into each target via update_task.",
+        { placeholder_id: z3.string(), into_ids: z3.array(z3.string()).min(1) },
+        async (args) => {
+          const okd = await ctx.foldTask(args.placeholder_id, args.into_ids);
+          return ok2(
+            okd ? `Folded ${args.placeholder_id} into ${args.into_ids.join(", ")}.` : "Fold failed."
+          );
+        }
+      ),
+      tool2(
+        "delete_task",
+        "Remove a task from the board. A valid grooming outcome: an idea that shouldn't exist as its own task and isn't being folded into another. Every idea must end as a definite task operation \u2014 refine it, fold it, or delete it; never leave one half-groomed.",
+        { task_id: z3.string() },
+        async (args) => {
+          const okd = await ctx.deleteTask(args.task_id);
+          return ok2(okd ? `Deleted task ${args.task_id}.` : `Task ${args.task_id} not found.`);
+        }
+      ),
+      tool2(
+        "move_task",
+        "Move a task to a lane. Moving into an automated lane starts that phase's agent. The move is applied asynchronously: this returns once the request is queued, and if the move is rejected (e.g. an invalid transition) you will RECEIVE A MESSAGE explaining why \u2014 verify with list_tasks if in doubt.",
+        { task_id: z3.string(), to_lane: z3.enum(LANE_IDS) },
+        async (args) => {
+          const okd = await ctx.moveTask(args.task_id, args.to_lane);
+          return ok2(
+            okd ? `Move of task ${args.task_id} to ${args.to_lane} requested. If it can't be applied, you'll receive a message explaining why.` : "Move failed."
+          );
+        }
+      ),
+      tool2(
+        "start_task",
+        `Start a backlog task now. The board picks the first phase the task's scope (size) requires under the project's dev-speed \u2014 e.g. a small task skips discovery/architecture and begins at implementation. Estimate the size with update_task first so the right phases are chosen. The start is applied asynchronously (like move_task): a rejected start is delivered back to you as a message.`,
+        { task_id: z3.string() },
+        async (args) => {
+          const okd = await ctx.startTask(args.task_id);
+          return ok2(
+            okd ? `Start of task ${args.task_id} requested. If it can't be applied, you'll receive a message explaining why.` : `Start failed \u2014 task ${args.task_id} not found in backlog (or it has no startable phase).`
+          );
+        }
+      ),
+      tool2(
+        "rename_session",
+        "Rename your own tab to a short descriptive name (only takes effect for a side-session fork \u2014 the main project agent's tab is fixed).",
+        { name: z3.string() },
+        async (args) => {
+          await ctx.renameSession(args.name);
+          return ok2(`Renamed session tab to "${args.name}".`);
+        }
+      )
+    ]
+  });
+}
+
+// apps/server/src/agent/kickoff.ts
+function kickoffLane(task, devSpeed) {
+  if (task.status !== "backlog") return null;
+  return firstPlannedLane(devSpeed, taskScopeSize(task));
+}
+
+// apps/server/src/storage/eventStore.ts
+import { promises as fs2 } from "node:fs";
+import { createHash as createHash2 } from "node:crypto";
+import { basename, join as join2 } from "node:path";
+
+// apps/server/src/config.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+var PORT = Number(process.env.OPERATOR_PORT ?? 4317);
+var OPERATOR_DIR = ".operator";
+var WORKTREES_DIR = "worktrees";
+var OPERATOR_HOME = process.env.OPERATOR_HOME ?? join(homedir(), ".operator");
+var PROJECTS_REGISTRY = join(OPERATOR_HOME, "projects.json");
+var GLOBAL_SETTINGS = join(OPERATOR_HOME, "settings.json");
+var USAGE_HISTORY = join(OPERATOR_HOME, "usage-history.json");
+function operatorDir(projectPath) {
+  return join(projectPath, OPERATOR_DIR);
+}
+function worktreesDir(projectPath) {
+  return join(operatorDir(projectPath), WORKTREES_DIR);
+}
+
+// apps/server/src/storage/util.ts
+import { promises as fs } from "node:fs";
+import { dirname } from "node:path";
+import { createHash, randomBytes } from "node:crypto";
+import { customAlphabet } from "nanoid";
+var newTaskId = customAlphabet("0123456789abcdefghijklmnopqrstuvwxyz", 8);
+async function atomicWriteFile(file, data, opts = {}) {
+  const tmp = `${file}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+  try {
+    const fh = await fs.open(tmp, "w", opts.mode);
+    try {
+      await fh.writeFile(data);
+      await fh.sync();
+    } finally {
+      await fh.close();
+    }
+    await fs.rename(tmp, file);
+  } catch (e) {
+    await fs.rm(tmp, { force: true }).catch(() => {
+    });
+    throw e;
+  }
+  try {
+    const dh = await fs.open(dirname(file), "r");
+    await dh.sync().finally(() => dh.close());
+  } catch {
+  }
+}
+var LockTimeoutError = class extends Error {
+  constructor(file) {
+    super(`Timed out waiting for the write lock on ${file} \u2014 the board is busy; retry.`);
+    this.file = file;
+    this.name = "LockTimeoutError";
+  }
+  statusCode = 503;
+};
+async function withFileLock(file, fn, opts = {}) {
+  const lock = `${file}.lock`;
+  const timeoutMs = opts.timeoutMs ?? 5e3;
+  const staleMs = opts.staleMs ?? 3e4;
+  const retryMs = opts.retryMs ?? 25;
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    try {
+      await fs.mkdir(lock);
+      break;
+    } catch {
+      try {
+        const st = await fs.stat(lock);
+        if (Date.now() - st.mtimeMs > staleMs) {
+          await fs.rm(lock, { recursive: true, force: true });
+          continue;
+        }
+      } catch {
+      }
+      if (Date.now() > deadline) throw new LockTimeoutError(file);
+      await new Promise((r) => setTimeout(r, retryMs));
+    }
+  }
+  const beat = setInterval(() => {
+    const now = /* @__PURE__ */ new Date();
+    void fs.utimes(lock, now, now).catch(() => {
+    });
+  }, Math.max(50, Math.floor(staleMs / 3)));
+  beat.unref?.();
+  try {
+    return await fn();
+  } finally {
+    clearInterval(beat);
+    await fs.rm(lock, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+function chainPerKey(chains, key, fn) {
+  const prev = chains.get(key) ?? Promise.resolve();
+  const run = prev.then(fn, fn);
+  const tail = run.then(
+    () => void 0,
+    () => void 0
+  );
+  chains.set(key, tail);
+  void tail.then(() => {
+    if (chains.get(key) === tail) chains.delete(key);
+  });
+  return run;
+}
+function sanitizeKey(key) {
+  return key.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "").slice(0, 48) || "task";
+}
+
+// apps/server/src/storage/eventStore.ts
+function eventsDir(projectPath) {
+  return join2(operatorDir(projectPath), ".events");
+}
+function assetsDir(projectPath) {
+  return join2(eventsDir(projectPath), "assets");
+}
+var EXT_BY_MIME = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/gif": "gif",
+  "image/webp": "webp"
+};
+async function writeAsset(project2, dataBase64, mediaType) {
+  try {
+    const buf = Buffer.from(dataBase64, "base64");
+    if (!buf.length) return null;
+    const hash = createHash2("sha256").update(buf).digest("hex").slice(0, 16);
+    const ext = EXT_BY_MIME[mediaType] ?? "bin";
+    const file = `${hash}.${ext}`;
+    const dir = assetsDir(project2.path);
+    await fs2.mkdir(dir, { recursive: true });
+    await fs2.writeFile(join2(dir, file), buf, { flag: "wx" }).catch((e) => {
+      if (e?.code !== "EEXIST") throw e;
+    });
+    return file;
+  } catch {
+    return null;
+  }
+}
+function sanitize(key) {
+  return key.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+function eventFile(project2, key) {
+  return join2(eventsDir(project2.path), `${sanitize(key)}.jsonl`);
+}
+var streamWriteChains = /* @__PURE__ */ new Map();
+function withStreamQueue(project2, key, fn) {
+  const file = eventFile(project2, key);
+  return chainPerKey(streamWriteChains, file, async () => {
+    await fs2.mkdir(eventsDir(project2.path), { recursive: true });
+    return withFileLock(file, fn);
+  });
+}
+var tailHealed = /* @__PURE__ */ new Set();
+async function healTornTail(file) {
+  if (tailHealed.has(file)) return;
+  tailHealed.add(file);
+  let fh;
+  try {
+    fh = await fs2.open(file, "r");
+    const { size } = await fh.stat();
+    if (size === 0) return;
+    const buf = Buffer.alloc(1);
+    await fh.read(buf, 0, 1, size - 1);
+    if (buf[0] !== 10) await fs2.appendFile(file, "\n");
+  } catch {
+  } finally {
+    await fh?.close().catch(() => {
+    });
+  }
+}
+var rotateAtBytes = Number(process.env.OPERATOR_EVENT_LOG_ROTATE_BYTES ?? 64 * 1024 * 1024);
+async function appendEvent(project2, key, event) {
+  return withStreamQueue(project2, key, () => appendLocked(project2, key, event)).catch(
+    () => null
+    // a wedged file lock must not break the stream either
+  );
+}
+async function appendLocked(project2, key, event) {
+  try {
+    const file = eventFile(project2, key);
+    await healTornTail(file);
+    let seq = await fs2.stat(file).then((s) => s.size, () => 0);
+    if (seq >= rotateAtBytes) {
+      await fs2.rename(file, `${file}.1`);
+      seq = 0;
+    }
+    await fs2.appendFile(file, JSON.stringify(event) + "\n");
+    return seq;
+  } catch {
+    return null;
+  }
+}
+async function truncateEventsToUserMessage(project2, key, ordinal) {
+  if (ordinal < 1) return false;
+  return withStreamQueue(project2, key, () => truncateSerialized(project2, key, ordinal));
+}
+async function truncateSerialized(project2, key, ordinal) {
+  try {
+    const file = eventFile(project2, key);
+    const lines = (await fs2.readFile(file, "utf8")).split("\n").filter(Boolean);
+    let seen = 0;
+    let cut = -1;
+    for (let i = 0; i < lines.length; i++) {
+      try {
+        if (JSON.parse(lines[i]).type === "user_message" && ++seen === ordinal) {
+          cut = i;
+          break;
+        }
+      } catch {
+      }
+    }
+    if (cut < 0) return false;
+    await atomicWriteFile(file, lines.slice(0, cut + 1).join("\n") + "\n");
+    return true;
+  } catch {
+    return false;
+  }
+}
+var READ_TAIL_BYTES = 16 * 1024 * 1024;
+
+// apps/server/src/storage/actionLog.ts
+import { promises as fs3 } from "node:fs";
+import { join as join3 } from "node:path";
+function actionFile(project2) {
+  return join3(operatorDir(project2.path), ".actions", "log.jsonl");
+}
+var actionWriteChains = /* @__PURE__ */ new Map();
+async function logAction(project2, entry) {
+  const line = JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry }) + "\n";
+  const file = actionFile(project2);
+  await chainPerKey(actionWriteChains, file, async () => {
+    await fs3.mkdir(join3(operatorDir(project2.path), ".actions"), { recursive: true });
+    await withFileLock(file, () => fs3.appendFile(file, line));
+  }).catch(() => {
+  });
+}
+
+// apps/server/src/storage/boardStore.ts
+import { promises as fs4 } from "node:fs";
+import { join as join5, basename as basename2 } from "node:path";
+import matter from "gray-matter";
+import chokidar from "chokidar";
+
+// apps/server/src/storage/boardGit.ts
+import { join as join4, relative } from "node:path";
+import { simpleGit } from "simple-git";
+function boardMdFile(project2) {
+  return join4(operatorDir(project2.path), "board.md");
+}
+var failureCount = 0;
+var lastFailure = null;
+var TRANSIENT = /index\.lock|cannot lock ref|another git process/i;
+var BENIGN = /not a git repository|MERGE_HEAD|nothing to commit/i;
+var RETRY_DELAYS_MS = [100, 300, 900];
+async function commitBoard(project2, paths, summary) {
+  if (paths.length === 0) return;
+  for (let attempt = 0; ; attempt++) {
+    try {
+      await commitBoardOnce(project2, paths, summary);
+      return;
+    } catch (e) {
+      const msg = e?.message ?? String(e);
+      if (BENIGN.test(msg)) return;
+      if (TRANSIENT.test(msg) && attempt < RETRY_DELAYS_MS.length) {
+        await new Promise((r) => setTimeout(r, RETRY_DELAYS_MS[attempt]));
+        continue;
+      }
+      failureCount++;
+      lastFailure = { at: (/* @__PURE__ */ new Date()).toISOString(), project: project2.name, summary, message: msg };
+      console.warn(`[operator] commitBoard failed (${summary}):`, msg);
+      return;
+    }
+  }
+}
+async function commitBoardOnce(project2, paths, summary) {
+  const git = simpleGit(project2.path);
+  const allRels = paths.map((p) => relative(project2.path, p));
+  let rels = allRels;
+  try {
+    const ignored = new Set(
+      (await git.raw(["check-ignore", "--", ...allRels])).split("\n").map((s) => s.trim()).filter(Boolean)
+    );
+    if (ignored.size) rels = allRels.filter((r) => !ignored.has(r));
+  } catch {
+  }
+  if (rels.length === 0) return;
+  await git.raw(["add", "-A", "--", ...rels]);
+  const staged = (await git.raw(["diff", "--cached", "--name-only", "--", ...rels])).trim();
+  if (!staged) return;
+  await git.commit(`chore(operator): ${summary}`, rels, { "--no-verify": null });
+}
+async function commitBoardMd(project2, summary) {
+  await commitBoard(project2, [boardMdFile(project2)], `persist project settings (${summary})`);
+}
+
+// apps/server/src/storage/boardStore.ts
+function yamlSafe(data) {
+  const out = {};
+  for (const [k, v] of Object.entries(data)) if (v !== void 0) out[k] = v;
+  return out;
+}
+function parseFrontmatter(data) {
+  return TaskFrontmatterSchema.parse(data ?? {});
+}
+var taskMutationChains = /* @__PURE__ */ new Map();
+function withTaskMutex(project2, taskId, fn) {
+  return chainPerKey(taskMutationChains, `${project2.path}\0${taskId}`, fn);
+}
+var BUCKETS = ["backlog", "in-progress", "done"];
+var IN_PROGRESS_BUCKET = "in-progress";
+var OPERATIONAL_DIRS = [
+  WORKTREES_DIR,
+  ".events",
+  ".runners",
+  ".runs",
+  ".composer",
+  ".merge-lock",
+  ".merge-queue",
+  ".actions"
+];
+var FALLBACK_IN_PROGRESS_LANE = "implementation";
+function bucketForLane(lane) {
+  if (lane === "backlog") return "backlog";
+  if (lane === "done") return "done";
+  return IN_PROGRESS_BUCKET;
+}
+function bucketDir(project2, bucket) {
+  return join5(operatorDir(project2.path), bucket);
+}
+function laneDir(project2, lane) {
+  return bucketDir(project2, bucketForLane(lane));
+}
+function asLaneId(v) {
+  return LANE_IDS.includes(v) ? v : null;
+}
+function laneForBucketFile(bucket, status) {
+  if (bucket === "backlog") return "backlog";
+  if (bucket === "done") return "done";
+  const st = asLaneId(status);
+  if (st && bucketForLane(st) === IN_PROGRESS_BUCKET) return st;
+  return FALLBACK_IN_PROGRESS_LANE;
+}
+async function effectiveLane(file, bucket) {
+  if (bucket === "backlog") return "backlog";
+  if (bucket === "done") return "done";
+  try {
+    return laneForBucketFile(bucket, matter(await fs4.readFile(file, "utf8")).data.status);
+  } catch {
+    return FALLBACK_IN_PROGRESS_LANE;
+  }
+}
+function taskFileName(id, title) {
+  return `${id}-${slugify(title)}.md`;
+}
+function idFromFile(file) {
+  const stem = basename2(file).replace(/\.md$/, "");
+  const dash = stem.indexOf("-");
+  return dash === -1 ? stem : stem.slice(0, dash);
+}
+function matchesTaskId(name, id) {
+  return name === `${id}.md` || name.startsWith(`${id}-`);
+}
+async function listBucketFiles(project2, bucket) {
+  try {
+    const names = await fs4.readdir(bucketDir(project2, bucket));
+    return names.filter((n) => n.endsWith(".md")).map((n) => join5(bucketDir(project2, bucket), n));
+  } catch {
+    return [];
+  }
+}
+async function listLaneFiles(project2, lane) {
+  const bucket = bucketForLane(lane);
+  const files = await listBucketFiles(project2, bucket);
+  if (bucket !== IN_PROGRESS_BUCKET) return files;
+  const out = [];
+  for (const file of files) if (await effectiveLane(file, bucket) === lane) out.push(file);
+  return out;
+}
+async function findAllTaskFiles(project2, id) {
+  const out = [];
+  for (const bucket of BUCKETS) {
+    for (const file of await listBucketFiles(project2, bucket)) {
+      if (matchesTaskId(basename2(file), id)) {
+        const st = await fs4.stat(file).catch(() => null);
+        out.push({ lane: await effectiveLane(file, bucket), file, mtimeMs: st?.mtimeMs ?? 0 });
+      }
+    }
+  }
+  return out;
+}
+function canonicalTaskFile(all) {
+  return all.reduce((a, b) => {
+    const la = LANE_IDS.indexOf(a.lane);
+    const lb = LANE_IDS.indexOf(b.lane);
+    if (lb !== la) return lb > la ? b : a;
+    if (b.mtimeMs !== a.mtimeMs) return b.mtimeMs > a.mtimeMs ? b : a;
+    return b.file < a.file ? b : a;
+  });
+}
+async function findTaskFile(project2, id) {
+  const all = await findAllTaskFiles(project2, id);
+  if (all.length === 0) return null;
+  return canonicalTaskFile(all);
+}
+async function ensureSkeleton(project2) {
+  await fs4.mkdir(operatorDir(project2.path), { recursive: true });
+  for (const bucket of BUCKETS) await fs4.mkdir(bucketDir(project2, bucket), { recursive: true });
+  await fs4.mkdir(worktreesDir(project2.path), { recursive: true });
+  const skeletonCommit = [];
+  const boardMd = join5(operatorDir(project2.path), "board.md");
+  if (!await exists(boardMd)) {
+    const fm = matter.stringify(`# ${project2.name}
+
+Operator board. Drag tasks between lanes to run each phase.
+`, yamlSafe({
+      name: project2.name,
+      trunk: project2.trunk,
+      reviewMode: project2.reviewMode ?? "local",
+      autoExpand: project2.autoExpand ?? true,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+    await atomicWriteFile(boardMd, fm);
+    skeletonCommit.push(boardMd);
+  }
+  const ignore = join5(operatorDir(project2.path), ".gitignore");
+  const requiredIgnores = [...OPERATIONAL_DIRS.map((d) => `${d}/`), "in-progress/"];
+  let current = "";
+  try {
+    current = await fs4.readFile(ignore, "utf8");
+  } catch {
+  }
+  const present = new Set(current.split("\n").map((l) => l.trim()));
+  const missing = requiredIgnores.filter((line) => !present.has(line));
+  if (missing.length) {
+    const prefix = current === "" || current.endsWith("\n") ? current : `${current}
+`;
+    await atomicWriteFile(ignore, `${prefix}${missing.join("\n")}
+`);
+    skeletonCommit.push(ignore);
+  }
+  if (skeletonCommit.length) await commitBoard(project2, skeletonCommit, "init operator skeleton");
+  await migrateFromListFormat(project2);
+  await reconcileBuckets(project2);
+}
+async function reconcileBuckets(project2) {
+  const op = operatorDir(project2.path);
+  const tvDir = join5(op, "to-verify");
+  let markers = [];
+  try {
+    markers = await fs4.readdir(tvDir);
+  } catch {
+  }
+  for (const id of markers) {
+    for (const { file } of await findAllTaskFiles(project2, id)) {
+      await withFileLock(file, async () => {
+        const fresh = await readFreshDoc(file);
+        if (!fresh) return;
+        await atomicWriteFile(
+          file,
+          matter.stringify(fresh.body, yamlSafe({ ...fresh.data, status: "prod-testing" }))
+        );
+      });
+    }
+  }
+  if (markers.length || await exists(tvDir)) await fs4.rm(tvDir, { recursive: true, force: true }).catch(() => {
+  });
+  const legacyDirs = LANE_IDS.filter((l) => bucketForLane(l) === IN_PROGRESS_BUCKET);
+  const sourceDirs = [...BUCKETS, ...legacyDirs];
+  const touched = [];
+  for (const src of sourceDirs) {
+    const dir = join5(op, src);
+    let names;
+    try {
+      names = await fs4.readdir(dir);
+    } catch {
+      continue;
+    }
+    for (const name of names.filter((n) => n.endsWith(".md"))) {
+      const file = join5(dir, name);
+      let status;
+      try {
+        const parsed = matter(await fs4.readFile(file, "utf8"));
+        if (!parsed.data.id) {
+          const idFromName = name.split("-")[0];
+          if (/^[a-z0-9]{6,}$/i.test(idFromName)) {
+            await withFileLock(file, async () => {
+              const fresh = await readFreshDoc(file);
+              if (!fresh || fresh.data.id) return;
+              await atomicWriteFile(
+                file,
+                matter.stringify(fresh.body, yamlSafe({ ...fresh.data, id: idFromName }))
+              );
+            });
+            touched.push(file);
+          }
+        }
+        status = asLaneId(parsed.data.status) ?? asLaneId(src) ?? FALLBACK_IN_PROGRESS_LANE;
+      } catch {
+        continue;
+      }
+      const target = bucketForLane(status);
+      if (src === target) continue;
+      await withFileLock(file, async () => {
+        const fresh = await readFreshDoc(file);
+        if (!fresh) return;
+        const freshStatus = asLaneId(fresh.data.status) ?? asLaneId(src) ?? FALLBACK_IN_PROGRESS_LANE;
+        const freshTarget = bucketForLane(freshStatus);
+        if (src === freshTarget) return;
+        const destDir = bucketDir(project2, freshTarget);
+        await fs4.mkdir(destDir, { recursive: true });
+        const dest = join5(destDir, name);
+        await fs4.rename(file, dest).catch(() => {
+        });
+        touched.push(file, dest);
+      }).catch(() => {
+      });
+    }
+  }
+  for (const lane of legacyDirs) await fs4.rm(join5(op, lane), { recursive: true, force: true }).catch(() => {
+  });
+  if (touched.length) await commitBoard(project2, touched, "migrate tasks to lane-decoupled buckets");
+}
+var OLD_ITEM_RE = /^- \*\*(.+?)\*\*(?:\s+—\s+(.*?))?\s*(?:\(\[[^\]]*\]\([^)]*\)\))?\s*<!--\s*id:(\w+)\s*-->\s*$/;
+async function migrateFromListFormat(project2) {
+  const oldLanesDir = join5(operatorDir(project2.path), "lanes");
+  const oldTasksDir = join5(operatorDir(project2.path), "tasks");
+  if (!await exists(oldLanesDir)) return;
+  for (const lane of LANE_IDS) {
+    let text;
+    try {
+      text = await fs4.readFile(join5(oldLanesDir, `${lane}.md`), "utf8");
+    } catch {
+      continue;
+    }
+    let order = 0;
+    for (const line of text.split("\n")) {
+      const m = OLD_ITEM_RE.exec(line.trimEnd());
+      if (!m) continue;
+      const [, title, desc, id] = m;
+      let data = {};
+      let body = "";
+      const oldDoc = await findOldDoc(oldTasksDir, id);
+      if (oldDoc) {
+        const parsed = matter(await fs4.readFile(oldDoc, "utf8"));
+        data = parseFrontmatter(parsed.data);
+        body = parsed.content;
+      }
+      data = {
+        ...data,
+        id,
+        title,
+        shortDescription: (desc ?? "").trim() || data.shortDescription || "",
+        status: lane,
+        order: data.order ?? order++,
+        createdAt: data.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (!body.trim()) body = `# ${title}
+
+${data.shortDescription ?? ""}
+`;
+      await atomicWriteFile(
+        join5(laneDir(project2, lane), taskFileName(id, title)),
+        matter.stringify(body, yamlSafe(data))
+      );
+    }
+  }
+  await fs4.rm(oldLanesDir, { recursive: true, force: true });
+  await fs4.rm(oldTasksDir, { recursive: true, force: true });
+}
+async function findOldDoc(oldTasksDir, id) {
+  try {
+    const names = await fs4.readdir(oldTasksDir);
+    const match = names.find((n) => matchesTaskId(n, id));
+    return match ? join5(oldTasksDir, match) : null;
+  } catch {
+    return null;
+  }
+}
+async function readBoardConfig(project2) {
+  let fm;
+  try {
+    fm = BoardFrontmatterSchema.parse(matter(await fs4.readFile(boardMdFile(project2), "utf8")).data ?? {});
+  } catch {
+    fm = BoardFrontmatterSchema.parse({});
+  }
+  return {
+    reviewMode: fm.reviewMode,
+    trunk: fm.trunk,
+    autoExpand: fm.autoExpand,
+    devSpeed: fm.devSpeed,
+    iframeCaching: fm.iframeCaching,
+    orchestratorSessionId: fm.orchestratorSessionId,
+    orchestratorModel: fm.orchestratorModel,
+    orchestratorEffort: fm.orchestratorEffort,
+    orchestratorPermissionMode: fm.orchestratorPermissionMode,
+    orchestratorForks: fm.orchestratorForks,
+    stepGates: { ...DEFAULT_STEP_GATES, ...fm.stepGates },
+    phaseHooks: fm.phaseHooks,
+    devCommand: fm.devCommand && fm.devCommand.trim() ? fm.devCommand : void 0,
+    worktreeSetup: fm.worktreeSetup && fm.worktreeSetup.trim() ? fm.worktreeSetup : void 0
+  };
+}
+function applyBoardConfig(project2, config2) {
+  return {
+    ...project2,
+    reviewMode: config2.reviewMode,
+    autoExpand: config2.autoExpand,
+    devSpeed: config2.devSpeed,
+    iframeCaching: config2.iframeCaching,
+    stepGates: config2.stepGates,
+    phaseHooks: config2.phaseHooks,
+    worktreeSetup: config2.worktreeSetup,
+    trunk: config2.trunk ?? project2.trunk,
+    orchestratorModel: config2.orchestratorModel,
+    orchestratorEffort: config2.orchestratorEffort,
+    orchestratorPermissionMode: config2.orchestratorPermissionMode,
+    orchestratorForks: config2.orchestratorForks
+  };
+}
+var EPHEMERAL_FRONTMATTER = /* @__PURE__ */ new Set(["sessionId", "forks", "pendingKickoff", "kickedLane", "grooming"]);
+async function setProjectSettings(project2, patch) {
+  const file = boardMdFile(project2);
+  await withFileLock(file, async () => {
+    let parsed;
+    try {
+      parsed = matter(await fs4.readFile(file, "utf8"));
+    } catch {
+      await ensureSkeleton(project2);
+      parsed = matter(await fs4.readFile(file, "utf8"));
+    }
+    const data = { ...parsed.data };
+    if (patch.reviewMode) data.reviewMode = patch.reviewMode;
+    if (patch.trunk) data.trunk = patch.trunk;
+    if (patch.autoExpand !== void 0) data.autoExpand = patch.autoExpand;
+    if (patch.devSpeed) data.devSpeed = patch.devSpeed;
+    if (patch.iframeCaching) data.iframeCaching = patch.iframeCaching;
+    if (patch.orchestratorSessionId) data.orchestratorSessionId = patch.orchestratorSessionId;
+    if (patch.orchestratorModel) data.orchestratorModel = patch.orchestratorModel;
+    if (patch.orchestratorEffort) data.orchestratorEffort = patch.orchestratorEffort;
+    if (patch.orchestratorPermissionMode)
+      data.orchestratorPermissionMode = patch.orchestratorPermissionMode;
+    if (patch.stepGates) {
+      const existing = BoardFrontmatterSchema.parse(data).stepGates;
+      data.stepGates = { ...existing, ...patch.stepGates };
+    }
+    if (patch.phaseHooks) {
+      const merged = { ...BoardFrontmatterSchema.parse(data).phaseHooks };
+      for (const [lane, cmd] of Object.entries(patch.phaseHooks)) {
+        if (cmd && cmd.trim()) merged[lane] = cmd.trim();
+        else delete merged[lane];
+      }
+      data.phaseHooks = merged;
+    }
+    if (patch.worktreeSetup !== void 0) {
+      if (patch.worktreeSetup.trim()) data.worktreeSetup = patch.worktreeSetup.trim();
+      else delete data.worktreeSetup;
+    }
+    await atomicWriteFile(file, matter.stringify(parsed.content, yamlSafe(data)));
+  });
+  const settingKeys = Object.keys(patch).filter((k) => k !== "orchestratorSessionId");
+  if (settingKeys.length) await commitBoardMd(project2, settingKeys.join(", "));
+}
+function laneDefsFor(mode) {
+  if (mode === "remote") return LANES;
+  const localTitles = {
+    "pr-review": { title: "Review", blurb: "Independent local reviews; fix findings. No PR." },
+    ci: { title: "Merge", blurb: "Merge into local trunk and delete the branch." },
+    "prod-testing": { title: "Verify", blurb: "Verify the merged trunk locally." }
+  };
+  return LANES.map((l) => localTitles[l.id] ? { ...l, ...localTitles[l.id] } : l);
+}
+function frontmatterToTask(fm, lane, fallbackId) {
+  return {
+    id: fm.id ?? fallbackId,
+    title: fm.title || "",
+    shortDescription: fm.shortDescription ?? "",
+    status: lane,
+    order: fm.order ?? 0,
+    hasDoc: true,
+    sessionId: fm.sessionId,
+    worktree: fm.worktree,
+    branch: fm.branch,
+    model: fm.model,
+    effort: fm.effort,
+    size: fm.size,
+    permissionMode: fm.permissionMode,
+    autonomous: fm.autonomous,
+    forks: fm.forks,
+    prUrl: fm.prUrl,
+    prNumber: fm.prNumber,
+    createdAt: fm.createdAt ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+    doneAt: fm.doneAt,
+    workflowEnteredAt: fm.workflowEnteredAt,
+    pendingKickoff: fm.pendingKickoff,
+    kickedLane: fm.kickedLane,
+    proposedLane: fm.proposedLane,
+    grooming: fm.grooming
+  };
+}
+async function readTaskDoc(project2, id) {
+  const found = await findTaskFile(project2, id);
+  if (!found) return null;
+  const parsed = matter(await fs4.readFile(found.file, "utf8"));
+  return { data: parseFrontmatter(parsed.data), body: parsed.content, file: found.file };
+}
+async function patchTaskFrontmatter(project2, id, patch) {
+  const { written, file } = await mutateTaskDoc(project2, id, ({ data, body }) => ({
+    data: { ...data, ...patch },
+    body
+  }));
+  if (!written || !file) return false;
+  const keys = Object.keys(patch);
+  if (keys.some((k) => !EPHEMERAL_FRONTMATTER.has(k))) {
+    await commitBoard(project2, [file], `update ${id} (${keys.join(", ")})`);
+  }
+  return true;
+}
+async function patchFork(project2, taskId, forkKey, patch) {
+  await mutateTaskDoc(project2, taskId, ({ data, body }) => ({
+    data: { ...data, forks: (data.forks ?? []).map((f) => f.key === forkKey ? { ...f, ...patch } : f) },
+    body
+  }));
+}
+async function patchForkSession(project2, taskId, forkKey, sessionId2) {
+  await patchFork(project2, taskId, forkKey, { sessionId: sessionId2 });
+}
+async function patchForkLabel(project2, taskId, forkKey, label) {
+  await patchFork(project2, taskId, forkKey, { label });
+}
+async function mutateOrchestratorForks(project2, mutate) {
+  const file = boardMdFile(project2);
+  await withFileLock(file, async () => {
+    let parsed;
+    try {
+      parsed = matter(await fs4.readFile(file, "utf8"));
+    } catch {
+      await ensureSkeleton(project2);
+      parsed = matter(await fs4.readFile(file, "utf8"));
+    }
+    const current = BoardFrontmatterSchema.parse(parsed.data).orchestratorForks ?? [];
+    const next = mutate(current);
+    const data = { ...parsed.data };
+    if (next.length) data.orchestratorForks = next;
+    else delete data.orchestratorForks;
+    await atomicWriteFile(file, matter.stringify(parsed.content, yamlSafe(data)));
+  });
+}
+async function patchOrchestratorFork(project2, forkKey, patch) {
+  await mutateOrchestratorForks(
+    project2,
+    (forks) => forks.map((f) => f.key === forkKey ? { ...f, ...patch } : f)
+  );
+}
+async function patchOrchestratorForkSession(project2, forkKey, sessionId2) {
+  await patchOrchestratorFork(project2, forkKey, { sessionId: sessionId2 });
+}
+async function patchOrchestratorForkLabel(project2, forkKey, label) {
+  await patchOrchestratorFork(project2, forkKey, { label });
+}
+async function readFreshDoc(file) {
+  try {
+    const parsed = matter(await fs4.readFile(file, "utf8"));
+    return { data: parseFrontmatter(parsed.data), body: parsed.content };
+  } catch {
+    return null;
+  }
+}
+async function mutateTaskDoc(project2, id, mutate) {
+  return withTaskMutex(project2, id, () => mutateTaskDocSerialized(project2, id, mutate));
+}
+async function mutateTaskDocSerialized(project2, id, mutate) {
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const found = await findTaskFile(project2, id);
+    if (!found) return { written: false, file: null };
+    const file = found.file;
+    let outcome = "moved";
+    await withFileLock(file, async () => {
+      const fresh = await readFreshDoc(file);
+      if (!fresh) {
+        outcome = "moved";
+        return;
+      }
+      const next = mutate(fresh);
+      if (!next) {
+        outcome = "skip";
+        return;
+      }
+      await atomicWriteFile(file, matter.stringify(next.body, yamlSafe(next.data)));
+      outcome = "written";
+    });
+    if (outcome === "moved") continue;
+    return { written: outcome === "written", file };
+  }
+  return { written: false, file: null };
+}
+async function updateTask(project2, id, patch) {
+  const { written, file } = await mutateTaskDoc(project2, id, ({ data: fresh, body: freshBody }) => {
+    const data = { ...fresh };
+    if (patch.title !== void 0) data.title = patch.title;
+    if (patch.shortDescription !== void 0) data.shortDescription = patch.shortDescription;
+    if (patch.effort !== void 0) data.effort = patch.effort;
+    if (patch.size !== void 0) data.size = patch.size;
+    if (patch.grooming !== void 0) {
+      if (patch.grooming) data.grooming = true;
+      else delete data.grooming;
+    }
+    data.lastGroomedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const body = patch.fields ? patchTaskBody(freshBody, patch.fields, patch.appendFields) : freshBody;
+    return { data, body };
+  });
+  if (!written || !file) return false;
+  await commitBoard(project2, [file], `update task ${id}`);
+  return true;
+}
+async function appendTaskField(project2, id, markdown, field = "notes", opts = {}) {
+  const { written, file } = await mutateTaskDoc(project2, id, ({ data, body }) => ({
+    data: { ...data, lastDocUpdatedAt: (/* @__PURE__ */ new Date()).toISOString() },
+    body: patchTaskBody(body, { [field]: markdown.trim() }, [field])
+  }));
+  if (written && file && opts.commit !== false) await commitBoard(project2, [file], `append to task ${id}`);
+  return written;
+}
+async function patchTaskFields(project2, id, fields, opts = {}) {
+  const { written, file } = await mutateTaskDoc(project2, id, ({ data, body }) => ({
+    data: { ...data, lastDocUpdatedAt: (/* @__PURE__ */ new Date()).toISOString() },
+    body: patchTaskBody(body, fields)
+  }));
+  if (written && file && opts.commit !== false) await commitBoard(project2, [file], `update test brief ${id}`);
+  return written;
+}
+async function readBoard(project2) {
+  const config2 = await readBoardConfig(project2);
+  const projectWithConfig = applyBoardConfig(project2, config2);
+  const byLane = /* @__PURE__ */ new Map();
+  for (const bucket of BUCKETS) {
+    for (const file of await listBucketFiles(project2, bucket)) {
+      let fm;
+      try {
+        fm = parseFrontmatter(matter(await fs4.readFile(file, "utf8")).data);
+      } catch {
+        continue;
+      }
+      const lane = laneForBucketFile(bucket, fm.status);
+      let arr = byLane.get(lane);
+      if (!arr) byLane.set(lane, arr = []);
+      arr.push(frontmatterToTask(fm, lane, idFromFile(file)));
+    }
+  }
+  const byId = /* @__PURE__ */ new Map();
+  for (const lane of LANE_IDS) {
+    const laneTasks = byLane.get(lane);
+    if (!laneTasks) continue;
+    laneTasks.sort((a, b) => compareTasksInLane(lane, a, b));
+    for (const t of laneTasks) byId.set(t.id, t);
+  }
+  const tasks = [];
+  for (const lane of LANE_IDS) {
+    for (const t of byId.values()) if (t.status === lane) tasks.push(t);
+  }
+  return { project: projectWithConfig, lanes: laneDefsFor(config2.reviewMode), tasks };
+}
+async function laneEntries(project2, lane, excludeId) {
+  const entries = [];
+  for (const file of await listLaneFiles(project2, lane)) {
+    if (excludeId && matchesTaskId(basename2(file), excludeId)) continue;
+    try {
+      const fm = parseFrontmatter(matter(await fs4.readFile(file, "utf8")).data);
+      entries.push({ file, order: fm.order ?? 0 });
+    } catch {
+    }
+  }
+  return entries.sort((a, b) => a.order - b.order);
+}
+async function laneOrders(project2, lane, excludeId) {
+  return (await laneEntries(project2, lane, excludeId)).map((e) => e.order);
+}
+async function renormalizeLane(project2, lane) {
+  const entries = await laneEntries(project2, lane);
+  const bucket = bucketForLane(lane);
+  await Promise.all(
+    entries.map(async ({ file }, i) => {
+      await withFileLock(file, async () => {
+        const fresh = await readFreshDoc(file);
+        if (!fresh) return;
+        if (laneForBucketFile(bucket, fresh.data.status) !== lane) return;
+        if (fresh.data.order === i) return;
+        await atomicWriteFile(
+          file,
+          matter.stringify(fresh.body, yamlSafe({ ...fresh.data, order: i }))
+        );
+      });
+    })
+  );
+}
+async function createTask(project2, input, lane = "backlog") {
+  const id = newTaskId();
+  const title = input.title.trim();
+  const desc = input.shortDescription.trim();
+  const orders = await laneOrders(project2, lane);
+  const order = orders.length ? orders[orders.length - 1] + 1 : 0;
+  const data = {
+    id,
+    title,
+    shortDescription: desc,
+    status: lane,
+    order,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const body = input.fields ? serializeTaskBody(input.fields) : input.body ? serializeTaskBody(parseTaskBody(input.body)) : "";
+  await fs4.mkdir(laneDir(project2, lane), { recursive: true });
+  const file = join5(laneDir(project2, lane), taskFileName(id, title || desc));
+  await atomicWriteFile(file, matter.stringify(body, yamlSafe(data)));
+  const laneNow = await laneOrders(project2, lane);
+  if (new Set(laneNow).size !== laneNow.length) {
+    await renormalizeLane(project2, lane);
+    const fresh = await readFreshDoc(file);
+    if (fresh?.data.order !== void 0) data.order = fresh.data.order;
+  }
+  await commitBoard(project2, [file], `add task ${id} \u2014 ${title} [${lane}]`);
+  return frontmatterToTask(data, lane, id);
+}
+async function exists(p) {
+  try {
+    await fs4.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// apps/server/src/runner/protocol.ts
+import { join as join6 } from "node:path";
+import { createHash as createHash3 } from "node:crypto";
+import { tmpdir } from "node:os";
+var PROTOCOL_VERSION = 2;
+function writeMsg(socket, msg) {
+  if (socket.writable) socket.write(JSON.stringify(msg) + "\n");
+}
+function attachLineReader(socket, onMessage) {
+  let buf = "";
+  socket.on("data", (d) => {
+    buf += d.toString();
+    let nl;
+    while ((nl = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, nl);
+      buf = buf.slice(nl + 1);
+      if (line.trim()) onMessage(line);
+    }
+  });
+}
+function runnersDir(projectPath) {
+  return join6(operatorDir(projectPath), ".runners");
+}
+function sockPath(projectPath, key) {
+  const full = join6(runnersDir(projectPath), `${sanitizeKey(key)}.sock`);
+  if (Buffer.byteLength(full) <= 100) return full;
+  const digest = createHash3("sha1").update(key).digest("hex").slice(0, 16);
+  const inDir = join6(runnersDir(projectPath), `s-${digest}.sock`);
+  if (Buffer.byteLength(inDir) <= 100) return inDir;
+  const scoped = createHash3("sha1").update(`${projectPath}\0${key}`).digest("hex").slice(0, 16);
+  return join6(tmpdir(), `operator-${scoped}.sock`);
+}
+function metaPath(projectPath, key) {
+  return join6(runnersDir(projectPath), `${sanitizeKey(key)}.json`);
+}
+
+// apps/server/src/runner/outbox.ts
+var Outbox = class {
+  constructor(write, genId) {
+    this.write = write;
+    this.genId = genId;
+  }
+  items = /* @__PURE__ */ new Map();
+  /** Assign a delivery id, remember the request, and send it now (best-effort). */
+  enqueue(msg) {
+    const id = msg.id ?? this.genId();
+    const withId = { ...msg, id };
+    this.items.set(id, withId);
+    this.write(withId);
+    return id;
+  }
+  /** Drop an acknowledged request so it isn't replayed. */
+  ack(id) {
+    this.items.delete(id);
+  }
+  /** Re-send every still-unacked request — call on each (re)connection. */
+  replay(write) {
+    for (const m of this.items.values()) write(m);
+  }
+  /** Count of unacked requests (for tests / introspection). */
+  get size() {
+    return this.items.size;
+  }
+};
+
+// apps/server/src/runner/fakeAgentSession.ts
+import { promises as fs5 } from "node:fs";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { join as join7 } from "node:path";
+var execFileP = promisify(execFile);
+async function execRetry(cmd, args, opts) {
+  try {
+    return await execFileP(cmd, args, opts);
+  } catch (e) {
+    if (!/spawn\s+\S+\s+(ENOENT|EAGAIN)/i.test(String(e))) throw e;
+    await new Promise((r) => setTimeout(r, 150));
+    return execFileP(cmd, args, opts);
+  }
+}
+function fakeAgentScriptPath(dir, key) {
+  return join7(dir, `${key.replace(/[^a-zA-Z0-9_-]/g, "_")}.json`);
+}
+var FakeAgentSession = class {
+  constructor(hooks, scriptFile) {
+    this.hooks = hooks;
+    this.scriptFile = scriptFile;
+  }
+  turnsUsed = /* @__PURE__ */ new Set();
+  /** Bumped by interrupt() AND by each new send(): a step loop only continues
+   *  while it still owns the current generation, so an interrupted (or
+   *  superseded) turn stops at its next step instead of running concurrently
+   *  with the rerun. */
+  gen = 0;
+  async script() {
+    try {
+      return JSON.parse(await fs5.readFile(this.scriptFile, "utf8"));
+    } catch {
+      return { turns: [] };
+    }
+  }
+  async send(text) {
+    const my = ++this.gen;
+    const { onEvent } = this.hooks;
+    await Promise.resolve(this.hooks.onSessionId(`fake-${Date.now().toString(36)}`));
+    onEvent({ type: "status", state: "running" });
+    const script = await this.script();
+    const idx = script.turns.findIndex(
+      (t, i) => !this.turnsUsed.has(i) && (!t.match || new RegExp(t.match, "i").test(text))
+    );
+    const turn = idx >= 0 ? script.turns[idx] : { steps: [{ text: "(fake agent: no scripted turn \u2014 idling)" }] };
+    if (idx >= 0) this.turnsUsed.add(idx);
+    const boom = turn.steps.find((st) => st.throwError);
+    if (boom) throw new Error(boom.throwError);
+    try {
+      for (const step of turn.steps) {
+        if (this.gen !== my) return;
+        if (step.sleepMs) {
+          for (let left = step.sleepMs; left > 0 && this.gen === my; left -= 100) {
+            await new Promise((r) => setTimeout(r, Math.min(100, left)));
+          }
+          if (this.gen !== my) return;
+        }
+        if (step.text) onEvent({ type: "assistant_text", text: step.text });
+        if (step.writeFile) {
+          await fs5.writeFile(join7(this.hooks.cwd, step.writeFile.path), step.writeFile.content);
+          onEvent({ type: "tool_use", id: `fk-${Date.now().toString(36)}`, name: "Write", input: { file_path: step.writeFile.path } });
+        }
+        if (step.commit) {
+          await execRetry("git", ["add", "-A"], { cwd: this.hooks.cwd });
+          await execRetry("git", ["commit", "-m", step.commit, "--no-verify"], { cwd: this.hooks.cwd });
+        }
+        if (step.run) {
+          try {
+            await execRetry("sh", ["-c", step.run], { cwd: this.hooks.cwd });
+          } catch (err) {
+            onEvent({ type: "error", message: `fake agent run failed: ${String(err).slice(0, 300)}` });
+          }
+        }
+        if (step.throwError) throw new Error(step.throwError);
+        if (step.runTests && this.hooks.runTests) {
+          const id = this.hooks.runTests(step.runTests.name, step.runTests.command);
+          onEvent({ type: "assistant_text", text: `(fake agent) run_tests queued: ${step.runTests.name} (${id})` });
+        }
+        if (step.doc) await this.hooks.appendDoc(step.doc);
+        if (step.permission) {
+          const r = await this.hooks.requestPermission(step.permission.toolName, step.permission.input ?? {});
+          onEvent({
+            type: "assistant_text",
+            text: r.allow ? `(fake agent) permission allowed: ${step.permission.toolName}` : `(fake agent) permission denied: ${r.message ?? "(no message)"}`
+          });
+        }
+        if (step.orchestrate) {
+          const o = step.orchestrate;
+          if (o.createTask) {
+            const id = this.hooks.orchestrateCreateTask ? await this.hooks.orchestrateCreateTask(o.createTask.title, o.createTask.summary ?? "", o.createTask.fields) : null;
+            onEvent({ type: "assistant_text", text: `(fake agent) create_task: ${id ?? "FAILED"}` });
+          }
+          if (o.updateTask) {
+            const { id, ...patch } = o.updateTask;
+            const ok3 = this.hooks.orchestrateUpdateTask ? await this.hooks.orchestrateUpdateTask(id, patch) : false;
+            onEvent({ type: "assistant_text", text: `(fake agent) update_task ${id}: ${ok3 ? "updated" : "FAILED"}` });
+          }
+          if (o.moveTask) {
+            const ok3 = this.hooks.orchestrateMoveTask ? await this.hooks.orchestrateMoveTask(o.moveTask.id, o.moveTask.toLane) : false;
+            onEvent({ type: "assistant_text", text: `(fake agent) move_task ${o.moveTask.id} -> ${o.moveTask.toLane}: ${ok3 ? "requested" : "FAILED"}` });
+          }
+          if (o.listTasks) {
+            const tasks = this.hooks.orchestrateListTasks ? await this.hooks.orchestrateListTasks() : null;
+            onEvent({ type: "assistant_text", text: `(fake agent) list_tasks: ${tasks ? JSON.stringify(tasks) : "FAILED"}` });
+          }
+          if (o.getTask) {
+            const t = this.hooks.orchestrateGetTask ? await this.hooks.orchestrateGetTask(o.getTask.id) : null;
+            onEvent({ type: "assistant_text", text: `(fake agent) get_task ${o.getTask.id}: ${t ? JSON.stringify(t) : "null"}` });
+          }
+          if (o.foldTask) {
+            const ok3 = this.hooks.orchestrateFoldTask ? await this.hooks.orchestrateFoldTask(o.foldTask.placeholderId, o.foldTask.intoIds) : false;
+            onEvent({ type: "assistant_text", text: `(fake agent) fold_task ${o.foldTask.placeholderId} -> ${o.foldTask.intoIds.join(",")}: ${ok3 ? "requested" : "FAILED"}` });
+          }
+          if (o.deleteTask) {
+            const ok3 = this.hooks.orchestrateDeleteTask ? await this.hooks.orchestrateDeleteTask(o.deleteTask.id) : false;
+            onEvent({ type: "assistant_text", text: `(fake agent) delete_task ${o.deleteTask.id}: ${ok3 ? "requested" : "FAILED"}` });
+          }
+        }
+        if (step.clarify) {
+          const answer = await this.hooks.requestClarification(step.clarify.question, step.clarify.options);
+          onEvent({ type: "assistant_text", text: `(fake agent) clarification answered: ${answer}` });
+        }
+        if (step.propose) {
+          const r = await this.hooks.proposeAdvance(
+            step.propose.toLane,
+            step.propose.rationale,
+            step.propose.confident ?? true
+          );
+          if (typeof r === "string") onEvent({ type: "assistant_text", text: `(fake agent) proposal feedback received: ${r.slice(0, 200)}` });
+          else onEvent({ type: "assistant_text", text: `(fake agent) proposal resolved: ${r}` });
+        }
+      }
+      if (this.gen !== my) return;
+      onEvent({ type: "result", subtype: "success", isError: false });
+    } catch (err) {
+      onEvent({ type: "error", message: `fake agent step failed: ${String(err)}` });
+    } finally {
+      if (this.gen === my) onEvent({ type: "status", state: "idle" });
+    }
+  }
+  async interrupt() {
+    this.gen++;
+    this.hooks.onEvent({ type: "status", state: "idle" });
+  }
+  // Surface parity with AgentSession (the runner calls these unconditionally).
+  async stop() {
+  }
+  async retry() {
+  }
+  async rewind(_toUuid, _preview) {
+  }
+  async setModel(_m) {
+  }
+  setEffort(_e) {
+  }
+  async setPermissionMode(_m) {
+  }
+  setAutonomous(_v) {
+  }
+  setAuthToken(_t) {
+  }
+};
+
+// apps/server/src/runner/main.ts
+import { join as join8 } from "node:path";
+var configPath = process.argv[2];
+var config = JSON.parse(readFileSync(configPath, "utf8"));
+var project = {
+  id: config.projectId,
+  name: config.projectName,
+  path: config.projectPath,
+  trunk: config.trunk,
+  reviewMode: "local",
+  autoExpand: true,
+  // Auto-advance policy (dev-speed + step gates) lives on the server; the runner
+  // only needs placeholders to satisfy the Project shape.
+  devSpeed: "enterprise",
+  stepGates: {},
+  phaseHooks: {},
+  iframeCaching: "eager"
+};
+var conns = /* @__PURE__ */ new Set();
+var pending = /* @__PURE__ */ new Map();
+var sessionId = config.resumeSessionId;
+var sessionState = "idle";
+var accountId = config.accountId;
+var authToken = config.env?.CLAUDE_CODE_OAUTH_TOKEN;
+var limitStalled = false;
+var throttle = null;
+var slashCommands = [];
+var IDLE_MS = Number(process.env.OPERATOR_RUNNER_IDLE_MS ?? 5 * 60 * 1e3);
+var SESSION_IDLE_MS = Number(process.env.OPERATOR_RUNNER_SESSION_IDLE_MS ?? 15 * 60 * 1e3);
+var disconnectedAt = Date.now();
+var lastActiveAt = Date.now();
+function onConnected() {
+  disconnectedAt = null;
+  lastActiveAt = Date.now();
+}
+function onDisconnected() {
+  if (conns.size === 0) disconnectedAt = Date.now();
+}
+function toServer(msg) {
+  for (const c of conns) writeMsg(c, msg);
+}
+var outbox = new Outbox(toServer, () => nanoid2(10));
+var emitChain = Promise.resolve();
+function actionForEvent(event) {
+  switch (event.type) {
+    case "tool_use":
+      return { actor: "agent", action: "tool_use", detail: { name: event.name } };
+    case "tool_result":
+      return { actor: "agent", action: "tool_result", detail: { isError: event.isError ?? false } };
+    case "permission_request":
+      return { actor: "agent", action: "permission_request", detail: { toolName: event.toolName } };
+    case "clarification":
+      return { actor: "agent", action: "clarification" };
+    case "ask_user_question":
+      return { actor: "agent", action: "ask_user_question", detail: { count: event.questions.length } };
+    case "advance_proposal":
+      return { actor: "agent", action: "advance_proposal", detail: { toLane: event.toLane, confident: event.confident } };
+    case "user_message":
+      return { actor: "user", action: "message" };
+    default:
+      return null;
+  }
+}
+function emit(event) {
+  lastActiveAt = Date.now();
+  const action = actionForEvent(event);
+  if (action) void logAction(project, { key: config.key, ...action });
+  if (event.type === "slash_commands") slashCommands = event.commands;
+  if (event.type === "session_init") sessionId = event.sessionId;
+  if (event.type === "status") {
+    sessionState = event.state;
+    if (event.state === "running") limitStalled = false;
+    if (event.state !== "throttled") throttle = null;
+  }
+  if (event.type === "throttled") {
+    throttle = { resetsAt: event.resetsAt, limitType: event.limitType };
+    if (event.resetsAt) limitStalled = true;
+  }
+  const persisted = event.type !== "rate_limit" && event.type !== "slash_commands";
+  emitChain = emitChain.then(async () => {
+    const seq = persisted ? await appendEvent(project, config.key, event) : null;
+    toServer({ t: "event", event, ...seq !== null ? { seq } : {} });
+  });
+  if (event.type === "error" && !cwdGone) void abortIfCwdGone();
+}
+var cwdGone = false;
+async function cwdExists() {
+  try {
+    await fs6.access(config.cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function abortIfCwdGone() {
+  if (cwdGone) return true;
+  if (await cwdExists()) return false;
+  cwdGone = true;
+  emit({
+    type: "error",
+    message: `Working directory no longer exists: ${config.cwd}. The task's git worktree was removed (typically after its branch merged), so this agent can't continue here. Stopping it \u2014 move the card or restart the task to run in a fresh worktree.`
+  });
+  emit({ type: "status", state: "error" });
+  void shutdown("worktree (cwd) removed");
+  return true;
+}
+function awaitResolution(kind, register, opts) {
+  return new Promise((resolve) => {
+    const id = nanoid2(10);
+    pending.set(id, { kind, resolve });
+    register(id);
+    if (opts) {
+      const timer = setTimeout(() => {
+        if (!pending.has(id)) return;
+        pending.delete(id);
+        resolve(opts.onTimeout());
+      }, opts.timeoutMs);
+      timer.unref();
+    }
+  });
+}
+function taskMcpContext(taskId) {
+  const docTaskId = parentTaskId(taskId);
+  return {
+    taskId,
+    project,
+    requestClarification: (question, options) => awaitResolution(
+      "clarification",
+      (id) => emit({ type: "clarification", id, question, options })
+    ),
+    proposeAdvance: (toLane, rationale, confident) => awaitResolution(
+      "advance",
+      (id) => emit({ type: "advance_proposal", id, toLane, rationale: rationale ?? "", confident })
+    ),
+    // Throws on a miss so the MCP tool returns an error (the SDK turns a handler
+    // throw into an isError tool result) instead of a phantom "updated". Fork
+    // sessions write the PARENT task's doc (docTaskId via parentTaskId).
+    appendDoc: async (markdown) => {
+      if (!await appendTaskField(project, docTaskId, markdown))
+        throw new Error(`Task ${docTaskId} not found \u2014 the task document was not updated.`);
+    },
+    emitArtifact: (kind, title, path2, data) => emit({ type: "artifact", kind, title, path: path2, data }),
+    renderMockup: (title, html, css) => emit({ type: "mockup", id: nanoid2(10), title, html, css }),
+    renderDiagram: (source, title) => emit({ type: "diagram", id: nanoid2(10), title, source }),
+    // Reuse the existing (durable, taskId-addressed) ask_user_question round-trip:
+    // emit the same event the SDK's AskUserQuestion uses and park the turn under its
+    // id until the user submits/cancels — resolves with the answers map, or null.
+    askForm: (questions) => awaitResolution(
+      "ask_user_question",
+      (id) => emit({ type: "ask_user_question", id, questions })
+    ),
+    setPr: async (url, number) => {
+      if (!await patchTaskFrontmatter(project, docTaskId, { prUrl: url, prNumber: number }))
+        throw new Error(`Task ${docTaskId} not found \u2014 the PR was not recorded.`);
+    },
+    startRun: (name, command, url) => {
+      const runId = nanoid2(10);
+      outbox.enqueue({ t: "run", action: "start", runId, name, command, url });
+      return runId;
+    },
+    runTests: (name, command) => {
+      const runId = nanoid2(10);
+      outbox.enqueue({ t: "run", action: "start", runId, name, command, kind: "test" });
+      return runId;
+    },
+    stopRun: (runId) => outbox.enqueue({ t: "run", action: "stop", runId }),
+    setSize: async (size) => {
+      if (!await patchTaskFrontmatter(project, docTaskId, { size }))
+        throw new Error(`Task ${docTaskId} not found \u2014 size unchanged.`);
+    },
+    // The test brief is task BODY content (Expected result / Affected areas) — write
+    // it to the parent task's doc, like update_task_doc. Throw on a miss so the tool
+    // reports the failure instead of a phantom success. Omitted fields are dropped
+    // so an unset one isn't blanked.
+    setTestBrief: async ({ expectedResult, affectedAreas }) => {
+      const fields = {};
+      if (expectedResult !== void 0) fields.expectedResult = expectedResult;
+      if (affectedAreas !== void 0) fields.affectedAreas = affectedAreas;
+      if (!await patchTaskFields(project, docTaskId, fields))
+        throw new Error(`Task ${docTaskId} not found \u2014 the test brief was not updated.`);
+    },
+    // Only a fork tab has a renamable label; for a main session this is a no-op.
+    // `config.forkOf` is the owning task id, `config.key` the fork's stream key.
+    // Returns whether a rename actually happened so the tool can say so.
+    renameSession: async (name) => {
+      const label = name.trim();
+      if (!config.forkOf || !label) return false;
+      await patchForkLabel(project, config.forkOf, config.key, label);
+      return true;
+    },
+    // Forward to the server, which routes to a connected preview overlay and replies
+    // via a `resolve` (kind "devtools"). Same round-trip shape as the other callbacks.
+    pageCommand: (action, args) => awaitResolution(
+      "devtools",
+      (id) => toServer({ t: "devtools", requestId: id, action, args }),
+      {
+        timeoutMs: 3e4,
+        onTimeout: () => ({ ok: false, error: "Operator server unreachable \u2014 preview command timed out." })
+      }
+    )
+  };
+}
+function orchestratorMcpContext() {
+  return {
+    project,
+    // Only an orchestrator side-session fork has a renamable tab; the main project
+    // agent's tab is fixed, so this is a no-op there (config.forkOf unset).
+    renameSession: async (name) => {
+      const label = name.trim();
+      if (config.forkOf && label) await patchOrchestratorForkLabel(project, config.key, label);
+    },
+    createTask: async (title, summary, fields) => {
+      const task = await createTask(project, { title, shortDescription: summary, fields });
+      return task.id;
+    },
+    updateTask: async (id, patch) => {
+      const ok3 = await updateTask(project, id, { ...patch, grooming: false });
+      if (ok3 && patch.size) {
+        const board = await readBoard(project);
+        const task = board.tasks.find((t) => t.id === id);
+        if (task?.status === "backlog") {
+          const { devSpeed } = await readBoardConfig(project);
+          const proposed = kickoffLane(task, devSpeed);
+          if (proposed) await patchTaskFrontmatter(project, id, { proposedLane: proposed });
+        }
+      }
+      return ok3;
+    },
+    listTasks: async () => {
+      const board = await readBoard(project);
+      return board.tasks.map((t) => ({
+        id: t.id,
+        title: t.title,
+        status: t.status,
+        summary: t.shortDescription ?? ""
+      }));
+    },
+    getTask: async (id) => {
+      const board = await readBoard(project);
+      const task = board.tasks.find((t) => t.id === id);
+      if (!task) return null;
+      const doc = await readTaskDoc(project, id);
+      return {
+        id: task.id,
+        title: task.title,
+        summary: task.shortDescription ?? "",
+        body: doc?.body ?? "",
+        size: task.size,
+        status: task.status
+      };
+    },
+    foldTask: async (placeholderId, intoIds) => {
+      outbox.enqueue({ t: "orchestrate", action: "fold", taskId: placeholderId, into: intoIds });
+      return true;
+    },
+    deleteTask: async (id) => {
+      outbox.enqueue({ t: "orchestrate", action: "delete", taskId: id });
+      return true;
+    },
+    moveTask: async (id, toLane) => {
+      outbox.enqueue({ t: "orchestrate", action: "move", taskId: id, toLane });
+      return true;
+    },
+    startTask: async (id) => {
+      const board = await readBoard(project);
+      const task = board.tasks.find((t) => t.id === id);
+      if (!task) return false;
+      const { devSpeed } = await readBoardConfig(project);
+      const toLane = kickoffLane(task, devSpeed);
+      if (!toLane) return false;
+      outbox.enqueue({ t: "orchestrate", action: "move", taskId: id, toLane });
+      return true;
+    }
+  };
+}
+var mcp = config.kind === "orchestrator" ? buildOrchestratorMcp(orchestratorMcpContext()) : buildOperatorMcp(taskMcpContext(config.key));
+function buildSession() {
+  if (process.env.OPERATOR_FAKE_AGENT) {
+    const ctx = taskMcpContext(config.key);
+    const orch = config.kind === "orchestrator" ? orchestratorMcpContext() : void 0;
+    const dir = process.env.OPERATOR_FAKE_AGENT_DIR ?? join8(config.projectPath, ".operator", ".fake-agent");
+    return new FakeAgentSession(
+      {
+        cwd: config.cwd,
+        onEvent: emit,
+        onSessionId: (id) => {
+          sessionId = id;
+        },
+        proposeAdvance: ctx.proposeAdvance,
+        requestClarification: ctx.requestClarification,
+        runTests: config.kind === "task" ? ctx.runTests : void 0,
+        appendDoc: config.kind === "task" ? ctx.appendDoc : async () => {
+        },
+        // Mirror onPermissionRequest: park the turn in the runner's pending map
+        // under a fresh id — but emit the durable permission_request event here
+        // (for the real session the SDK runtime emits it before the callback).
+        requestPermission: (toolName, input) => awaitResolution(
+          "permission",
+          (id) => emit({ type: "permission_request", id, toolName, input })
+        ),
+        ...orch ? {
+          orchestrateUpdateTask: (id, patch) => orch.updateTask(id, patch),
+          orchestrateCreateTask: (title, summary, fields) => orch.createTask(title, summary, fields),
+          orchestrateMoveTask: (id, toLane) => orch.moveTask(id, toLane),
+          orchestrateListTasks: () => orch.listTasks(),
+          orchestrateGetTask: (id) => orch.getTask(id),
+          orchestrateFoldTask: (placeholderId, intoIds) => orch.foldTask(placeholderId, intoIds),
+          orchestrateDeleteTask: (id) => orch.deleteTask(id)
+        } : {}
+      },
+      fakeAgentScriptPath(dir, config.key)
+    );
+  }
+  return realSession();
+}
+function realSession() {
+  return new AgentSession({
+    cwd: config.cwd,
+    resumeSessionId: config.resumeSessionId,
+    model: config.model,
+    effort: config.effort,
+    permissionMode: config.permissionMode,
+    autonomous: config.autonomous,
+    appendSystemPrompt: config.appendSystemPrompt,
+    plugins: config.plugins,
+    mcpServers: { operator: mcp },
+    passthroughUserSettings: config.passthroughUserSettings,
+    env: config.env,
+    onEvent: emit,
+    saveImage: (data, mediaType) => writeAsset(project, data, mediaType),
+    onSessionId: async (id) => {
+      sessionId = id;
+      if (config.forkOf) {
+        if (isOrchestratorKey(config.forkOf)) {
+          await patchOrchestratorForkSession(project, config.key, id).catch(() => {
+          });
+        } else {
+          await patchForkSession(project, config.forkOf, config.key, id).catch(() => {
+          });
+        }
+      } else if (config.kind === "orchestrator") {
+        await setProjectSettings(project, { orchestratorSessionId: id }).catch(() => {
+        });
+      } else if (!config.ephemeralSession) {
+        await patchTaskFrontmatter(project, config.key, { sessionId: id }).catch(() => {
+        });
+      }
+    },
+    onPermissionRequest: (req) => new Promise((resolve) => {
+      pending.set(req.id, { kind: "permission", resolve });
+    }),
+    // The runtime already emitted the `ask_user_question` event (carrying the
+    // questions to the UI); here we just park the turn under its request id until
+    // the user answers — mirroring onPermissionRequest. Resolves with the answers
+    // map, or null if the user cancels.
+    onAskUserQuestion: (req) => new Promise((resolve) => {
+      pending.set(req.id, { kind: "ask_user_question", resolve });
+    })
+  });
+}
+var session = buildSession();
+function retireParkedPrompts() {
+  const had = pending.size > 0;
+  for (const [id, p] of pending) {
+    pending.delete(id);
+    if (p.kind === "permission") p.resolve({ allow: false, message: "Interrupted by the user." });
+    else if (p.kind === "advance") p.resolve(false);
+    else if (p.kind === "ask_user_question") p.resolve(null);
+    else if (p.kind === "devtools") p.resolve({ ok: false, error: "interrupted" });
+    else p.resolve("(interrupted by the user)");
+    emit({ type: "prompt_dismissed", id });
+  }
+  return had;
+}
+function handle(msg) {
+  lastActiveAt = Date.now();
+  switch (msg.t) {
+    case "send":
+      void (async () => {
+        if (await abortIfCwdGone()) return;
+        emit({ type: "user_message", text: msg.text });
+        try {
+          await session.send(msg.text);
+        } catch (err) {
+          emit({
+            type: "error",
+            message: `The message could not start a turn: ${String(err).slice(0, 300)}. The runner is still alive \u2014 retry, or interrupt and resend.`
+          });
+          emit({ type: "status", state: "idle" });
+        }
+      })();
+      break;
+    case "interrupt":
+      retireParkedPrompts();
+      void session.interrupt();
+      break;
+    case "retry":
+      void session.retry();
+      break;
+    case "rewind":
+      void (async () => {
+        if (retireParkedPrompts()) await session.interrupt();
+        if (typeof msg.index === "number") {
+          await truncateEventsToUserMessage(project, config.key, msg.index + 2).catch(() => {
+          });
+        }
+        await session.rewind(msg.toUuid, msg.preview);
+      })();
+      break;
+    case "setModel":
+      void session.setModel(msg.model);
+      break;
+    case "setEffort":
+      session.setEffort(msg.effort);
+      break;
+    case "setPermissionMode":
+      void session.setPermissionMode(msg.mode);
+      break;
+    case "setAutonomous":
+      session.setAutonomous(msg.value);
+      break;
+    case "setAuth": {
+      accountId = msg.accountId;
+      if (msg.token !== authToken) {
+        authToken = msg.token;
+        session.setAuthToken(msg.token);
+      }
+      if (limitStalled) {
+        limitStalled = false;
+        throttle = null;
+        void session.retry();
+      }
+      break;
+    }
+    case "resolve": {
+      const p = pending.get(msg.requestId);
+      if (!p) return;
+      pending.delete(msg.requestId);
+      if (p.kind === "permission") {
+        const v = msg.value;
+        p.resolve({ allow: v.allow, message: v.message });
+      } else {
+        p.resolve(msg.value);
+      }
+      break;
+    }
+    case "ack":
+      outbox.ack(msg.id);
+      break;
+    case "dismiss": {
+      const feedback = msg.feedback?.trim() || void 0;
+      if (feedback) emit({ type: "user_message", text: feedback });
+      let consumed = false;
+      for (const [id, p] of pending) {
+        pending.delete(id);
+        if (p.kind === "permission") {
+          p.resolve({ allow: false, message: feedback ?? "Dismissed \u2014 user took a different action." });
+          consumed ||= !!feedback;
+        } else if (p.kind === "advance") {
+          p.resolve(feedback ? advanceFeedback(feedback) : false);
+          consumed ||= !!feedback;
+        } else if (p.kind === "ask_user_question") {
+          p.resolve(null);
+        } else if (p.kind === "devtools") {
+          p.resolve({ ok: false, error: "dismissed" });
+        } else {
+          p.resolve(feedback ?? "(dismissed \u2014 user responded with a message or moved the task instead)");
+          consumed ||= !!feedback;
+        }
+        emit({ type: "prompt_dismissed", id });
+      }
+      if (feedback && !consumed) void session.send(feedback);
+      break;
+    }
+    case "shutdown":
+      void shutdown();
+      break;
+  }
+}
+async function start() {
+  await fs6.mkdir(runnersDir(project.path), { recursive: true });
+  const sPath = sockPath(project.path, config.key);
+  await fs6.rm(sPath, { force: true }).catch(() => {
+  });
+  const server = net.createServer((conn) => {
+    conns.add(conn);
+    onConnected();
+    writeMsg(conn, {
+      t: "snapshot",
+      protocolVersion: PROTOCOL_VERSION,
+      pending: [...pending.keys()],
+      sessionId,
+      state: sessionState,
+      throttle,
+      accountId,
+      limitStalled,
+      commands: slashCommands
+    });
+    outbox.replay((m) => writeMsg(conn, m));
+    attachLineReader(conn, (line) => {
+      try {
+        handle(JSON.parse(line));
+      } catch {
+      }
+    });
+    const drop = () => {
+      conns.delete(conn);
+      onDisconnected();
+    };
+    conn.on("close", drop);
+    conn.on("error", drop);
+  });
+  const idleTimer = setInterval(() => {
+    if (throttle?.resetsAt) return;
+    if (pending.size > 0) return;
+    if (disconnectedAt != null && Date.now() - disconnectedAt >= IDLE_MS) {
+      void shutdown(`idle: no Operator connection for ${Math.round((Date.now() - disconnectedAt) / 1e3)}s`);
+      return;
+    }
+    if (sessionState === "running") return;
+    if (disconnectedAt == null && Date.now() - lastActiveAt >= SESSION_IDLE_MS) {
+      void shutdown(`idle: session inactive for ${Math.round((Date.now() - lastActiveAt) / 1e3)}s`);
+    }
+  }, 3e4);
+  idleTimer.unref();
+  server.listen(sPath, async () => {
+    const meta = {
+      key: config.key,
+      pid: process.pid,
+      projectId: config.projectId,
+      projectPath: config.projectPath,
+      sock: sPath,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      protocolVersion: PROTOCOL_VERSION,
+      // Echo the spawning server's code version so a later server lifetime can
+      // detect this runner is on stale code and recycle it once idle.
+      codeVersion: config.codeVersion
+    };
+    await fs6.writeFile(metaPath(project.path, config.key), JSON.stringify(meta, null, 2));
+  });
+}
+var delay = (ms) => new Promise((r) => setTimeout(r, ms));
+var shuttingDown = false;
+async function shutdown(reason = "shutdown") {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  console.log(`[runner ${config.key}] stopping: ${reason}`);
+  await Promise.race([session.stop().catch(() => {
+  }), delay(1e4)]);
+  await fs6.rm(sockPath(project.path, config.key), { force: true }).catch(() => {
+  });
+  await fs6.rm(metaPath(project.path, config.key), { force: true }).catch(() => {
+  });
+  process.exit(0);
+}
+process.on("SIGTERM", () => void shutdown("SIGTERM"));
+process.on("SIGINT", () => void shutdown("SIGINT"));
+start().catch((err) => {
+  console.error("[runner] fatal", err);
+  process.exit(1);
+});