syntaur 0.14.0 → 0.16.0

package/dist/launch/index.js

@@ -0,0 +1,3122 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// src/utils/paths.ts
+import { homedir } from "os";
+import { resolve } from "path";
+function expandHome(p) {
+  if (p.startsWith("~/") || p === "~") {
+    return resolve(homedir(), p.slice(2));
+  }
+  return p;
+}
+function syntaurRoot() {
+  const override = process.env.SYNTAUR_HOME;
+  if (override && override.length > 0) {
+    return resolve(expandHome(override));
+  }
+  return resolve(homedir(), ".syntaur");
+}
+function defaultProjectDir() {
+  return resolve(syntaurRoot(), "projects");
+}
+var init_paths = __esm({
+  "src/utils/paths.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/fs.ts
+import { mkdir, writeFile, access, rename } from "fs/promises";
+import { dirname, join } from "path";
+async function ensureDir(dir) {
+  await mkdir(dir, { recursive: true });
+}
+async function fileExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writeFileForce(filePath, content) {
+  const dir = dirname(filePath);
+  const tempPath = join(
+    dir,
+    `.${Math.random().toString(36).slice(2)}.${Date.now()}.tmp`
+  );
+  await ensureDir(dir);
+  await writeFile(tempPath, content, "utf-8");
+  await rename(tempPath, filePath);
+}
+var init_fs = __esm({
+  "src/utils/fs.ts"() {
+    "use strict";
+  }
+});
+
+// src/templates/config.ts
+var init_config = __esm({
+  "src/templates/config.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/fs-migration.ts
+import { readdir, readFile, rename as rename2, writeFile as writeFile2 } from "fs/promises";
+import { resolve as resolve2 } from "path";
+async function migrateLegacyProjectFiles(projectsDir) {
+  const result = {
+    renamedProjectFiles: [],
+    legacyExtras: []
+  };
+  if (!await fileExists(projectsDir)) return result;
+  let entries;
+  try {
+    entries = await readdir(projectsDir, { withFileTypes: true });
+  } catch {
+    return result;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+    const projectDir = resolve2(projectsDir, entry.name);
+    const legacy = resolve2(projectDir, "mission.md");
+    const target = resolve2(projectDir, "project.md");
+    try {
+      if (await fileExists(legacy) && !await fileExists(target)) {
+        await rename2(legacy, target);
+        result.renamedProjectFiles.push(`${entry.name}/mission.md`);
+      }
+    } catch {
+      continue;
+    }
+    for (const stale of ["agent.md", "claude.md"]) {
+      try {
+        if (await fileExists(resolve2(projectDir, stale))) {
+          result.legacyExtras.push(`${entry.name}/${stale}`);
+        }
+      } catch {
+      }
+    }
+  }
+  return result;
+}
+async function migrateLegacyConfig(configPath) {
+  const result = {
+    renamedField: false,
+    renamedDir: false,
+    resolvedProjectsDir: null
+  };
+  if (!await fileExists(configPath)) return result;
+  let content;
+  try {
+    content = await readFile(configPath, "utf-8");
+  } catch {
+    return result;
+  }
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n?/);
+  if (!fmMatch) return result;
+  const fmBlock = fmMatch[1];
+  const afterFm = content.slice(fmMatch[0].length);
+  const missionLineRe = /^(\s*)defaultMissionDir\s*:\s*(.*)$/m;
+  const missionLineMatch = fmBlock.match(missionLineRe);
+  const hasProjectLine = /^\s*defaultProjectDir\s*:/m.test(fmBlock);
+  let newFmBlock = fmBlock;
+  let missionValue = null;
+  if (missionLineMatch) {
+    missionValue = missionLineMatch[2].trim();
+    if (!hasProjectLine) {
+      newFmBlock = fmBlock.replace(
+        missionLineRe,
+        `$1defaultProjectDir: ${missionValue}`
+      );
+      result.renamedField = true;
+    } else {
+      newFmBlock = fmBlock.replace(missionLineRe, "").replace(/\n{2,}/g, "\n");
+      result.renamedField = true;
+    }
+  }
+  const projectLineRe = /^\s*defaultProjectDir\s*:\s*(.*)$/m;
+  const projectLineMatch = newFmBlock.match(projectLineRe);
+  const projectsDirRaw = projectLineMatch ? projectLineMatch[1].trim().replace(/^['"]|['"]$/g, "") : missionValue;
+  const expand = (p) => p.startsWith("~") ? resolve2(process.env.HOME ?? "/", p.slice(p.startsWith("~/") ? 2 : 1)) : p;
+  let resolvedProjectsDir = projectsDirRaw ? expand(projectsDirRaw) : null;
+  if (resolvedProjectsDir && resolvedProjectsDir.endsWith("/missions")) {
+    const siblingProjectsDir = resolvedProjectsDir.replace(/\/missions$/, "/projects");
+    if (await fileExists(resolvedProjectsDir) && !await fileExists(siblingProjectsDir)) {
+      try {
+        await rename2(resolvedProjectsDir, siblingProjectsDir);
+        const newValue = projectsDirRaw.endsWith("/missions") ? projectsDirRaw.replace(/\/missions$/, "/projects") : siblingProjectsDir;
+        newFmBlock = newFmBlock.replace(
+          projectLineRe,
+          `defaultProjectDir: ${newValue}`
+        );
+        resolvedProjectsDir = siblingProjectsDir;
+        result.renamedDir = true;
+      } catch {
+      }
+    }
+  }
+  result.resolvedProjectsDir = resolvedProjectsDir;
+  if (result.renamedField || result.renamedDir) {
+    const newContent = `---
+${newFmBlock.replace(/\n+$/, "")}
+---
+${afterFm.startsWith("\n") ? afterFm.slice(1) : afterFm}`;
+    try {
+      await writeFile2(configPath, newContent, "utf-8");
+    } catch {
+      result.renamedField = false;
+      result.renamedDir = false;
+    }
+  }
+  return result;
+}
+var init_fs_migration = __esm({
+  "src/utils/fs-migration.ts"() {
+    "use strict";
+    init_fs();
+  }
+});
+
+// src/utils/hotkeysCatalog.ts
+function isBindableActionKind(value) {
+  return typeof value === "string" && BINDABLE_ACTION_KINDS.includes(value);
+}
+function canonicalizeCombo(input) {
+  if (typeof input !== "string") return "";
+  const trimmed = input.trim();
+  if (!trimmed) return "";
+  if (/\s/.test(trimmed) && !trimmed.includes("+")) {
+    return trimmed.split(/\s+/).map(canonicalizeCombo).filter((part) => part.length > 0).join(" ");
+  }
+  const parts = trimmed.split("+").map((p) => p.trim()).filter((p) => p.length > 0);
+  if (parts.length === 0) return "";
+  if (parts.length === 1) {
+    return parts[0].toLowerCase();
+  }
+  const key = parts[parts.length - 1].toLowerCase();
+  const mods = parts.slice(0, -1).map((m) => m.toLowerCase());
+  const seen = /* @__PURE__ */ new Set();
+  const ordered = [];
+  for (const m of MODIFIER_ORDER) {
+    if (mods.includes(m) && !seen.has(m)) {
+      ordered.push(m);
+      seen.add(m);
+    }
+  }
+  for (const m of mods) {
+    if (!seen.has(m)) {
+      ordered.push(m);
+      seen.add(m);
+    }
+  }
+  return [...ordered, key].join("+");
+}
+var BINDABLE_ACTION_KINDS, MODIFIER_ORDER, DEFAULT_BINDABLE_HOTKEYS;
+var init_hotkeysCatalog = __esm({
+  "src/utils/hotkeysCatalog.ts"() {
+    "use strict";
+    BINDABLE_ACTION_KINDS = [
+      "new-workspace",
+      "new-project",
+      "new-todo",
+      "new-assignment"
+    ];
+    MODIFIER_ORDER = ["mod", "ctrl", "alt", "shift"];
+    DEFAULT_BINDABLE_HOTKEYS = {
+      "new-workspace": canonicalizeCombo("Mod+Shift+Alt+w"),
+      "new-project": canonicalizeCombo("Mod+Shift+Alt+p"),
+      "new-todo": canonicalizeCombo("Mod+Shift+Alt+t"),
+      "new-assignment": canonicalizeCombo("Mod+Shift+Alt+a")
+    };
+  }
+});
+
+// src/utils/agents-schema.ts
+var BUILTIN_AGENTS, AGENT_ID_PATTERN, PROMPT_ARG_POSITIONS;
+var init_agents_schema = __esm({
+  "src/utils/agents-schema.ts"() {
+    "use strict";
+    BUILTIN_AGENTS = [
+      {
+        id: "claude",
+        label: "Claude",
+        command: "claude",
+        default: true,
+        resume: { args: ["--resume", "{id}"] },
+        fork: { args: ["--resume", "{id}", "--fork-session"] }
+      },
+      {
+        id: "codex",
+        label: "Codex",
+        command: "codex",
+        resume: { args: ["resume", "{id}"] },
+        fork: { args: ["fork", "{id}"] }
+      }
+    ];
+    AGENT_ID_PATTERN = /^[a-z0-9][a-z0-9_-]*$/;
+    PROMPT_ARG_POSITIONS = ["first", "last", "none"];
+  }
+});
+
+// src/utils/config.ts
+import { readFile as readFile2 } from "fs/promises";
+import { resolve as resolve3, isAbsolute } from "path";
+function parseAgentCommand(value, agentId) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new AgentConfigError(
+      `agent${agentId ? ` "${agentId}"` : ""} has empty command`
+    );
+  }
+  const expanded = expandHome(value.trim());
+  if (isAbsolute(expanded)) {
+    return resolve3(expanded);
+  }
+  if (expanded.includes("/")) {
+    throw new AgentConfigError(
+      `agent${agentId ? ` "${agentId}"` : ""} command "${value}" is a relative path \u2014 use an absolute path or a bare binary name`
+    );
+  }
+  return expanded;
+}
+function validateAgentList(agents) {
+  const seen = /* @__PURE__ */ new Set();
+  let defaults = 0;
+  for (const agent of agents) {
+    if (!AGENT_ID_PATTERN.test(agent.id)) {
+      throw new AgentConfigError(
+        `agent id "${agent.id}" is invalid \u2014 must match /^[a-z0-9][a-z0-9_-]*$/`
+      );
+    }
+    if (seen.has(agent.id)) {
+      throw new AgentConfigError(`duplicate agent id "${agent.id}"`);
+    }
+    seen.add(agent.id);
+    if (!agent.label || agent.label.trim() === "") {
+      throw new AgentConfigError(`agent "${agent.id}" has empty label`);
+    }
+    parseAgentCommand(agent.command, agent.id);
+    if (agent.promptArgPosition !== void 0 && !PROMPT_ARG_POSITIONS.includes(agent.promptArgPosition)) {
+      throw new AgentConfigError(
+        `agent "${agent.id}" has invalid promptArgPosition "${agent.promptArgPosition}" \u2014 expected first|last|none`
+      );
+    }
+    validateSessionInvocation(agent, "resume", agent.resume);
+    validateSessionInvocation(agent, "fork", agent.fork);
+    if (agent.default) defaults++;
+  }
+  if (defaults > 1) {
+    throw new AgentConfigError(
+      `more than one agent is marked default: true (only one is allowed)`
+    );
+  }
+}
+function validateSessionInvocation(agent, mode, invocation) {
+  if (invocation === void 0) return;
+  if (!Array.isArray(invocation.args)) {
+    throw new AgentConfigError(
+      `agent "${agent.id}" ${mode}.args must be an array of strings`
+    );
+  }
+  for (const a of invocation.args) {
+    if (typeof a !== "string") {
+      throw new AgentConfigError(
+        `agent "${agent.id}" ${mode}.args must contain only strings`
+      );
+    }
+  }
+  if (invocation.command !== void 0 && (typeof invocation.command !== "string" || invocation.command.trim() === "")) {
+    throw new AgentConfigError(
+      `agent "${agent.id}" ${mode}.command must be a non-empty string when present`
+    );
+  }
+}
+function cloneDefaultConfig() {
+  return {
+    ...DEFAULT_CONFIG,
+    onboarding: { ...DEFAULT_CONFIG.onboarding },
+    agentDefaults: { ...DEFAULT_CONFIG.agentDefaults },
+    integrations: { ...DEFAULT_CONFIG.integrations },
+    backup: DEFAULT_CONFIG.backup ? { ...DEFAULT_CONFIG.backup } : null,
+    statuses: DEFAULT_CONFIG.statuses ? {
+      statuses: DEFAULT_CONFIG.statuses.statuses.map((s) => ({ ...s })),
+      order: [...DEFAULT_CONFIG.statuses.order],
+      transitions: DEFAULT_CONFIG.statuses.transitions.map((t) => ({ ...t }))
+    } : null,
+    types: DEFAULT_CONFIG.types ? {
+      definitions: DEFAULT_CONFIG.types.definitions.map((d) => ({ ...d })),
+      default: DEFAULT_CONFIG.types.default
+    } : null,
+    agents: DEFAULT_CONFIG.agents ? DEFAULT_CONFIG.agents.map((a) => ({
+      ...a,
+      ...a.args ? { args: [...a.args] } : {},
+      ...a.resume ? { resume: { ...a.resume, args: [...a.resume.args] } } : {},
+      ...a.fork ? { fork: { ...a.fork, args: [...a.fork.args] } } : {}
+    })) : null,
+    playbooks: {
+      disabled: [...DEFAULT_CONFIG.playbooks.disabled]
+    },
+    theme: DEFAULT_CONFIG.theme ? { ...DEFAULT_CONFIG.theme } : null,
+    hotkeys: DEFAULT_CONFIG.hotkeys ? { bindings: { ...DEFAULT_CONFIG.hotkeys.bindings } } : null,
+    terminal: DEFAULT_CONFIG.terminal
+  };
+}
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const result = {};
+  const lines = match[1].split("\n");
+  let currentParent = null;
+  for (const line of lines) {
+    if (line.trim() === "") continue;
+    const indent = line.length - line.trimStart().length;
+    const colonIndex = line.indexOf(":");
+    if (colonIndex < 0) continue;
+    const key = line.slice(0, colonIndex).trim();
+    const value = line.slice(colonIndex + 1).trim();
+    if (indent === 0) {
+      if (value === "" || value === void 0) {
+        currentParent = key;
+      } else {
+        currentParent = null;
+        result[key] = value.replace(/^["']|["']$/g, "");
+      }
+    } else if (indent > 0 && currentParent) {
+      result[`${currentParent}.${key}`] = value.replace(/^["']|["']$/g, "");
+    }
+  }
+  return result;
+}
+function parseStatusConfig(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const fmBlock = match[1];
+  const statusesStart = fmBlock.match(/^statuses:\s*$/m);
+  if (!statusesStart) return null;
+  const startIdx = fmBlock.indexOf(statusesStart[0]) + statusesStart[0].length;
+  const remaining = fmBlock.slice(startIdx);
+  const statuses = [];
+  const order = [];
+  const transitions = [];
+  let currentSection = null;
+  const lines = remaining.split("\n");
+  function parseListEntry(lineIdx, baseIndent) {
+    const entry = {};
+    const firstLine = lines[lineIdx].trimStart().slice(2).trim();
+    const colonIdx = firstLine.indexOf(":");
+    if (colonIdx > 0) {
+      entry[firstLine.slice(0, colonIdx).trim()] = firstLine.slice(colonIdx + 1).trim();
+    }
+    let consumed = 1;
+    for (let i = lineIdx + 1; i < lines.length; i++) {
+      const next = lines[i];
+      const nextTrimmed = next.trimStart();
+      const nextIndent = next.length - nextTrimmed.length;
+      if (nextIndent <= baseIndent || nextTrimmed.startsWith("- ")) break;
+      const ci = nextTrimmed.indexOf(":");
+      if (ci > 0) {
+        entry[nextTrimmed.slice(0, ci).trim()] = nextTrimmed.slice(ci + 1).trim();
+      }
+      consumed++;
+    }
+    return { entry, consumed };
+  }
+  for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+    const line = lines[lineIdx];
+    const trimmed = line.trimStart();
+    const indent = line.length - trimmed.length;
+    if (indent === 2 && trimmed.endsWith(":")) {
+      const key = trimmed.slice(0, -1).trim();
+      if (key === "definitions") currentSection = "definitions";
+      else if (key === "order") currentSection = "order";
+      else if (key === "transitions") currentSection = "transitions";
+      else currentSection = null;
+      continue;
+    }
+    if (indent === 0 && trimmed.includes(":")) break;
+    if (currentSection === "order" && indent >= 4 && trimmed.startsWith("- ")) {
+      order.push(trimmed.slice(2).trim());
+      continue;
+    }
+    if (currentSection === "definitions" && indent >= 4 && trimmed.startsWith("- ")) {
+      const { entry, consumed } = parseListEntry(lineIdx, indent);
+      if (entry["id"]) {
+        statuses.push({
+          id: entry["id"],
+          label: entry["label"] ?? entry["id"],
+          description: entry["description"],
+          color: entry["color"],
+          icon: entry["icon"],
+          terminal: entry["terminal"] === "true"
+        });
+      }
+      lineIdx += consumed - 1;
+      continue;
+    }
+    if (currentSection === "transitions" && indent >= 4 && trimmed.startsWith("- ")) {
+      const { entry, consumed } = parseListEntry(lineIdx, indent);
+      if (entry["from"] && entry["command"] && entry["to"]) {
+        transitions.push({
+          from: entry["from"],
+          command: entry["command"],
+          to: entry["to"],
+          label: entry["label"],
+          description: entry["description"],
+          requiresReason: entry["requiresReason"] === "true"
+        });
+      }
+      lineIdx += consumed - 1;
+      continue;
+    }
+  }
+  if (statuses.length === 0) return null;
+  return {
+    statuses,
+    order: order.length > 0 ? order : statuses.map((s) => s.id),
+    transitions
+  };
+}
+function parsePlaybooksConfig(fmBlock) {
+  const blockStart = fmBlock.match(/^playbooks:\s*$/m);
+  if (!blockStart) {
+    return { disabled: [] };
+  }
+  const startIdx = fmBlock.indexOf(blockStart[0]) + blockStart[0].length;
+  const remaining = fmBlock.slice(startIdx).split("\n");
+  const disabled = [];
+  let currentSection = null;
+  for (const line of remaining) {
+    const trimmed = line.trimStart();
+    const indent = line.length - trimmed.length;
+    if (indent === 0 && trimmed.length > 0) break;
+    if (trimmed === "") continue;
+    if (indent === 2 && trimmed.startsWith("disabled:")) {
+      currentSection = "disabled";
+      const afterColon = trimmed.slice("disabled:".length).trim();
+      if (afterColon === "[]" || afterColon === "") {
+        continue;
+      }
+      continue;
+    }
+    if (currentSection === "disabled" && indent >= 4 && trimmed.startsWith("- ")) {
+      const raw = trimmed.slice(2).trim().replace(/^["']|["']$/g, "");
+      if (raw.length === 0) continue;
+      if (/\s/.test(raw)) {
+        console.warn(`Warning: config.md playbooks.disabled entry "${raw}" contains whitespace, ignoring`);
+        continue;
+      }
+      disabled.push(raw);
+      continue;
+    }
+  }
+  return { disabled };
+}
+function parseThemeConfig(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const fmBlock = match[1];
+  const blockStart = fmBlock.match(/^theme:\s*$/m);
+  if (!blockStart) return null;
+  const startIdx = fmBlock.indexOf(blockStart[0]) + blockStart[0].length;
+  const remaining = fmBlock.slice(startIdx).split("\n");
+  let preset = null;
+  for (const line of remaining) {
+    const trimmed = line.trimStart();
+    const indent = line.length - trimmed.length;
+    if (indent === 0 && trimmed.length > 0) break;
+    if (trimmed === "") continue;
+    if (indent === 2 && trimmed.startsWith("preset:")) {
+      const value = trimmed.slice("preset:".length).trim().replace(/^["']|["']$/g, "");
+      if (value.length > 0) preset = value;
+    }
+  }
+  if (!preset) return null;
+  return { preset };
+}
+function parseHotkeyBindingsConfig(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const fmBlock = match[1];
+  const blockStart = fmBlock.match(/^hotkeys:\s*$/m);
+  if (!blockStart) return null;
+  const startIdx = fmBlock.indexOf(blockStart[0]) + blockStart[0].length;
+  const remaining = fmBlock.slice(startIdx).split("\n");
+  const bindings = {};
+  let inBindings = false;
+  for (const line of remaining) {
+    const trimmed = line.trimStart();
+    const indent = line.length - trimmed.length;
+    if (indent === 0 && trimmed.length > 0) break;
+    if (trimmed === "") continue;
+    if (indent === 2 && trimmed === "bindings:") {
+      inBindings = true;
+      continue;
+    }
+    if (inBindings && indent === 4) {
+      const colonIdx = trimmed.indexOf(":");
+      if (colonIdx <= 0) continue;
+      const rawKind = trimmed.slice(0, colonIdx).trim();
+      const rawValue = trimmed.slice(colonIdx + 1).trim().replace(/^["']|["']$/g, "");
+      if (!isBindableActionKind(rawKind)) continue;
+      if (rawValue.length === 0) continue;
+      bindings[rawKind] = canonicalizeCombo(rawValue);
+    }
+  }
+  if (Object.keys(bindings).length === 0) return null;
+  return { bindings };
+}
+function parseOptionalAbsolutePath(value, fieldName) {
+  if (!value) {
+    return null;
+  }
+  const expanded = expandHome(String(value));
+  if (!isAbsolute(expanded)) {
+    console.warn(
+      `Warning: config.md ${fieldName} is not an absolute path ("${value}"), ignoring it`
+    );
+    return null;
+  }
+  return resolve3(expanded);
+}
+function parseAgentsConfig(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const fmBlock = match[1];
+  const agentsStart = fmBlock.match(/^agents:\s*$/m);
+  if (!agentsStart) return null;
+  const startIdx = fmBlock.indexOf(agentsStart[0]) + agentsStart[0].length;
+  const remaining = fmBlock.slice(startIdx);
+  const lines = remaining.split("\n");
+  const agents = [];
+  let current = null;
+  let argsCapture = null;
+  let argsBaseIndent = 0;
+  let nestedKey = null;
+  let nestedInvocation = null;
+  let nestedBaseIndent = 0;
+  function flushCurrent() {
+    if (!current) return;
+    if (!current.id || !current.command || !current.label) {
+      current = null;
+      return;
+    }
+    agents.push({
+      id: current.id,
+      label: current.label,
+      command: current.command,
+      ...current.args && current.args.length > 0 ? { args: current.args } : {},
+      ...current.promptArgPosition ? { promptArgPosition: current.promptArgPosition } : {},
+      ...current.default ? { default: true } : {},
+      ...current.resolveFromShellAliases ? { resolveFromShellAliases: true } : {},
+      ...current.resume ? { resume: current.resume } : {},
+      ...current.fork ? { fork: current.fork } : {}
+    });
+    current = null;
+    argsCapture = null;
+    nestedKey = null;
+    nestedInvocation = null;
+  }
+  function closeNestedBlock() {
+    if (!nestedKey) return;
+    if (current && (nestedKey === "resume" || nestedKey === "fork") && nestedInvocation) {
+      if (Array.isArray(nestedInvocation.args)) {
+        current[nestedKey] = nestedInvocation;
+      }
+    }
+    nestedKey = null;
+    nestedInvocation = null;
+    argsCapture = null;
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trimStart();
+    const indent = line.length - trimmed.length;
+    if (indent === 0 && trimmed !== "" && !trimmed.startsWith("#")) {
+      closeNestedBlock();
+      break;
+    }
+    if (argsCapture) {
+      if (indent > argsBaseIndent && trimmed.startsWith("- ")) {
+        argsCapture.push(decodeYamlScalar(trimmed.slice(2).trim()));
+        continue;
+      } else {
+        argsCapture = null;
+      }
+    }
+    if (indent === 2 && trimmed.startsWith("- ")) {
+      closeNestedBlock();
+      flushCurrent();
+      current = {};
+      const rest = trimmed.slice(2).trim();
+      const colonIdx = rest.indexOf(":");
+      if (colonIdx > 0) {
+        const k = rest.slice(0, colonIdx).trim();
+        const v = rest.slice(colonIdx + 1).trim();
+        assignAgentField(current, k, v);
+      }
+      continue;
+    }
+    if (!current) continue;
+    if (nestedKey && indent > nestedBaseIndent) {
+      const colonIdx = trimmed.indexOf(":");
+      if (colonIdx <= 0) continue;
+      const k = trimmed.slice(0, colonIdx).trim();
+      const v = trimmed.slice(colonIdx + 1).trim();
+      if (nestedKey === "resume" || nestedKey === "fork") {
+        if (!nestedInvocation) nestedInvocation = { args: [] };
+        if (k === "args" && v === "") {
+          nestedInvocation.args = [];
+          argsCapture = nestedInvocation.args;
+          argsBaseIndent = indent;
+          continue;
+        }
+        if (k === "command" && v !== "") {
+          nestedInvocation.command = decodeYamlScalar(v);
+          continue;
+        }
+      }
+      continue;
+    }
+    if (nestedKey && indent <= nestedBaseIndent) {
+      closeNestedBlock();
+    }
+    if (indent >= 4 && current) {
+      const colonIdx = trimmed.indexOf(":");
+      if (colonIdx <= 0) continue;
+      const k = trimmed.slice(0, colonIdx).trim();
+      const v = trimmed.slice(colonIdx + 1).trim();
+      if (k === "args" && v === "") {
+        argsCapture = [];
+        argsBaseIndent = indent;
+        current.args = argsCapture;
+        continue;
+      }
+      if ((k === "resume" || k === "fork") && v === "") {
+        nestedKey = k;
+        nestedInvocation = { args: [] };
+        nestedBaseIndent = indent;
+        continue;
+      }
+      if (v === "" && !KNOWN_AGENT_SCALAR_FIELDS.has(k)) {
+        nestedKey = "__skip__";
+        nestedInvocation = null;
+        nestedBaseIndent = indent;
+        continue;
+      }
+      assignAgentField(current, k, v);
+    }
+  }
+  closeNestedBlock();
+  flushCurrent();
+  if (agents.length === 0) return [];
+  return agents;
+}
+function normalizeAgentsFromConfig(agents) {
+  if (agents === null) return null;
+  try {
+    const normalized = agents.map((agent) => ({
+      ...agent,
+      command: parseAgentCommand(agent.command, agent.id)
+    }));
+    validateAgentList(normalized);
+    return normalized;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.warn(
+      `Warning: ~/.syntaur/config.md agents block is invalid (${msg}) \u2014 using built-in defaults`
+    );
+    return null;
+  }
+}
+function decodeYamlScalar(value) {
+  const trimmed = value.trim();
+  if (trimmed.length >= 2 && trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    const body = trimmed.slice(1, -1);
+    let out = "";
+    for (let i = 0; i < body.length; i++) {
+      const ch = body[i];
+      if (ch === "\\" && i + 1 < body.length) {
+        const next = body[i + 1];
+        switch (next) {
+          case "\\":
+            out += "\\";
+            break;
+          case '"':
+            out += '"';
+            break;
+          case "n":
+            out += "\n";
+            break;
+          case "t":
+            out += "	";
+            break;
+          case "r":
+            out += "\r";
+            break;
+          default:
+            out += next;
+            break;
+        }
+        i++;
+        continue;
+      }
+      out += ch;
+    }
+    return out;
+  }
+  if (trimmed.length >= 2 && trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1).replace(/''/g, "'");
+  }
+  return trimmed;
+}
+function assignAgentField(target, key, rawValue) {
+  const value = decodeYamlScalar(rawValue);
+  switch (key) {
+    case "id":
+      target.id = value;
+      break;
+    case "label":
+      target.label = value;
+      break;
+    case "command":
+      target.command = value;
+      break;
+    case "promptArgPosition":
+      target.promptArgPosition = value;
+      break;
+    case "default":
+      target.default = value === "true";
+      break;
+    case "resolveFromShellAliases":
+      target.resolveFromShellAliases = value === "true";
+      break;
+  }
+}
+async function readConfig() {
+  const configPath = resolve3(syntaurRoot(), "config.md");
+  if (!await fileExists(configPath)) {
+    return cloneDefaultConfig();
+  }
+  if (!migratedConfigPaths.has(configPath)) {
+    migratedConfigPaths.add(configPath);
+    await migrateLegacyConfig(configPath);
+  }
+  const content = await readFile2(configPath, "utf-8");
+  const fm = parseFrontmatter(content);
+  if (Object.keys(fm).length === 0) {
+    console.warn("Warning: ~/.syntaur/config.md has malformed frontmatter, using defaults");
+    return cloneDefaultConfig();
+  }
+  let projectDir = fm["defaultProjectDir"] ? expandHome(String(fm["defaultProjectDir"])) : DEFAULT_CONFIG.defaultProjectDir;
+  if (!isAbsolute(projectDir)) {
+    console.warn(
+      `Warning: config.md defaultProjectDir is not an absolute path ("${fm["defaultProjectDir"]}"), using default`
+    );
+    projectDir = DEFAULT_CONFIG.defaultProjectDir;
+  }
+  const fmBlock = content.match(/^---\n([\s\S]*?)\n---/)?.[1] ?? "";
+  return {
+    version: fm["version"] || DEFAULT_CONFIG.version,
+    defaultProjectDir: projectDir,
+    onboarding: {
+      completed: fm["onboarding.completed"] === "true"
+    },
+    agentDefaults: {
+      trustLevel: fm["agentDefaults.trustLevel"] || DEFAULT_CONFIG.agentDefaults.trustLevel,
+      autoApprove: fm["agentDefaults.autoApprove"] === "true" || DEFAULT_CONFIG.agentDefaults.autoApprove,
+      autoCreateWorktree: AUTO_CREATE_WORKTREE_VALUES.includes(
+        fm["agentDefaults.autoCreateWorktree"]
+      ) ? fm["agentDefaults.autoCreateWorktree"] : DEFAULT_CONFIG.agentDefaults.autoCreateWorktree
+    },
+    integrations: {
+      claudePluginDir: parseOptionalAbsolutePath(
+        fm["integrations.claudePluginDir"],
+        "integrations.claudePluginDir"
+      ),
+      codexPluginDir: parseOptionalAbsolutePath(
+        fm["integrations.codexPluginDir"],
+        "integrations.codexPluginDir"
+      ),
+      codexMarketplacePath: parseOptionalAbsolutePath(
+        fm["integrations.codexMarketplacePath"],
+        "integrations.codexMarketplacePath"
+      )
+    },
+    backup: fm["backup.repo"] || fm["backup.categories"] ? {
+      repo: fm["backup.repo"] && fm["backup.repo"] !== "null" ? fm["backup.repo"] : null,
+      categories: fm["backup.categories"] || "projects, playbooks, todos, servers, config",
+      lastBackup: fm["backup.lastBackup"] && fm["backup.lastBackup"] !== "null" ? fm["backup.lastBackup"] : null,
+      lastRestore: fm["backup.lastRestore"] && fm["backup.lastRestore"] !== "null" ? fm["backup.lastRestore"] : null
+    } : null,
+    statuses: parseStatusConfig(content),
+    types: null,
+    agents: normalizeAgentsFromConfig(parseAgentsConfig(content)),
+    playbooks: parsePlaybooksConfig(fmBlock),
+    theme: parseThemeConfig(content),
+    hotkeys: parseHotkeyBindingsConfig(content),
+    terminal: (() => {
+      try {
+        return parseTerminalConfig(fm["terminal"]);
+      } catch (err) {
+        const msg = err instanceof TerminalConfigError ? err.message : String(err);
+        console.warn(`Warning: ${msg} \u2014 falling back to default`);
+        return null;
+      }
+    })()
+  };
+}
+function getAgents(config) {
+  return config.agents ?? BUILTIN_AGENTS;
+}
+function parseTerminalConfig(value) {
+  if (value === void 0 || value === null || value === "") return null;
+  if (typeof value !== "string") {
+    throw new TerminalConfigError(
+      `terminal must be a string \u2014 got ${typeof value}`
+    );
+  }
+  const trimmed = value.trim();
+  if (trimmed === "") return null;
+  if (!TERMINAL_CHOICES.includes(trimmed)) {
+    throw new TerminalConfigError(
+      `terminal "${trimmed}" is not a known choice \u2014 expected one of ${TERMINAL_CHOICES.join("|")}`
+    );
+  }
+  return trimmed;
+}
+function getTerminal(config) {
+  return config.terminal ?? "terminal-app";
+}
+var TERMINAL_CHOICES, DEFAULT_CONFIG, AUTO_CREATE_WORKTREE_VALUES, AgentConfigError, KNOWN_AGENT_SCALAR_FIELDS, migratedConfigPaths, TerminalConfigError;
+var init_config2 = __esm({
+  "src/utils/config.ts"() {
+    "use strict";
+    init_paths();
+    init_fs();
+    init_config();
+    init_fs_migration();
+    init_hotkeysCatalog();
+    init_agents_schema();
+    TERMINAL_CHOICES = [
+      "terminal-app",
+      "iterm",
+      "ghostty",
+      "alacritty",
+      "warp",
+      "kitty"
+    ];
+    DEFAULT_CONFIG = {
+      version: "2.0",
+      defaultProjectDir: defaultProjectDir(),
+      onboarding: {
+        completed: false
+      },
+      agentDefaults: {
+        trustLevel: "medium",
+        autoApprove: false,
+        autoCreateWorktree: "ask"
+      },
+      integrations: {
+        claudePluginDir: null,
+        codexPluginDir: null,
+        codexMarketplacePath: null
+      },
+      backup: null,
+      statuses: null,
+      types: null,
+      agents: null,
+      playbooks: {
+        disabled: []
+      },
+      theme: null,
+      hotkeys: null,
+      terminal: null
+    };
+    AUTO_CREATE_WORKTREE_VALUES = ["skip", "ask", "always"];
+    AgentConfigError = class extends Error {
+    };
+    KNOWN_AGENT_SCALAR_FIELDS = /* @__PURE__ */ new Set([
+      "id",
+      "label",
+      "command",
+      "promptArgPosition",
+      "default",
+      "resolveFromShellAliases"
+    ]);
+    migratedConfigPaths = /* @__PURE__ */ new Set();
+    TerminalConfigError = class extends Error {
+    };
+  }
+});
+
+// src/dashboard/parser.ts
+function extractFrontmatter(fileContent) {
+  const match = fileContent.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) {
+    return ["", fileContent];
+  }
+  const frontmatterBlock = match[1];
+  const body = fileContent.slice(match[0].length).trim();
+  return [frontmatterBlock, body];
+}
+function parseSimpleValue(raw) {
+  const trimmed = raw.trim();
+  if (trimmed === "null" || trimmed === "~" || trimmed === "") return null;
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function getField(frontmatter, key) {
+  const match = frontmatter.match(new RegExp(`^${key}:\\s*(.*)$`, "m"));
+  if (!match) return null;
+  return parseSimpleValue(match[1]);
+}
+function getNestedField(frontmatter, parent, key) {
+  const parentRegex = new RegExp(`^${parent}:\\s*\\n((?:\\s+.*\\n?)*)`, "m");
+  const parentMatch = frontmatter.match(parentRegex);
+  if (!parentMatch) return null;
+  const block = parentMatch[1];
+  const fieldMatch = block.match(new RegExp(`^\\s+${key}:\\s*(.*)$`, "m"));
+  if (!fieldMatch) return null;
+  return parseSimpleValue(fieldMatch[1]);
+}
+function parseListField(frontmatter, fieldName) {
+  const inlineMatch = frontmatter.match(new RegExp(`^${fieldName}:\\s*\\[\\s*\\]`, "m"));
+  if (inlineMatch) return [];
+  const results = [];
+  const blockMatch = frontmatter.match(
+    new RegExp(`^${fieldName}:\\s*\\n((?:\\s+-\\s+.*\\n?)*)`, "m")
+  );
+  if (blockMatch) {
+    let item;
+    const regex = /^\s+-\s+(.+)$/gm;
+    while ((item = regex.exec(blockMatch[1])) !== null) {
+      results.push(item[1].trim());
+    }
+  }
+  return results;
+}
+function parseProject(fileContent) {
+  const [fm, body] = extractFrontmatter(fileContent);
+  const slug = getField(fm, "slug") ?? getField(fm, "mission") ?? "";
+  return {
+    id: getField(fm, "id") ?? "",
+    slug,
+    title: getField(fm, "title") ?? "",
+    archived: getField(fm, "archived") === "true",
+    archivedAt: getField(fm, "archivedAt"),
+    archivedReason: getField(fm, "archivedReason"),
+    statusOverride: getField(fm, "statusOverride"),
+    created: getField(fm, "created") ?? "",
+    updated: getField(fm, "updated") ?? "",
+    tags: parseListField(fm, "tags"),
+    workspace: getField(fm, "workspace"),
+    externalIds: parseExternalIds(fm),
+    body
+  };
+}
+function parseStatus(fileContent) {
+  const [fm, body] = extractFrontmatter(fileContent);
+  const progress = { total: 0 };
+  const progressMatch = fm.match(/^progress:\s*\n((?:\s+.*\n?)*)/m);
+  if (progressMatch) {
+    const lines = progressMatch[1].split("\n");
+    for (const line of lines) {
+      const kv = line.match(/^\s+(\w+):\s*(\d+)/);
+      if (kv) {
+        progress[kv[1]] = parseInt(kv[2], 10);
+      }
+    }
+  }
+  return {
+    project: getField(fm, "project") ?? "",
+    status: getField(fm, "status") ?? "pending",
+    progress,
+    needsAttention: {
+      blockedCount: parseInt(getNestedField(fm, "needsAttention", "blockedCount") ?? "0", 10),
+      failedCount: parseInt(getNestedField(fm, "needsAttention", "failedCount") ?? "0", 10),
+      openQuestions: parseInt(getNestedField(fm, "needsAttention", "openQuestions") ?? "0", 10)
+    },
+    body
+  };
+}
+function parseExternalIds(frontmatter) {
+  const inlineMatch = frontmatter.match(/^externalIds:\s*\[\s*\]/m);
+  if (inlineMatch) return [];
+  const results = [];
+  const blockMatch = frontmatter.match(
+    /^externalIds:\s*\n((?:\s+-\s+[\s\S]*?)(?=^\w|\n---))/m
+  );
+  if (!blockMatch) return [];
+  const itemBlocks = blockMatch[1].split(/\n\s+-\s+/).filter(Boolean);
+  for (const block of itemBlocks) {
+    const lines = block.split("\n");
+    const entry = {};
+    for (const line of lines) {
+      const colonIdx = line.indexOf(":");
+      if (colonIdx < 0) continue;
+      const key = line.slice(0, colonIdx).trim().replace(/^-\s+/, "");
+      if (!key) continue;
+      entry[key] = parseSimpleValue(line.slice(colonIdx + 1));
+    }
+    if (entry["system"] && entry["id"]) {
+      results.push({
+        system: entry["system"],
+        id: entry["id"],
+        url: entry["url"] || null
+      });
+    }
+  }
+  return results;
+}
+function parseAssignmentFull(fileContent) {
+  const [fm, body] = extractFrontmatter(fileContent);
+  return {
+    id: getField(fm, "id") ?? "",
+    slug: getField(fm, "slug") ?? "",
+    title: getField(fm, "title") ?? "",
+    project: getField(fm, "project"),
+    workspaceGroup: getField(fm, "workspaceGroup"),
+    type: getField(fm, "type"),
+    status: getField(fm, "status") ?? "pending",
+    priority: getField(fm, "priority") ?? "medium",
+    assignee: getField(fm, "assignee"),
+    dependsOn: parseListField(fm, "dependsOn"),
+    links: parseListField(fm, "links"),
+    blockedReason: getField(fm, "blockedReason"),
+    workspace: {
+      repository: getNestedField(fm, "workspace", "repository"),
+      worktreePath: getNestedField(fm, "workspace", "worktreePath"),
+      branch: getNestedField(fm, "workspace", "branch"),
+      parentBranch: getNestedField(fm, "workspace", "parentBranch")
+    },
+    externalIds: parseExternalIds(fm),
+    tags: parseListField(fm, "tags"),
+    created: getField(fm, "created") ?? "",
+    updated: getField(fm, "updated") ?? "",
+    body
+  };
+}
+function parsePlan(fileContent) {
+  const [fm, body] = extractFrontmatter(fileContent);
+  return {
+    assignment: getField(fm, "assignment") ?? "",
+    status: getField(fm, "status") ?? "",
+    created: getField(fm, "created") ?? "",
+    updated: getField(fm, "updated") ?? "",
+    body
+  };
+}
+function parseScratchpad(fileContent) {
+  const [fm, body] = extractFrontmatter(fileContent);
+  return {
+    assignment: getField(fm, "assignment") ?? "",
+    updated: getField(fm, "updated") ?? "",
+    body
+  };
+}
+function parseHandoff(fileContent) {
+  const [fm, body] = extractFrontmatter(fileContent);
+  return {
+    assignment: getField(fm, "assignment") ?? "",
+    handoffCount: parseInt(getField(fm, "handoffCount") ?? "0", 10),
+    updated: getField(fm, "updated") ?? "",
+    body
+  };
+}
+function parseDecisionRecord(fileContent) {
+  const [fm, body] = extractFrontmatter(fileContent);
+  return {
+    assignment: getField(fm, "assignment") ?? "",
+    decisionCount: parseInt(getField(fm, "decisionCount") ?? "0", 10),
+    updated: getField(fm, "updated") ?? "",
+    body
+  };
+}
+function parseComments(fileContent) {
+  const [fm, body] = extractFrontmatter(fileContent);
+  const entries = [];
+  const sections = body.split(/^## /m).slice(1);
+  for (const section of sections) {
+    const newlineIdx = section.indexOf("\n");
+    if (newlineIdx === -1) continue;
+    const id = section.slice(0, newlineIdx).trim();
+    const rest = section.slice(newlineIdx + 1);
+    const headerMatch = rest.match(
+      /^\s*\*\*Recorded:\*\*\s*(.*)\n\*\*Author:\*\*\s*(.*)\n\*\*Type:\*\*\s*(question|note|feedback)(?:\n\*\*Reply to:\*\*\s*(.*))?(?:\n\*\*Resolved:\*\*\s*(true|false))?\n+([\s\S]*)$/
+    );
+    if (!headerMatch) continue;
+    const [, timestamp, author, type, replyTo, resolvedStr, entryBody] = headerMatch;
+    const entry = {
+      id,
+      timestamp: timestamp.trim(),
+      author: author.trim(),
+      type,
+      body: entryBody.trim()
+    };
+    if (replyTo) entry.replyTo = replyTo.trim();
+    if (resolvedStr) entry.resolved = resolvedStr === "true";
+    entries.push(entry);
+  }
+  return {
+    assignment: getField(fm, "assignment") ?? "",
+    entryCount: parseInt(getField(fm, "entryCount") ?? "0", 10),
+    updated: getField(fm, "updated") ?? "",
+    entries,
+    body
+  };
+}
+function parseProgress(fileContent) {
+  const [fm, body] = extractFrontmatter(fileContent);
+  const entries = [];
+  const sections = body.split(/^## /m).slice(1);
+  for (const section of sections) {
+    const newlineIdx = section.indexOf("\n");
+    if (newlineIdx === -1) continue;
+    const timestamp = section.slice(0, newlineIdx).trim();
+    const entryBody = section.slice(newlineIdx + 1).trim();
+    entries.push({ timestamp, body: entryBody });
+  }
+  return {
+    assignment: getField(fm, "assignment") ?? "",
+    entryCount: parseInt(getField(fm, "entryCount") ?? "0", 10),
+    updated: getField(fm, "updated") ?? "",
+    entries,
+    body
+  };
+}
+function extractMermaidGraph(body) {
+  const match = body.match(/```mermaid\n([\s\S]*?)```/);
+  return match ? match[1].trim() : null;
+}
+var init_parser = __esm({
+  "src/dashboard/parser.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/assignment-resolver.ts
+import { resolve as resolve4 } from "path";
+import { readdir as readdir2, readFile as readFile3 } from "fs/promises";
+async function resolveAssignmentById(projectsDir, assignmentsDir, id) {
+  let standaloneMatch = null;
+  let projectMatch = null;
+  const standaloneDir = resolve4(assignmentsDir, id);
+  const standalonePath = resolve4(standaloneDir, "assignment.md");
+  if (await fileExists(standalonePath)) {
+    let workspaceGroup = null;
+    try {
+      const content = await readFile3(standalonePath, "utf-8");
+      const [fm] = extractFrontmatter(content);
+      workspaceGroup = getField(fm, "workspaceGroup");
+    } catch {
+    }
+    standaloneMatch = {
+      assignmentDir: standaloneDir,
+      projectSlug: null,
+      assignmentSlug: id,
+      id,
+      standalone: true,
+      workspaceGroup
+    };
+  }
+  if (await fileExists(projectsDir)) {
+    try {
+      const projects = await readdir2(projectsDir, { withFileTypes: true });
+      for (const p of projects) {
+        if (!p.isDirectory()) continue;
+        if (p.name.startsWith(".") || p.name.startsWith("_")) continue;
+        const assignmentsPath = resolve4(projectsDir, p.name, "assignments");
+        if (!await fileExists(assignmentsPath)) continue;
+        const entries = await readdir2(assignmentsPath, { withFileTypes: true });
+        for (const a of entries) {
+          if (!a.isDirectory()) continue;
+          const aPath = resolve4(assignmentsPath, a.name, "assignment.md");
+          if (!await fileExists(aPath)) continue;
+          try {
+            const content = await readFile3(aPath, "utf-8");
+            const [fm] = extractFrontmatter(content);
+            const fileId = getField(fm, "id");
+            if (fileId === id) {
+              projectMatch = {
+                assignmentDir: resolve4(assignmentsPath, a.name),
+                projectSlug: p.name,
+                assignmentSlug: a.name,
+                id,
+                standalone: false,
+                workspaceGroup: null
+              };
+              break;
+            }
+          } catch {
+          }
+        }
+        if (projectMatch) break;
+      }
+    } catch {
+    }
+  }
+  if (standaloneMatch && projectMatch) {
+    console.warn(
+      `Duplicate assignment ID ${id} found in both standalone and project-nested locations; using standalone`
+    );
+    return standaloneMatch;
+  }
+  return standaloneMatch ?? projectMatch ?? null;
+}
+var init_assignment_resolver = __esm({
+  "src/utils/assignment-resolver.ts"() {
+    "use strict";
+    init_fs();
+    init_parser();
+  }
+});
+
+// src/lifecycle/types.ts
+var DEFAULT_STATUSES;
+var init_types = __esm({
+  "src/lifecycle/types.ts"() {
+    "use strict";
+    DEFAULT_STATUSES = [
+      "draft",
+      "pending",
+      "ready_for_planning",
+      "ready_to_implement",
+      "in_progress",
+      "blocked",
+      "review",
+      "completed",
+      "failed"
+    ];
+  }
+});
+
+// src/lifecycle/state-machine.ts
+function buildTransitionTable(transitions) {
+  const table = /* @__PURE__ */ new Map();
+  for (const t of transitions) {
+    table.set(`${t.from}:${t.command}`, t.to);
+  }
+  return table;
+}
+function getTargetStatus(_from, command, table) {
+  if (!table || table === DEFAULT_TRANSITION_TABLE) {
+    return DEFAULT_COMMAND_TARGETS.get(command) ?? null;
+  }
+  return table.get(command) ?? table.get(`${_from}:${command}`) ?? null;
+}
+var DEFAULT_COMMAND_TARGETS, DEFAULT_TRANSITION_TABLE;
+var init_state_machine = __esm({
+  "src/lifecycle/state-machine.ts"() {
+    "use strict";
+    init_types();
+    DEFAULT_COMMAND_TARGETS = /* @__PURE__ */ new Map([
+      ["start", "in_progress"],
+      ["shape", "ready_for_planning"],
+      ["plan-ready", "ready_to_implement"],
+      ["implement", "in_progress"],
+      ["block", "blocked"],
+      ["unblock", "in_progress"],
+      ["review", "review"],
+      ["complete", "completed"],
+      ["fail", "failed"],
+      ["reopen", "in_progress"]
+    ]);
+    DEFAULT_TRANSITION_TABLE = /* @__PURE__ */ new Map([
+      ["pending:start", "in_progress"],
+      ["pending:block", "blocked"],
+      ["draft:shape", "ready_for_planning"],
+      ["draft:start", "in_progress"],
+      ["ready_for_planning:plan-ready", "ready_to_implement"],
+      ["ready_for_planning:start", "in_progress"],
+      ["ready_to_implement:implement", "in_progress"],
+      ["in_progress:block", "blocked"],
+      ["in_progress:review", "review"],
+      ["in_progress:complete", "completed"],
+      ["in_progress:fail", "failed"],
+      ["blocked:unblock", "in_progress"],
+      ["review:start", "in_progress"],
+      ["review:complete", "completed"],
+      ["review:fail", "failed"],
+      ["completed:reopen", "in_progress"],
+      ["failed:reopen", "in_progress"]
+    ]);
+  }
+});
+
+// src/lifecycle/frontmatter.ts
+var init_frontmatter = __esm({
+  "src/lifecycle/frontmatter.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/timestamp.ts
+var init_timestamp = __esm({
+  "src/utils/timestamp.ts"() {
+    "use strict";
+  }
+});
+
+// src/todos/parser.ts
+import { randomBytes } from "crypto";
+import { readFile as readFile4 } from "fs/promises";
+import { resolve as resolve5 } from "path";
+var init_parser2 = __esm({
+  "src/todos/parser.ts"() {
+    "use strict";
+    init_parser();
+    init_fs();
+  }
+});
+
+// src/lifecycle/linked-todos.ts
+import { readdir as readdir3 } from "fs/promises";
+import { resolve as resolve6 } from "path";
+var init_linked_todos = __esm({
+  "src/lifecycle/linked-todos.ts"() {
+    "use strict";
+    init_parser2();
+    init_fs();
+  }
+});
+
+// src/lifecycle/transitions.ts
+import { resolve as resolve7 } from "path";
+import { readFile as readFile5 } from "fs/promises";
+var init_transitions = __esm({
+  "src/lifecycle/transitions.ts"() {
+    "use strict";
+    init_fs();
+    init_timestamp();
+    init_state_machine();
+    init_frontmatter();
+    init_linked_todos();
+  }
+});
+
+// src/lifecycle/index.ts
+var init_lifecycle = __esm({
+  "src/lifecycle/index.ts"() {
+    "use strict";
+    init_types();
+    init_state_machine();
+    init_frontmatter();
+    init_transitions();
+  }
+});
+
+// src/utils/slug.ts
+var init_slug = __esm({
+  "src/utils/slug.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/playbooks.ts
+import { resolve as resolve8 } from "path";
+import { readdir as readdir4, readFile as readFile6, unlink } from "fs/promises";
+var init_playbooks = __esm({
+  "src/utils/playbooks.ts"() {
+    "use strict";
+    init_fs();
+    init_parser();
+    init_timestamp();
+    init_config2();
+    init_slug();
+  }
+});
+
+// src/dashboard/help.ts
+var CLI_COMMANDS, WORKFLOW;
+var init_help = __esm({
+  "src/dashboard/help.ts"() {
+    "use strict";
+    init_api();
+    CLI_COMMANDS = [
+      // --- Core setup & scaffolding (indices 0-4) ---
+      {
+        command: "syntaur setup",
+        description: "Initialize Syntaur and optionally install plugins or launch the dashboard.",
+        example: "syntaur setup"
+      },
+      {
+        command: "syntaur init",
+        description: "Initialize the local Syntaur home directory and config scaffolding without any prompts.",
+        example: "syntaur init"
+      },
+      {
+        command: "syntaur create-project",
+        description: "Create a new project folder with the required source and derived files.",
+        example: 'syntaur create-project "Ship dashboard overhaul"'
+      },
+      {
+        command: "syntaur create-assignment",
+        description: "Create a new assignment inside a project.",
+        example: 'syntaur create-assignment "Implement overview API" --project ui-overhaul'
+      },
+      {
+        command: "syntaur assign",
+        description: "Set the assignee for an assignment before work begins.",
+        example: "syntaur assign implement-overview --project ui-overhaul --agent codex-1"
+      },
+      // --- Lifecycle transitions ---
+      {
+        command: "syntaur start",
+        description: "Transition an assignment to in_progress.",
+        example: "syntaur start implement-overview --project ui-overhaul"
+      },
+      {
+        command: "syntaur shape",
+        description: "Transition a draft assignment to ready_for_planning once the Objective and Acceptance Criteria are fleshed out.",
+        example: "syntaur shape implement-overview --project ui-overhaul"
+      },
+      {
+        command: "syntaur plan-ready",
+        description: "Transition a ready_for_planning assignment to ready_to_implement once a plan has been written and approved.",
+        example: "syntaur plan-ready implement-overview --project ui-overhaul"
+      },
+      {
+        command: "syntaur implement",
+        description: "Transition a ready_to_implement assignment to in_progress when coding begins.",
+        example: "syntaur implement implement-overview --project ui-overhaul"
+      },
+      {
+        command: "syntaur migrate-statuses",
+        description: "Suggest pending -> ready_for_planning promotions for fleshed-out assignments. Dry-run by default; pass --apply to write.",
+        example: "syntaur migrate-statuses --apply"
+      },
+      {
+        command: "syntaur review",
+        description: "Move active work into review once implementation is ready for inspection.",
+        example: "syntaur review implement-overview --project ui-overhaul"
+      },
+      {
+        command: "syntaur complete",
+        description: "Mark an assignment completed after review or direct completion.",
+        example: "syntaur complete implement-overview --project ui-overhaul"
+      },
+      {
+        command: "syntaur block",
+        description: "Mark an assignment blocked and record the explicit reason.",
+        example: 'syntaur block implement-overview --project ui-overhaul --reason "Waiting on API spec"'
+      },
+      {
+        command: "syntaur unblock",
+        description: "Move a blocked assignment back to in_progress after the blocker is cleared.",
+        example: "syntaur unblock implement-overview --project ui-overhaul"
+      },
+      {
+        command: "syntaur fail",
+        description: "Mark an assignment failed when it cannot be completed as planned.",
+        example: "syntaur fail implement-overview --project ui-overhaul"
+      },
+      {
+        command: "syntaur reopen",
+        description: "Reopen a completed or failed assignment back to in_progress.",
+        example: "syntaur reopen implement-overview --project ui-overhaul"
+      },
+      // --- Dashboard (index 12) ---
+      {
+        command: "syntaur dashboard",
+        description: "Start the local dashboard UI over the project files on disk.",
+        example: "syntaur dashboard --port 4800"
+      },
+      // --- Plugin & adapter setup (indices 13-16) ---
+      {
+        command: "syntaur install-plugin",
+        description: "Install the Syntaur Claude Code plugin, detecting the local Claude marketplace when available and prompting for the target directory when interactive.",
+        example: "syntaur install-plugin --target-dir ~/.claude/plugins/marketplaces/user-plugins/plugins/syntaur"
+      },
+      {
+        command: "syntaur install-codex-plugin",
+        description: "Install the Syntaur Codex plugin and register its marketplace entry, prompting for both paths when interactive.",
+        example: "syntaur install-codex-plugin --target-dir ~/plugins/syntaur --marketplace-path ~/.agents/plugins/marketplace.json"
+      },
+      {
+        command: "syntaur uninstall",
+        description: "Remove Syntaur plugins and optionally local ~/.syntaur data.",
+        example: "syntaur uninstall --all"
+      },
+      {
+        command: "syntaur setup-adapter",
+        description: "Generate adapter instruction files for cursor, codex, or opencode in the current directory.",
+        example: "syntaur setup-adapter cursor --project ui-overhaul --assignment implement-overview"
+      },
+      // --- Session & server tracking (index 17) ---
+      {
+        command: "syntaur track-session",
+        description: "Register an agent session. Requires --session-id from the agent runtime (real, not generated). Pass --transcript-path for the rollout/transcript file. --project and --assignment are optional.",
+        example: "syntaur track-session --agent claude --session-id <real-id> --transcript-path <path> --project ui-overhaul --assignment implement-overview"
+      },
+      // --- Browsing & playbooks (indices 18-20) ---
+      {
+        command: "syntaur browse",
+        description: "Interactive TUI browser for projects and assignments.",
+        example: "syntaur browse"
+      },
+      {
+        command: "syntaur create-playbook",
+        description: "Create a new playbook with behavioral rules for agents.",
+        example: 'syntaur create-playbook "Code Review Standards"'
+      },
+      {
+        command: "syntaur list-playbooks",
+        description: "List playbooks in the Syntaur home directory. Disabled playbooks are excluded by default; pass --all to include them with a (disabled) tag.",
+        example: "syntaur list-playbooks --all"
+      },
+      {
+        command: "syntaur enable-playbook",
+        description: "Re-enable a previously-disabled playbook so agents load it again. Updates config.md and rebuilds manifest.md.",
+        example: "syntaur enable-playbook commit-discipline"
+      },
+      {
+        command: "syntaur disable-playbook",
+        description: "Disable a playbook so agents no longer list or load it. Playbook file is untouched; state is tracked in config.md.",
+        example: "syntaur disable-playbook commit-discipline"
+      },
+      {
+        command: "syntaur delete-playbook",
+        description: "Delete a playbook from disk and regenerate the manifest. Refuses to delete the manifest itself.",
+        example: "syntaur delete-playbook scratch-foo"
+      }
+    ];
+    WORKFLOW = [
+      {
+        title: "Initialize the workspace",
+        detail: "Run setup once so Syntaur can initialize its local home directory and offer plugin installation.",
+        command: CLI_COMMANDS[0]
+      },
+      {
+        title: "Create a project",
+        detail: "Use a project for a higher-level objective. Projects group assignments, shared resources, and memories.",
+        command: CLI_COMMANDS[2],
+        href: "/create/project"
+      },
+      {
+        title: "Create the first assignment",
+        detail: "Assignments are the execution unit. Create one for each concrete chunk of work inside the project.",
+        command: CLI_COMMANDS[3]
+      },
+      {
+        title: "Assign the work",
+        detail: "Setting an assignee before starting is recommended for clarity, but not required.",
+        command: CLI_COMMANDS[4]
+      },
+      {
+        title: "Start, review, complete, or block through lifecycle actions",
+        detail: "Status changes happen through lifecycle actions, kanban drag-and-drop, or the status override controls.",
+        command: CLI_COMMANDS[5]
+      },
+      {
+        title: "Use the dashboard for triage and context",
+        detail: "Overview shows the current queue, project pages show health, assignment pages show the execution surface.",
+        command: CLI_COMMANDS[12],
+        href: "/"
+      }
+    ];
+  }
+});
+
+// src/dashboard/session-db.ts
+import Database from "better-sqlite3";
+import { resolve as resolve9 } from "path";
+import { readdir as readdir5 } from "fs/promises";
+function getSessionDb() {
+  if (!db) {
+    throw new Error(
+      "Session database not initialized. Call initSessionDb() first."
+    );
+  }
+  return db;
+}
+var db;
+var init_session_db = __esm({
+  "src/dashboard/session-db.ts"() {
+    "use strict";
+    init_paths();
+    init_fs();
+    db = null;
+  }
+});
+
+// src/dashboard/agent-sessions.ts
+import { readFile as readFile7 } from "fs/promises";
+import { resolve as resolve10 } from "path";
+function rowToSession(row) {
+  return {
+    sessionId: row.session_id,
+    projectSlug: row.project_slug ?? null,
+    assignmentSlug: row.assignment_slug ?? null,
+    agent: row.agent,
+    started: row.started,
+    ended: row.ended ?? null,
+    status: row.status,
+    path: row.path ?? "",
+    description: row.description ?? null,
+    transcriptPath: row.transcript_path ?? null,
+    pid: row.pid ?? null,
+    pidStartedAt: row.pid_started_at ?? null
+  };
+}
+function getSessionById(sessionId) {
+  const db2 = getSessionDb();
+  const row = db2.prepare("SELECT * FROM sessions WHERE session_id = ? LIMIT 1").get(sessionId);
+  return row ? rowToSession(row) : null;
+}
+var init_agent_sessions = __esm({
+  "src/dashboard/agent-sessions.ts"() {
+    "use strict";
+    init_fs();
+    init_session_db();
+  }
+});
+
+// src/dashboard/overviewCopy.ts
+var init_overviewCopy = __esm({
+  "src/dashboard/overviewCopy.ts"() {
+    "use strict";
+  }
+});
+
+// src/dashboard/api.ts
+import { readdir as readdir6, readFile as readFile8, writeFile as writeFile3 } from "fs/promises";
+import { resolve as resolve11, dirname as dirname2, basename } from "path";
+async function listStandaloneRecords(assignmentsDir) {
+  if (!assignmentsDir) return [];
+  if (!await fileExists(assignmentsDir)) return [];
+  const entries = await readdir6(assignmentsDir, { withFileTypes: true });
+  const records = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
+    const assignmentDir = resolve11(assignmentsDir, entry.name);
+    const assignmentMdPath = resolve11(assignmentDir, "assignment.md");
+    if (!await fileExists(assignmentMdPath)) continue;
+    try {
+      const content = await readFile8(assignmentMdPath, "utf-8");
+      const record = parseAssignmentFull(content);
+      records.push({ assignmentDir, id: entry.name, record });
+    } catch {
+    }
+  }
+  records.sort((left, right) => compareTimestamps(right.record.updated, left.record.updated));
+  return records;
+}
+function toTitleCase(s) {
+  return s.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function getTransitionDefinitions(config) {
+  if (!config.custom) return DEFAULT_TRANSITION_DEFINITIONS;
+  const seen = /* @__PURE__ */ new Set();
+  return config.transitions.filter((t) => {
+    if (seen.has(t.command)) return false;
+    seen.add(t.command);
+    return true;
+  }).map((t) => ({
+    command: t.command,
+    label: t.label ?? toTitleCase(t.command),
+    description: t.description ?? `Transition via ${t.command}.`,
+    requiresReason: t.requiresReason ?? false
+  }));
+}
+async function getStatusConfig() {
+  if (_cachedConfig) return _cachedConfig;
+  const config = await readConfig();
+  if (config.statuses) {
+    const terminalSet = new Set(
+      config.statuses.statuses.filter((s) => s.terminal).map((s) => s.id)
+    );
+    _cachedConfig = {
+      custom: true,
+      statuses: config.statuses.statuses,
+      order: config.statuses.order,
+      transitions: config.statuses.transitions,
+      transitionTable: buildTransitionTable(config.statuses.transitions),
+      terminalStatuses: terminalSet.size > 0 ? terminalSet : /* @__PURE__ */ new Set(["completed", "failed"])
+    };
+  } else {
+    _cachedConfig = {
+      custom: false,
+      statuses: DEFAULT_STATUSES.map((id) => ({
+        id,
+        label: toTitleCase(id),
+        color: DEFAULT_STATUS_COLORS[id] ?? "gray",
+        terminal: id === "completed" || id === "failed"
+      })),
+      order: [...DEFAULT_STATUSES],
+      transitions: Array.from(DEFAULT_TRANSITION_TABLE.entries()).map(([key, to]) => {
+        const [from, command] = key.split(":");
+        return { from, command, to };
+      }),
+      transitionTable: DEFAULT_TRANSITION_TABLE,
+      terminalStatuses: /* @__PURE__ */ new Set(["completed", "failed"])
+    };
+  }
+  return _cachedConfig;
+}
+async function getStandaloneAvailableTransitions(assignment) {
+  const config = await getStatusConfig();
+  const transitionDefs = getTransitionDefinitions(config);
+  const actions = [];
+  for (const definition of transitionDefs) {
+    let warning = null;
+    if (definition.command === "start" && !assignment.assignee) {
+      warning = "No assignee set \u2014 consider assigning before starting.";
+    }
+    const target = getTargetStatus(assignment.status, definition.command, config.transitionTable);
+    actions.push({
+      command: definition.command,
+      label: definition.label,
+      description: definition.description,
+      targetStatus: target ?? definition.command,
+      disabled: false,
+      disabledReason: null,
+      warning,
+      requiresReason: definition.requiresReason
+    });
+  }
+  return actions;
+}
+async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
+  const assignmentDir = resolve11(projectsDir, projectSlug, "assignments", assignmentSlug);
+  const assignmentMdPath = resolve11(assignmentDir, "assignment.md");
+  if (!await fileExists(assignmentMdPath)) {
+    return null;
+  }
+  const assignmentContent = await readFile8(assignmentMdPath, "utf-8");
+  const assignment = parseAssignmentFull(assignmentContent);
+  let projectWorkspace = null;
+  const projectMdPath = resolve11(projectsDir, projectSlug, "project.md");
+  if (await fileExists(projectMdPath)) {
+    const projectContent = await readFile8(projectMdPath, "utf-8");
+    projectWorkspace = parseProject(projectContent).workspace;
+  }
+  let plan = null;
+  const planPath = resolve11(assignmentDir, "plan.md");
+  if (await fileExists(planPath)) {
+    const planContent = await readFile8(planPath, "utf-8");
+    const parsed = parsePlan(planContent);
+    plan = {
+      status: parsed.status,
+      updated: parsed.updated,
+      body: parsed.body
+    };
+  }
+  let scratchpad = null;
+  const scratchpadPath = resolve11(assignmentDir, "scratchpad.md");
+  if (await fileExists(scratchpadPath)) {
+    const scratchpadContent = await readFile8(scratchpadPath, "utf-8");
+    const parsed = parseScratchpad(scratchpadContent);
+    scratchpad = {
+      updated: parsed.updated,
+      body: parsed.body
+    };
+  }
+  let handoff = null;
+  const handoffPath = resolve11(assignmentDir, "handoff.md");
+  if (await fileExists(handoffPath)) {
+    const handoffContent = await readFile8(handoffPath, "utf-8");
+    const parsed = parseHandoff(handoffContent);
+    handoff = {
+      updated: parsed.updated,
+      handoffCount: parsed.handoffCount,
+      body: parsed.body
+    };
+  }
+  let decisionRecord = null;
+  const decisionRecordPath = resolve11(assignmentDir, "decision-record.md");
+  if (await fileExists(decisionRecordPath)) {
+    const decisionRecordContent = await readFile8(decisionRecordPath, "utf-8");
+    const parsed = parseDecisionRecord(decisionRecordContent);
+    decisionRecord = {
+      updated: parsed.updated,
+      decisionCount: parsed.decisionCount,
+      body: parsed.body
+    };
+  }
+  let progress = null;
+  const progressPath = resolve11(assignmentDir, "progress.md");
+  if (await fileExists(progressPath)) {
+    const progressContent = await readFile8(progressPath, "utf-8");
+    const parsed = parseProgress(progressContent);
+    progress = {
+      updated: parsed.updated,
+      entryCount: parsed.entryCount,
+      entries: parsed.entries
+    };
+  }
+  let comments = null;
+  const commentsPath = resolve11(assignmentDir, "comments.md");
+  if (await fileExists(commentsPath)) {
+    const commentsContent = await readFile8(commentsPath, "utf-8");
+    const parsed = parseComments(commentsContent);
+    comments = {
+      updated: parsed.updated,
+      entryCount: parsed.entryCount,
+      entries: parsed.entries
+    };
+  }
+  const detail = {
+    id: assignment.id,
+    projectSlug,
+    slug: assignment.slug || assignmentSlug,
+    title: assignment.title,
+    status: assignment.status,
+    priority: assignment.priority,
+    assignee: assignment.assignee,
+    dependsOn: assignment.dependsOn,
+    links: assignment.links,
+    reverseLinks: [],
+    enrichedLinks: [],
+    blockedReason: assignment.blockedReason,
+    workspace: assignment.workspace,
+    projectWorkspace,
+    externalIds: assignment.externalIds,
+    tags: assignment.tags,
+    created: assignment.created,
+    updated: assignment.updated,
+    body: assignment.body,
+    plan,
+    scratchpad,
+    handoff,
+    decisionRecord,
+    progress,
+    comments,
+    referencedBy: [],
+    availableTransitions: await getAvailableTransitions(
+      projectsDir,
+      projectSlug,
+      assignmentSlug,
+      assignment
+    )
+  };
+  const selfSlug = `${projectSlug}/${detail.slug}`;
+  const projectRecords = await listProjectRecords(projectsDir);
+  const reverseLinks = [];
+  for (const mr of projectRecords) {
+    for (const a of mr.assignments) {
+      const qualifiedSlug = `${mr.summary.slug}/${a.slug}`;
+      if (qualifiedSlug === selfSlug) continue;
+      if (a.links.includes(selfSlug)) {
+        reverseLinks.push(qualifiedSlug);
+      }
+    }
+  }
+  const isValidLinkFormat = (l) => {
+    const parts = l.split("/");
+    return parts.length === 2 && parts[0].length > 0 && parts[1].length > 0;
+  };
+  const forwardLinks = assignment.links.filter((l) => l !== selfSlug && isValidLinkFormat(l));
+  const forwardSet = new Set(forwardLinks);
+  const dedupedReverseLinks = reverseLinks.filter((l) => !forwardSet.has(l));
+  detail.links = forwardLinks;
+  detail.reverseLinks = dedupedReverseLinks;
+  const allProjectAssignments = /* @__PURE__ */ new Map();
+  for (const mr of projectRecords) {
+    for (const a of mr.assignments) {
+      allProjectAssignments.set(`${mr.summary.slug}/${a.slug}`, {
+        title: a.title,
+        status: a.status
+      });
+    }
+  }
+  const enrichedLinks = [];
+  for (const linkSlug of forwardLinks) {
+    const [ms, as] = linkSlug.split("/");
+    const info = allProjectAssignments.get(linkSlug);
+    enrichedLinks.push({
+      slug: linkSlug,
+      projectSlug: ms,
+      assignmentSlug: as,
+      title: info?.title ?? linkSlug,
+      status: info?.status ?? "pending",
+      isReverse: false
+    });
+  }
+  for (const linkSlug of dedupedReverseLinks) {
+    const [ms, as] = linkSlug.split("/");
+    const info = allProjectAssignments.get(linkSlug);
+    enrichedLinks.push({
+      slug: linkSlug,
+      projectSlug: ms,
+      assignmentSlug: as,
+      title: info?.title ?? linkSlug,
+      status: info?.status ?? "pending",
+      isReverse: true
+    });
+  }
+  detail.enrichedLinks = enrichedLinks;
+  detail.referencedBy = await computeReferencedBy(
+    { id: assignment.id, projectSlug, slug: detail.slug },
+    projectsDir,
+    void 0
+  );
+  return detail;
+}
+async function computeReferencedBy(target, projectsDir, assignmentsDir) {
+  const sources = [];
+  const projectRecords = await listProjectRecords(projectsDir);
+  for (const rec of projectRecords) {
+    for (const a of rec.assignments) {
+      sources.push({
+        id: a.id,
+        slug: a.slug,
+        title: a.title,
+        projectSlug: rec.summary.slug,
+        assignmentDir: resolve11(rec.projectPath, "assignments", a.slug)
+      });
+    }
+  }
+  const standaloneRecords = await listStandaloneRecords(assignmentsDir);
+  for (const sr of standaloneRecords) {
+    sources.push({
+      id: sr.id,
+      slug: sr.record.slug || sr.id,
+      title: sr.record.title,
+      projectSlug: null,
+      assignmentDir: sr.assignmentDir
+    });
+  }
+  const references = [];
+  for (const source of sources) {
+    if (source.id === target.id) continue;
+    const mentions = await countMentionsInAssignment(source.assignmentDir, target);
+    if (mentions > 0) {
+      references.push({
+        sourceId: source.id,
+        sourceSlug: source.slug,
+        sourceTitle: source.title,
+        sourceProjectSlug: source.projectSlug,
+        mentions
+      });
+    }
+    if (references.length >= REFERENCED_BY_LIMIT) break;
+  }
+  return references.slice(0, REFERENCED_BY_LIMIT);
+}
+async function countMentionsInAssignment(sourceDir, target) {
+  const bodies = [];
+  const assignmentMd = resolve11(sourceDir, "assignment.md");
+  if (await fileExists(assignmentMd)) {
+    const content = await readFile8(assignmentMd, "utf-8");
+    const todosMatch = content.match(/^## Todos\s*$([\s\S]*?)(?=^## |$(?![\r\n]))/m);
+    if (todosMatch) bodies.push(todosMatch[1]);
+  }
+  for (const filename of ["progress.md", "comments.md", "handoff.md"]) {
+    const path = resolve11(sourceDir, filename);
+    if (await fileExists(path)) {
+      try {
+        bodies.push(await readFile8(path, "utf-8"));
+      } catch {
+      }
+    }
+  }
+  let total = 0;
+  const patterns = buildLinkPatternsForTarget(target);
+  for (const body of bodies) {
+    for (const pattern of patterns) {
+      const matches = body.match(pattern);
+      if (matches) total += matches.length;
+    }
+  }
+  return total;
+}
+function buildLinkPatternsForTarget(target) {
+  const patterns = [];
+  patterns.push(new RegExp(`/assignments/${escapeRegExpLocal(target.id)}(?:/|\\b)`, "g"));
+  if (target.projectSlug) {
+    patterns.push(
+      new RegExp(
+        `/projects/${escapeRegExpLocal(target.projectSlug)}/assignments/${escapeRegExpLocal(target.slug)}(?:/|\\b)`,
+        "g"
+      )
+    );
+    patterns.push(
+      new RegExp(`\\.\\./${escapeRegExpLocal(target.slug)}(?:/|\\b)`, "g")
+    );
+  }
+  return patterns;
+}
+function escapeRegExpLocal(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function getAssignmentDetailById(projectsDir, assignmentsDir, id) {
+  const resolved = await resolveAssignmentById(projectsDir, assignmentsDir, id);
+  if (!resolved) return null;
+  if (!resolved.standalone && resolved.projectSlug) {
+    const detail = await getAssignmentDetail(projectsDir, resolved.projectSlug, resolved.assignmentSlug);
+    if (!detail) return null;
+    detail.referencedBy = await computeReferencedBy(
+      { id: detail.id, projectSlug: detail.projectSlug, slug: detail.slug },
+      projectsDir,
+      assignmentsDir
+    );
+    return detail;
+  }
+  const standaloneDetail = await buildStandaloneAssignmentDetail(resolved);
+  if (!standaloneDetail) return null;
+  standaloneDetail.referencedBy = await computeReferencedBy(
+    { id: standaloneDetail.id, projectSlug: null, slug: standaloneDetail.slug },
+    projectsDir,
+    assignmentsDir
+  );
+  return standaloneDetail;
+}
+async function buildStandaloneAssignmentDetail(resolved) {
+  const assignmentDir = resolved.assignmentDir;
+  const assignmentMdPath = resolve11(assignmentDir, "assignment.md");
+  if (!await fileExists(assignmentMdPath)) return null;
+  const assignmentContent = await readFile8(assignmentMdPath, "utf-8");
+  const assignment = parseAssignmentFull(assignmentContent);
+  let plan = null;
+  const planPath = resolve11(assignmentDir, "plan.md");
+  if (await fileExists(planPath)) {
+    const parsed = parsePlan(await readFile8(planPath, "utf-8"));
+    plan = { status: parsed.status, updated: parsed.updated, body: parsed.body };
+  }
+  let scratchpad = null;
+  const scratchpadPath = resolve11(assignmentDir, "scratchpad.md");
+  if (await fileExists(scratchpadPath)) {
+    const parsed = parseScratchpad(await readFile8(scratchpadPath, "utf-8"));
+    scratchpad = { updated: parsed.updated, body: parsed.body };
+  }
+  let handoff = null;
+  const handoffPath = resolve11(assignmentDir, "handoff.md");
+  if (await fileExists(handoffPath)) {
+    const parsed = parseHandoff(await readFile8(handoffPath, "utf-8"));
+    handoff = { updated: parsed.updated, handoffCount: parsed.handoffCount, body: parsed.body };
+  }
+  let decisionRecord = null;
+  const decisionRecordPath = resolve11(assignmentDir, "decision-record.md");
+  if (await fileExists(decisionRecordPath)) {
+    const parsed = parseDecisionRecord(await readFile8(decisionRecordPath, "utf-8"));
+    decisionRecord = { updated: parsed.updated, decisionCount: parsed.decisionCount, body: parsed.body };
+  }
+  let progress = null;
+  const progressPath = resolve11(assignmentDir, "progress.md");
+  if (await fileExists(progressPath)) {
+    const parsed = parseProgress(await readFile8(progressPath, "utf-8"));
+    progress = { updated: parsed.updated, entryCount: parsed.entryCount, entries: parsed.entries };
+  }
+  let comments = null;
+  const commentsPath = resolve11(assignmentDir, "comments.md");
+  if (await fileExists(commentsPath)) {
+    const parsed = parseComments(await readFile8(commentsPath, "utf-8"));
+    comments = { updated: parsed.updated, entryCount: parsed.entryCount, entries: parsed.entries };
+  }
+  const detail = {
+    id: assignment.id,
+    projectSlug: null,
+    slug: assignment.slug || resolved.id,
+    title: assignment.title,
+    status: assignment.status,
+    priority: assignment.priority,
+    assignee: assignment.assignee,
+    dependsOn: [],
+    // standalone cannot declare dependencies
+    links: [],
+    reverseLinks: [],
+    enrichedLinks: [],
+    blockedReason: assignment.blockedReason,
+    workspace: assignment.workspace,
+    projectWorkspace: assignment.workspaceGroup,
+    externalIds: assignment.externalIds,
+    tags: assignment.tags,
+    created: assignment.created,
+    updated: assignment.updated,
+    body: assignment.body,
+    plan,
+    scratchpad,
+    handoff,
+    decisionRecord,
+    progress,
+    comments,
+    referencedBy: [],
+    availableTransitions: await getStandaloneAvailableTransitions(assignment)
+  };
+  return detail;
+}
+async function listProjectRecords(projectsDir) {
+  if (!await fileExists(projectsDir)) {
+    return [];
+  }
+  if (!migratedProjectsDirs.has(projectsDir)) {
+    migratedProjectsDirs.add(projectsDir);
+    await migrateLegacyProjectFiles(projectsDir);
+  }
+  const entries = await readdir6(projectsDir, { withFileTypes: true });
+  const projectDirs = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
+  const records = [];
+  for (const entry of projectDirs) {
+    const projectPath = resolve11(projectsDir, entry.name);
+    const projectMdPath = resolve11(projectPath, "project.md");
+    if (!await fileExists(projectMdPath)) {
+      continue;
+    }
+    const projectContent = await readFile8(projectMdPath, "utf-8");
+    const project = parseProject(projectContent);
+    const assignments = await listAssignmentRecords(projectPath);
+    const rollup = await buildProjectRollup(projectPath, project, assignments);
+    const updated = getProjectActivityTimestamp(project.updated, assignments);
+    records.push({
+      projectPath,
+      project,
+      assignments,
+      dependencyGraph: await loadDependencyGraph(projectPath, assignments),
+      summary: {
+        slug: project.slug || entry.name,
+        title: project.title,
+        status: rollup.status,
+        statusOverride: project.statusOverride,
+        archived: project.archived,
+        archivedAt: project.archivedAt,
+        archivedReason: project.archivedReason,
+        created: project.created,
+        updated,
+        tags: project.tags,
+        progress: rollup.progress,
+        needsAttention: rollup.needsAttention,
+        workspace: project.workspace
+      }
+    });
+  }
+  records.sort((left, right) => compareTimestamps(right.summary.updated, left.summary.updated));
+  return records;
+}
+async function listAssignmentRecords(projectPath) {
+  const assignmentsDir = resolve11(projectPath, "assignments");
+  if (!await fileExists(assignmentsDir)) {
+    return [];
+  }
+  const entries = await readdir6(assignmentsDir, { withFileTypes: true });
+  const records = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const assignmentMd = resolve11(assignmentsDir, entry.name, "assignment.md");
+    if (!await fileExists(assignmentMd)) {
+      continue;
+    }
+    const content = await readFile8(assignmentMd, "utf-8");
+    records.push(parseAssignmentFull(content));
+  }
+  records.sort((left, right) => compareTimestamps(right.updated, left.updated));
+  return records;
+}
+async function loadDependencyGraph(projectPath, assignments) {
+  const statusPath = resolve11(projectPath, "_status.md");
+  if (await fileExists(statusPath)) {
+    const statusContent = await readFile8(statusPath, "utf-8");
+    const parsed = parseStatus(statusContent);
+    const derivedGraph = extractMermaidGraph(parsed.body);
+    if (derivedGraph) {
+      return derivedGraph;
+    }
+  }
+  return buildDependencyGraph(assignments);
+}
+async function buildProjectRollup(projectPath, project, assignments) {
+  const progress = { total: assignments.length };
+  let openQuestions = 0;
+  for (const assignment of assignments) {
+    const s = assignment.status;
+    progress[s] = (progress[s] ?? 0) + 1;
+    openQuestions += await countOpenQuestions(projectPath, assignment.slug);
+  }
+  const needsAttention = {
+    blockedCount: progress["blocked"] ?? 0,
+    failedCount: progress["failed"] ?? 0,
+    openQuestions
+  };
+  let status = "pending";
+  if (project.statusOverride) {
+    status = project.statusOverride;
+  } else if (project.archived) {
+    status = "archived";
+  } else if (progress.total > 0 && (progress["completed"] ?? 0) === progress.total) {
+    status = "completed";
+  } else if ((progress["in_progress"] ?? 0) > 0 || (progress["review"] ?? 0) > 0) {
+    status = "active";
+  } else if ((progress["failed"] ?? 0) > 0) {
+    status = "failed";
+  } else if ((progress["blocked"] ?? 0) > 0) {
+    status = "blocked";
+  } else if (progress.total === 0 || (progress["pending"] ?? 0) === progress.total) {
+    status = "pending";
+  } else {
+    status = "active";
+  }
+  return { progress, needsAttention, status };
+}
+function buildDependencyGraph(assignments) {
+  const edges = [];
+  const usedStatuses = /* @__PURE__ */ new Set();
+  for (const assignment of assignments) {
+    for (const dependency of assignment.dependsOn) {
+      const depStatus = findAssignmentStatus(assignments, dependency);
+      usedStatuses.add(depStatus);
+      usedStatuses.add(assignment.status);
+      edges.push(
+        `    ${dependency}:::${depStatus} --> ${assignment.slug}:::${assignment.status}`
+      );
+    }
+  }
+  if (edges.length === 0) {
+    return null;
+  }
+  const classDefs = [];
+  for (const status of usedStatuses) {
+    const colors = DEFAULT_GRAPH_COLORS[status] ?? "fill:#94a3b8,stroke:#64748b,color:#ffffff";
+    classDefs.push(`    classDef ${status} ${colors}`);
+  }
+  return ["graph TD", ...edges, ...classDefs].join("\n");
+}
+function findAssignmentStatus(assignments, slug) {
+  return assignments.find((assignment) => assignment.slug === slug)?.status ?? "pending";
+}
+async function getAvailableTransitions(projectsDir, projectSlug, assignmentSlug, assignment) {
+  const config = await getStatusConfig();
+  const transitionDefs = getTransitionDefinitions(config);
+  const actions = [];
+  const projectPath = resolve11(projectsDir, projectSlug);
+  for (const definition of transitionDefs) {
+    let warning = null;
+    if (definition.command === "start" && !assignment.assignee) {
+      warning = "No assignee set \u2014 consider assigning before starting.";
+    }
+    if (definition.command === "start" && assignment.dependsOn.length > 0) {
+      const unmetDependencies = await getUnmetDependencies(projectPath, assignment.dependsOn, config.terminalStatuses);
+      if (unmetDependencies.length > 0) {
+        warning = `Unmet dependencies: ${unmetDependencies.join(", ")}.`;
+      }
+    }
+    const target = getTargetStatus(assignment.status, definition.command, config.transitionTable);
+    actions.push({
+      command: definition.command,
+      label: definition.label,
+      description: definition.description,
+      targetStatus: target ?? definition.command,
+      disabled: false,
+      disabledReason: null,
+      warning,
+      requiresReason: definition.requiresReason
+    });
+  }
+  return actions;
+}
+async function getUnmetDependencies(projectPath, dependsOn, terminalStatuses) {
+  const terminals = terminalStatuses ?? /* @__PURE__ */ new Set(["completed"]);
+  const unmet = [];
+  for (const dependency of dependsOn) {
+    const dependencyPath = resolve11(projectPath, "assignments", dependency, "assignment.md");
+    if (!await fileExists(dependencyPath)) {
+      unmet.push(`${dependency} (missing)`);
+      continue;
+    }
+    const content = await readFile8(dependencyPath, "utf-8");
+    const parsed = parseAssignmentFull(content);
+    if (!terminals.has(parsed.status)) {
+      unmet.push(`${dependency} (${parsed.status})`);
+    }
+  }
+  return unmet;
+}
+function compareTimestamps(left, right) {
+  return parseTimestamp(left) - parseTimestamp(right);
+}
+function parseTimestamp(timestamp) {
+  const parsed = Date.parse(timestamp);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+async function countOpenQuestions(projectPath, assignmentSlug) {
+  const commentsPath = resolve11(
+    projectPath,
+    "assignments",
+    assignmentSlug,
+    "comments.md"
+  );
+  if (!await fileExists(commentsPath)) {
+    return 0;
+  }
+  try {
+    const content = await readFile8(commentsPath, "utf-8");
+    const parsed = parseComments(content);
+    return parsed.entries.filter(
+      (e) => e.type === "question" && e.resolved !== true
+    ).length;
+  } catch {
+    return 0;
+  }
+}
+function getProjectActivityTimestamp(projectUpdated, assignments) {
+  let latest = projectUpdated;
+  for (const assignment of assignments) {
+    if (compareTimestamps(assignment.updated, latest) > 0) {
+      latest = assignment.updated;
+    }
+  }
+  return latest;
+}
+var STALE_ASSIGNMENT_MS, DEFAULT_TRANSITION_DEFINITIONS, DEFAULT_STATUS_COLORS, _cachedConfig, REFERENCED_BY_LIMIT, migratedProjectsDirs, DEFAULT_GRAPH_COLORS;
+var init_api = __esm({
+  "src/dashboard/api.ts"() {
+    "use strict";
+    init_lifecycle();
+    init_fs();
+    init_timestamp();
+    init_config2();
+    init_playbooks();
+    init_fs_migration();
+    init_assignment_resolver();
+    init_parser();
+    init_help();
+    init_agent_sessions();
+    init_overviewCopy();
+    STALE_ASSIGNMENT_MS = 7 * 24 * 60 * 60 * 1e3;
+    DEFAULT_TRANSITION_DEFINITIONS = [
+      {
+        command: "start",
+        label: "Start",
+        description: "Move pending or review work into active execution.",
+        requiresReason: false
+      },
+      {
+        command: "shape",
+        label: "Shape",
+        description: "Promote a draft assignment to ready_for_planning once the Objective and Acceptance Criteria are fleshed out.",
+        requiresReason: false
+      },
+      {
+        command: "plan-ready",
+        label: "Plan Ready",
+        description: "Promote a ready_for_planning assignment to ready_to_implement after the plan is written and approved.",
+        requiresReason: false
+      },
+      {
+        command: "implement",
+        label: "Implement",
+        description: "Move a ready_to_implement assignment into in_progress when coding begins.",
+        requiresReason: false
+      },
+      {
+        command: "review",
+        label: "Send To Review",
+        description: "Mark the assignment ready for inspection.",
+        requiresReason: false
+      },
+      {
+        command: "complete",
+        label: "Complete",
+        description: "Mark the assignment done.",
+        requiresReason: false
+      },
+      {
+        command: "block",
+        label: "Block",
+        description: "Record an exceptional blocker and pause work.",
+        requiresReason: true
+      },
+      {
+        command: "unblock",
+        label: "Unblock",
+        description: "Resume active work after the blocker is cleared.",
+        requiresReason: false
+      },
+      {
+        command: "fail",
+        label: "Fail",
+        description: "Mark the assignment as failed when it cannot be completed as planned.",
+        requiresReason: false
+      },
+      {
+        command: "reopen",
+        label: "Reopen",
+        description: "Reopen a completed or failed assignment to resume work.",
+        requiresReason: false
+      }
+    ];
+    DEFAULT_STATUS_COLORS = {
+      pending: "slate",
+      in_progress: "teal",
+      blocked: "amber",
+      review: "violet",
+      completed: "emerald",
+      failed: "rose"
+    };
+    _cachedConfig = null;
+    REFERENCED_BY_LIMIT = 50;
+    migratedProjectsDirs = /* @__PURE__ */ new Set();
+    DEFAULT_GRAPH_COLORS = {
+      completed: "fill:#4ea84f,stroke:#1f6b29,color:#ffffff",
+      in_progress: "fill:#1e6fd9,stroke:#0f3f8f,color:#ffffff",
+      pending: "fill:#c0ccd9,stroke:#738399,color:#163047",
+      blocked: "fill:#db5a3f,stroke:#8d2815,color:#ffffff",
+      failed: "fill:#9f2d2d,stroke:#651616,color:#ffffff",
+      review: "fill:#c6911e,stroke:#7a5a10,color:#ffffff"
+    };
+  }
+});
+
+// src/launch/url.ts
+var OpenUrlError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "OpenUrlError";
+  }
+};
+var SESSION_MODES = ["resume", "fork"];
+function parseOpenUrl(input) {
+  let url;
+  try {
+    url = new URL(input);
+  } catch {
+    throw new OpenUrlError(
+      "malformed",
+      `Could not parse URL: ${JSON.stringify(input)}`
+    );
+  }
+  if (url.protocol !== "syntaur:") {
+    throw new OpenUrlError(
+      "bad-scheme",
+      `Expected scheme 'syntaur:' but got '${url.protocol}'`
+    );
+  }
+  if (url.hostname !== "open") {
+    throw new OpenUrlError(
+      "bad-host",
+      `Expected host 'open' but got '${url.hostname}'`
+    );
+  }
+  const assignmentVals = url.searchParams.getAll("assignment");
+  const sessionVals = url.searchParams.getAll("session");
+  if (assignmentVals.length > 1) {
+    throw new OpenUrlError(
+      "duplicate-param",
+      "URL has more than one `assignment` query param"
+    );
+  }
+  if (sessionVals.length > 1) {
+    throw new OpenUrlError(
+      "duplicate-param",
+      "URL has more than one `session` query param"
+    );
+  }
+  if (assignmentVals.length === 1 && sessionVals.length === 1) {
+    throw new OpenUrlError(
+      "both-ids",
+      "URL has both `assignment` and `session` query params \u2014 only one is allowed"
+    );
+  }
+  if (assignmentVals.length === 1) {
+    const id = assignmentVals[0];
+    if (id.trim() === "") {
+      throw new OpenUrlError(
+        "missing-id",
+        "`assignment` query param is empty"
+      );
+    }
+    return { kind: "assignment", id };
+  }
+  if (sessionVals.length === 1) {
+    const id = sessionVals[0];
+    if (id.trim() === "") {
+      throw new OpenUrlError("missing-id", "`session` query param is empty");
+    }
+    const modeVals = url.searchParams.getAll("mode");
+    if (modeVals.length > 1) {
+      throw new OpenUrlError(
+        "duplicate-param",
+        "URL has more than one `mode` query param"
+      );
+    }
+    let mode = "resume";
+    if (modeVals.length === 1) {
+      const raw = modeVals[0];
+      if (!SESSION_MODES.includes(raw)) {
+        throw new OpenUrlError(
+          "bad-mode",
+          `\`mode\` must be one of ${SESSION_MODES.join("|")} (got "${raw}")`
+        );
+      }
+      mode = raw;
+    }
+    return { kind: "session", id, mode };
+  }
+  throw new OpenUrlError(
+    "missing-id",
+    "URL must include either `assignment=<id>` or `session=<id>`"
+  );
+}
+
+// src/launch/plan.ts
+init_config2();
+init_assignment_resolver();
+init_api();
+import { isAbsolute as isAbsolute4 } from "path";
+
+// src/tui/launch.ts
+init_api();
+import { spawn } from "child_process";
+import { mkdir as mkdir2, writeFile as writeFile4 } from "fs/promises";
+import { isAbsolute as isAbsolute2, resolve as resolve12 } from "path";
+var INITIAL_PROMPT = (params) => {
+  if (params.projectSlug) {
+    return `/grab-assignment ${params.projectSlug} ${params.assignmentSlug}`;
+  }
+  if (params.id) {
+    return `/grab-assignment --id ${params.id}`;
+  }
+  return `/grab-assignment ${params.assignmentSlug}`;
+};
+function formatFallbackCwdWarning(opts) {
+  const missing = [];
+  if (!opts.worktreePath) missing.push("worktreePath");
+  if (!opts.branch) missing.push("branch");
+  if (missing.length === 0) return null;
+  const fields = missing.map((m) => `workspace.${m}`).join(" and ");
+  return `syntaur: ${fields} not set for ${opts.assignmentSlug} \u2014 launching in ${opts.workspaceDir}`;
+}
+function shellQuote(arg) {
+  if (arg === "") return "''";
+  return `'${arg.replace(/'/g, `'\\''`)}'`;
+}
+function buildAgentArgv(agent, prompt, env = process.env) {
+  const position = agent.promptArgPosition ?? "first";
+  const baseArgs = [...agent.args ?? []];
+  const agentArgs = position === "first" ? [prompt, ...baseArgs] : position === "last" ? [...baseArgs, prompt] : baseArgs;
+  if (agent.resolveFromShellAliases) {
+    const requested = env.SHELL;
+    let shell = requested;
+    let warning = null;
+    if (!shell || !isAbsolute2(shell)) {
+      warning = `syntaur: $SHELL ${requested ? `("${requested}") is not absolute` : "is unset"} \u2014 falling back to /bin/sh for shell-alias resolution`;
+      shell = "/bin/sh";
+    }
+    const quoted = [agent.command, ...agentArgs].map(shellQuote).join(" ");
+    return {
+      argv: { command: shell, args: ["-i", "-c", quoted] },
+      shellFallbackWarning: warning
+    };
+  }
+  return {
+    argv: { command: agent.command, args: agentArgs },
+    shellFallbackWarning: null
+  };
+}
+
+// src/launch/plan.ts
+init_agent_sessions();
+
+// src/launch/argv.ts
+import { isAbsolute as isAbsolute3 } from "path";
+var buildFreshArgv = buildAgentArgv;
+function buildSessionArgv(agent, sessionId, mode, env = process.env) {
+  const invocation = agent[mode];
+  if (!invocation) {
+    throw new LaunchError(
+      "mode-not-supported",
+      `Agent "${agent.id}" does not support ${mode} (no agent.${mode} configured)`
+    );
+  }
+  const substituted = invocation.args.map(
+    (a) => a === "{id}" ? sessionId : a
+  );
+  const command = invocation.command ?? agent.command;
+  const agentArgs = [...agent.args ?? [], ...substituted];
+  if (agent.resolveFromShellAliases) {
+    const requested = env.SHELL;
+    let shell = requested;
+    let warning = null;
+    if (!shell || !isAbsolute3(shell)) {
+      warning = `syntaur: $SHELL ${requested ? `("${requested}") is not absolute` : "is unset"} \u2014 falling back to /bin/sh for shell-alias resolution`;
+      shell = "/bin/sh";
+    }
+    const quoted = [command, ...agentArgs].map(shellQuote).join(" ");
+    return {
+      argv: { command: shell, args: ["-i", "-c", quoted] },
+      shellFallbackWarning: warning
+    };
+  }
+  return {
+    argv: { command, args: agentArgs },
+    shellFallbackWarning: null
+  };
+}
+
+// src/launch/plan.ts
+var LaunchError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "LaunchError";
+  }
+};
+function pickAgent(config) {
+  const agents = getAgents(config);
+  if (agents.length === 0) {
+    throw new LaunchError(
+      "no-agents-configured",
+      "No agents in ~/.syntaur/config.md. Run `syntaur agents add` to configure one."
+    );
+  }
+  return agents.find((a) => a.default) ?? agents[0];
+}
+async function resolveLaunchPlan(input) {
+  const terminal = getTerminal(input.config);
+  if (input.kind === "assignment") {
+    return resolveAssignmentPlan(input, terminal);
+  }
+  return resolveSessionPlan(input, terminal);
+}
+async function resolveAssignmentPlan(input, terminal) {
+  const resolved = await resolveAssignmentById(
+    input.projectsDir,
+    input.assignmentsDir,
+    input.id
+  );
+  if (!resolved) {
+    throw new LaunchError(
+      "assignment-not-found",
+      `Assignment with id ${JSON.stringify(input.id)} not found`
+    );
+  }
+  const detail = await getAssignmentDetailById(
+    input.projectsDir,
+    input.assignmentsDir,
+    input.id
+  );
+  if (!detail) {
+    throw new LaunchError(
+      "assignment-not-found",
+      `Assignment ${input.id} resolver returned a directory but detail could not be loaded`
+    );
+  }
+  const { cwd, fallbackWarning } = pickCwd({
+    worktreePath: detail.workspace.worktreePath,
+    repository: detail.workspace.repository,
+    branch: detail.workspace.branch,
+    assignmentSlug: resolved.assignmentSlug,
+    fallbackPath: process.cwd()
+  });
+  const agent = pickAgent(input.config);
+  const { argv, shellFallbackWarning } = buildFreshArgv(
+    agent,
+    INITIAL_PROMPT({
+      projectSlug: resolved.projectSlug,
+      assignmentSlug: resolved.assignmentSlug,
+      id: resolved.id
+    })
+  );
+  return {
+    terminal,
+    cwd,
+    argv,
+    env: process.env,
+    agentId: agent.id,
+    fallbackWarning,
+    shellFallbackWarning
+  };
+}
+async function resolveSessionPlan(input, terminal) {
+  const session = getSessionById(input.id);
+  if (!session) {
+    throw new LaunchError(
+      "session-not-found",
+      `Session with id ${JSON.stringify(input.id)} not found`
+    );
+  }
+  let cwd = session.path;
+  let fallbackWarning = null;
+  if (session.projectSlug && session.assignmentSlug) {
+    const detail = await getAssignmentDetail(
+      input.projectsDir,
+      session.projectSlug,
+      session.assignmentSlug
+    );
+    if (detail) {
+      const picked = pickCwd({
+        worktreePath: detail.workspace.worktreePath,
+        repository: detail.workspace.repository,
+        branch: detail.workspace.branch,
+        assignmentSlug: session.assignmentSlug,
+        fallbackPath: session.path
+      });
+      cwd = picked.cwd;
+      fallbackWarning = picked.fallbackWarning;
+    }
+  }
+  const agent = getAgents(input.config).find((a) => a.id === session.agent);
+  if (!agent) {
+    throw new LaunchError(
+      "agent-not-configured",
+      `Session ${input.id} was started with agent "${session.agent}" which is not in your agents list. Run \`syntaur agents add ${session.agent}\` or pick a different session.`
+    );
+  }
+  const { argv, shellFallbackWarning } = buildSessionArgv(
+    agent,
+    session.sessionId,
+    input.mode ?? "resume"
+  );
+  return {
+    terminal,
+    cwd,
+    argv,
+    env: process.env,
+    agentId: agent.id,
+    fallbackWarning,
+    shellFallbackWarning
+  };
+}
+function pickCwd(input) {
+  if (input.worktreePath && isAbsolute4(input.worktreePath)) {
+    return { cwd: input.worktreePath, fallbackWarning: null };
+  }
+  const workspaceDir = input.repository && isAbsolute4(input.repository) ? input.repository : input.fallbackPath;
+  const fallbackWarning = formatFallbackCwdWarning({
+    assignmentSlug: input.assignmentSlug,
+    workspaceDir,
+    worktreePath: input.worktreePath,
+    branch: input.branch
+  });
+  return { cwd: workspaceDir, fallbackWarning };
+}
+
+// src/launch/execute.ts
+import { spawn as spawn2 } from "child_process";
+var TerminalNotFoundError = class extends Error {
+  terminal;
+  remediation;
+  constructor(terminal, remediation) {
+    super(
+      `Terminal "${terminal}" is not installed or not invokable. ${remediation}`
+    );
+    this.terminal = terminal;
+    this.remediation = remediation;
+    this.name = "TerminalNotFoundError";
+  }
+};
+var realSpawn = (command, args, options) => spawn2(command, args, options);
+var WRAPPER_COMMANDS = /* @__PURE__ */ new Set(["osascript", "open"]);
+var WRAPPER_EXIT_TIMEOUT_MS = 1500;
+async function executeLaunchPlan(plan, spawnFn = realSpawn) {
+  if (plan.terminal === "warp") {
+    console.error(
+      `syntaur: Warp will open a window at ${plan.cwd} but cannot auto-start ${plan.argv.command} \u2014 run it yourself once the window appears`
+    );
+  }
+  const invocation = buildTerminalInvocation(plan);
+  const isWrapper = WRAPPER_COMMANDS.has(invocation.command);
+  let child;
+  try {
+    child = spawnFn(invocation.command, invocation.args, {
+      detached: true,
+      // Wrappers: capture stderr so we can surface error text. Direct CLI
+      // launchers: ignore all streams so they keep running after we detach.
+      stdio: isWrapper ? ["ignore", "ignore", "pipe"] : "ignore",
+      env: plan.env
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new TerminalNotFoundError(
+      plan.terminal,
+      `Spawn failed: ${msg}. Verify the terminal is installed and on PATH.`
+    );
+  }
+  await new Promise((resolve14, reject) => {
+    let settled = false;
+    let stderr = "";
+    const finishOk = () => {
+      if (settled) return;
+      settled = true;
+      try {
+        child.unref();
+      } catch {
+      }
+      resolve14();
+    };
+    const finishErr = (remediation) => {
+      if (settled) return;
+      settled = true;
+      reject(new TerminalNotFoundError(plan.terminal, remediation));
+    };
+    if (child.stderr) {
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+    }
+    child.once("error", (err) => {
+      finishErr(
+        `Spawn failed: ${err.message}. Verify the terminal is installed and on PATH.`
+      );
+    });
+    if (isWrapper) {
+      child.once("exit", (code, signal) => {
+        if (code === 0 || code === null) {
+          finishOk();
+        } else {
+          const detail = stderr.trim() || (signal ? `terminated by signal ${signal}` : "check that the terminal app is installed and the URL scheme handler is registered");
+          finishErr(`${invocation.command} exited with code ${code}: ${detail}`);
+        }
+      });
+      setTimeout(finishOk, WRAPPER_EXIT_TIMEOUT_MS).unref();
+    } else {
+      child.once("spawn", () => {
+        finishOk();
+      });
+    }
+  });
+}
+function buildTerminalInvocation(plan) {
+  const commandLine = [plan.argv.command, ...plan.argv.args].map(shellQuote).join(" ");
+  const cdAndRun = `cd ${shellQuote(plan.cwd)} && ${commandLine}`;
+  switch (plan.terminal) {
+    case "terminal-app":
+      return {
+        command: "osascript",
+        args: [
+          "-e",
+          'tell application "Terminal"',
+          "-e",
+          "activate",
+          "-e",
+          `do script ${appleScriptString(cdAndRun)}`,
+          "-e",
+          "end tell"
+        ]
+      };
+    case "iterm":
+      return {
+        command: "osascript",
+        args: [
+          "-e",
+          'tell application "iTerm"',
+          "-e",
+          "activate",
+          "-e",
+          "set newWindow to (create window with default profile)",
+          "-e",
+          `tell current session of newWindow to write text ${appleScriptString(cdAndRun)}`,
+          "-e",
+          "end tell"
+        ]
+      };
+    case "ghostty":
+      return {
+        command: "osascript",
+        args: [
+          "-e",
+          'tell application "Ghostty"',
+          "-e",
+          "activate",
+          "-e",
+          "set newWin to (new window)",
+          "-e",
+          "delay 0.2",
+          "-e",
+          "set t to terminal 1 of selected tab of newWin",
+          "-e",
+          `input text ${appleScriptString(cdAndRun)} to t`,
+          "-e",
+          'send key "enter" to t',
+          "-e",
+          "end tell"
+        ]
+      };
+    case "alacritty":
+      return {
+        command: "alacritty",
+        args: [
+          "--working-directory",
+          plan.cwd,
+          "-e",
+          plan.argv.command,
+          ...plan.argv.args
+        ]
+      };
+    case "warp": {
+      const params = new URLSearchParams({ path: plan.cwd });
+      return {
+        command: "open",
+        args: [`warp://action/new_window?${params.toString()}`]
+      };
+    }
+    case "kitty":
+      return {
+        command: "kitty",
+        args: [
+          "--directory",
+          plan.cwd,
+          "--",
+          plan.argv.command,
+          ...plan.argv.args
+        ]
+      };
+  }
+}
+function appleScriptString(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+// src/launch/install-detection.ts
+init_paths();
+init_fs();
+import { fileURLToPath } from "url";
+import { dirname as dirname3, resolve as resolve13, join as join2 } from "path";
+import { realpathSync, readFileSync, mkdirSync } from "fs";
+var NPX_PATTERNS = [
+  { kind: "npm", re: /\/_npx\/([^/]+)\/node_modules(?:\/|$)/ },
+  { kind: "pnpm", re: /\/pnpm\/dlx\/([^/]+)\/node_modules(?:\/|$)/ },
+  { kind: "bun", re: /\/bunx-([^/]+)\/node_modules(?:\/|$)/ }
+];
+var GLOBAL_PATTERN = /\/lib\/node_modules\/syntaur(?:\/|$)/;
+function resolveScriptPath(scriptUrl, realpath) {
+  let p;
+  try {
+    p = fileURLToPath(scriptUrl);
+  } catch {
+    return null;
+  }
+  try {
+    return realpath(p);
+  } catch {
+    return p;
+  }
+}
+function normalizeSlashes(p) {
+  return p.replace(/\\/g, "/");
+}
+function detectInstallKind(scriptUrl, opts = {}) {
+  const realpath = opts.realpath ?? realpathSync.native;
+  const readFile9 = opts.readFile ?? ((p) => readFileSync(p, "utf-8"));
+  const ua = opts.envUserAgent !== void 0 ? opts.envUserAgent : process.env.npm_config_user_agent ?? "";
+  const resolved = resolveScriptPath(scriptUrl, realpath);
+  if (resolved === null) {
+    return "unknown";
+  }
+  const norm = normalizeSlashes(resolved);
+  for (const pat of NPX_PATTERNS) {
+    if (pat.re.test(norm)) return "npx";
+  }
+  if (ua.includes("npx/")) {
+    return "npx";
+  }
+  if (GLOBAL_PATTERN.test(norm)) {
+    return "global";
+  }
+  let dir = dirname3(resolved);
+  for (let depth = 0; depth < 8; depth++) {
+    const pkgJsonPath = join2(dir, "package.json");
+    let raw;
+    try {
+      raw = readFile9(pkgJsonPath);
+    } catch {
+      const parent2 = dirname3(dir);
+      if (parent2 === dir) break;
+      dir = parent2;
+      continue;
+    }
+    try {
+      const pkg = JSON.parse(raw);
+      if (typeof pkg.name === "string" && pkg.name === "syntaur" && !normalizeSlashes(dir).includes("/node_modules/")) {
+        return "local";
+      }
+    } catch {
+    }
+    const parent = dirname3(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return "unknown";
+}
+function extractNpxHash(scriptUrl, opts = {}) {
+  const realpath = opts.realpath ?? realpathSync.native;
+  const resolved = resolveScriptPath(scriptUrl, realpath);
+  if (resolved === null) return null;
+  const norm = normalizeSlashes(resolved);
+  for (const pat of NPX_PATTERNS) {
+    const m = norm.match(pat.re);
+    if (m) return m[1] ?? null;
+  }
+  return null;
+}
+function nudgeStampDir() {
+  return resolve13(syntaurRoot(), "npx-handler-nudge");
+}
+function sanitizeHash(hash) {
+  return hash.replace(/[^A-Za-z0-9_-]/g, "_") || "_";
+}
+function nudgeStampPath(hash) {
+  return join2(nudgeStampDir(), sanitizeHash(hash));
+}
+async function hasNudgedHash(hash) {
+  return fileExists(nudgeStampPath(hash));
+}
+async function recordNudge(hash) {
+  try {
+    mkdirSync(nudgeStampDir(), { recursive: true });
+  } catch {
+  }
+  try {
+    await writeFileForce(nudgeStampPath(hash), "");
+  } catch {
+  }
+}
+function isHandlerNudgeDisabled() {
+  const raw = process.env.SYNTAUR_SKIP_HANDLER_NUDGE;
+  if (raw === void 0) return false;
+  const trimmed = raw.trim();
+  return /^(1|true|yes)$/i.test(trimmed);
+}
+function nudgeMessage() {
+  return 'syntaur: running from npx \u2014 the syntaur:// deep-link handler is not registered. Install durably with `npm i -g syntaur` to enable "Open in agent" buttons.';
+}
+async function shouldNudgeForNpx(hash) {
+  if (isHandlerNudgeDisabled()) return false;
+  if (hash === null) return false;
+  if (await hasNudgedHash(hash)) return false;
+  return true;
+}
+var META_ARGS = /* @__PURE__ */ new Set(["-h", "--help", "-V", "--version", "help"]);
+async function maybeNudgeForNpxInstall(scriptUrl) {
+  if (detectInstallKind(scriptUrl) !== "npx") return;
+  const args = process.argv.slice(2);
+  if (args.some((a) => META_ARGS.has(a))) return;
+  const hash = extractNpxHash(scriptUrl);
+  if (!await shouldNudgeForNpx(hash)) return;
+  console.error(nudgeMessage());
+  if (hash !== null) {
+    await recordNudge(hash);
+  }
+}
+export {
+  LaunchError,
+  OpenUrlError,
+  TerminalNotFoundError,
+  buildFreshArgv,
+  buildSessionArgv,
+  buildTerminalInvocation,
+  detectInstallKind,
+  executeLaunchPlan,
+  extractNpxHash,
+  hasNudgedHash,
+  isHandlerNudgeDisabled,
+  maybeNudgeForNpxInstall,
+  nudgeMessage,
+  nudgeStampDir,
+  nudgeStampPath,
+  parseOpenUrl,
+  pickAgent,
+  recordNudge,
+  resolveLaunchPlan,
+  shouldNudgeForNpx
+};
+//# sourceMappingURL=index.js.map