syntaur 0.41.2 → 0.42.0

package/dist/launch/index.js

@@ -1,7 +1,12 @@
+var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/utils/terminal-schema.ts
 var TERMINAL_CHOICES;
@@ -76,6 +81,27 @@ var init_fs = __esm({
 });
 
 // src/templates/config.ts
+function renderConfig(params) {
+  return `---
+version: "1.0"
+defaultProjectDir: ${params.defaultProjectDir}
+onboarding:
+  completed: false
+agentDefaults:
+  trustLevel: medium
+  autoApprove: false
+backup:
+  repo: null
+  categories: projects, playbooks, todos, servers, config
+  lastBackup: null
+  lastRestore: null
+---
+
+# Syntaur Configuration
+
+Global configuration for the Syntaur CLI.
+`;
+}
 var init_config = __esm({
   "src/templates/config.ts"() {
     "use strict";
@@ -464,6 +490,51 @@ function parseExternalIds(frontmatter) {
   }
   return results;
 }
+function parseStatusHistory(frontmatter) {
+  if (/^statusHistory:\s*\[\s*\]/m.test(frontmatter)) return [];
+  const headerMatch = frontmatter.match(/^statusHistory:\s*$/m);
+  if (!headerMatch) return [];
+  const headerStart = headerMatch.index ?? frontmatter.indexOf(headerMatch[0]);
+  const bodyStart = headerStart + headerMatch[0].length + 1;
+  const after = frontmatter.slice(bodyStart);
+  const bodyLines = [];
+  for (const line of after.split("\n")) {
+    if (line.length === 0) {
+      bodyLines.push(line);
+      continue;
+    }
+    if (line[0] !== " " && line[0] !== "	") break;
+    bodyLines.push(line);
+  }
+  const body = bodyLines.join("\n");
+  const results = [];
+  const itemBlocks = body.split(/\n\s+-\s+/).filter((b) => b.trim().length > 0);
+  for (const block of itemBlocks) {
+    const entry = {};
+    for (const line of block.split("\n")) {
+      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["to"]) continue;
+    const result = {
+      at: entry["at"] ?? "",
+      from: entry["from"] ?? null,
+      to: entry["to"],
+      command: entry["command"] ?? "",
+      by: entry["by"] ?? null
+    };
+    if (entry["reason"] != null) result.reason = entry["reason"];
+    if ("phaseFrom" in entry) result.phaseFrom = entry["phaseFrom"];
+    if ("phaseTo" in entry) result.phaseTo = entry["phaseTo"];
+    if ("dispositionFrom" in entry) result.dispositionFrom = entry["dispositionFrom"];
+    if ("dispositionTo" in entry) result.dispositionTo = entry["dispositionTo"];
+    results.push(result);
+  }
+  return results;
+}
 function parseAssignmentFull(fileContent) {
   const [fm, body] = extractFrontmatter(fileContent);
   return {
@@ -486,13 +557,40 @@ function parseAssignmentFull(fileContent) {
       parentBranch: getNestedField(fm, "workspace", "parentBranch")
     },
     externalIds: parseExternalIds(fm),
+    statusHistory: parseStatusHistory(fm),
     tags: parseListField(fm, "tags"),
     archived: getField(fm, "archived") === "true",
     archivedAt: getField(fm, "archivedAt"),
     archivedReason: getField(fm, "archivedReason"),
     created: getField(fm, "created") ?? "",
     updated: getField(fm, "updated") ?? "",
-    body
+    body,
+    phase: getField(fm, "phase"),
+    disposition: getField(fm, "disposition"),
+    parked: getField(fm, "parked") === "true",
+    reviewRequested: getField(fm, "reviewRequested") === "true",
+    implementationStarted: getField(fm, "implementationStarted") === "true",
+    planApproval: (() => {
+      const file = getNestedField(fm, "planApproval", "file");
+      const digest = getNestedField(fm, "planApproval", "digest");
+      if (!file || !digest) return null;
+      return {
+        file,
+        digest,
+        by: getNestedField(fm, "planApproval", "by"),
+        at: getNestedField(fm, "planApproval", "at") ?? ""
+      };
+    })(),
+    override: (() => {
+      const status = getNestedField(fm, "override", "status");
+      if (!status) return null;
+      return {
+        status,
+        source: getNestedField(fm, "override", "source") ?? "human",
+        reason: getNestedField(fm, "override", "reason"),
+        at: getNestedField(fm, "override", "at") ?? ""
+      };
+    })()
   };
 }
 function parsePlan(fileContent) {
@@ -675,7 +773,12 @@ function canonicalizeCombo(input) {
   }
   return [...ordered, key].join("+");
 }
-var BINDABLE_ACTION_KINDS, MODIFIER_ORDER, DEFAULT_BINDABLE_HOTKEYS;
+function isReservedCombo(combo) {
+  const c = canonicalizeCombo(combo);
+  if (!c) return false;
+  return BUILTIN_RESERVED_COMBOS.includes(c);
+}
+var BINDABLE_ACTION_KINDS, BUILTIN_RESERVED_COMBOS, MODIFIER_ORDER, DEFAULT_BINDABLE_HOTKEYS;
 var init_hotkeysCatalog = __esm({
   "src/utils/hotkeysCatalog.ts"() {
     "use strict";
@@ -685,6 +788,40 @@ var init_hotkeysCatalog = __esm({
       "new-todo",
       "new-assignment"
     ];
+    BUILTIN_RESERVED_COMBOS = [
+      "mod+k",
+      "mod+shift+k",
+      "?",
+      "escape",
+      "enter",
+      "shift+t",
+      // g-chord starter + suffixes
+      "g",
+      "g o",
+      "g m",
+      "g a",
+      "g t",
+      "g s",
+      "g !",
+      "g ,",
+      // list-scope navigation
+      "j",
+      "k",
+      "o",
+      // ProjectDetail page
+      "a",
+      "e",
+      // AssignmentsPage board
+      "/",
+      "r",
+      // AssignmentDetail page
+      "p",
+      "h",
+      "d",
+      "s",
+      "[",
+      "]"
+    ];
     MODIFIER_ORDER = ["mod", "ctrl", "alt", "shift"];
     DEFAULT_BINDABLE_HOTKEYS = {
       "new-workspace": canonicalizeCombo("Mod+Shift+Alt+w"),
@@ -808,6 +945,47 @@ var init_workspace_visibility_schema = __esm({
 });
 
 // src/utils/config.ts
+var config_exports = {};
+__export(config_exports, {
+  AGENT_ID_PATTERN: () => AGENT_ID_PATTERN,
+  AgentConfigError: () => AgentConfigError,
+  BUILTIN_AGENTS: () => BUILTIN_AGENTS,
+  DEFAULT_ASSIGNMENT_TYPES: () => DEFAULT_ASSIGNMENT_TYPES,
+  DEFAULT_DERIVE_CONFIG: () => DEFAULT_DERIVE_CONFIG,
+  DEFAULT_STATUS_COLORS: () => DEFAULT_STATUS_COLORS,
+  PROMPT_ARG_POSITIONS: () => PROMPT_ARG_POSITIONS,
+  TERMINAL_CHOICES: () => TERMINAL_CHOICES,
+  TerminalConfigError: () => TerminalConfigError,
+  buildDefaultStatusConfig: () => buildDefaultStatusConfig,
+  deleteAgentsConfig: () => deleteAgentsConfig,
+  deleteHotkeyBindingsConfig: () => deleteHotkeyBindingsConfig,
+  deleteStatusConfig: () => deleteStatusConfig,
+  deleteTerminalConfig: () => deleteTerminalConfig,
+  deleteThemeConfig: () => deleteThemeConfig,
+  deleteWorkspaceVisibilityConfig: () => deleteWorkspaceVisibilityConfig,
+  getAgents: () => getAgents,
+  getAssignmentTypes: () => getAssignmentTypes,
+  getTerminal: () => getTerminal,
+  parseAgentCommand: () => parseAgentCommand,
+  parseStatusConfig: () => parseStatusConfig,
+  parseTerminalConfig: () => parseTerminalConfig,
+  readConfig: () => readConfig,
+  serializeStatusConfig: () => serializeStatusConfig,
+  toTitleCase: () => toTitleCase,
+  updateAgentsConfig: () => updateAgentsConfig,
+  updateBackupConfig: () => updateBackupConfig,
+  updateIntegrationConfig: () => updateIntegrationConfig,
+  updateOnboardingConfig: () => updateOnboardingConfig,
+  updatePlaybooksConfig: () => updatePlaybooksConfig,
+  validateAgentList: () => validateAgentList,
+  validateDeriveConfig: () => validateDeriveConfig,
+  writeAgentsConfig: () => writeAgentsConfig,
+  writeHotkeyBindingsConfig: () => writeHotkeyBindingsConfig,
+  writeStatusConfig: () => writeStatusConfig,
+  writeTerminalConfig: () => writeTerminalConfig,
+  writeThemeConfig: () => writeThemeConfig,
+  writeWorkspaceVisibilityConfig: () => writeWorkspaceVisibilityConfig
+});
 import { readFile as readFile5 } from "fs/promises";
 import { spawnSync } from "child_process";
 import { resolve as resolve6, isAbsolute } from "path";
@@ -972,6 +1150,16 @@ function parseStatusConfig(content) {
   const statuses = [];
   const order = [];
   const transitions = [];
+  const phaseLadder = [];
+  const disposition = [];
+  const headline = {};
+  const unquote = (v) => {
+    const t = v.trim();
+    if (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'")) {
+      return t.slice(1, -1);
+    }
+    return t;
+  };
   let currentSection = null;
   const lines = remaining.split("\n");
   function parseListEntry(lineIdx, baseIndent) {
@@ -1004,6 +1192,9 @@ function parseStatusConfig(content) {
       if (key === "definitions") currentSection = "definitions";
       else if (key === "order") currentSection = "order";
       else if (key === "transitions") currentSection = "transitions";
+      else if (key === "phaseLadder") currentSection = "phaseLadder";
+      else if (key === "disposition") currentSection = "disposition";
+      else if (key === "headline") currentSection = "headline";
       else currentSection = null;
       continue;
     }
@@ -1042,12 +1233,52 @@ function parseStatusConfig(content) {
       lineIdx += consumed - 1;
       continue;
     }
+    if (currentSection === "phaseLadder" && indent >= 4 && trimmed.startsWith("- ")) {
+      const { entry, consumed } = parseListEntry(lineIdx, indent);
+      if (entry["phase"] && entry["when"] !== void 0) {
+        phaseLadder.push({
+          phase: unquote(entry["phase"]),
+          when: unquote(entry["when"]),
+          next: entry["next"] !== void 0 ? unquote(entry["next"]) : void 0
+        });
+      }
+      lineIdx += consumed - 1;
+      continue;
+    }
+    if (currentSection === "disposition" && indent >= 4 && trimmed.startsWith("- ")) {
+      const { entry, consumed } = parseListEntry(lineIdx, indent);
+      if (entry["else"] !== void 0) {
+        disposition.push({ when: null, is: unquote(entry["else"]) });
+      } else if (entry["when"] !== void 0 && entry["is"]) {
+        disposition.push({ when: unquote(entry["when"]), is: unquote(entry["is"]) });
+      }
+      lineIdx += consumed - 1;
+      continue;
+    }
+    if (currentSection === "headline" && indent >= 4 && !trimmed.startsWith("- ")) {
+      const ci = trimmed.indexOf(":");
+      if (ci > 0) {
+        headline[trimmed.slice(0, ci).trim()] = unquote(trimmed.slice(ci + 1));
+      }
+      continue;
+    }
   }
   if (statuses.length === 0) return null;
+  const derive = phaseLadder.length > 0 || disposition.length > 0 || Object.keys(headline).length > 0 ? {
+    phaseLadder: phaseLadder.length > 0 ? phaseLadder : DEFAULT_DERIVE_CONFIG.phaseLadder,
+    disposition: disposition.length > 0 ? disposition : DEFAULT_DERIVE_CONFIG.disposition,
+    headline: {
+      terminal: "passthrough",
+      parked: headline["parked"] ?? DEFAULT_DERIVE_CONFIG.headline.parked,
+      blocked: headline["blocked"] ?? DEFAULT_DERIVE_CONFIG.headline.blocked,
+      active: "phase"
+    }
+  } : null;
   return {
     statuses,
     order: order.length > 0 ? order : statuses.map((s) => s.id),
-    transitions
+    transitions,
+    derive
   };
 }
 function toTitleCase(s) {
@@ -1068,6 +1299,137 @@ function buildDefaultStatusConfig() {
     })
   };
 }
+function serializeStatusConfig(statuses) {
+  const lines = [];
+  lines.push("statuses:");
+  lines.push("  definitions:");
+  for (const s of statuses.statuses) {
+    lines.push(`    - id: ${s.id}`);
+    lines.push(`      label: ${s.label}`);
+    if (s.description) lines.push(`      description: ${s.description}`);
+    if (s.color) lines.push(`      color: ${s.color}`);
+    if (s.icon) lines.push(`      icon: ${s.icon}`);
+    if (s.terminal) lines.push(`      terminal: true`);
+  }
+  lines.push("  order:");
+  for (const id of statuses.order) {
+    lines.push(`    - ${id}`);
+  }
+  if (statuses.transitions.length > 0) {
+    lines.push("  transitions:");
+    for (const t of statuses.transitions) {
+      lines.push(`    - from: ${t.from}`);
+      lines.push(`      command: ${t.command}`);
+      lines.push(`      to: ${t.to}`);
+      if (t.label) lines.push(`      label: ${t.label}`);
+      if (t.description) lines.push(`      description: ${t.description}`);
+      if (t.requiresReason) lines.push(`      requiresReason: true`);
+    }
+  }
+  if (statuses.derive) {
+    const d = statuses.derive;
+    lines.push("  phaseLadder:");
+    for (const rung of d.phaseLadder) {
+      lines.push(`    - phase: ${rung.phase}`);
+      lines.push(`      when: "${rung.when.replace(/"/g, '\\"')}"`);
+      if (rung.next) lines.push(`      next: "${rung.next.replace(/"/g, '\\"')}"`);
+    }
+    lines.push("  disposition:");
+    for (const rule of d.disposition) {
+      if (rule.when === null) {
+        lines.push(`    - else: ${rule.is}`);
+      } else {
+        lines.push(`    - when: "${rule.when.replace(/"/g, '\\"')}"`);
+        lines.push(`      is: ${rule.is}`);
+      }
+    }
+    lines.push("  headline:");
+    lines.push(`    terminal: passthrough`);
+    lines.push(`    parked: ${d.headline.parked}`);
+    lines.push(`    blocked: ${d.headline.blocked}`);
+    lines.push(`    active: phase`);
+  }
+  return lines.join("\n");
+}
+function validateDeriveConfig(derive, statusConfig, validateWhen = () => null) {
+  const problems = [];
+  const ids = new Set(statusConfig.statuses.map((s) => s.id));
+  if (derive.phaseLadder.length === 0) {
+    problems.push("phaseLadder must have at least one rung");
+  }
+  for (const rung of derive.phaseLadder) {
+    if (!ids.has(rung.phase)) {
+      problems.push(`phaseLadder rung "${rung.phase}" is not a defined status id`);
+    }
+    const err = rung.when === "*" ? null : validateWhen(rung.when);
+    if (err) problems.push(`phaseLadder rung "${rung.phase}": invalid condition \u2014 ${err}`);
+  }
+  const VALID_DISPOSITIONS = /* @__PURE__ */ new Set(["active", "blocked", "parked"]);
+  let sawElse = false;
+  for (const rule of derive.disposition) {
+    if (!VALID_DISPOSITIONS.has(rule.is)) {
+      problems.push(
+        `disposition "${rule.is}" is not valid (expected active, blocked, or parked \u2014 terminal is never a rule)`
+      );
+    }
+    if (rule.when === null) sawElse = true;
+    else {
+      const err = validateWhen(rule.when);
+      if (err) problems.push(`disposition rule "${rule.is}": invalid condition \u2014 ${err}`);
+    }
+  }
+  if (!sawElse) problems.push("disposition rules must end with an `else:` arm");
+  for (const key of ["parked", "blocked"]) {
+    if (!ids.has(derive.headline[key])) {
+      problems.push(
+        `headline.${key} \u2192 "${derive.headline[key]}" is not a defined status id (add the definition or run migrate-derive)`
+      );
+    }
+  }
+  return problems;
+}
+function serializeIntegrationConfig(integrations) {
+  const lines = [];
+  if (integrations.claudePluginDir) {
+    lines.push(`  claudePluginDir: ${integrations.claudePluginDir}`);
+  }
+  if (integrations.codexPluginDir) {
+    lines.push(`  codexPluginDir: ${integrations.codexPluginDir}`);
+  }
+  if (integrations.codexMarketplacePath) {
+    lines.push(`  codexMarketplacePath: ${integrations.codexMarketplacePath}`);
+  }
+  if (integrations.installedAgents) {
+    for (const [id, rec] of Object.entries(integrations.installedAgents)) {
+      lines.push(`  installedAgents.${id}: ${rec.scope}`);
+    }
+  }
+  if (lines.length === 0) {
+    return null;
+  }
+  return ["integrations:", ...lines].join("\n");
+}
+function serializeOnboardingConfig(onboarding) {
+  return ["onboarding:", `  completed: ${onboarding.completed ? "true" : "false"}`].join("\n");
+}
+function serializeBackupConfig(backup) {
+  const lines = ["backup:"];
+  lines.push(`  repo: ${backup.repo ?? "null"}`);
+  lines.push(`  categories: ${backup.categories}`);
+  lines.push(`  lastBackup: ${backup.lastBackup ?? "null"}`);
+  lines.push(`  lastRestore: ${backup.lastRestore ?? "null"}`);
+  return lines.join("\n");
+}
+function serializePlaybooksConfig(playbooks) {
+  if (!playbooks.disabled || playbooks.disabled.length === 0) {
+    return null;
+  }
+  const lines = ["playbooks:", "  disabled:"];
+  for (const slug of playbooks.disabled) {
+    lines.push(`    - ${slug}`);
+  }
+  return lines.join("\n");
+}
 function parsePlaybooksConfig(fmBlock) {
   const blockStart = fmBlock.match(/^playbooks:\s*$/m);
   if (!blockStart) {
@@ -1103,6 +1465,37 @@ function parsePlaybooksConfig(fmBlock) {
   }
   return { disabled };
 }
+async function updatePlaybooksConfig(playbooks) {
+  const configPath = resolve6(syntaurRoot(), "config.md");
+  const current = (await readConfig()).playbooks;
+  const nextPlaybooks = {
+    disabled: Array.from(new Set(playbooks.disabled ?? current.disabled))
+  };
+  const playbooksBlock = serializePlaybooksConfig(nextPlaybooks);
+  const existing = await fileExists(configPath) ? await readFile5(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
+  const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
+  if (!fmMatch) {
+    const bodyBlock = playbooksBlock ? `${playbooksBlock}
+` : "";
+    const content = `---
+version: "2.0"
+defaultProjectDir: ${defaultProjectDir()}
+${bodyBlock}---
+${existing}`;
+    await writeFileForce(configPath, content);
+    return;
+  }
+  const fmBlock = fmMatch[2];
+  const afterFrontmatter = existing.slice(fmMatch[0].length);
+  const cleanedFm = stripTopLevelBlock(fmBlock, "playbooks");
+  const newFm = playbooksBlock ? `${cleanedFm}
+${playbooksBlock}`.replace(/^\n+/, "") : cleanedFm;
+  const normalizedFm = newFm.replace(/\n+$/, "");
+  const newContent = `---
+${normalizedFm}
+---${afterFrontmatter}`;
+  await writeFileForce(configPath, newContent);
+}
 function parseThemeConfig(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
   if (!match) return null;
@@ -1125,6 +1518,58 @@ function parseThemeConfig(content) {
   if (!preset) return null;
   return { preset };
 }
+function serializeThemeConfig(theme) {
+  return ["theme:", `  preset: ${theme.preset}`].join("\n");
+}
+async function writeThemeConfig(theme) {
+  const configPath = resolve6(syntaurRoot(), "config.md");
+  const themeBlock = serializeThemeConfig(theme);
+  const existing = await fileExists(configPath) ? await readFile5(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
+  const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
+  if (!fmMatch) {
+    const content = `---
+version: "2.0"
+defaultProjectDir: ${defaultProjectDir()}
+${themeBlock}
+---
+${existing}`;
+    await writeFileForce(configPath, content);
+    return;
+  }
+  const fmBlock = fmMatch[2];
+  const afterFrontmatter = existing.slice(fmMatch[0].length);
+  const cleanedFm = stripTopLevelBlock(fmBlock, "theme");
+  const newFm = `${cleanedFm}
+${themeBlock}`.replace(/^\n+/, "");
+  const normalizedFm = newFm.replace(/\n+$/, "");
+  const newContent = `---
+${normalizedFm}
+---${afterFrontmatter}`;
+  await writeFileForce(configPath, newContent);
+}
+async function deleteThemeConfig() {
+  const configPath = resolve6(syntaurRoot(), "config.md");
+  if (!await fileExists(configPath)) return;
+  const existing = await readFile5(configPath, "utf-8");
+  const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
+  if (!fmMatch) return;
+  const fmBlock = fmMatch[2];
+  const afterFrontmatter = existing.slice(fmMatch[0].length);
+  const cleanedFm = stripTopLevelBlock(fmBlock, "theme");
+  const newContent = `---
+${cleanedFm}
+---${afterFrontmatter}`;
+  await writeFileForce(configPath, newContent);
+}
+function serializeWorkspaceVisibilityConfig(cfg) {
+  const hidden = normalizeHiddenList(cfg.hidden);
+  if (hidden.length === 0) return null;
+  const lines = ["workspaceVisibility:", "  hidden:"];
+  for (const name of hidden) {
+    lines.push(`    - ${JSON.stringify(name)}`);
+  }
+  return lines.join("\n");
+}
 function parseWorkspaceVisibilityConfig(fmBlock) {
   const blockStart = fmBlock.match(/^workspaceVisibility:\s*$/m);
   if (!blockStart) {
@@ -1162,6 +1607,93 @@ function parseWorkspaceVisibilityConfig(fmBlock) {
   }
   return { hidden: normalizeHiddenList(hidden) };
 }
+async function writeWorkspaceVisibilityConfig(cfg) {
+  const configPath = resolve6(syntaurRoot(), "config.md");
+  const block = serializeWorkspaceVisibilityConfig(cfg);
+  const existing = await fileExists(configPath) ? await readFile5(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
+  const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
+  if (!fmMatch) {
+    const bodyBlock = block ? `${block}
+` : "";
+    const content = `---
+version: "2.0"
+defaultProjectDir: ${defaultProjectDir()}
+${bodyBlock}---
+${existing}`;
+    await writeFileForce(configPath, content);
+    return;
+  }
+  const fmBlock = fmMatch[2];
+  const afterFrontmatter = existing.slice(fmMatch[0].length);
+  const cleanedFm = stripTopLevelBlock(fmBlock, "workspaceVisibility");
+  const newFm = block ? `${cleanedFm}
+${block}`.replace(/^\n+/, "") : cleanedFm;
+  const normalizedFm = newFm.replace(/\n+$/, "");
+  const newContent = `---
+${normalizedFm}
+---${afterFrontmatter}`;
+  await writeFileForce(configPath, newContent);
+}
+async function deleteWorkspaceVisibilityConfig() {
+  const configPath = resolve6(syntaurRoot(), "config.md");
+  if (!await fileExists(configPath)) return;
+  const existing = await readFile5(configPath, "utf-8");
+  const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
+  if (!fmMatch) return;
+  const fmBlock = fmMatch[2];
+  const afterFrontmatter = existing.slice(fmMatch[0].length);
+  const cleanedFm = stripTopLevelBlock(fmBlock, "workspaceVisibility");
+  const newContent = `---
+${cleanedFm}
+---${afterFrontmatter}`;
+  await writeFileForce(configPath, newContent);
+}
+function stripTopLevelScalar(fmBlock, key) {
+  const lines = fmBlock.split("\n");
+  const keyRegex = new RegExp(`^${key}:\\s*\\S`);
+  const filtered = lines.filter((line) => !keyRegex.test(line));
+  return filtered.join("\n").replace(/\n+$/, "");
+}
+async function writeTerminalConfig(terminal) {
+  const configPath = resolve6(syntaurRoot(), "config.md");
+  const terminalLine = `terminal: ${terminal}`;
+  const existing = await fileExists(configPath) ? await readFile5(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
+  const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
+  if (!fmMatch) {
+    const content = `---
+version: "2.0"
+defaultProjectDir: ${defaultProjectDir()}
+${terminalLine}
+---
+${existing}`;
+    await writeFileForce(configPath, content);
+    return;
+  }
+  const fmBlock = fmMatch[2];
+  const afterFrontmatter = existing.slice(fmMatch[0].length);
+  const cleanedFm = stripTopLevelScalar(fmBlock, "terminal");
+  const newFm = `${cleanedFm}
+${terminalLine}`.replace(/^\n+/, "");
+  const normalizedFm = newFm.replace(/\n+$/, "");
+  const newContent = `---
+${normalizedFm}
+---${afterFrontmatter}`;
+  await writeFileForce(configPath, newContent);
+}
+async function deleteTerminalConfig() {
+  const configPath = resolve6(syntaurRoot(), "config.md");
+  if (!await fileExists(configPath)) return;
+  const existing = await readFile5(configPath, "utf-8");
+  const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
+  if (!fmMatch) return;
+  const fmBlock = fmMatch[2];
+  const afterFrontmatter = existing.slice(fmMatch[0].length);
+  const cleanedFm = stripTopLevelScalar(fmBlock, "terminal");
+  const newContent = `---
+${cleanedFm}
+---${afterFrontmatter}`;
+  await writeFileForce(configPath, newContent);
+}
 function parseHotkeyBindingsConfig(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
   if (!match) return null;
@@ -1194,6 +1726,92 @@ function parseHotkeyBindingsConfig(content) {
   if (Object.keys(bindings).length === 0) return null;
   return { bindings };
 }
+function serializeHotkeyBindingsConfig(cfg) {
+  const lines = ["hotkeys:", "  bindings:"];
+  for (const kind of BINDABLE_ACTION_KINDS) {
+    const value = cfg.bindings[kind];
+    if (!value) continue;
+    lines.push(`    ${kind}: "${canonicalizeCombo(value)}"`);
+  }
+  if (lines.length === 2) return "";
+  return lines.join("\n");
+}
+async function writeHotkeyBindingsConfig(cfg) {
+  const cleaned = {};
+  for (const kind of BINDABLE_ACTION_KINDS) {
+    const raw = cfg.bindings[kind];
+    if (typeof raw !== "string" || raw.trim() === "") continue;
+    const canonical = canonicalizeCombo(raw);
+    if (!canonical) continue;
+    if (isReservedCombo(canonical)) continue;
+    cleaned[kind] = canonical;
+  }
+  if (Object.keys(cleaned).length === 0) {
+    await deleteHotkeyBindingsConfig();
+    return;
+  }
+  const configPath = resolve6(syntaurRoot(), "config.md");
+  const block = serializeHotkeyBindingsConfig({ bindings: cleaned });
+  const existing = await fileExists(configPath) ? await readFile5(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
+  const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
+  if (!fmMatch) {
+    const content = `---
+version: "2.0"
+defaultProjectDir: ${defaultProjectDir()}
+${block}
+---
+${existing}`;
+    await writeFileForce(configPath, content);
+    return;
+  }
+  const fmBlock = fmMatch[2];
+  const afterFrontmatter = existing.slice(fmMatch[0].length);
+  const cleanedFm = stripTopLevelBlock(fmBlock, "hotkeys");
+  const newFm = `${cleanedFm}
+${block}`.replace(/^\n+/, "");
+  const normalizedFm = newFm.replace(/\n+$/, "");
+  const newContent = `---
+${normalizedFm}
+---${afterFrontmatter}`;
+  await writeFileForce(configPath, newContent);
+}
+async function deleteHotkeyBindingsConfig() {
+  const configPath = resolve6(syntaurRoot(), "config.md");
+  if (!await fileExists(configPath)) return;
+  const existing = await readFile5(configPath, "utf-8");
+  const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
+  if (!fmMatch) return;
+  const fmBlock = fmMatch[2];
+  const afterFrontmatter = existing.slice(fmMatch[0].length);
+  const cleanedFm = stripTopLevelBlock(fmBlock, "hotkeys");
+  const newContent = `---
+${cleanedFm}
+---${afterFrontmatter}`;
+  await writeFileForce(configPath, newContent);
+}
+function stripTopLevelBlock(fmBlock, key) {
+  const blockStart = fmBlock.match(new RegExp(`^${key}:\\s*$`, "m"));
+  if (!blockStart) {
+    return fmBlock.replace(/\n+$/, "");
+  }
+  const startIdx = fmBlock.indexOf(blockStart[0]);
+  const before = fmBlock.slice(0, startIdx);
+  const after = fmBlock.slice(startIdx + blockStart[0].length);
+  const remaining = after.split("\n");
+  let endIdx = 0;
+  for (let i = 0; i < remaining.length; i++) {
+    const line = remaining[i];
+    if (line.trim() === "") {
+      endIdx = i + 1;
+      continue;
+    }
+    if (line.length > 0 && line[0] !== " ") {
+      break;
+    }
+    endIdx = i + 1;
+  }
+  return (before + remaining.slice(endIdx).join("\n")).replace(/\n+$/, "");
+}
 function parseOptionalAbsolutePath(value, fieldName) {
   if (!value) {
     return null;
@@ -1429,6 +2047,266 @@ function assignAgentField(target, key, rawValue) {
       break;
   }
 }
+function yamlQuoteScalar(value) {
+  if (/[\r\n]/.test(value)) {
+    throw new AgentConfigError(
+      `value contains newlines, which the agents config serializer does not support: ${JSON.stringify(value)}`
+    );
+  }
+  if (value === "" || /[:#{}[\],&*?|>!%@`"'\\\t]/.test(value) || /^\s|\s$/.test(value)) {
+    const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\t/g, "\\t");
+    return `"${escaped}"`;
+  }
+  return value;
+}
+function serializeAgentsConfig(agents) {
+  const lines = ["agents:"];
+  for (const a of agents) {
+    lines.push(`  - id: ${yamlQuoteScalar(a.id)}`);
+    lines.push(`    label: ${yamlQuoteScalar(a.label)}`);
+    lines.push(`    command: ${yamlQuoteScalar(a.command)}`);
+    if (a.model) {
+      lines.push(`    model: ${yamlQuoteScalar(a.model)}`);
+    }
+    if (a.playbook) {
+      lines.push(`    playbook: ${yamlQuoteScalar(a.playbook)}`);
+    }
+    if (a.args && a.args.length > 0) {
+      lines.push(`    args:`);
+      for (const arg of a.args) {
+        lines.push(`      - ${yamlQuoteScalar(arg)}`);
+      }
+    }
+    if (a.promptArgPosition && a.promptArgPosition !== "first") {
+      lines.push(`    promptArgPosition: ${a.promptArgPosition}`);
+    }
+    if (a.default) {
+      lines.push(`    default: true`);
+    }
+    if (a.resolveFromShellAliases) {
+      lines.push(`    resolveFromShellAliases: true`);
+    }
+    if (a.resume) {
+      appendSessionInvocation(lines, "resume", a.resume);
+    }
+    if (a.fork) {
+      appendSessionInvocation(lines, "fork", a.fork);
+    }
+  }
+  return lines.join("\n");
+}
+function appendSessionInvocation(lines, key, invocation) {
+  lines.push(`    ${key}:`);
+  if (invocation.command !== void 0) {
+    lines.push(`      command: ${yamlQuoteScalar(invocation.command)}`);
+  }
+  lines.push(`      args:`);
+  for (const arg of invocation.args) {
+    lines.push(`        - ${yamlQuoteScalar(arg)}`);
+  }
+}
+async function writeAgentsConfig(agents) {
+  validateAgentList(agents);
+  const configPath = resolve6(syntaurRoot(), "config.md");
+  const agentsBlock = serializeAgentsConfig(agents);
+  const existing = await fileExists(configPath) ? await readFile5(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
+  const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
+  if (!fmMatch) {
+    const content = `---
+version: "2.0"
+defaultProjectDir: ${defaultProjectDir()}
+${agentsBlock}
+---
+${existing}`;
+    await writeFileForce(configPath, content.replace(/\n\n---/, "\n---"));
+    return;
+  }
+  const fmBlock = fmMatch[2];
+  const afterFrontmatter = existing.slice(fmMatch[0].length);
+  const cleanedFm = stripTopLevelBlock(fmBlock, "agents");
+  const newFm = `${cleanedFm}
+${agentsBlock}`.replace(/^\n+/, "").replace(/\n+$/, "");
+  const newContent = `---
+${newFm}
+---${afterFrontmatter}`;
+  await writeFileForce(configPath, newContent);
+}
+async function deleteAgentsConfig() {
+  const configPath = resolve6(syntaurRoot(), "config.md");
+  if (!await fileExists(configPath)) return;
+  const existing = await readFile5(configPath, "utf-8");
+  const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
+  if (!fmMatch) return;
+  const fmBlock = fmMatch[2];
+  const afterFrontmatter = existing.slice(fmMatch[0].length);
+  const cleanedFm = stripTopLevelBlock(fmBlock, "agents");
+  const newContent = `---
+${cleanedFm}
+---${afterFrontmatter}`;
+  await writeFileForce(configPath, newContent);
+}
+async function writeStatusConfig(statuses) {
+  const configPath = resolve6(syntaurRoot(), "config.md");
+  const statusBlock = serializeStatusConfig(statuses);
+  if (!await fileExists(configPath)) {
+    const content = `---
+version: "2.0"
+defaultProjectDir: ~/projects
+${statusBlock}
+---
+`;
+    await writeFileForce(configPath, content);
+    return;
+  }
+  const existing = await readFile5(configPath, "utf-8");
+  const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
+  if (!fmMatch) {
+    const content = `---
+version: "2.0"
+${statusBlock}
+---
+${existing}`;
+    await writeFileForce(configPath, content);
+    return;
+  }
+  const fmBlock = fmMatch[2];
+  const afterFrontmatter = existing.slice(fmMatch[0].length);
+  const statusesStart = fmBlock.match(/^statuses:\s*$/m);
+  let cleanedFm;
+  if (statusesStart) {
+    const startIdx = fmBlock.indexOf(statusesStart[0]);
+    const before = fmBlock.slice(0, startIdx);
+    const after = fmBlock.slice(startIdx + statusesStart[0].length);
+    const remaining = after.split("\n");
+    let endIdx = 0;
+    for (let i = 0; i < remaining.length; i++) {
+      const line = remaining[i];
+      if (line.trim() === "") {
+        endIdx = i + 1;
+        continue;
+      }
+      if (line.length > 0 && line[0] !== " ") break;
+      endIdx = i + 1;
+    }
+    cleanedFm = before + remaining.slice(endIdx).join("\n");
+  } else {
+    cleanedFm = fmBlock;
+  }
+  cleanedFm = cleanedFm.replace(/\n+$/, "");
+  const newContent = `---
+${cleanedFm}
+${statusBlock}
+---${afterFrontmatter}`;
+  await writeFileForce(configPath, newContent);
+}
+async function deleteStatusConfig() {
+  const configPath = resolve6(syntaurRoot(), "config.md");
+  if (!await fileExists(configPath)) return;
+  const existing = await readFile5(configPath, "utf-8");
+  const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
+  if (!fmMatch) return;
+  const fmBlock = fmMatch[2];
+  const afterFrontmatter = existing.slice(fmMatch[0].length);
+  const cleanedFm = stripTopLevelBlock(fmBlock, "statuses");
+  const newContent = `---
+${cleanedFm}
+---${afterFrontmatter}`;
+  await writeFileForce(configPath, newContent);
+}
+async function updateIntegrationConfig(integrations) {
+  const configPath = resolve6(syntaurRoot(), "config.md");
+  const nextIntegrations = {
+    ...(await readConfig()).integrations,
+    ...integrations
+  };
+  const integrationBlock = serializeIntegrationConfig(nextIntegrations);
+  const existing = await fileExists(configPath) ? await readFile5(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
+  const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
+  if (!fmMatch) {
+    const content = `---
+version: "2.0"
+defaultProjectDir: ${defaultProjectDir()}
+${integrationBlock ?? ""}
+---
+${existing}`;
+    await writeFileForce(configPath, content.replace(/\n\n---/, "\n---"));
+    return;
+  }
+  const fmBlock = fmMatch[2];
+  const afterFrontmatter = existing.slice(fmMatch[0].length);
+  const cleanedFm = stripTopLevelBlock(fmBlock, "integrations");
+  const newFm = integrationBlock ? `${cleanedFm}
+${integrationBlock}`.replace(/^\n+/, "") : cleanedFm;
+  const normalizedFm = newFm.replace(/\n+$/, "");
+  const newContent = `---
+${normalizedFm}
+---${afterFrontmatter}`;
+  await writeFileForce(configPath, newContent);
+}
+async function updateOnboardingConfig(onboarding) {
+  const configPath = resolve6(syntaurRoot(), "config.md");
+  const nextOnboarding = {
+    ...(await readConfig()).onboarding,
+    ...onboarding
+  };
+  const onboardingBlock = serializeOnboardingConfig(nextOnboarding);
+  const existing = await fileExists(configPath) ? await readFile5(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
+  const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
+  if (!fmMatch) {
+    const content = `---
+version: "2.0"
+defaultProjectDir: ${defaultProjectDir()}
+${onboardingBlock}
+---
+${existing}`;
+    await writeFileForce(configPath, content.replace(/\n\n---/, "\n---"));
+    return;
+  }
+  const fmBlock = fmMatch[2];
+  const afterFrontmatter = existing.slice(fmMatch[0].length);
+  const cleanedFm = stripTopLevelBlock(fmBlock, "onboarding");
+  const newFm = `${cleanedFm}
+${onboardingBlock}`.replace(/^\n+/, "");
+  const normalizedFm = newFm.replace(/\n+$/, "");
+  const newContent = `---
+${normalizedFm}
+---${afterFrontmatter}`;
+  await writeFileForce(configPath, newContent);
+}
+async function updateBackupConfig(backup) {
+  const configPath = resolve6(syntaurRoot(), "config.md");
+  const current = (await readConfig()).backup;
+  const nextBackup = {
+    repo: current?.repo ?? null,
+    categories: current?.categories ?? "projects, playbooks, todos, servers, config",
+    lastBackup: current?.lastBackup ?? null,
+    lastRestore: current?.lastRestore ?? null,
+    ...backup
+  };
+  const backupBlock = serializeBackupConfig(nextBackup);
+  const existing = await fileExists(configPath) ? await readFile5(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
+  const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
+  if (!fmMatch) {
+    const content = `---
+version: "2.0"
+defaultProjectDir: ${defaultProjectDir()}
+${backupBlock}
+---
+${existing}`;
+    await writeFileForce(configPath, content.replace(/\n\n---/, "\n---"));
+    return;
+  }
+  const fmBlock = fmMatch[2];
+  const afterFrontmatter = existing.slice(fmMatch[0].length);
+  const cleanedFm = stripTopLevelBlock(fmBlock, "backup");
+  const newFm = `${cleanedFm}
+${backupBlock}`.replace(/^\n+/, "");
+  const normalizedFm = newFm.replace(/\n+$/, "");
+  const newContent = `---
+${normalizedFm}
+---${afterFrontmatter}`;
+  await writeFileForce(configPath, newContent);
+}
 async function readConfig() {
   const configPath = resolve6(syntaurRoot(), "config.md");
   if (!await fileExists(configPath)) {
@@ -1504,6 +2382,9 @@ async function readConfig() {
     workspaceVisibility: parseWorkspaceVisibilityConfig(fmBlock)
   };
 }
+function getAssignmentTypes(config) {
+  return config.types ?? DEFAULT_ASSIGNMENT_TYPES;
+}
 function getAgents(config) {
   if (config.agents === null) return BUILTIN_AGENTS;
   const builtinById = new Map(BUILTIN_AGENTS.map((a) => [a.id, a]));
@@ -1550,7 +2431,18 @@ function getTerminal(config) {
   }
   return "terminal-app";
 }
-var DEFAULT_CONFIG, AUTO_CREATE_WORKTREE_VALUES, AgentConfigError, DEFAULT_STATUS_COLORS, KNOWN_AGENT_SCALAR_FIELDS, migratedConfigPaths, TerminalConfigError;
+async function updateAgentsConfig(mutation, options = {}) {
+  const config = await readConfig();
+  const previous = config.agents ?? [...BUILTIN_AGENTS];
+  const next = mutation.apply(previous);
+  validateAgentList(next);
+  if (options.dryRun) {
+    return { previous, next, written: false };
+  }
+  await writeAgentsConfig(next);
+  return { previous, next, written: true };
+}
+var DEFAULT_DERIVE_CONFIG, DEFAULT_ASSIGNMENT_TYPES, DEFAULT_CONFIG, AUTO_CREATE_WORKTREE_VALUES, AgentConfigError, DEFAULT_STATUS_COLORS, KNOWN_AGENT_SCALAR_FIELDS, migratedConfigPaths, TerminalConfigError;
 var init_config2 = __esm({
   "src/utils/config.ts"() {
     "use strict";
@@ -1564,6 +2456,45 @@ var init_config2 = __esm({
     init_slug();
     init_terminal_schema();
     init_workspace_visibility_schema();
+    DEFAULT_DERIVE_CONFIG = {
+      phaseLadder: [
+        { phase: "draft", when: "*", next: "Fill in the objective and acceptance criteria" },
+        {
+          // planExists-but-not-approved also sits here: the default status set has
+          // no `planning` id. Users who define one add a `planExists:true` rung.
+          phase: "ready_for_planning",
+          when: "hasRealObjective:true AND acRealTotal > 0",
+          next: "Write a plan and get it approved"
+        },
+        { phase: "ready_to_implement", when: "planApproved:true", next: "Start implementing" },
+        {
+          phase: "in_progress",
+          when: "planApproved:true AND implementationStarted:true",
+          next: "Finish acceptance criteria, then request review"
+        },
+        {
+          phase: "review",
+          when: "acAllChecked:true OR reviewRequested:true",
+          next: "Complete, or address review feedback"
+        }
+      ],
+      disposition: [
+        { when: "parked:true", is: "parked" },
+        { when: "blocked:true", is: "blocked" },
+        { when: null, is: "active" }
+      ],
+      headline: { terminal: "passthrough", parked: "parked", blocked: "blocked", active: "phase" }
+    };
+    DEFAULT_ASSIGNMENT_TYPES = {
+      definitions: [
+        { id: "feature", label: "Feature" },
+        { id: "bug", label: "Bug" },
+        { id: "refactor", label: "Refactor" },
+        { id: "research", label: "Research" },
+        { id: "chore", label: "Chore" }
+      ],
+      default: "feature"
+    };
     DEFAULT_CONFIG = {
       version: "2.0",
       defaultProjectDir: defaultProjectDir(),
@@ -1965,9 +2896,875 @@ var init_overviewCopy = __esm({
   }
 });
 
+// src/lifecycle/facts.ts
+var facts_exports = {};
+__export(facts_exports, {
+  areDependenciesSatisfied: () => areDependenciesSatisfied,
+  computeFacts: () => computeFacts,
+  countRealAcceptanceCriteria: () => countRealAcceptanceCriteria,
+  countUnresolvedQuestions: () => countUnresolvedQuestions,
+  hasRealObjective: () => hasRealObjective,
+  isPlanApproved: () => isPlanApproved,
+  latestPlanFile: () => latestPlanFile,
+  planDigest: () => planDigest
+});
+import { createHash } from "crypto";
+import { readdir as readdir6, readFile as readFile9 } from "fs/promises";
+import { resolve as resolve11 } from "path";
+function sectionBody(body, heading) {
+  const re = new RegExp(`^##\\s+${heading}\\s*$`, "m");
+  const m = body.match(re);
+  if (!m || m.index === void 0) return null;
+  const start = m.index + m[0].length;
+  const rest = body.slice(start);
+  const next = rest.search(/^##\s+/m);
+  return next >= 0 ? rest.slice(0, next) : rest;
+}
+function hasRealObjective(body) {
+  const section = sectionBody(body, "Objective");
+  if (section === null) return false;
+  return section.replace(HTML_COMMENT_RE, "").trim().length > 0;
+}
+function countRealAcceptanceCriteria(body) {
+  const section = sectionBody(body, "Acceptance Criteria");
+  if (section === null) return { total: 0, checked: 0 };
+  let total = 0;
+  let checked = 0;
+  for (const line of section.split("\n")) {
+    const m = line.match(/^\s*-\s*\[([ xX])\]\s*(.*)$/);
+    if (!m) continue;
+    const content = m[2].replace(HTML_COMMENT_RE, "").trim();
+    if (content.length === 0) continue;
+    total++;
+    if (m[1].toLowerCase() === "x") checked++;
+  }
+  return { total, checked };
+}
+async function latestPlanFile(assignmentDir) {
+  let entries;
+  try {
+    entries = await readdir6(assignmentDir);
+  } catch {
+    return null;
+  }
+  let best = null;
+  for (const name of entries) {
+    const m = name.match(PLAN_FILE_RE);
+    if (!m) continue;
+    const version = m[1] ? parseInt(m[1], 10) : 1;
+    if (!best || version > best.version) best = { name, version };
+  }
+  return best?.name ?? null;
+}
+function planDigest(content) {
+  return createHash("sha256").update(content, "utf-8").digest("hex");
+}
+async function isPlanApproved(assignmentDir, frontmatter) {
+  const approval = frontmatter.planApproval;
+  if (!approval) return false;
+  const latest = await latestPlanFile(assignmentDir);
+  if (!latest || latest !== approval.file) return false;
+  try {
+    const content = await readFile9(resolve11(assignmentDir, latest), "utf-8");
+    return planDigest(content) === approval.digest;
+  } catch {
+    return false;
+  }
+}
+async function countUnresolvedQuestions(assignmentDir) {
+  const commentsPath = resolve11(assignmentDir, "comments.md");
+  if (!await fileExists(commentsPath)) return 0;
+  try {
+    const content = await readFile9(commentsPath, "utf-8");
+    let count = 0;
+    for (const block of content.split(/^##\s+/m).slice(1)) {
+      if (/^\*\*Type:\*\*\s*question\s*$/m.test(block) && /^\*\*Resolved:\*\*\s*false\s*$/m.test(block)) {
+        count++;
+      }
+    }
+    return count;
+  } catch {
+    return 0;
+  }
+}
+async function areDependenciesSatisfied(projectDir, dependsOn, terminalStatuses) {
+  if (dependsOn.length === 0 || projectDir === null) return true;
+  for (const depSlug of dependsOn) {
+    const depPath = resolve11(projectDir, "assignments", depSlug, "assignment.md");
+    if (!await fileExists(depPath)) return false;
+    try {
+      const content = await readFile9(depPath, "utf-8");
+      const m = content.match(/^status:\s*(.+)$/m);
+      const status = m ? m[1].trim() : "";
+      if (!terminalStatuses.has(status)) return false;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+async function computeFacts(input) {
+  const { assignmentDir, frontmatter, body, projectDir, terminalStatuses } = input;
+  const ac = countRealAcceptanceCriteria(body);
+  const [planFile, planApproved, unresolvedQuestions, depsSatisfied] = await Promise.all([
+    latestPlanFile(assignmentDir),
+    isPlanApproved(assignmentDir, frontmatter),
+    countUnresolvedQuestions(assignmentDir),
+    areDependenciesSatisfied(projectDir, frontmatter.dependsOn, terminalStatuses)
+  ]);
+  return {
+    hasRealObjective: hasRealObjective(body),
+    acRealTotal: ac.total,
+    acRealChecked: ac.checked,
+    acAllChecked: ac.total > 0 && ac.checked === ac.total,
+    planExists: planFile !== null,
+    planApproved,
+    workspaceSet: frontmatter.workspace.repository !== null && frontmatter.workspace.branch !== null,
+    implementationStarted: frontmatter.implementationStarted,
+    depsSatisfied,
+    unresolvedQuestions,
+    blocked: frontmatter.blockedReason !== null,
+    parked: frontmatter.parked,
+    reviewRequested: frontmatter.reviewRequested,
+    pinned: frontmatter.override !== null
+  };
+}
+var HTML_COMMENT_RE, PLAN_FILE_RE;
+var init_facts = __esm({
+  "src/lifecycle/facts.ts"() {
+    "use strict";
+    init_fs();
+    HTML_COMMENT_RE = /<!--[\s\S]*?-->/g;
+    PLAN_FILE_RE = /^plan(?:-v(\d+))?\.md$/;
+  }
+});
+
+// src/utils/query/fields.ts
+function resolveField(registry, name) {
+  return registry[name.toLowerCase()] ?? null;
+}
+function readField(def, fieldName, item) {
+  if (def.get) return def.get(item);
+  return item[fieldName] ?? item[fieldName.toLowerCase()];
+}
+var init_fields = __esm({
+  "src/utils/query/fields.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/query/evaluate.ts
+function localDayBounds(date) {
+  const [y, m, d] = date.split("-").map((n) => parseInt(n, 10));
+  const start = new Date(y, m - 1, d).getTime();
+  const end = new Date(y, m - 1, d + 1).getTime();
+  return [start, end];
+}
+function toEpoch(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "string" && value.length > 0) {
+    const t = Date.parse(value);
+    return Number.isNaN(t) ? null : t;
+  }
+  return null;
+}
+function toNumber(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "string" && value.trim() !== "") {
+    const n = Number(value);
+    return Number.isFinite(n) ? n : null;
+  }
+  return null;
+}
+function ciEquals(a, b) {
+  return typeof a === "string" && a.toLowerCase() === b.toLowerCase();
+}
+function isNone(value) {
+  return value === null || value === void 0 || value === "";
+}
+function compileEquality(def, field, value, atomPos) {
+  switch (def.kind) {
+    case "enum":
+    case "string":
+      if (def.noneSentinel && value.raw.toLowerCase() === "none") {
+        return (item) => isNone(readField(def, field, item));
+      }
+      return (item) => ciEquals(readField(def, field, item), value.raw);
+    case "substring":
+      return (item) => {
+        const v = readField(def, field, item);
+        return typeof v === "string" && v.toLowerCase().includes(value.raw.toLowerCase());
+      };
+    case "bool": {
+      const want = value.raw.toLowerCase();
+      if (want !== "true" && want !== "false") {
+        throw new CompileError([
+          { pos: value.pos, message: `Field "${field}" is boolean \u2014 use ${field}:true or ${field}:false` }
+        ]);
+      }
+      const expected = want === "true";
+      return (item) => {
+        const v = readField(def, field, item);
+        const b = typeof v === "boolean" ? v : v === "true" ? true : v === "false" || v === null || v === void 0 || v === "" ? false : null;
+        return b !== null && b === expected;
+      };
+    }
+    case "number": {
+      const n = value.num ?? toNumber(value.raw);
+      if (n === null) {
+        throw new CompileError([{ pos: value.pos, message: `Field "${field}" is numeric \u2014 "${value.raw}" is not a number` }]);
+      }
+      return (item) => toNumber(readField(def, field, item)) === n;
+    }
+    case "ordinal":
+      return (item) => ciEquals(readField(def, field, item), value.raw);
+    case "list":
+      return (item) => {
+        const v = readField(def, field, item);
+        return Array.isArray(v) && v.some((el) => ciEquals(el, value.raw));
+      };
+    case "timestamp": {
+      if (value.type === "date") {
+        const [start, end] = localDayBounds(value.raw);
+        return (item) => {
+          const t = toEpoch(readField(def, field, item));
+          return t !== null && t >= start && t < end;
+        };
+      }
+      throw new CompileError([
+        { pos: value.pos, message: `Field "${field}" is a timestamp \u2014 use a comparison (e.g. ${field} > -36h) or an absolute date (${field}:2026-06-01)` }
+      ]);
+    }
+    case "duration":
+      throw new CompileError([
+        { pos: atomPos, message: `Field "${field}" is a duration \u2014 use a comparison (e.g. ${field} > 3d)` }
+      ]);
+  }
+}
+function compileComparison(def, field, op, value) {
+  const cmp = (a, b) => {
+    switch (op) {
+      case "<":
+        return a < b;
+      case ">":
+        return a > b;
+      case "<=":
+        return a <= b;
+      case ">=":
+        return a >= b;
+      case "=":
+        return a === b;
+      case "!=":
+        return a !== b;
+      default:
+        return false;
+    }
+  };
+  switch (def.kind) {
+    case "number": {
+      const n = value.num ?? toNumber(value.raw);
+      if (n === null) {
+        throw new CompileError([{ pos: value.pos, message: `"${value.raw}" is not a number (field "${field}")` }]);
+      }
+      return (item) => {
+        const v = toNumber(readField(def, field, item));
+        return v !== null && cmp(v, n);
+      };
+    }
+    case "ordinal": {
+      const order = def.order ?? [];
+      const idx = order.findIndex((o) => o.toLowerCase() === value.raw.toLowerCase());
+      if (idx < 0) {
+        throw new CompileError([
+          { pos: value.pos, message: `"${value.raw}" is not a valid ${field} (expected one of: ${order.join(", ")})` }
+        ]);
+      }
+      return (item) => {
+        const raw = readField(def, field, item);
+        const vIdx = typeof raw === "string" ? order.findIndex((o) => o.toLowerCase() === raw.toLowerCase()) : -1;
+        return vIdx >= 0 && cmp(vIdx, idx);
+      };
+    }
+    case "timestamp": {
+      if (value.type === "duration") {
+        const sign = value.sign === 0 ? -1 : value.sign ?? -1;
+        const offset = sign * (value.num ?? 0);
+        return (item, ctx) => {
+          const t = toEpoch(readField(def, field, item));
+          return t !== null && cmp(t, ctx.now + offset);
+        };
+      }
+      if (value.type === "date") {
+        const [start, end] = localDayBounds(value.raw);
+        return (item) => {
+          const t = toEpoch(readField(def, field, item));
+          if (t === null) return false;
+          switch (op) {
+            case "<":
+              return t < start;
+            case "<=":
+              return t < end;
+            case ">":
+              return t >= end;
+            case ">=":
+              return t >= start;
+            case "=":
+              return t >= start && t < end;
+            case "!=":
+              return t < start || t >= end;
+            default:
+              return false;
+          }
+        };
+      }
+      throw new CompileError([
+        { pos: value.pos, message: `Compare timestamp field "${field}" to a duration (e.g. -36h) or a date (YYYY-MM-DD)` }
+      ]);
+    }
+    case "duration": {
+      if (value.type !== "duration") {
+        throw new CompileError([
+          { pos: value.pos, message: `Compare duration field "${field}" to a duration literal (e.g. 3d)` }
+        ]);
+      }
+      const magnitude = value.num ?? 0;
+      return (item) => {
+        const v = toNumber(readField(def, field, item));
+        return v !== null && cmp(v, magnitude);
+      };
+    }
+    case "enum":
+    case "string":
+    case "substring":
+    case "list": {
+      if (op === "=") {
+        return compileEquality(def, field, value, value.pos);
+      }
+      if (op === "!=") {
+        const eq = compileEquality(def, field, value, value.pos);
+        return (item, ctx) => !eq(item, ctx);
+      }
+      throw new CompileError([
+        { pos: value.pos, message: `Field "${field}" does not support ordering comparisons (use ":" or "=").` }
+      ]);
+    }
+    case "bool": {
+      if (op === "=" || op === "!=") {
+        const eq = compileEquality(def, field, value, value.pos);
+        return op === "=" ? eq : (item, ctx) => !eq(item, ctx);
+      }
+      throw new CompileError([{ pos: value.pos, message: `Field "${field}" is boolean \u2014 use ${field}:true / ${field}:false` }]);
+    }
+  }
+}
+function compileAtom(atom, registry) {
+  const def = resolveField(registry, atom.field);
+  if (!def) {
+    throw new CompileError([{ pos: atom.pos, message: `Unknown field "${atom.field}"` }]);
+  }
+  if (atom.op === ":") {
+    const preds = atom.values.map((v) => compileEquality(def, atom.field, v, atom.pos));
+    if (preds.length === 1) return preds[0];
+    return (item, ctx) => preds.some((p) => p(item, ctx));
+  }
+  return compileComparison(def, atom.field, atom.op, atom.values[0]);
+}
+function compileNode(node, registry) {
+  switch (node.kind) {
+    case "all":
+      return () => true;
+    case "atom":
+      return compileAtom(node, registry);
+    case "not": {
+      const inner = compileNode(node.child, registry);
+      return (item, ctx) => !inner(item, ctx);
+    }
+    case "and": {
+      const preds = node.children.map((c) => compileNode(c, registry));
+      return (item, ctx) => preds.every((p) => p(item, ctx));
+    }
+    case "or": {
+      const preds = node.children.map((c) => compileNode(c, registry));
+      return (item, ctx) => preds.some((p) => p(item, ctx));
+    }
+  }
+}
+var CompileError;
+var init_evaluate = __esm({
+  "src/utils/query/evaluate.ts"() {
+    "use strict";
+    init_fields();
+    CompileError = class extends Error {
+      constructor(errors) {
+        super(errors.map((e) => `${e.message} (at ${e.pos})`).join("; "));
+        this.errors = errors;
+        this.name = "CompileError";
+      }
+    };
+  }
+});
+
+// src/utils/query/lexer.ts
+function lex(input) {
+  const tokens = [];
+  let i = 0;
+  const numberOrDuration = (start, sign) => {
+    let j = i;
+    while (j < input.length && /\d/.test(input[j])) j++;
+    const digits = input.slice(i, j);
+    let unit = "";
+    while (j < input.length && /[a-z]/i.test(input[j])) {
+      unit += input[j];
+      j++;
+    }
+    i = j;
+    if (unit.length > 0) {
+      const ms = DURATION_MS[unit.toLowerCase()];
+      if (ms === void 0) {
+        throw new LexError(start, `Unknown duration unit "${unit}" (expected h, d, w, m, mo, or y)`);
+      }
+      return {
+        type: "DURATION",
+        text: input.slice(start, j),
+        pos: start,
+        num: parseInt(digits, 10) * ms,
+        sign
+      };
+    }
+    if (sign !== 0) {
+      return { type: "NUMBER", text: input.slice(start, j), pos: start, num: sign * parseInt(digits, 10) };
+    }
+    return { type: "NUMBER", text: digits, pos: start, num: parseInt(digits, 10) };
+  };
+  while (i < input.length) {
+    const c = input[i];
+    const start = i;
+    if (c === " " || c === "	" || c === "\n" || c === "\r") {
+      i++;
+      continue;
+    }
+    if (c === "(") {
+      tokens.push({ type: "LPAREN", text: c, pos: start });
+      i++;
+      continue;
+    }
+    if (c === ")") {
+      tokens.push({ type: "RPAREN", text: c, pos: start });
+      i++;
+      continue;
+    }
+    if (c === ",") {
+      tokens.push({ type: "COMMA", text: c, pos: start });
+      i++;
+      continue;
+    }
+    if (c === ":") {
+      tokens.push({ type: "COLON", text: c, pos: start });
+      i++;
+      continue;
+    }
+    if (c === "*") {
+      tokens.push({ type: "STAR", text: c, pos: start });
+      i++;
+      continue;
+    }
+    if (c === "<" || c === ">") {
+      if (input[i + 1] === "=") {
+        tokens.push({ type: "OP", text: c + "=", pos: start });
+        i += 2;
+      } else {
+        tokens.push({ type: "OP", text: c, pos: start });
+        i++;
+      }
+      continue;
+    }
+    if (c === "!") {
+      if (input[i + 1] === "=") {
+        tokens.push({ type: "OP", text: "!=", pos: start });
+        i += 2;
+        continue;
+      }
+      throw new LexError(start, `Unexpected "!" (did you mean "!="?)`);
+    }
+    if (c === "=") {
+      i += input[i + 1] === "=" ? 2 : 1;
+      tokens.push({ type: "OP", text: "=", pos: start });
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      const quote = c;
+      let j = i + 1;
+      let out = "";
+      while (j < input.length && input[j] !== quote) {
+        if (input[j] === "\\" && j + 1 < input.length) {
+          out += input[j + 1];
+          j += 2;
+        } else {
+          out += input[j];
+          j++;
+        }
+      }
+      if (j >= input.length) throw new LexError(start, "Unterminated string literal");
+      tokens.push({ type: "STRING", text: out, pos: start });
+      i = j + 1;
+      continue;
+    }
+    if (c === "-" || c === "+") {
+      if (/\d/.test(input[i + 1] ?? "")) {
+        const sign = c === "-" ? -1 : 1;
+        i++;
+        tokens.push(numberOrDuration(start, sign));
+        continue;
+      }
+      if (c === "-") {
+        tokens.push({ type: "MINUS", text: "-", pos: start });
+        i++;
+        continue;
+      }
+      throw new LexError(start, 'Unexpected "+"');
+    }
+    if (/\d/.test(c)) {
+      const dateMatch = input.slice(i).match(DATE_RE);
+      if (dateMatch) {
+        tokens.push({ type: "DATE", text: dateMatch[0], pos: start });
+        i += dateMatch[0].length;
+        continue;
+      }
+      tokens.push(numberOrDuration(start, 0));
+      continue;
+    }
+    if (IDENT_START.test(c)) {
+      let j = i + 1;
+      while (j < input.length && IDENT_CHAR.test(input[j])) j++;
+      const word = input.slice(i, j);
+      const kw = word.toLowerCase();
+      if (kw === "and") tokens.push({ type: "AND", text: word, pos: start });
+      else if (kw === "or") tokens.push({ type: "OR", text: word, pos: start });
+      else if (kw === "not") tokens.push({ type: "NOT", text: word, pos: start });
+      else tokens.push({ type: "IDENT", text: word, pos: start });
+      i = j;
+      continue;
+    }
+    throw new LexError(start, `Unexpected character "${c}"`);
+  }
+  tokens.push({ type: "EOF", text: "", pos: input.length });
+  return tokens;
+}
+var LexError, DURATION_MS, IDENT_START, IDENT_CHAR, DATE_RE;
+var init_lexer = __esm({
+  "src/utils/query/lexer.ts"() {
+    "use strict";
+    LexError = class extends Error {
+      constructor(pos, message) {
+        super(message);
+        this.pos = pos;
+        this.name = "LexError";
+      }
+    };
+    DURATION_MS = {
+      h: 36e5,
+      d: 864e5,
+      w: 7 * 864e5,
+      m: 30 * 864e5,
+      mo: 30 * 864e5,
+      y: 365 * 864e5
+    };
+    IDENT_START = /[A-Za-z_]/;
+    IDENT_CHAR = /[A-Za-z0-9_-]/;
+    DATE_RE = /^\d{4}-\d{2}-\d{2}/;
+  }
+});
+
+// src/utils/query/parser.ts
+function parseQuery(input) {
+  try {
+    const tokens = lex(input);
+    const ast = new Parser(tokens).parseQuery();
+    return { ast, errors: [] };
+  } catch (err) {
+    if (err instanceof LexError || err instanceof ParseError) {
+      return { ast: null, errors: [{ pos: err.pos, message: err.message }] };
+    }
+    throw err;
+  }
+}
+var ParseError, VALUE_TOKENS, TERM_START, Parser;
+var init_parser3 = __esm({
+  "src/utils/query/parser.ts"() {
+    "use strict";
+    init_lexer();
+    ParseError = class extends Error {
+      constructor(pos, message) {
+        super(message);
+        this.pos = pos;
+        this.name = "ParseError";
+      }
+    };
+    VALUE_TOKENS = /* @__PURE__ */ new Set(["IDENT", "STRING", "NUMBER", "DATE", "DURATION"]);
+    TERM_START = /* @__PURE__ */ new Set(["IDENT", "NOT", "MINUS", "LPAREN", "STAR"]);
+    Parser = class {
+      constructor(tokens) {
+        this.tokens = tokens;
+      }
+      pos = 0;
+      peek() {
+        return this.tokens[this.pos];
+      }
+      next() {
+        return this.tokens[this.pos++];
+      }
+      expect(type, what) {
+        const tok = this.peek();
+        if (tok.type !== type) {
+          throw new ParseError(tok.pos, `Expected ${what}, got "${tok.text || tok.type}"`);
+        }
+        return this.next();
+      }
+      parseQuery() {
+        if (this.peek().type === "EOF") return { kind: "all" };
+        const node = this.orExpr();
+        const tok = this.peek();
+        if (tok.type !== "EOF") {
+          throw new ParseError(tok.pos, `Unexpected "${tok.text}" \u2014 unbalanced parentheses or stray token`);
+        }
+        return node;
+      }
+      orExpr() {
+        const children = [this.andExpr()];
+        while (this.peek().type === "OR") {
+          this.next();
+          children.push(this.andExpr());
+        }
+        return children.length === 1 ? children[0] : { kind: "or", children };
+      }
+      andExpr() {
+        const children = [this.unary()];
+        for (; ; ) {
+          const tok = this.peek();
+          if (tok.type === "AND") {
+            this.next();
+            children.push(this.unary());
+          } else if (TERM_START.has(tok.type)) {
+            children.push(this.unary());
+          } else {
+            break;
+          }
+        }
+        return children.length === 1 ? children[0] : { kind: "and", children };
+      }
+      unary() {
+        const tok = this.peek();
+        if (tok.type === "NOT") {
+          this.next();
+          return { kind: "not", child: this.unary() };
+        }
+        if (tok.type === "MINUS") {
+          this.next();
+          const inner = this.peek();
+          if (inner.type !== "IDENT") {
+            throw new ParseError(inner.pos, 'Expected a field atom after "-" negation');
+          }
+          return { kind: "not", child: this.atom() };
+        }
+        return this.primary();
+      }
+      primary() {
+        const tok = this.peek();
+        if (tok.type === "LPAREN") {
+          this.next();
+          const node = this.orExpr();
+          this.expect("RPAREN", '")"');
+          return node;
+        }
+        if (tok.type === "STAR") {
+          this.next();
+          return { kind: "all" };
+        }
+        if (tok.type === "IDENT") {
+          return this.atom();
+        }
+        throw new ParseError(tok.pos, `Expected a field, "(", "*", or NOT \u2014 got "${tok.text || "end of query"}"`);
+      }
+      atom() {
+        const fieldTok = this.expect("IDENT", "a field name");
+        const opTok = this.peek();
+        if (opTok.type === "COLON") {
+          this.next();
+          const values = this.valueOrList();
+          return { kind: "atom", field: fieldTok.text, op: ":", values, pos: fieldTok.pos };
+        }
+        if (opTok.type === "OP") {
+          this.next();
+          const value = this.value();
+          return {
+            kind: "atom",
+            field: fieldTok.text,
+            op: opTok.text,
+            values: [value],
+            pos: fieldTok.pos
+          };
+        }
+        throw new ParseError(
+          opTok.pos,
+          `Expected ":" or a comparison operator after field "${fieldTok.text}"`
+        );
+      }
+      valueOrList() {
+        if (this.peek().type === "LPAREN") {
+          this.next();
+          const values = [this.value()];
+          while (this.peek().type === "COMMA") {
+            this.next();
+            values.push(this.value());
+          }
+          this.expect("RPAREN", '")" to close the value list');
+          return values;
+        }
+        return [this.value()];
+      }
+      value() {
+        const tok = this.peek();
+        if (!VALUE_TOKENS.has(tok.type)) {
+          throw new ParseError(tok.pos, `Expected a value, got "${tok.text || tok.type}"`);
+        }
+        this.next();
+        switch (tok.type) {
+          case "STRING":
+            return { type: "string", raw: tok.text, pos: tok.pos };
+          case "NUMBER":
+            return { type: "number", raw: tok.text, num: tok.num, pos: tok.pos };
+          case "DATE":
+            return { type: "date", raw: tok.text, pos: tok.pos };
+          case "DURATION":
+            return { type: "duration", raw: tok.text, num: tok.num, sign: tok.sign ?? 0, pos: tok.pos };
+          default:
+            return { type: "word", raw: tok.text, pos: tok.pos };
+        }
+      }
+    };
+  }
+});
+
+// src/utils/query/index.ts
+var init_query = __esm({
+  "src/utils/query/index.ts"() {
+    "use strict";
+    init_evaluate();
+    init_fields();
+    init_parser3();
+    init_parser3();
+    init_evaluate();
+    init_fields();
+  }
+});
+
+// src/lifecycle/derive.ts
+var derive_exports = {};
+__export(derive_exports, {
+  DERIVE_FIELDS: () => DERIVE_FIELDS,
+  deriveDimensions: () => deriveDimensions,
+  validateDeriveCondition: () => validateDeriveCondition
+});
+function validateDeriveCondition(when) {
+  if (when === "*") return null;
+  const parsed = parseQuery(when);
+  if (!parsed.ast) return parsed.errors[0]?.message ?? "unparseable condition";
+  try {
+    compileNode(parsed.ast, DERIVE_FIELDS);
+    return null;
+  } catch (err) {
+    if (err instanceof CompileError) return err.errors[0]?.message ?? "invalid condition";
+    throw err;
+  }
+}
+function compiledWhen(derive, when) {
+  let cache = conditionCache.get(derive);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    conditionCache.set(derive, cache);
+  }
+  let pred = cache.get(when);
+  if (!pred) {
+    if (when === "*") {
+      pred = () => true;
+    } else {
+      const parsed = parseQuery(when);
+      if (!parsed.ast) {
+        throw new CompileError(parsed.errors);
+      }
+      pred = compileNode(parsed.ast, DERIVE_FIELDS);
+    }
+    cache.set(when, pred);
+  }
+  return pred;
+}
+function deriveDimensions(input) {
+  const { facts, derive, currentStatus, terminalStatuses, knownStatusIds, override } = input;
+  if (terminalStatuses.has(currentStatus)) return null;
+  const ctx = { now: 0 };
+  const item = facts;
+  let phase = derive.phaseLadder[0]?.phase ?? currentStatus;
+  let nextAction = derive.phaseLadder[0]?.next ?? null;
+  for (let i = derive.phaseLadder.length - 1; i >= 0; i--) {
+    const rung = derive.phaseLadder[i];
+    if (compiledWhen(derive, rung.when)(item, ctx)) {
+      phase = rung.phase;
+      nextAction = rung.next ?? null;
+      break;
+    }
+  }
+  let disposition = "active";
+  for (const rule of derive.disposition) {
+    if (rule.when === null || compiledWhen(derive, rule.when)(item, ctx)) {
+      disposition = rule.is;
+      break;
+    }
+  }
+  let derivedStatus;
+  switch (disposition) {
+    case "parked":
+      derivedStatus = knownStatusIds.has(derive.headline.parked) ? derive.headline.parked : phase;
+      break;
+    case "blocked":
+      derivedStatus = knownStatusIds.has(derive.headline.blocked) ? derive.headline.blocked : phase;
+      break;
+    default:
+      derivedStatus = phase;
+  }
+  let status = derivedStatus;
+  if (override && override.status && !terminalStatuses.has(override.status) && knownStatusIds.has(override.status)) {
+    status = override.status;
+  }
+  return { phase, disposition, derivedStatus, status, nextAction };
+}
+var DERIVE_FIELDS, conditionCache;
+var init_derive = __esm({
+  "src/lifecycle/derive.ts"() {
+    "use strict";
+    init_query();
+    DERIVE_FIELDS = {
+      hasrealobjective: { kind: "bool", get: (i) => i["hasRealObjective"] },
+      acrealtotal: { kind: "number", get: (i) => i["acRealTotal"] },
+      acrealchecked: { kind: "number", get: (i) => i["acRealChecked"] },
+      acallchecked: { kind: "bool", get: (i) => i["acAllChecked"] },
+      planexists: { kind: "bool", get: (i) => i["planExists"] },
+      planapproved: { kind: "bool", get: (i) => i["planApproved"] },
+      workspaceset: { kind: "bool", get: (i) => i["workspaceSet"] },
+      implementationstarted: { kind: "bool", get: (i) => i["implementationStarted"] },
+      depssatisfied: { kind: "bool", get: (i) => i["depsSatisfied"] },
+      unresolvedquestions: { kind: "number", get: (i) => i["unresolvedQuestions"] },
+      blocked: { kind: "bool" },
+      parked: { kind: "bool" },
+      reviewrequested: { kind: "bool", get: (i) => i["reviewRequested"] },
+      pinned: { kind: "bool" }
+    };
+    conditionCache = /* @__PURE__ */ new WeakMap();
+  }
+});
+
 // src/dashboard/api.ts
-import { readdir as readdir6, readFile as readFile9, writeFile as writeFile3 } from "fs/promises";
-import { resolve as resolve11, dirname as dirname2, basename } from "path";
+import { readdir as readdir7, readFile as readFile10, writeFile as writeFile3 } from "fs/promises";
+import { resolve as resolve12, dirname as dirname2, basename } from "path";
 function activeAssignments(items) {
   return items.filter((item) => item.archived !== true);
 }
@@ -1987,15 +3784,15 @@ async function listStandaloneRecords(assignmentsDir) {
 async function computeStandaloneRecords(assignmentsDir) {
   if (!assignmentsDir) return [];
   if (!await fileExists(assignmentsDir)) return [];
-  const entries = await readdir6(assignmentsDir, { withFileTypes: true });
+  const entries = await readdir7(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");
+    const assignmentDir = resolve12(assignmentsDir, entry.name);
+    const assignmentMdPath = resolve12(assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMdPath)) continue;
     try {
-      const content = await readFile9(assignmentMdPath, "utf-8");
+      const content = await readFile10(assignmentMdPath, "utf-8");
       const record = parseAssignmentFull(content);
       records.push({ assignmentDir, id: entry.name, record });
     } catch {
@@ -2036,7 +3833,8 @@ async function getStatusConfig() {
       order: config.statuses.order,
       transitions: effectiveTransitions,
       transitionTable: buildTransitionTable(effectiveTransitions),
-      terminalStatuses: terminalSet.size > 0 ? terminalSet : /* @__PURE__ */ new Set(["completed", "failed"])
+      terminalStatuses: terminalSet.size > 0 ? terminalSet : /* @__PURE__ */ new Set(["completed", "failed"]),
+      derive: config.statuses.derive ?? null
     };
   } else {
     const def = buildDefaultStatusConfig();
@@ -2046,7 +3844,8 @@ async function getStatusConfig() {
       order: def.order,
       transitions: def.transitions,
       transitionTable: DEFAULT_TRANSITION_TABLE,
-      terminalStatuses: /* @__PURE__ */ new Set(["completed", "failed"])
+      terminalStatuses: /* @__PURE__ */ new Set(["completed", "failed"]),
+      derive: null
     };
   }
   return _cachedConfig;
@@ -2076,23 +3875,23 @@ async function getStandaloneAvailableTransitions(assignment) {
   return actions;
 }
 async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
-  const assignmentDir = resolve11(projectsDir, projectSlug, "assignments", assignmentSlug);
-  const assignmentMdPath = resolve11(assignmentDir, "assignment.md");
+  const assignmentDir = resolve12(projectsDir, projectSlug, "assignments", assignmentSlug);
+  const assignmentMdPath = resolve12(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath)) {
     return null;
   }
-  const assignmentContent = await readFile9(assignmentMdPath, "utf-8");
+  const assignmentContent = await readFile10(assignmentMdPath, "utf-8");
   const assignment = parseAssignmentFull(assignmentContent);
   let projectWorkspace = null;
-  const projectMdPath = resolve11(projectsDir, projectSlug, "project.md");
+  const projectMdPath = resolve12(projectsDir, projectSlug, "project.md");
   if (await fileExists(projectMdPath)) {
-    const projectContent = await readFile9(projectMdPath, "utf-8");
+    const projectContent = await readFile10(projectMdPath, "utf-8");
     projectWorkspace = parseProject(projectContent).workspace;
   }
   let plan = null;
-  const planPath = resolve11(assignmentDir, "plan.md");
+  const planPath = resolve12(assignmentDir, "plan.md");
   if (await fileExists(planPath)) {
-    const planContent = await readFile9(planPath, "utf-8");
+    const planContent = await readFile10(planPath, "utf-8");
     const parsed = parsePlan(planContent);
     plan = {
       status: parsed.status,
@@ -2101,9 +3900,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let scratchpad = null;
-  const scratchpadPath = resolve11(assignmentDir, "scratchpad.md");
+  const scratchpadPath = resolve12(assignmentDir, "scratchpad.md");
   if (await fileExists(scratchpadPath)) {
-    const scratchpadContent = await readFile9(scratchpadPath, "utf-8");
+    const scratchpadContent = await readFile10(scratchpadPath, "utf-8");
     const parsed = parseScratchpad(scratchpadContent);
     scratchpad = {
       updated: parsed.updated,
@@ -2111,9 +3910,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let handoff = null;
-  const handoffPath = resolve11(assignmentDir, "handoff.md");
+  const handoffPath = resolve12(assignmentDir, "handoff.md");
   if (await fileExists(handoffPath)) {
-    const handoffContent = await readFile9(handoffPath, "utf-8");
+    const handoffContent = await readFile10(handoffPath, "utf-8");
     const parsed = parseHandoff(handoffContent);
     handoff = {
       updated: parsed.updated,
@@ -2122,9 +3921,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let decisionRecord = null;
-  const decisionRecordPath = resolve11(assignmentDir, "decision-record.md");
+  const decisionRecordPath = resolve12(assignmentDir, "decision-record.md");
   if (await fileExists(decisionRecordPath)) {
-    const decisionRecordContent = await readFile9(decisionRecordPath, "utf-8");
+    const decisionRecordContent = await readFile10(decisionRecordPath, "utf-8");
     const parsed = parseDecisionRecord(decisionRecordContent);
     decisionRecord = {
       updated: parsed.updated,
@@ -2133,9 +3932,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let progress = null;
-  const progressPath = resolve11(assignmentDir, "progress.md");
+  const progressPath = resolve12(assignmentDir, "progress.md");
   if (await fileExists(progressPath)) {
-    const progressContent = await readFile9(progressPath, "utf-8");
+    const progressContent = await readFile10(progressPath, "utf-8");
     const parsed = parseProgress(progressContent);
     progress = {
       updated: parsed.updated,
@@ -2144,9 +3943,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let comments = null;
-  const commentsPath = resolve11(assignmentDir, "comments.md");
+  const commentsPath = resolve12(assignmentDir, "comments.md");
   if (await fileExists(commentsPath)) {
-    const commentsContent = await readFile9(commentsPath, "utf-8");
+    const commentsContent = await readFile10(commentsPath, "utf-8");
     const parsed = parseComments(commentsContent);
     comments = {
       updated: parsed.updated,
@@ -2154,6 +3953,7 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
       entries: parsed.entries
     };
   }
+  const { terminalStatuses } = await getStatusConfig();
   const detail = {
     id: assignment.id,
     projectSlug,
@@ -2175,6 +3975,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     archived: assignment.archived,
     archivedAt: assignment.archivedAt,
     archivedReason: assignment.archivedReason,
+    ...deriveStatusVirtuals(assignment, terminalStatuses),
+    override: assignment.override,
+    derived: await buildDerivedDetail(assignment, assignmentDir, resolve12(projectsDir, projectSlug)),
     created: assignment.created,
     updated: assignment.updated,
     body: assignment.body,
@@ -2265,7 +4068,7 @@ async function computeReferencedBy(target, projectsDir, assignmentsDir) {
         slug: a.slug,
         title: a.title,
         projectSlug: rec.summary.slug,
-        assignmentDir: resolve11(rec.projectPath, "assignments", a.slug)
+        assignmentDir: resolve12(rec.projectPath, "assignments", a.slug)
       });
     }
   }
@@ -2298,17 +4101,17 @@ async function computeReferencedBy(target, projectsDir, assignmentsDir) {
 }
 async function countMentionsInAssignment(sourceDir, target) {
   const bodies = [];
-  const assignmentMd = resolve11(sourceDir, "assignment.md");
+  const assignmentMd = resolve12(sourceDir, "assignment.md");
   if (await fileExists(assignmentMd)) {
-    const content = await readFile9(assignmentMd, "utf-8");
+    const content = await readFile10(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);
+    const path = resolve12(sourceDir, filename);
     if (await fileExists(path)) {
       try {
-        bodies.push(await readFile9(path, "utf-8"));
+        bodies.push(await readFile10(path, "utf-8"));
       } catch {
       }
     }
@@ -2366,46 +4169,47 @@ async function getAssignmentDetailById(projectsDir, assignmentsDir, id) {
 }
 async function buildStandaloneAssignmentDetail(resolved) {
   const assignmentDir = resolved.assignmentDir;
-  const assignmentMdPath = resolve11(assignmentDir, "assignment.md");
+  const assignmentMdPath = resolve12(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath)) return null;
-  const assignmentContent = await readFile9(assignmentMdPath, "utf-8");
+  const assignmentContent = await readFile10(assignmentMdPath, "utf-8");
   const assignment = parseAssignmentFull(assignmentContent);
   let plan = null;
-  const planPath = resolve11(assignmentDir, "plan.md");
+  const planPath = resolve12(assignmentDir, "plan.md");
   if (await fileExists(planPath)) {
-    const parsed = parsePlan(await readFile9(planPath, "utf-8"));
+    const parsed = parsePlan(await readFile10(planPath, "utf-8"));
     plan = { status: parsed.status, updated: parsed.updated, body: parsed.body };
   }
   let scratchpad = null;
-  const scratchpadPath = resolve11(assignmentDir, "scratchpad.md");
+  const scratchpadPath = resolve12(assignmentDir, "scratchpad.md");
   if (await fileExists(scratchpadPath)) {
-    const parsed = parseScratchpad(await readFile9(scratchpadPath, "utf-8"));
+    const parsed = parseScratchpad(await readFile10(scratchpadPath, "utf-8"));
     scratchpad = { updated: parsed.updated, body: parsed.body };
   }
   let handoff = null;
-  const handoffPath = resolve11(assignmentDir, "handoff.md");
+  const handoffPath = resolve12(assignmentDir, "handoff.md");
   if (await fileExists(handoffPath)) {
-    const parsed = parseHandoff(await readFile9(handoffPath, "utf-8"));
+    const parsed = parseHandoff(await readFile10(handoffPath, "utf-8"));
     handoff = { updated: parsed.updated, handoffCount: parsed.handoffCount, body: parsed.body };
   }
   let decisionRecord = null;
-  const decisionRecordPath = resolve11(assignmentDir, "decision-record.md");
+  const decisionRecordPath = resolve12(assignmentDir, "decision-record.md");
   if (await fileExists(decisionRecordPath)) {
-    const parsed = parseDecisionRecord(await readFile9(decisionRecordPath, "utf-8"));
+    const parsed = parseDecisionRecord(await readFile10(decisionRecordPath, "utf-8"));
     decisionRecord = { updated: parsed.updated, decisionCount: parsed.decisionCount, body: parsed.body };
   }
   let progress = null;
-  const progressPath = resolve11(assignmentDir, "progress.md");
+  const progressPath = resolve12(assignmentDir, "progress.md");
   if (await fileExists(progressPath)) {
-    const parsed = parseProgress(await readFile9(progressPath, "utf-8"));
+    const parsed = parseProgress(await readFile10(progressPath, "utf-8"));
     progress = { updated: parsed.updated, entryCount: parsed.entryCount, entries: parsed.entries };
   }
   let comments = null;
-  const commentsPath = resolve11(assignmentDir, "comments.md");
+  const commentsPath = resolve12(assignmentDir, "comments.md");
   if (await fileExists(commentsPath)) {
-    const parsed = parseComments(await readFile9(commentsPath, "utf-8"));
+    const parsed = parseComments(await readFile10(commentsPath, "utf-8"));
     comments = { updated: parsed.updated, entryCount: parsed.entryCount, entries: parsed.entries };
   }
+  const { terminalStatuses } = await getStatusConfig();
   const detail = {
     id: assignment.id,
     projectSlug: null,
@@ -2428,6 +4232,9 @@ async function buildStandaloneAssignmentDetail(resolved) {
     archived: assignment.archived,
     archivedAt: assignment.archivedAt,
     archivedReason: assignment.archivedReason,
+    ...deriveStatusVirtuals(assignment, terminalStatuses),
+    override: assignment.override,
+    derived: await buildDerivedDetail(assignment, assignmentDir, null),
     created: assignment.created,
     updated: assignment.updated,
     body: assignment.body,
@@ -2459,17 +4266,17 @@ async function computeProjectRecords(projectsDir, traces) {
     await migrateLegacyProjectFiles(projectsDir);
     await migrateLegacyArchivedProjects(projectsDir);
   }
-  const entries = await readdir6(projectsDir, { withFileTypes: true });
+  const entries = await readdir7(projectsDir, { withFileTypes: true });
   const projectDirs = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
   const maybeRecords = await Promise.all(
     projectDirs.map(async (entry) => {
-      const projectPath = resolve11(projectsDir, entry.name);
-      const projectMdPath = resolve11(projectPath, "project.md");
+      const projectPath = resolve12(projectsDir, entry.name);
+      const projectMdPath = resolve12(projectPath, "project.md");
       if (!await fileExists(projectMdPath)) {
         return null;
       }
       const t0 = traces ? performance.now() : 0;
-      const projectContent = await readFile9(projectMdPath, "utf-8");
+      const projectContent = await readFile10(projectMdPath, "utf-8");
       const project = parseProject(projectContent);
       if (traces) accumulatePhase(traces, "parse-project-md", performance.now() - t0);
       const t1 = traces ? performance.now() : 0;
@@ -2510,20 +4317,20 @@ async function computeProjectRecords(projectsDir, traces) {
   return records;
 }
 async function listAssignmentRecords(projectPath, traces) {
-  const assignmentsDir = resolve11(projectPath, "assignments");
+  const assignmentsDir = resolve12(projectPath, "assignments");
   if (!await fileExists(assignmentsDir)) {
     return [];
   }
-  const entries = await readdir6(assignmentsDir, { withFileTypes: true });
+  const entries = await readdir7(assignmentsDir, { withFileTypes: true });
   const dirEntries = entries.filter((entry) => entry.isDirectory());
   const maybeRecords = await Promise.all(
     dirEntries.map(async (entry) => {
-      const assignmentMd = resolve11(assignmentsDir, entry.name, "assignment.md");
+      const assignmentMd = resolve12(assignmentsDir, entry.name, "assignment.md");
       if (!await fileExists(assignmentMd)) {
         return null;
       }
       const t0 = traces ? performance.now() : 0;
-      const content = await readFile9(assignmentMd, "utf-8");
+      const content = await readFile10(assignmentMd, "utf-8");
       const parsed = parseAssignmentFull(content);
       if (traces) accumulatePhase(traces, "read-assignment-md", performance.now() - t0);
       return parsed;
@@ -2534,9 +4341,9 @@ async function listAssignmentRecords(projectPath, traces) {
   return records;
 }
 async function loadDependencyGraph(projectPath, assignments) {
-  const statusPath = resolve11(projectPath, "_status.md");
+  const statusPath = resolve12(projectPath, "_status.md");
   if (await fileExists(statusPath)) {
-    const statusContent = await readFile9(statusPath, "utf-8");
+    const statusContent = await readFile10(statusPath, "utf-8");
     const parsed = parseStatus(statusContent);
     const derivedGraph = extractMermaidGraph(parsed.body);
     if (derivedGraph) {
@@ -2586,6 +4393,78 @@ async function buildProjectRollup(projectPath, project, assignments, traces) {
   }
   return { progress, needsAttention, status };
 }
+function deriveStatusVirtuals(assignment, terminalStatuses) {
+  const hist = assignment.statusHistory ?? [];
+  let completedAt = null;
+  if (terminalStatuses.has(assignment.status)) {
+    for (const entry of hist) {
+      if (entry.to === assignment.status) completedAt = entry.at;
+    }
+  }
+  let statusAge = null;
+  for (let i = hist.length - 1; i >= 0; i--) {
+    const entry = hist[i];
+    if (entry.from !== entry.to || entry.from === null) {
+      const t = Date.parse(entry.at);
+      statusAge = Number.isNaN(t) ? null : Date.now() - t;
+      break;
+    }
+  }
+  let phaseAge = null;
+  for (let i = hist.length - 1; i >= 0; i--) {
+    const entry = hist[i];
+    if (entry.phaseTo !== void 0 && entry.phaseFrom !== entry.phaseTo) {
+      const t = Date.parse(entry.at);
+      phaseAge = Number.isNaN(t) ? null : Date.now() - t;
+      break;
+    }
+  }
+  return {
+    completedAt,
+    statusAge,
+    phaseAge,
+    phase: assignment.phase,
+    disposition: assignment.disposition,
+    pinned: assignment.override !== null
+  };
+}
+async function buildDerivedDetail(assignment, assignmentDir, projectDir) {
+  const config = await getStatusConfig();
+  if (config.terminalStatuses.has(assignment.status)) return null;
+  try {
+    const { computeFacts: computeFacts2 } = await Promise.resolve().then(() => (init_facts(), facts_exports));
+    const { deriveDimensions: deriveDimensions2 } = await Promise.resolve().then(() => (init_derive(), derive_exports));
+    const { DEFAULT_DERIVE_CONFIG: DEFAULT_DERIVE_CONFIG2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
+    const facts = await computeFacts2({
+      assignmentDir,
+      frontmatter: {
+        ...assignment
+        // AssignmentRecord ⊃ the fields computeFacts reads; statusHistory and
+        // derived caches ride along untouched.
+      },
+      body: assignment.body,
+      projectDir,
+      terminalStatuses: config.terminalStatuses
+    });
+    const dims = deriveDimensions2({
+      facts,
+      derive: config.derive ?? DEFAULT_DERIVE_CONFIG2,
+      currentStatus: assignment.status,
+      terminalStatuses: config.terminalStatuses,
+      knownStatusIds: new Set(config.statuses.map((s) => s.id)),
+      override: assignment.override
+    });
+    if (!dims) return null;
+    return {
+      derivedStatus: dims.derivedStatus,
+      nextAction: dims.nextAction,
+      facts
+    };
+  } catch (err) {
+    console.warn(`buildDerivedDetail failed for ${assignmentDir}:`, err);
+    return null;
+  }
+}
 function buildDependencyGraph(assignments) {
   const edges = [];
   const usedStatuses = /* @__PURE__ */ new Set();
@@ -2616,7 +4495,7 @@ async function getAvailableTransitions(projectsDir, projectSlug, assignmentSlug,
   const config = await getStatusConfig();
   const transitionDefs = getTransitionDefinitions(config);
   const actions = [];
-  const projectPath = resolve11(projectsDir, projectSlug);
+  const projectPath = resolve12(projectsDir, projectSlug);
   const traces = options?.traces;
   for (const definition of transitionDefs) {
     const target = getTargetStatus(assignment.status, definition.command, config.transitionTable);
@@ -2664,12 +4543,12 @@ async function getUnmetDependencies(projectPath, dependsOn, terminalStatuses, de
         continue;
       }
     }
-    const dependencyPath = resolve11(projectPath, "assignments", dependency, "assignment.md");
+    const dependencyPath = resolve12(projectPath, "assignments", dependency, "assignment.md");
     if (!await fileExists(dependencyPath)) {
       unmet.push(`${dependency} (missing)`);
       continue;
     }
-    const content = await readFile9(dependencyPath, "utf-8");
+    const content = await readFile10(dependencyPath, "utf-8");
     const parsed = parseAssignmentFull(content);
     if (!terminals.has(parsed.status)) {
       unmet.push(`${dependency} (${parsed.status})`);
@@ -2685,7 +4564,7 @@ function parseTimestamp(timestamp) {
   return Number.isFinite(parsed) ? parsed : 0;
 }
 async function countOpenQuestions(projectPath, assignmentSlug) {
-  const commentsPath = resolve11(
+  const commentsPath = resolve12(
     projectPath,
     "assignments",
     assignmentSlug,
@@ -2695,7 +4574,7 @@ async function countOpenQuestions(projectPath, assignmentSlug) {
     return 0;
   }
   try {
-    const content = await readFile9(commentsPath, "utf-8");
+    const content = await readFile10(commentsPath, "utf-8");
     const parsed = parseComments(content);
     return parsed.entries.filter(
       (e) => e.type === "question" && e.resolved !== true
@@ -2951,7 +4830,7 @@ init_api();
 init_agents_schema();
 import { spawn } from "child_process";
 import { mkdir as mkdir2, writeFile as writeFile4 } from "fs/promises";
-import { isAbsolute as isAbsolute3, resolve as resolve12 } from "path";
+import { isAbsolute as isAbsolute3, resolve as resolve13 } from "path";
 
 // src/launch/cwd.ts
 import { existsSync, statSync } from "fs";
@@ -3327,7 +5206,7 @@ async function executeLaunchPlan(plan, spawnFn = realSpawn) {
       `Spawn failed: ${msg}. Verify the terminal is installed and on PATH.`
     );
   }
-  await new Promise((resolve14, reject) => {
+  await new Promise((resolve15, reject) => {
     let settled = false;
     let stderr = "";
     const finishOk = () => {
@@ -3337,7 +5216,7 @@ async function executeLaunchPlan(plan, spawnFn = realSpawn) {
         child.unref();
       } catch {
       }
-      resolve14();
+      resolve15();
     };
     const finishErr = (remediation) => {
       if (settled) return;
@@ -3522,7 +5401,7 @@ function appleScriptString(value) {
 init_paths();
 init_fs();
 import { fileURLToPath } from "url";
-import { dirname as dirname3, resolve as resolve13, join as join3 } from "path";
+import { dirname as dirname3, resolve as resolve14, join as join3 } from "path";
 import { realpathSync, readFileSync, mkdirSync } from "fs";
 var NPX_PATTERNS = [
   { kind: "npm", re: /\/_npx\/([^/]+)\/node_modules(?:\/|$)/ },
@@ -3548,7 +5427,7 @@ function normalizeSlashes(p) {
 }
 function detectInstallKind(scriptUrl, opts = {}) {
   const realpath = opts.realpath ?? realpathSync.native;
-  const readFile10 = opts.readFile ?? ((p) => readFileSync(p, "utf-8"));
+  const readFile11 = 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) {
@@ -3569,7 +5448,7 @@ function detectInstallKind(scriptUrl, opts = {}) {
     const pkgJsonPath = join3(dir, "package.json");
     let raw;
     try {
-      raw = readFile10(pkgJsonPath);
+      raw = readFile11(pkgJsonPath);
     } catch {
       const parent2 = dirname3(dir);
       if (parent2 === dir) break;
@@ -3601,7 +5480,7 @@ function extractNpxHash(scriptUrl, opts = {}) {
   return null;
 }
 function nudgeStampDir() {
-  return resolve13(syntaurRoot(), "npx-handler-nudge");
+  return resolve14(syntaurRoot(), "npx-handler-nudge");
 }
 function sanitizeHash(hash) {
   return hash.replace(/[^A-Za-z0-9_-]/g, "_") || "_";