syntaur 0.41.2 → 0.42.0

package/dist/dashboard/server.js

@@ -88,7 +88,7 @@ var init_paths = __esm({
 });
 
 // src/lifecycle/types.ts
-var DEFAULT_STATUSES;
+var DEFAULT_STATUSES, DEFAULT_TERMINAL_STATUSES;
 var init_types = __esm({
   "src/lifecycle/types.ts"() {
     "use strict";
@@ -103,6 +103,10 @@ var init_types = __esm({
       "completed",
       "failed"
     ];
+    DEFAULT_TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+      "completed",
+      "failed"
+    ]);
   }
 });
 
@@ -160,6 +164,17 @@ var init_state_machine = __esm({
 });
 
 // src/lifecycle/frontmatter.ts
+var frontmatter_exports = {};
+__export(frontmatter_exports, {
+  appendStatusHistoryEntry: () => appendStatusHistoryEntry,
+  parseAssignmentFrontmatter: () => parseAssignmentFrontmatter,
+  renameStatusInHistory: () => renameStatusInHistory,
+  updateAssignmentFile: () => updateAssignmentFile,
+  updateAssignmentWorkspace: () => updateAssignmentWorkspace,
+  updateNestedBlock: () => updateNestedBlock,
+  updateOverride: () => updateOverride,
+  updatePlanApproval: () => updatePlanApproval
+});
 function extractFrontmatter(fileContent) {
   const match = fileContent.match(/^---\n([\s\S]*?)\n---/);
   if (!match) {
@@ -172,7 +187,10 @@ function extractFrontmatter(fileContent) {
 function parseSimpleValue(raw2) {
   const trimmed = raw2.trim();
   if (trimmed === "null" || trimmed === "~" || trimmed === "") return null;
-  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') && trimmed.length >= 2) {
+    return trimmed.slice(1, -1).replace(/\\(["\\])/g, "$1");
+  }
+  if (trimmed.startsWith("'") && trimmed.endsWith("'") && trimmed.length >= 2) {
     return trimmed.slice(1, -1);
   }
   return trimmed;
@@ -232,6 +250,89 @@ 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 parseNestedBlock(frontmatter, header) {
+  if (new RegExp(`^${header}:\\s*(null|~)\\s*$`, "m").test(frontmatter)) return null;
+  const headerMatch = frontmatter.match(new RegExp(`^${header}:\\s*$`, "m"));
+  if (!headerMatch) return null;
+  const headerStart = headerMatch.index ?? frontmatter.indexOf(headerMatch[0]);
+  const after = frontmatter.slice(headerStart + headerMatch[0].length + 1);
+  const out = {};
+  for (const line of after.split("\n")) {
+    if (line.length === 0) continue;
+    if (line[0] !== " " && line[0] !== "	") break;
+    const colonIdx = line.indexOf(":");
+    if (colonIdx < 0) continue;
+    const key = line.slice(0, colonIdx).trim();
+    if (!key) continue;
+    out[key] = parseSimpleValue(line.slice(colonIdx + 1));
+  }
+  return Object.keys(out).length > 0 ? out : null;
+}
+function parsePlanApproval(frontmatter) {
+  const block = parseNestedBlock(frontmatter, "planApproval");
+  if (!block || !block["file"] || !block["digest"]) return null;
+  return {
+    file: block["file"],
+    digest: block["digest"],
+    by: block["by"] ?? null,
+    at: block["at"] ?? ""
+  };
+}
+function parseOverride(frontmatter) {
+  const block = parseNestedBlock(frontmatter, "override");
+  if (!block || !block["status"]) return null;
+  return {
+    status: block["status"],
+    source: block["source"] ?? "human",
+    reason: block["reason"] ?? null,
+    at: block["at"] ?? ""
+  };
+}
 function parseWorkspace(frontmatter) {
   const defaults = {
     repository: null,
@@ -280,6 +381,7 @@ function parseAssignmentFrontmatter(fileContent) {
     updated: getField2("updated") ?? "",
     assignee: getField2("assignee"),
     externalIds: parseExternalIds(frontmatter),
+    statusHistory: parseStatusHistory(frontmatter),
     dependsOn: parseDependsOn(frontmatter),
     links: parseLinks(frontmatter),
     blockedReason: getField2("blockedReason"),
@@ -287,16 +389,29 @@ function parseAssignmentFrontmatter(fileContent) {
     tags: parseTags(frontmatter),
     archived: getField2("archived") === "true",
     archivedAt: getField2("archivedAt"),
-    archivedReason: getField2("archivedReason")
+    archivedReason: getField2("archivedReason"),
+    phase: getField2("phase"),
+    disposition: getField2("disposition"),
+    planApproval: parsePlanApproval(frontmatter),
+    parked: getField2("parked") === "true",
+    reviewRequested: getField2("reviewRequested") === "true",
+    implementationStarted: getField2("implementationStarted") === "true",
+    override: parseOverride(frontmatter)
   };
 }
 function formatYamlValue(value) {
   if (typeof value === "boolean") return value ? "true" : "false";
   if (value === null) return "null";
+  if (/[\r\n]/.test(value)) {
+    value = value.replace(/\s*[\r\n]+\s*/g, " ").trim();
+  }
   if (/^\d{4}-\d{2}-\d{2}T/.test(value)) {
     return `"${value}"`;
   }
-  if (/[:#{}[\],&*?|>!%@`]/.test(value) || /^\s|\s$/.test(value) || value === "") {
+  if (/^(null|~|true|false|-?\d+(\.\d+)?)$/i.test(value)) {
+    return `"${value}"`;
+  }
+  if (/[:#{}[\],&*?|>!%@\`]/.test(value) || /^\s|\s$/.test(value) || value === "") {
     const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
     return `"${escaped}"`;
   }
@@ -376,6 +491,123 @@ ${lines.join("\n")}`;
   }
   return `${fmMatch[1]}${newFm}${fmMatch[3]}${fileContent.slice(fmMatch[0].length)}`;
 }
+function renameStatusInHistory(content, oldId, newId) {
+  const fmMatch = content.match(/^(---\n)([\s\S]*?)(\n---)/);
+  if (!fmMatch) return content;
+  const esc = oldId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const re = new RegExp(`^(\\s+(?:from|to|phaseFrom|phaseTo):[ \\t]*)("?)${esc}\\2[ \\t]*$`, "gm");
+  const newFm = fmMatch[2].replace(re, (_m, prefix, quote) => `${prefix}${quote}${newId}${quote}`);
+  return `${fmMatch[1]}${newFm}${fmMatch[3]}${content.slice(fmMatch[0].length)}`;
+}
+function findStatusHistoryBlock(fmBlock) {
+  const headerMatch = fmBlock.match(/^statusHistory:\s*$/m);
+  if (!headerMatch) return null;
+  const headerStart = headerMatch.index ?? fmBlock.indexOf(headerMatch[0]);
+  const bodyStart = headerStart + headerMatch[0].length + 1;
+  const after = fmBlock.slice(bodyStart);
+  const lines = after.split("\n");
+  let consumed = 0;
+  for (const line of lines) {
+    if (line.length === 0) {
+      consumed += line.length + 1;
+      continue;
+    }
+    if (line[0] !== " " && line[0] !== "	") break;
+    consumed += line.length + 1;
+  }
+  const bodyEnd = Math.min(bodyStart + consumed, fmBlock.length);
+  return { headerStart, bodyStart, bodyEnd };
+}
+function renderStatusHistoryItem(entry) {
+  const lines = [
+    `  - at: ${formatYamlValue(entry.at)}`,
+    `    from: ${formatYamlValue(entry.from)}`,
+    `    to: ${formatYamlValue(entry.to)}`,
+    `    command: ${formatYamlValue(entry.command)}`,
+    `    by: ${formatYamlValue(entry.by)}`
+  ];
+  if (entry.reason !== void 0 && entry.reason !== null) {
+    lines.push(`    reason: ${formatYamlValue(entry.reason)}`);
+  }
+  for (const key of ["phaseFrom", "phaseTo", "dispositionFrom", "dispositionTo"]) {
+    if (entry[key] !== void 0) {
+      lines.push(`    ${key}: ${formatYamlValue(entry[key] ?? null)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function updateNestedBlock(fileContent, header, record) {
+  const fmMatch = fileContent.match(/^(---\n)([\s\S]*?)(\n---)/);
+  if (!fmMatch) {
+    throw new Error("No frontmatter found in assignment file. Expected --- delimiters.");
+  }
+  const fmBlock = fmMatch[2];
+  const rendered = record === null ? `${header}: null` : [`${header}:`, ...Object.entries(record).map(([k, v]) => `  ${k}: ${formatYamlValue(v)}`)].join("\n");
+  const headerRe = new RegExp(`^${header}:.*$`, "m");
+  const headerMatch = fmBlock.match(headerRe);
+  let newFm;
+  if (headerMatch) {
+    const start = headerMatch.index ?? 0;
+    let end = start + headerMatch[0].length;
+    const after = fmBlock.slice(end);
+    let scanned = 0;
+    for (const line of after.split("\n").slice(1)) {
+      if (line.length === 0) {
+        scanned += 1 + line.length;
+        continue;
+      }
+      if (line[0] !== " " && line[0] !== "	") break;
+      scanned += 1 + line.length;
+      end += scanned;
+      scanned = 0;
+    }
+    newFm = fmBlock.slice(0, start) + rendered + fmBlock.slice(end);
+  } else {
+    newFm = `${fmBlock.replace(/\n+$/, "")}
+${rendered}`;
+  }
+  return `${fmMatch[1]}${newFm}${fmMatch[3]}${fileContent.slice(fmMatch[0].length)}`;
+}
+function updatePlanApproval(fileContent, approval) {
+  return updateNestedBlock(
+    fileContent,
+    "planApproval",
+    approval === null ? null : { file: approval.file, digest: approval.digest, by: approval.by, at: approval.at }
+  );
+}
+function updateOverride(fileContent, override) {
+  return updateNestedBlock(
+    fileContent,
+    "override",
+    override === null ? null : { status: override.status, source: override.source, reason: override.reason, at: override.at }
+  );
+}
+function appendStatusHistoryEntry(fileContent, entry) {
+  const fmMatch = fileContent.match(/^(---\n)([\s\S]*?)(\n---)/);
+  if (!fmMatch) {
+    throw new Error("No frontmatter found in assignment file. Expected --- delimiters.");
+  }
+  const fmBlock = fmMatch[2];
+  const item = renderStatusHistoryItem(entry);
+  const inlineRegex = /^statusHistory:[ \t]*\[[ \t]*\][ \t]*$/m;
+  const block = findStatusHistoryBlock(fmBlock);
+  let newFm;
+  if (inlineRegex.test(fmBlock)) {
+    newFm = fmBlock.replace(inlineRegex, `statusHistory:
+${item}`);
+  } else if (block) {
+    const before = fmBlock.slice(0, block.bodyEnd);
+    const rest = fmBlock.slice(block.bodyEnd);
+    const sep1 = before.endsWith("\n") ? "" : "\n";
+    const sep2 = rest.length > 0 && !rest.startsWith("\n") ? "\n" : "";
+    newFm = `${before}${sep1}${item}${sep2}${rest}`;
+  } else {
+    newFm = `${fmBlock.replace(/\n+$/, "")}
+statusHistory:
+${item}`;
+  }
+  return `${fmMatch[1]}${newFm}${fmMatch[3]}${fileContent.slice(fmMatch[0].length)}`;
+}
 var init_frontmatter = __esm({
   "src/lifecycle/frontmatter.ts"() {
     "use strict";
@@ -586,6 +818,51 @@ function parseExternalIds2(frontmatter) {
   }
   return results;
 }
+function parseStatusHistory2(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] = parseSimpleValue2(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] = extractFrontmatter2(fileContent);
   return {
@@ -608,13 +885,40 @@ function parseAssignmentFull(fileContent) {
       parentBranch: getNestedField(fm, "workspace", "parentBranch")
     },
     externalIds: parseExternalIds2(fm),
+    statusHistory: parseStatusHistory2(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) {
@@ -1309,7 +1613,10 @@ async function checkDependencies(projectDir, dependsOn, terminalStatuses) {
 async function executeTransition(projectDir, assignmentSlug, command, options = {}) {
   const filePath = resolveAssignmentPath(projectDir, assignmentSlug);
   const { content, frontmatter } = await readAssignment(filePath);
-  const targetStatus = getTargetStatus(frontmatter.status, command, options.transitionTable);
+  const targetStatus = (options.transitionTable ? getTargetStatus(frontmatter.status, command, options.transitionTable) : null) ?? options.commandTargets?.get(command) ?? // Built-ins apply only when NEITHER custom mechanism was supplied — a
+  // provided-but-miss commandTargets means "custom config had no answer",
+  // which must refuse, not silently fall back (codex r4).
+  (!options.transitionTable && !options.commandTargets ? getTargetStatus(frontmatter.status, command) : null);
   if (!targetStatus) {
     return {
       success: false,
@@ -1324,20 +1631,37 @@ async function executeTransition(projectDir, assignmentSlug, command, options =
       warnings.push(`Starting with unmet dependencies: ${depCheck.unmet.join(", ")}`);
     }
   }
+  const now = nowTimestamp();
   const updates = {
     status: targetStatus,
-    updated: nowTimestamp()
+    updated: now
   };
   if (ASSIGNEE_SETTING_COMMANDS.has(command) && options.agent && !frontmatter.assignee) {
     updates.assignee = options.agent;
   }
   if (command === "block") {
-    updates.blockedReason = options.reason ?? null;
+    updates.blockedReason = options.reason ?? "(unspecified)";
   }
   if (command === "unblock") {
     updates.blockedReason = null;
   }
-  const updatedContent = updateAssignmentFile(content, updates);
+  const terminalSet = options.terminalStatuses ?? /* @__PURE__ */ new Set(["completed", "failed"]);
+  const enteringTerminal = terminalSet.has(targetStatus) && frontmatter.disposition !== "terminal";
+  if (enteringTerminal) {
+    updates.disposition = "terminal";
+  }
+  let updatedContent = updateAssignmentFile(content, updates);
+  if (targetStatus !== frontmatter.status) {
+    updatedContent = appendStatusHistoryEntry(updatedContent, {
+      at: now,
+      from: frontmatter.status,
+      to: targetStatus,
+      command,
+      by: options.agent ?? frontmatter.assignee ?? null,
+      reason: command === "block" ? options.reason : void 0,
+      ...enteringTerminal ? { dispositionFrom: frontmatter.disposition, dispositionTo: "terminal" } : {}
+    });
+  }
   await writeFileForce(filePath, updatedContent);
   await applyLinkedTodosSideEffect(options.linkedTodosLookup, command, targetStatus, frontmatter);
   return {
@@ -1351,7 +1675,10 @@ async function executeTransition(projectDir, assignmentSlug, command, options =
 async function executeTransitionByDir(assignmentDir, command, options = {}) {
   const filePath = resolve4(assignmentDir, "assignment.md");
   const { content, frontmatter } = await readAssignment(filePath);
-  const targetStatus = getTargetStatus(frontmatter.status, command, options.transitionTable);
+  const targetStatus = (options.transitionTable ? getTargetStatus(frontmatter.status, command, options.transitionTable) : null) ?? options.commandTargets?.get(command) ?? // Built-ins apply only when NEITHER custom mechanism was supplied — a
+  // provided-but-miss commandTargets means "custom config had no answer",
+  // which must refuse, not silently fall back (codex r4).
+  (!options.transitionTable && !options.commandTargets ? getTargetStatus(frontmatter.status, command) : null);
   if (!targetStatus) {
     return {
       success: false,
@@ -1371,20 +1698,37 @@ async function executeTransitionByDir(assignmentDir, command, options = {}) {
       warnings.push(`Starting with unmet dependencies: ${depCheck.unmet.join(", ")}`);
     }
   }
+  const now = nowTimestamp();
   const updates = {
     status: targetStatus,
-    updated: nowTimestamp()
+    updated: now
   };
   if (ASSIGNEE_SETTING_COMMANDS.has(command) && options.agent && !frontmatter.assignee) {
     updates.assignee = options.agent;
   }
   if (command === "block") {
-    updates.blockedReason = options.reason ?? null;
+    updates.blockedReason = options.reason ?? "(unspecified)";
   }
   if (command === "unblock") {
     updates.blockedReason = null;
   }
-  const updatedContent = updateAssignmentFile(content, updates);
+  const terminalSetByDir = options.terminalStatuses ?? /* @__PURE__ */ new Set(["completed", "failed"]);
+  const enteringTerminalByDir = terminalSetByDir.has(targetStatus) && frontmatter.disposition !== "terminal";
+  if (enteringTerminalByDir) {
+    updates.disposition = "terminal";
+  }
+  let updatedContent = updateAssignmentFile(content, updates);
+  if (targetStatus !== frontmatter.status) {
+    updatedContent = appendStatusHistoryEntry(updatedContent, {
+      at: now,
+      from: frontmatter.status,
+      to: targetStatus,
+      command,
+      by: options.agent ?? frontmatter.assignee ?? null,
+      reason: command === "block" ? options.reason : void 0,
+      ...enteringTerminalByDir ? { dispositionFrom: frontmatter.disposition, dispositionTo: "terminal" } : {}
+    });
+  }
   await writeFileForce(filePath, updatedContent);
   await applyLinkedTodosSideEffect(options.linkedTodosLookup, command, targetStatus, frontmatter);
   return {
@@ -1862,6 +2206,7 @@ __export(config_exports, {
   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,
@@ -1888,6 +2233,7 @@ __export(config_exports, {
   updateOnboardingConfig: () => updateOnboardingConfig,
   updatePlaybooksConfig: () => updatePlaybooksConfig,
   validateAgentList: () => validateAgentList,
+  validateDeriveConfig: () => validateDeriveConfig,
   writeAgentsConfig: () => writeAgentsConfig,
   writeHotkeyBindingsConfig: () => writeHotkeyBindingsConfig,
   writeStatusConfig: () => writeStatusConfig,
@@ -2059,6 +2405,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) {
@@ -2091,6 +2447,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;
     }
@@ -2129,12 +2488,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) {
@@ -2182,8 +2581,68 @@ function serializeStatusConfig(statuses) {
       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) {
@@ -3238,7 +3697,7 @@ async function updateAgentsConfig(mutation, options = {}) {
   await writeAgentsConfig(next);
   return { previous, next, written: true };
 }
-var DEFAULT_ASSIGNMENT_TYPES, DEFAULT_CONFIG, AUTO_CREATE_WORKTREE_VALUES, AgentConfigError, DEFAULT_STATUS_COLORS, KNOWN_AGENT_SCALAR_FIELDS, migratedConfigPaths, TerminalConfigError;
+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";
@@ -3252,6 +3711,35 @@ 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" },
@@ -4230,8 +4718,8 @@ async function migrateFromMarkdown(projectsDir) {
   return allSessions.length;
 }
 async function parseMarkdownSessionsIndex(filePath, projectSlug) {
-  const { readFile: readFile21 } = await import("fs/promises");
-  const raw2 = await readFile21(filePath, "utf-8");
+  const { readFile: readFile23 } = await import("fs/promises");
+  const raw2 = await readFile23(filePath, "utf-8");
   const sessions = [];
   const lines = raw2.split("\n");
   let inTable = false;
@@ -4667,8 +5155,8 @@ function scanKey(serversDir2, projectsDir, assignmentsDir2) {
   return `${serversDir2}\0${projectsDir}\0${assignmentsDir2 ?? ""}`;
 }
 function delay(ms) {
-  return new Promise((resolve32) => {
-    const timer2 = setTimeout(resolve32, ms);
+  return new Promise((resolve34) => {
+    const timer2 = setTimeout(resolve34, ms);
     if (typeof timer2.unref === "function") {
       timer2.unref();
     }
@@ -5074,45 +5562,911 @@ async function scanAllSessions(serversDir2, projectsDir, options) {
       delay(COLD_WAIT_BUDGET_MS).then(() => emptyScan())
     ]);
   }
-  return refresh;
-}
-async function scanSingleSession(serversDir2, projectsDir, name, options) {
-  const data = await readSessionFile(serversDir2, name);
-  if (!data) return null;
-  const [lsofOutput, workspaceRecords, procSnapshot] = await Promise.all([
-    getLsofOutput(),
-    loadWorkspaceRecords(projectsDir, options?.assignmentsDir),
-    getProcessSnapshot()
-  ]);
-  if (data.kind === "process") {
-    return scanProcessSession(data, lsofOutput, workspaceRecords);
+  return refresh;
+}
+async function scanSingleSession(serversDir2, projectsDir, name, options) {
+  const data = await readSessionFile(serversDir2, name);
+  if (!data) return null;
+  const [lsofOutput, workspaceRecords, procSnapshot] = await Promise.all([
+    getLsofOutput(),
+    loadWorkspaceRecords(projectsDir, options?.assignmentsDir),
+    getProcessSnapshot()
+  ]);
+  if (data.kind === "process") {
+    return scanProcessSession(data, lsofOutput, workspaceRecords);
+  }
+  return scanSession(data, lsofOutput, workspaceRecords, procSnapshot);
+}
+var exec, cache, lastKnown, inFlight, forceFreshNext, scanEpoch, cacheKey, CACHE_TTL_MS, COLD_WAIT_BUDGET_MS, PROBE_TIMEOUT_MS, PROBE_MAX_BUFFER, tmuxAvailableCache;
+var init_scanner = __esm({
+  "src/dashboard/scanner.ts"() {
+    "use strict";
+    init_api();
+    init_servers();
+    exec = promisify(execFile);
+    cache = null;
+    lastKnown = null;
+    inFlight = null;
+    forceFreshNext = false;
+    scanEpoch = 0;
+    cacheKey = null;
+    CACHE_TTL_MS = 1e4;
+    COLD_WAIT_BUDGET_MS = 2500;
+    PROBE_TIMEOUT_MS = 15e3;
+    PROBE_MAX_BUFFER = 32 * 1024 * 1024;
+    tmuxAvailableCache = null;
+  }
+});
+
+// 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 readdir7, readFile as readFile10 } from "fs/promises";
+import { resolve as resolve13 } 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 readdir7(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 readFile10(resolve13(assignmentDir, latest), "utf-8");
+    return planDigest(content) === approval.digest;
+  } catch {
+    return false;
+  }
+}
+async function countUnresolvedQuestions(assignmentDir) {
+  const commentsPath = resolve13(assignmentDir, "comments.md");
+  if (!await fileExists(commentsPath)) return 0;
+  try {
+    const content = await readFile10(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 = resolve13(projectDir, "assignments", depSlug, "assignment.md");
+    if (!await fileExists(depPath)) return false;
+    try {
+      const content = await readFile10(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 raw2 = readField(def, field, item);
+        const vIdx = typeof raw2 === "string" ? order.findIndex((o) => o.toLowerCase() === raw2.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 cache2 = conditionCache.get(derive);
+  if (!cache2) {
+    cache2 = /* @__PURE__ */ new Map();
+    conditionCache.set(derive, cache2);
+  }
+  let pred = cache2.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);
+    }
+    cache2.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 scanSession(data, lsofOutput, workspaceRecords, procSnapshot);
+  return { phase, disposition, derivedStatus, status, nextAction };
 }
-var exec, cache, lastKnown, inFlight, forceFreshNext, scanEpoch, cacheKey, CACHE_TTL_MS, COLD_WAIT_BUDGET_MS, PROBE_TIMEOUT_MS, PROBE_MAX_BUFFER, tmuxAvailableCache;
-var init_scanner = __esm({
-  "src/dashboard/scanner.ts"() {
+var DERIVE_FIELDS, conditionCache;
+var init_derive = __esm({
+  "src/lifecycle/derive.ts"() {
     "use strict";
-    init_api();
-    init_servers();
-    exec = promisify(execFile);
-    cache = null;
-    lastKnown = null;
-    inFlight = null;
-    forceFreshNext = false;
-    scanEpoch = 0;
-    cacheKey = null;
-    CACHE_TTL_MS = 1e4;
-    COLD_WAIT_BUDGET_MS = 2500;
-    PROBE_TIMEOUT_MS = 15e3;
-    PROBE_MAX_BUFFER = 32 * 1024 * 1024;
-    tmuxAvailableCache = null;
+    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 readdir7, readFile as readFile10, writeFile as writeFile3 } from "fs/promises";
-import { resolve as resolve13, dirname as dirname2, basename } from "path";
+import { readdir as readdir8, readFile as readFile11, writeFile as writeFile3 } from "fs/promises";
+import { resolve as resolve14, dirname as dirname2, basename } from "path";
 function clearFrontmatterField(content, key) {
   const fieldRegex = new RegExp(`^(${escapeRegExp2(key)}:)\\s*.*$`, "m");
   return content.replace(fieldRegex, `$1 null`);
@@ -5191,15 +6545,15 @@ async function listStandaloneRecords(assignmentsDir2) {
 async function computeStandaloneRecords(assignmentsDir2) {
   if (!assignmentsDir2) return [];
   if (!await fileExists(assignmentsDir2)) return [];
-  const entries = await readdir7(assignmentsDir2, { withFileTypes: true });
+  const entries = await readdir8(assignmentsDir2, { withFileTypes: true });
   const records = [];
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
-    const assignmentDir = resolve13(assignmentsDir2, entry.name);
-    const assignmentMdPath = resolve13(assignmentDir, "assignment.md");
+    const assignmentDir = resolve14(assignmentsDir2, entry.name);
+    const assignmentMdPath = resolve14(assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMdPath)) continue;
     try {
-      const content = await readFile10(assignmentMdPath, "utf-8");
+      const content = await readFile11(assignmentMdPath, "utf-8");
       const record = parseAssignmentFull(content);
       records.push({ assignmentDir, id: entry.name, record });
     } catch {
@@ -5240,7 +6594,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();
@@ -5250,7 +6605,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;
@@ -5263,9 +6619,9 @@ async function listProjects(projectsDir) {
   return projectRecords.filter((record) => !isProjectArchived(record.summary)).map((record) => record.summary);
 }
 async function readWorkspaceRegistry(projectsDir) {
-  const registryPath = resolve13(dirname2(projectsDir), "workspaces.json");
+  const registryPath = resolve14(dirname2(projectsDir), "workspaces.json");
   try {
-    const raw2 = await readFile10(registryPath, "utf-8");
+    const raw2 = await readFile11(registryPath, "utf-8");
     const parsed = JSON.parse(raw2);
     return Array.isArray(parsed) ? parsed.filter((w) => typeof w === "string") : [];
   } catch {
@@ -5273,7 +6629,7 @@ async function readWorkspaceRegistry(projectsDir) {
   }
 }
 async function writeWorkspaceRegistry(projectsDir, workspaces) {
-  const registryPath = resolve13(dirname2(projectsDir), "workspaces.json");
+  const registryPath = resolve14(dirname2(projectsDir), "workspaces.json");
   await writeFile3(registryPath, JSON.stringify(workspaces, null, 2) + "\n", "utf-8");
 }
 async function listWorkspaces(projectsDir, assignmentsDir2) {
@@ -5353,8 +6709,8 @@ async function deleteWorkspace(projectsDir, name, opts = {}) {
   if (cascade) {
     const timestamp = nowTimestamp();
     for (const slug of projectsReferencing) {
-      const path = resolve13(projectsDir, slug, "project.md");
-      const raw2 = await readFile10(path, "utf-8");
+      const path = resolve14(projectsDir, slug, "project.md");
+      const raw2 = await readFile11(path, "utf-8");
       let next = clearFrontmatterField(raw2, "workspace");
       next = setUpdatedField(next, timestamp);
       await writeFileForce(path, next);
@@ -5362,8 +6718,8 @@ async function deleteWorkspace(projectsDir, name, opts = {}) {
     }
     for (const id of standalonesReferencing) {
       if (!opts.assignmentsDir) break;
-      const path = resolve13(opts.assignmentsDir, id, "assignment.md");
-      const raw2 = await readFile10(path, "utf-8");
+      const path = resolve14(opts.assignmentsDir, id, "assignment.md");
+      const raw2 = await readFile11(path, "utf-8");
       let next = clearFrontmatterField(raw2, "workspaceGroup");
       next = setUpdatedField(next, timestamp);
       await writeFileForce(path, next);
@@ -5559,8 +6915,9 @@ async function listArchived(projectsDir, assignmentsDir2) {
   return { projects, assignments: individuallyArchived };
 }
 async function toStandaloneBoardItem(sr) {
+  const { terminalStatuses } = await getStatusConfig();
   return {
-    ...toAssignmentSummary(sr.record),
+    ...toAssignmentSummary(sr.record, terminalStatuses),
     projectSlug: null,
     projectTitle: null,
     blockedReason: sr.record.blockedReason,
@@ -5600,7 +6957,7 @@ async function getEditableDocument(projectsDir, documentType, projectSlug, assig
   if (!filePath || !await fileExists(filePath)) {
     return null;
   }
-  const content = await readFile10(filePath, "utf-8");
+  const content = await readFile11(filePath, "utf-8");
   const title = getEditableDocumentTitle(documentType, projectSlug, assignmentSlug);
   return {
     documentType,
@@ -5624,9 +6981,9 @@ async function getEditableDocumentById(projectsDir, assignmentsDir2, documentTyp
   }
   const fileName = documentType === "assignment" ? "assignment.md" : documentType === "plan" ? "plan.md" : documentType === "scratchpad" ? "scratchpad.md" : documentType === "handoff" ? "handoff.md" : documentType === "decision-record" ? "decision-record.md" : null;
   if (!fileName) return null;
-  const filePath = resolve13(resolved.assignmentDir, fileName);
+  const filePath = resolve14(resolved.assignmentDir, fileName);
   if (!await fileExists(filePath)) return null;
-  const content = await readFile10(filePath, "utf-8");
+  const content = await readFile11(filePath, "utf-8");
   const label = resolved.id;
   const title = documentType === "assignment" ? `Edit Assignment: ${label}` : documentType === "plan" ? `Edit Plan: ${label}` : documentType === "scratchpad" ? `Edit Scratchpad: ${label}` : documentType === "handoff" ? `Append Handoff: ${label}` : `Append Decision: ${label}`;
   return {
@@ -5640,12 +6997,12 @@ async function getEditableDocumentById(projectsDir, assignmentsDir2, documentTyp
   };
 }
 async function getProjectDetail(projectsDir, slug) {
-  const projectPath = resolve13(projectsDir, slug);
-  const projectMdPath = resolve13(projectPath, "project.md");
+  const projectPath = resolve14(projectsDir, slug);
+  const projectMdPath = resolve14(projectPath, "project.md");
   if (!await fileExists(projectMdPath)) {
     return null;
   }
-  const projectContent = await readFile10(projectMdPath, "utf-8");
+  const projectContent = await readFile11(projectMdPath, "utf-8");
   const project = parseProject(projectContent);
   const assignments = await listAssignmentRecords(projectPath);
   const rollup = await buildProjectRollup(projectPath, project, assignments);
@@ -5653,6 +7010,7 @@ async function getProjectDetail(projectsDir, slug) {
   const resources = await listResources(projectPath);
   const memories = await listMemories(projectPath);
   const updated = getProjectActivityTimestamp(project.updated, activeAssignments(assignments));
+  const { terminalStatuses } = await getStatusConfig();
   return {
     slug: project.slug || slug,
     title: project.title,
@@ -5668,7 +7026,7 @@ async function getProjectDetail(projectsDir, slug) {
     body: project.body,
     progress: rollup.progress,
     needsAttention: rollup.needsAttention,
-    assignments: assignments.map(toAssignmentSummary).sort((left, right) => compareTimestamps(right.updated, left.updated)),
+    assignments: assignments.map((a) => toAssignmentSummary(a, terminalStatuses)).sort((left, right) => compareTimestamps(right.updated, left.updated)),
     resources,
     memories,
     dependencyGraph,
@@ -5677,23 +7035,23 @@ async function getProjectDetail(projectsDir, slug) {
   };
 }
 async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
-  const assignmentDir = resolve13(projectsDir, projectSlug, "assignments", assignmentSlug);
-  const assignmentMdPath = resolve13(assignmentDir, "assignment.md");
+  const assignmentDir = resolve14(projectsDir, projectSlug, "assignments", assignmentSlug);
+  const assignmentMdPath = resolve14(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath)) {
     return null;
   }
-  const assignmentContent = await readFile10(assignmentMdPath, "utf-8");
+  const assignmentContent = await readFile11(assignmentMdPath, "utf-8");
   const assignment = parseAssignmentFull(assignmentContent);
   let projectWorkspace = null;
-  const projectMdPath = resolve13(projectsDir, projectSlug, "project.md");
+  const projectMdPath = resolve14(projectsDir, projectSlug, "project.md");
   if (await fileExists(projectMdPath)) {
-    const projectContent = await readFile10(projectMdPath, "utf-8");
+    const projectContent = await readFile11(projectMdPath, "utf-8");
     projectWorkspace = parseProject(projectContent).workspace;
   }
   let plan = null;
-  const planPath = resolve13(assignmentDir, "plan.md");
+  const planPath = resolve14(assignmentDir, "plan.md");
   if (await fileExists(planPath)) {
-    const planContent = await readFile10(planPath, "utf-8");
+    const planContent = await readFile11(planPath, "utf-8");
     const parsed = parsePlan(planContent);
     plan = {
       status: parsed.status,
@@ -5702,9 +7060,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let scratchpad = null;
-  const scratchpadPath = resolve13(assignmentDir, "scratchpad.md");
+  const scratchpadPath = resolve14(assignmentDir, "scratchpad.md");
   if (await fileExists(scratchpadPath)) {
-    const scratchpadContent = await readFile10(scratchpadPath, "utf-8");
+    const scratchpadContent = await readFile11(scratchpadPath, "utf-8");
     const parsed = parseScratchpad(scratchpadContent);
     scratchpad = {
       updated: parsed.updated,
@@ -5712,9 +7070,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let handoff = null;
-  const handoffPath = resolve13(assignmentDir, "handoff.md");
+  const handoffPath = resolve14(assignmentDir, "handoff.md");
   if (await fileExists(handoffPath)) {
-    const handoffContent = await readFile10(handoffPath, "utf-8");
+    const handoffContent = await readFile11(handoffPath, "utf-8");
     const parsed = parseHandoff(handoffContent);
     handoff = {
       updated: parsed.updated,
@@ -5723,9 +7081,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let decisionRecord = null;
-  const decisionRecordPath = resolve13(assignmentDir, "decision-record.md");
+  const decisionRecordPath = resolve14(assignmentDir, "decision-record.md");
   if (await fileExists(decisionRecordPath)) {
-    const decisionRecordContent = await readFile10(decisionRecordPath, "utf-8");
+    const decisionRecordContent = await readFile11(decisionRecordPath, "utf-8");
     const parsed = parseDecisionRecord(decisionRecordContent);
     decisionRecord = {
       updated: parsed.updated,
@@ -5734,9 +7092,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let progress = null;
-  const progressPath = resolve13(assignmentDir, "progress.md");
+  const progressPath = resolve14(assignmentDir, "progress.md");
   if (await fileExists(progressPath)) {
-    const progressContent = await readFile10(progressPath, "utf-8");
+    const progressContent = await readFile11(progressPath, "utf-8");
     const parsed = parseProgress(progressContent);
     progress = {
       updated: parsed.updated,
@@ -5745,9 +7103,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let comments = null;
-  const commentsPath = resolve13(assignmentDir, "comments.md");
+  const commentsPath = resolve14(assignmentDir, "comments.md");
   if (await fileExists(commentsPath)) {
-    const commentsContent = await readFile10(commentsPath, "utf-8");
+    const commentsContent = await readFile11(commentsPath, "utf-8");
     const parsed = parseComments(commentsContent);
     comments = {
       updated: parsed.updated,
@@ -5755,6 +7113,7 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
       entries: parsed.entries
     };
   }
+  const { terminalStatuses } = await getStatusConfig();
   const detail = {
     id: assignment.id,
     projectSlug,
@@ -5776,6 +7135,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, resolve14(projectsDir, projectSlug)),
     created: assignment.created,
     updated: assignment.updated,
     body: assignment.body,
@@ -5866,7 +7228,7 @@ async function computeReferencedBy(target, projectsDir, assignmentsDir2) {
         slug: a.slug,
         title: a.title,
         projectSlug: rec.summary.slug,
-        assignmentDir: resolve13(rec.projectPath, "assignments", a.slug)
+        assignmentDir: resolve14(rec.projectPath, "assignments", a.slug)
       });
     }
   }
@@ -5899,17 +7261,17 @@ async function computeReferencedBy(target, projectsDir, assignmentsDir2) {
 }
 async function countMentionsInAssignment(sourceDir, target) {
   const bodies = [];
-  const assignmentMd = resolve13(sourceDir, "assignment.md");
+  const assignmentMd = resolve14(sourceDir, "assignment.md");
   if (await fileExists(assignmentMd)) {
-    const content = await readFile10(assignmentMd, "utf-8");
+    const content = await readFile11(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 = resolve13(sourceDir, filename);
+    const path = resolve14(sourceDir, filename);
     if (await fileExists(path)) {
       try {
-        bodies.push(await readFile10(path, "utf-8"));
+        bodies.push(await readFile11(path, "utf-8"));
       } catch {
       }
     }
@@ -5967,46 +7329,47 @@ async function getAssignmentDetailById(projectsDir, assignmentsDir2, id) {
 }
 async function buildStandaloneAssignmentDetail(resolved) {
   const assignmentDir = resolved.assignmentDir;
-  const assignmentMdPath = resolve13(assignmentDir, "assignment.md");
+  const assignmentMdPath = resolve14(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath)) return null;
-  const assignmentContent = await readFile10(assignmentMdPath, "utf-8");
+  const assignmentContent = await readFile11(assignmentMdPath, "utf-8");
   const assignment = parseAssignmentFull(assignmentContent);
   let plan = null;
-  const planPath = resolve13(assignmentDir, "plan.md");
+  const planPath = resolve14(assignmentDir, "plan.md");
   if (await fileExists(planPath)) {
-    const parsed = parsePlan(await readFile10(planPath, "utf-8"));
+    const parsed = parsePlan(await readFile11(planPath, "utf-8"));
     plan = { status: parsed.status, updated: parsed.updated, body: parsed.body };
   }
   let scratchpad = null;
-  const scratchpadPath = resolve13(assignmentDir, "scratchpad.md");
+  const scratchpadPath = resolve14(assignmentDir, "scratchpad.md");
   if (await fileExists(scratchpadPath)) {
-    const parsed = parseScratchpad(await readFile10(scratchpadPath, "utf-8"));
+    const parsed = parseScratchpad(await readFile11(scratchpadPath, "utf-8"));
     scratchpad = { updated: parsed.updated, body: parsed.body };
   }
   let handoff = null;
-  const handoffPath = resolve13(assignmentDir, "handoff.md");
+  const handoffPath = resolve14(assignmentDir, "handoff.md");
   if (await fileExists(handoffPath)) {
-    const parsed = parseHandoff(await readFile10(handoffPath, "utf-8"));
+    const parsed = parseHandoff(await readFile11(handoffPath, "utf-8"));
     handoff = { updated: parsed.updated, handoffCount: parsed.handoffCount, body: parsed.body };
   }
   let decisionRecord = null;
-  const decisionRecordPath = resolve13(assignmentDir, "decision-record.md");
+  const decisionRecordPath = resolve14(assignmentDir, "decision-record.md");
   if (await fileExists(decisionRecordPath)) {
-    const parsed = parseDecisionRecord(await readFile10(decisionRecordPath, "utf-8"));
+    const parsed = parseDecisionRecord(await readFile11(decisionRecordPath, "utf-8"));
     decisionRecord = { updated: parsed.updated, decisionCount: parsed.decisionCount, body: parsed.body };
   }
   let progress = null;
-  const progressPath = resolve13(assignmentDir, "progress.md");
+  const progressPath = resolve14(assignmentDir, "progress.md");
   if (await fileExists(progressPath)) {
-    const parsed = parseProgress(await readFile10(progressPath, "utf-8"));
+    const parsed = parseProgress(await readFile11(progressPath, "utf-8"));
     progress = { updated: parsed.updated, entryCount: parsed.entryCount, entries: parsed.entries };
   }
   let comments = null;
-  const commentsPath = resolve13(assignmentDir, "comments.md");
+  const commentsPath = resolve14(assignmentDir, "comments.md");
   if (await fileExists(commentsPath)) {
-    const parsed = parseComments(await readFile10(commentsPath, "utf-8"));
+    const parsed = parseComments(await readFile11(commentsPath, "utf-8"));
     comments = { updated: parsed.updated, entryCount: parsed.entryCount, entries: parsed.entries };
   }
+  const { terminalStatuses } = await getStatusConfig();
   const detail = {
     id: assignment.id,
     projectSlug: null,
@@ -6029,6 +7392,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,
@@ -6060,17 +7426,17 @@ async function computeProjectRecords(projectsDir, traces) {
     await migrateLegacyProjectFiles(projectsDir);
     await migrateLegacyArchivedProjects(projectsDir);
   }
-  const entries = await readdir7(projectsDir, { withFileTypes: true });
+  const entries = await readdir8(projectsDir, { withFileTypes: true });
   const projectDirs = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
   const maybeRecords = await Promise.all(
     projectDirs.map(async (entry) => {
-      const projectPath = resolve13(projectsDir, entry.name);
-      const projectMdPath = resolve13(projectPath, "project.md");
+      const projectPath = resolve14(projectsDir, entry.name);
+      const projectMdPath = resolve14(projectPath, "project.md");
       if (!await fileExists(projectMdPath)) {
         return null;
       }
       const t0 = traces ? performance.now() : 0;
-      const projectContent = await readFile10(projectMdPath, "utf-8");
+      const projectContent = await readFile11(projectMdPath, "utf-8");
       const project = parseProject(projectContent);
       if (traces) accumulatePhase(traces, "parse-project-md", performance.now() - t0);
       const t1 = traces ? performance.now() : 0;
@@ -6111,20 +7477,20 @@ async function computeProjectRecords(projectsDir, traces) {
   return records;
 }
 async function listAssignmentRecords(projectPath, traces) {
-  const assignmentsDir2 = resolve13(projectPath, "assignments");
+  const assignmentsDir2 = resolve14(projectPath, "assignments");
   if (!await fileExists(assignmentsDir2)) {
     return [];
   }
-  const entries = await readdir7(assignmentsDir2, { withFileTypes: true });
+  const entries = await readdir8(assignmentsDir2, { withFileTypes: true });
   const dirEntries = entries.filter((entry) => entry.isDirectory());
   const maybeRecords = await Promise.all(
     dirEntries.map(async (entry) => {
-      const assignmentMd = resolve13(assignmentsDir2, entry.name, "assignment.md");
+      const assignmentMd = resolve14(assignmentsDir2, entry.name, "assignment.md");
       if (!await fileExists(assignmentMd)) {
         return null;
       }
       const t0 = traces ? performance.now() : 0;
-      const content = await readFile10(assignmentMd, "utf-8");
+      const content = await readFile11(assignmentMd, "utf-8");
       const parsed = parseAssignmentFull(content);
       if (traces) accumulatePhase(traces, "read-assignment-md", performance.now() - t0);
       return parsed;
@@ -6135,18 +7501,18 @@ async function listAssignmentRecords(projectPath, traces) {
   return records;
 }
 async function listResources(projectPath) {
-  const resourcesDir = resolve13(projectPath, "resources");
+  const resourcesDir = resolve14(projectPath, "resources");
   if (!await fileExists(resourcesDir)) {
     return [];
   }
-  const entries = await readdir7(resourcesDir, { withFileTypes: true });
+  const entries = await readdir8(resourcesDir, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_")) {
       continue;
     }
-    const filePath = resolve13(resourcesDir, entry.name);
-    const content = await readFile10(filePath, "utf-8");
+    const filePath = resolve14(resourcesDir, entry.name);
+    const content = await readFile11(filePath, "utf-8");
     const parsed = parseResource(content);
     results.push({
       name: parsed.name,
@@ -6161,18 +7527,18 @@ async function listResources(projectPath) {
   return results;
 }
 async function listMemories(projectPath) {
-  const memoriesDir = resolve13(projectPath, "memories");
+  const memoriesDir = resolve14(projectPath, "memories");
   if (!await fileExists(memoriesDir)) {
     return [];
   }
-  const entries = await readdir7(memoriesDir, { withFileTypes: true });
+  const entries = await readdir8(memoriesDir, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_")) {
       continue;
     }
-    const filePath = resolve13(memoriesDir, entry.name);
-    const content = await readFile10(filePath, "utf-8");
+    const filePath = resolve14(memoriesDir, entry.name);
+    const content = await readFile11(filePath, "utf-8");
     const parsed = parseMemory(content);
     results.push({
       name: parsed.name,
@@ -6220,8 +7586,8 @@ async function listAllResources(projectsDir) {
   return all;
 }
 async function resolveProjectPath(projectsDir, projectSlug) {
-  const direct = resolve13(projectsDir, projectSlug);
-  if (await fileExists(resolve13(direct, "project.md"))) return direct;
+  const direct = resolve14(projectsDir, projectSlug);
+  if (await fileExists(resolve14(direct, "project.md"))) return direct;
   const records = await listProjectRecords(projectsDir);
   const match = records.find((r) => r.summary.slug === projectSlug);
   return match ? match.projectPath : null;
@@ -6233,9 +7599,9 @@ async function getMemoryDetail(projectsDir, projectSlug, itemSlug) {
     (p) => basename(p.projectPath) === projectSlug || p.summary.slug === projectSlug
   );
   if (!projectRecord) return null;
-  const filePath = resolve13(projectRecord.projectPath, "memories", `${itemSlug}.md`);
+  const filePath = resolve14(projectRecord.projectPath, "memories", `${itemSlug}.md`);
   if (!await fileExists(filePath)) return null;
-  const content = await readFile10(filePath, "utf-8");
+  const content = await readFile11(filePath, "utf-8");
   const parsed = parseMemory(content);
   return {
     name: parsed.name,
@@ -6259,9 +7625,9 @@ async function getResourceDetail(projectsDir, projectSlug, itemSlug) {
     (p) => basename(p.projectPath) === projectSlug || p.summary.slug === projectSlug
   );
   if (!projectRecord) return null;
-  const filePath = resolve13(projectRecord.projectPath, "resources", `${itemSlug}.md`);
+  const filePath = resolve14(projectRecord.projectPath, "resources", `${itemSlug}.md`);
   if (!await fileExists(filePath)) return null;
-  const content = await readFile10(filePath, "utf-8");
+  const content = await readFile11(filePath, "utf-8");
   const parsed = parseResource(content);
   return {
     name: parsed.name,
@@ -6277,9 +7643,9 @@ async function getResourceDetail(projectsDir, projectSlug, itemSlug) {
   };
 }
 async function loadDependencyGraph(projectPath, assignments) {
-  const statusPath = resolve13(projectPath, "_status.md");
+  const statusPath = resolve14(projectPath, "_status.md");
   if (await fileExists(statusPath)) {
-    const statusContent = await readFile10(statusPath, "utf-8");
+    const statusContent = await readFile11(statusPath, "utf-8");
     const parsed = parseStatus(statusContent);
     const derivedGraph = extractMermaidGraph(parsed.body);
     if (derivedGraph) {
@@ -6329,7 +7695,79 @@ async function buildProjectRollup(projectPath, project, assignments, traces) {
   }
   return { progress, needsAttention, status };
 }
-function toAssignmentSummary(assignment) {
+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 toAssignmentSummary(assignment, terminalStatuses) {
   return {
     id: assignment.id,
     slug: assignment.slug,
@@ -6345,12 +7783,14 @@ function toAssignmentSummary(assignment) {
     updated: assignment.updated,
     archived: assignment.archived,
     archivedAt: assignment.archivedAt,
-    archivedReason: assignment.archivedReason
+    archivedReason: assignment.archivedReason,
+    ...deriveStatusVirtuals(assignment, terminalStatuses)
   };
 }
 async function toAssignmentBoardItem(projectsDir, projectRecord, assignment) {
+  const { terminalStatuses } = await getStatusConfig();
   return {
-    ...toAssignmentSummary(assignment),
+    ...toAssignmentSummary(assignment, terminalStatuses),
     projectSlug: projectRecord.summary.slug,
     projectTitle: projectRecord.summary.title,
     blockedReason: assignment.blockedReason,
@@ -6393,7 +7833,7 @@ async function getAvailableTransitions(projectsDir, projectSlug, assignmentSlug,
   const config = await getStatusConfig();
   const transitionDefs = getTransitionDefinitions(config);
   const actions = [];
-  const projectPath = resolve13(projectsDir, projectSlug);
+  const projectPath = resolve14(projectsDir, projectSlug);
   const traces = options?.traces;
   for (const definition of transitionDefs) {
     const target = getTargetStatus(assignment.status, definition.command, config.transitionTable);
@@ -6441,12 +7881,12 @@ async function getUnmetDependencies(projectPath, dependsOn, terminalStatuses, de
         continue;
       }
     }
-    const dependencyPath = resolve13(projectPath, "assignments", dependency, "assignment.md");
+    const dependencyPath = resolve14(projectPath, "assignments", dependency, "assignment.md");
     if (!await fileExists(dependencyPath)) {
       unmet.push(`${dependency} (missing)`);
       continue;
     }
-    const content = await readFile10(dependencyPath, "utf-8");
+    const content = await readFile11(dependencyPath, "utf-8");
     const parsed = parseAssignmentFull(content);
     if (!terminals.has(parsed.status)) {
       unmet.push(`${dependency} (${parsed.status})`);
@@ -6731,7 +8171,7 @@ function isStale(updated) {
   return Date.now() - timestamp > STALE_ASSIGNMENT_MS;
 }
 async function countOpenQuestions(projectPath, assignmentSlug) {
-  const commentsPath = resolve13(
+  const commentsPath = resolve14(
     projectPath,
     "assignments",
     assignmentSlug,
@@ -6741,7 +8181,7 @@ async function countOpenQuestions(projectPath, assignmentSlug) {
     return 0;
   }
   try {
-    const content = await readFile10(commentsPath, "utf-8");
+    const content = await readFile11(commentsPath, "utf-8");
     const parsed = parseComments(content);
     return parsed.entries.filter(
       (e) => e.type === "question" && e.resolved !== true
@@ -6762,21 +8202,21 @@ function getProjectActivityTimestamp(projectUpdated, assignments) {
 function getDocumentPath(projectsDir, documentType, projectSlug, assignmentSlug) {
   switch (documentType) {
     case "project":
-      return resolve13(projectsDir, projectSlug, "project.md");
+      return resolve14(projectsDir, projectSlug, "project.md");
     case "assignment":
-      return assignmentSlug ? resolve13(projectsDir, projectSlug, "assignments", assignmentSlug, "assignment.md") : null;
+      return assignmentSlug ? resolve14(projectsDir, projectSlug, "assignments", assignmentSlug, "assignment.md") : null;
     case "plan":
-      return assignmentSlug ? resolve13(projectsDir, projectSlug, "assignments", assignmentSlug, "plan.md") : null;
+      return assignmentSlug ? resolve14(projectsDir, projectSlug, "assignments", assignmentSlug, "plan.md") : null;
     case "scratchpad":
-      return assignmentSlug ? resolve13(projectsDir, projectSlug, "assignments", assignmentSlug, "scratchpad.md") : null;
+      return assignmentSlug ? resolve14(projectsDir, projectSlug, "assignments", assignmentSlug, "scratchpad.md") : null;
     case "handoff":
-      return assignmentSlug ? resolve13(projectsDir, projectSlug, "assignments", assignmentSlug, "handoff.md") : null;
+      return assignmentSlug ? resolve14(projectsDir, projectSlug, "assignments", assignmentSlug, "handoff.md") : null;
     case "decision-record":
-      return assignmentSlug ? resolve13(projectsDir, projectSlug, "assignments", assignmentSlug, "decision-record.md") : null;
+      return assignmentSlug ? resolve14(projectsDir, projectSlug, "assignments", assignmentSlug, "decision-record.md") : null;
     case "memory":
-      return assignmentSlug ? resolve13(projectsDir, projectSlug, "memories", `${assignmentSlug}.md`) : null;
+      return assignmentSlug ? resolve14(projectsDir, projectSlug, "memories", `${assignmentSlug}.md`) : null;
     case "resource":
-      return assignmentSlug ? resolve13(projectsDir, projectSlug, "resources", `${assignmentSlug}.md`) : null;
+      return assignmentSlug ? resolve14(projectsDir, projectSlug, "resources", `${assignmentSlug}.md`) : null;
     default:
       return null;
   }
@@ -6809,12 +8249,12 @@ async function listPlaybooks(playbooksDir2) {
   if (!await fileExists(playbooksDir2)) return [];
   const config = await readConfig();
   const disabledSet = new Set(config.playbooks.disabled);
-  const entries = await readdir7(playbooksDir2, { withFileTypes: true });
+  const entries = await readdir8(playbooksDir2, { withFileTypes: true });
   const playbooks = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_") || entry.name === "manifest.md") continue;
-    const filePath = resolve13(playbooksDir2, entry.name);
-    const raw2 = await readFile10(filePath, "utf-8");
+    const filePath = resolve14(playbooksDir2, entry.name);
+    const raw2 = await readFile11(filePath, "utf-8");
     const parsed = parsePlaybook(raw2);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     playbooks.push({
@@ -6977,6 +8417,244 @@ var init_api = __esm({
   }
 });
 
+// src/lifecycle/recompute.ts
+var recompute_exports = {};
+__export(recompute_exports, {
+  isDeriveMigrated: () => isDeriveMigrated,
+  markDeriveMigrated: () => markDeriveMigrated,
+  recomputeAll: () => recomputeAll,
+  recomputeAndWrite: () => recomputeAndWrite,
+  recomputeDependents: () => recomputeDependents,
+  resolveDeriveContext: () => resolveDeriveContext
+});
+import { createHash as createHash2 } from "crypto";
+import { open, readdir as readdir10, readFile as readFile16, unlink as unlink5, stat } from "fs/promises";
+import { dirname as dirname4, resolve as resolve19 } from "path";
+async function isDeriveMigrated() {
+  return fileExists(resolve19(syntaurRoot(), MIGRATION_MARKER));
+}
+async function markDeriveMigrated() {
+  await writeFileForce(resolve19(syntaurRoot(), MIGRATION_MARKER), `${nowTimestamp()}
+`);
+}
+async function resolveDeriveContext() {
+  const config = await readConfig();
+  const statusConfig = config.statuses ?? buildDefaultStatusConfig();
+  const terminal = new Set(statusConfig.statuses.filter((s) => s.terminal).map((s) => s.id));
+  return {
+    derive: config.statuses?.derive ?? DEFAULT_DERIVE_CONFIG,
+    terminalStatuses: terminal.size > 0 ? terminal : DEFAULT_TERMINAL_STATUSES,
+    knownStatusIds: new Set(statusConfig.statuses.map((s) => s.id))
+  };
+}
+async function acquireLock(assignmentDir) {
+  const lockPath = resolve19(assignmentDir, LOCK_FILE);
+  const token = `${process.pid}:${createHash2("sha256").update(`${Math.random()}${Date.now()}`).digest("hex").slice(0, 12)}`;
+  for (let attempt = 0; attempt <= LOCK_MAX_WAITS; attempt++) {
+    try {
+      const handle = await open(lockPath, "wx");
+      await handle.writeFile(token, "utf-8");
+      await handle.close();
+      return async () => {
+        try {
+          const current = await readFile16(lockPath, "utf-8");
+          if (current === token) await unlink5(lockPath);
+        } catch {
+        }
+      };
+    } catch (err) {
+      const code = err.code;
+      if (code !== "EEXIST") throw err;
+      try {
+        const info = await stat(lockPath);
+        if (Date.now() - info.mtimeMs > LOCK_STALE_MS) {
+          await unlink5(lockPath).catch(() => {
+          });
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      await new Promise((r) => setTimeout(r, LOCK_WAIT_MS));
+    }
+  }
+  throw new Error(`Timed out waiting for ${lockPath} (held > ${LOCK_WAIT_MS * LOCK_MAX_WAITS / 1e3}s)`);
+}
+function contentHash(content) {
+  return createHash2("sha256").update(content, "utf-8").digest("hex");
+}
+function extractBody(content) {
+  const m = content.match(/^---\n[\s\S]*?\n---/);
+  return m ? content.slice(m[0].length) : content;
+}
+async function recomputeAndWrite(assignmentPath, opts) {
+  const assignmentDir = dirname4(assignmentPath);
+  const release = await acquireLock(assignmentDir);
+  try {
+    for (let attempt = 0; attempt < CAS_RETRIES; attempt++) {
+      const original = await readFile16(assignmentPath, "utf-8");
+      const hash = contentHash(original);
+      const originalFm = parseAssignmentFrontmatter(original);
+      if (opts.context.terminalStatuses.has(originalFm.status)) {
+        return { changed: false, status: originalFm.status, dimensions: null, deferredTerminal: true };
+      }
+      const content = opts.mutate ? await opts.mutate(original) : original;
+      const mutated = content !== original;
+      const frontmatter2 = mutated ? parseAssignmentFrontmatter(content) : originalFm;
+      const facts = await computeFacts({
+        assignmentDir,
+        frontmatter: frontmatter2,
+        body: extractBody(content),
+        projectDir: opts.projectDir,
+        terminalStatuses: opts.context.terminalStatuses
+      });
+      const dims = deriveDimensions({
+        facts,
+        derive: opts.context.derive,
+        currentStatus: frontmatter2.status,
+        terminalStatuses: opts.context.terminalStatuses,
+        knownStatusIds: opts.context.knownStatusIds,
+        override: frontmatter2.override
+      });
+      if (dims === null) {
+        return { changed: false, status: frontmatter2.status, dimensions: null, deferredTerminal: true };
+      }
+      const statusChanged = dims.status !== frontmatter2.status;
+      const phaseChanged = dims.phase !== frontmatter2.phase;
+      const dispositionChanged = dims.disposition !== frontmatter2.disposition;
+      if (!statusChanged && !phaseChanged && !dispositionChanged) {
+        if (mutated) {
+          const current2 = await readFile16(assignmentPath, "utf-8");
+          if (contentHash(current2) !== hash) continue;
+          await writeFileForce(assignmentPath, content);
+          return { changed: true, status: frontmatter2.status, dimensions: dims, deferredTerminal: false };
+        }
+        return { changed: false, status: frontmatter2.status, dimensions: dims, deferredTerminal: false };
+      }
+      const at = nowTimestamp();
+      let next = updateAssignmentFile(content, {
+        status: dims.status,
+        phase: dims.phase,
+        disposition: dims.disposition,
+        updated: at
+      });
+      next = appendStatusHistoryEntry(next, {
+        at,
+        from: frontmatter2.status,
+        to: dims.status,
+        command: opts.cause,
+        by: opts.by,
+        ...opts.reason !== void 0 ? { reason: opts.reason } : {},
+        ...phaseChanged ? { phaseFrom: frontmatter2.phase, phaseTo: dims.phase } : {},
+        ...dispositionChanged ? { dispositionFrom: frontmatter2.disposition, dispositionTo: dims.disposition } : {}
+      });
+      const current = await readFile16(assignmentPath, "utf-8");
+      if (contentHash(current) !== hash) {
+        continue;
+      }
+      await writeFileForce(assignmentPath, next);
+      return { changed: true, status: dims.status, dimensions: dims, deferredTerminal: false };
+    }
+    const frontmatter = parseAssignmentFrontmatter(await readFile16(assignmentPath, "utf-8"));
+    return {
+      changed: false,
+      status: frontmatter.status,
+      dimensions: null,
+      deferredTerminal: false,
+      warning: `recompute skipped after ${CAS_RETRIES} concurrent-edit retries: ${assignmentPath}`
+    };
+  } finally {
+    await release();
+  }
+}
+async function recomputeDependents(projectDir, changedSlug, opts) {
+  const assignmentsDir2 = resolve19(projectDir, "assignments");
+  let entries;
+  try {
+    entries = await readdir10(assignmentsDir2);
+  } catch {
+    return [];
+  }
+  const results = [];
+  for (const slug of entries) {
+    if (slug === changedSlug) continue;
+    const path = resolve19(assignmentsDir2, slug, "assignment.md");
+    if (!await fileExists(path)) continue;
+    try {
+      const fm = parseAssignmentFrontmatter(await readFile16(path, "utf-8"));
+      if (!fm.dependsOn.includes(changedSlug)) continue;
+      results.push(await recomputeAndWrite(path, { ...opts, projectDir }));
+    } catch {
+    }
+  }
+  return results;
+}
+async function recomputeAll(projectsDir, standaloneDir, opts) {
+  const summary = { scanned: 0, changed: 0, deferredTerminal: 0, warnings: [] };
+  const sweepOne = async (path, projectDir) => {
+    summary.scanned++;
+    try {
+      const result = await recomputeAndWrite(path, { ...opts, projectDir });
+      if (result.changed) summary.changed++;
+      if (result.deferredTerminal) summary.deferredTerminal++;
+      if (result.warning) summary.warnings.push(result.warning);
+    } catch (err) {
+      summary.warnings.push(`${path}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  };
+  let projects = [];
+  try {
+    projects = await readdir10(projectsDir);
+  } catch {
+  }
+  for (const project of projects) {
+    const projectDir = resolve19(projectsDir, project);
+    const assignmentsDir2 = resolve19(projectDir, "assignments");
+    let slugs = [];
+    try {
+      slugs = await readdir10(assignmentsDir2);
+    } catch {
+      continue;
+    }
+    for (const slug of slugs) {
+      const path = resolve19(assignmentsDir2, slug, "assignment.md");
+      if (await fileExists(path)) await sweepOne(path, projectDir);
+    }
+  }
+  if (standaloneDir) {
+    let ids = [];
+    try {
+      ids = await readdir10(standaloneDir);
+    } catch {
+    }
+    for (const id of ids) {
+      const path = resolve19(standaloneDir, id, "assignment.md");
+      if (await fileExists(path)) await sweepOne(path, null);
+    }
+  }
+  return summary;
+}
+var LOCK_FILE, LOCK_STALE_MS, LOCK_WAIT_MS, LOCK_MAX_WAITS, CAS_RETRIES, MIGRATION_MARKER;
+var init_recompute = __esm({
+  "src/lifecycle/recompute.ts"() {
+    "use strict";
+    init_config2();
+    init_fs();
+    init_paths();
+    init_timestamp();
+    init_facts();
+    init_derive();
+    init_frontmatter();
+    init_types();
+    LOCK_FILE = ".derive.lock";
+    LOCK_STALE_MS = 3e4;
+    LOCK_WAIT_MS = 50;
+    LOCK_MAX_WAITS = 100;
+    CAS_RETRIES = 3;
+    MIGRATION_MARKER = "derive-migrated";
+  }
+});
+
 // src/utils/assignment-todos.ts
 var assignment_todos_exports = {};
 __export(assignment_todos_exports, {
@@ -7031,8 +8709,8 @@ init_assignment_resolver();
 init_agent_sessions();
 import express from "express";
 import { createServer } from "http";
-import { resolve as resolve31 } from "path";
-import { writeFile as writeFile8, unlink as unlink7 } from "fs/promises";
+import { resolve as resolve33 } from "path";
+import { writeFile as writeFile8, unlink as unlink8 } from "fs/promises";
 import { WebSocketServer, WebSocket } from "ws";
 
 // src/dashboard/session-liveness.ts
@@ -7131,7 +8809,19 @@ function ignoreDotSegmentsBelow(root, pathApi = defaultPathApi) {
   };
 }
 function createWatcher(options) {
-  const { projectsDir, assignmentsDir: assignmentsDir2, serversDir: serversDir2, playbooksDir: playbooksDir2, todosDir: todosDir2, dbPath, onMessage, debounceMs = 300 } = options;
+  const {
+    projectsDir,
+    assignmentsDir: assignmentsDir2,
+    serversDir: serversDir2,
+    playbooksDir: playbooksDir2,
+    todosDir: todosDir2,
+    dbPath,
+    configPath,
+    onMessage,
+    onAssignmentChanged,
+    onConfigChanged,
+    debounceMs = 300
+  } = options;
   const pendingEvents = /* @__PURE__ */ new Map();
   const projectsWatcher = watch(projectsDir, {
     ignoreInitial: true,
@@ -7170,6 +8860,9 @@ function createWatcher(options) {
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         };
         onMessage(message);
+        if (assignmentSlug && onAssignmentChanged) {
+          onAssignmentChanged(projectSlug, assignmentSlug);
+        }
       }, debounceMs)
     );
   }
@@ -7198,6 +8891,7 @@ function createWatcher(options) {
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           };
           onMessage(message);
+          if (onAssignmentChanged) onAssignmentChanged(null, assignmentId);
         }, debounceMs)
       );
     };
@@ -7331,6 +9025,29 @@ function createWatcher(options) {
     leasesDbWatcher.on("add", handleDbChange2);
     leasesDbWatcher.on("unlink", handleDbChange2);
   }
+  let configWatcher = null;
+  if (configPath && onConfigChanged) {
+    let handleConfigChange2 = function() {
+      const debounceKey = "__config__";
+      const existing = pendingEvents.get(debounceKey);
+      if (existing) clearTimeout(existing);
+      pendingEvents.set(
+        debounceKey,
+        setTimeout(() => {
+          pendingEvents.delete(debounceKey);
+          onConfigChanged();
+        }, debounceMs)
+      );
+    };
+    var handleConfigChange = handleConfigChange2;
+    configWatcher = watch(configPath, {
+      ignoreInitial: true,
+      persistent: true,
+      depth: 0
+    });
+    configWatcher.on("change", handleConfigChange2);
+    configWatcher.on("add", handleConfigChange2);
+  }
   return {
     close: async () => {
       pendingEvents.forEach((timeout) => {
@@ -7343,6 +9060,7 @@ function createWatcher(options) {
       if (playbooksWatcher) await playbooksWatcher.close();
       if (todosWatcher) await todosWatcher.close();
       if (leasesDbWatcher) await leasesDbWatcher.close();
+      if (configWatcher) await configWatcher.close();
     }
   };
 }
@@ -7496,11 +9214,11 @@ function mergePatch(current, patch) {
 // src/utils/view-prefs.ts
 init_paths();
 init_fs();
-import { readFile as readFile11, rename as rename3, unlink as unlink3 } from "fs/promises";
-import { resolve as resolve14 } from "path";
+import { readFile as readFile12, rename as rename3, unlink as unlink3 } from "fs/promises";
+import { resolve as resolve15 } from "path";
 function corruptFilePath() {
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  return resolve14(syntaurRoot(), `view-prefs.corrupt-${ts}.json`);
+  return resolve15(syntaurRoot(), `view-prefs.corrupt-${ts}.json`);
 }
 function isViewPrefsFileShape(value) {
   if (!value || typeof value !== "object") return false;
@@ -7519,7 +9237,7 @@ async function readViewPrefsFile() {
   }
   let raw2;
   try {
-    raw2 = await readFile11(path, "utf-8");
+    raw2 = await readFile12(path, "utf-8");
   } catch {
     return { ...DEFAULT_VIEW_PREFS_FILE };
   }
@@ -7707,12 +9425,12 @@ function isDashboardSlot(value) {
 // src/utils/saved-views.ts
 init_paths();
 init_fs();
-import { readFile as readFile12, rename as rename4, unlink as unlink4 } from "fs/promises";
+import { readFile as readFile13, rename as rename4, unlink as unlink4 } from "fs/promises";
 import { randomUUID } from "crypto";
-import { resolve as resolve15 } from "path";
+import { resolve as resolve16 } from "path";
 function corruptFilePath2() {
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  return resolve15(syntaurRoot(), `saved-views.corrupt-${ts}.json`);
+  return resolve16(syntaurRoot(), `saved-views.corrupt-${ts}.json`);
 }
 function isSavedViewsFileShape(value) {
   if (!value || typeof value !== "object") return false;
@@ -7737,7 +9455,7 @@ async function readSavedViewsFile() {
   }
   let raw2;
   try {
-    raw2 = await readFile12(path, "utf-8");
+    raw2 = await readFile13(path, "utf-8");
   } catch {
     return cloneDefault();
   }
@@ -8053,10 +9771,11 @@ function createDashboardLayoutRouter() {
 
 // src/dashboard/api-write.ts
 init_lifecycle();
+init_frontmatter();
 init_slug();
 import { Router as Router2 } from "express";
-import { resolve as resolve18, basename as basename3, isAbsolute as isAbsolute4 } from "path";
-import { rm, readFile as readFile15, open as fsOpen, stat as fsStat, realpath as fsRealpath } from "fs/promises";
+import { resolve as resolve20, basename as basename3, isAbsolute as isAbsolute4 } from "path";
+import { rm, readFile as readFile17, open as fsOpen, stat as fsStat, realpath as fsRealpath } from "fs/promises";
 import { spawnSync as spawnSync3 } from "child_process";
 
 // src/utils/uuid.ts
@@ -8073,7 +9792,7 @@ init_fs();
 init_frontmatter();
 init_fs();
 import { spawn } from "child_process";
-import { readFile as readFile13 } from "fs/promises";
+import { readFile as readFile14 } from "fs/promises";
 
 // src/launch/cwd.ts
 import { existsSync, statSync as statSync2 } from "fs";
@@ -8276,7 +9995,7 @@ async function createWorktreeAndRecord(opts) {
   const { assignmentPath, repository, branch, worktreePath, parentBranch } = opts;
   await createWorktree({ repository, branch, worktreePath, parentBranch });
   try {
-    const content = await readFile13(assignmentPath, "utf-8");
+    const content = await readFile14(assignmentPath, "utf-8");
     const updated = updateAssignmentWorkspace(content, {
       repository,
       worktreePath,
@@ -8319,12 +10038,12 @@ function formatRollbackError(opts) {
 // src/utils/worktree-defaults.ts
 init_paths();
 import { spawnSync as spawnSync2 } from "child_process";
-import { resolve as resolve16 } from "path";
+import { resolve as resolve17 } from "path";
 function computeWorktreeDefaults(opts) {
   const repository = opts.existing.repository ?? detectCurrentGitRoot(opts.cwd);
   const branch = opts.projectSlug ? `syntaur/${opts.projectSlug}/${opts.assignmentSlug}` : `syntaur/${opts.assignmentSlug}`;
   const parentBranch = opts.existing.parentBranch ?? detectCurrentBranch(opts.cwd) ?? "main";
-  const worktreeBase = repository ? resolve16(repository, ".worktrees", branch) : resolve16(
+  const worktreeBase = repository ? resolve17(repository, ".worktrees", branch) : resolve17(
     syntaurRoot(),
     "worktrees",
     opts.projectSlug || "standalone",
@@ -8537,8 +10256,8 @@ function recreateOutcomeToHttp(outcome) {
 // src/dashboard/repository-candidates.ts
 init_fs();
 init_parser();
-import { readdir as readdir8, readFile as readFile14 } from "fs/promises";
-import { resolve as resolve17 } from "path";
+import { readdir as readdir9, readFile as readFile15 } from "fs/promises";
+import { resolve as resolve18 } from "path";
 function toSourceAssignment(parsed, fallbackId) {
   const repository = parsed.workspace.repository?.trim();
   const branch = parsed.workspace.branch?.trim();
@@ -8555,29 +10274,29 @@ function toSourceAssignment(parsed, fallbackId) {
 async function getProjectRepositoryCandidates(projectsDir, projectSlug) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
-  const projectPath = resolve17(projectsDir, projectSlug, "project.md");
+  const projectPath = resolve18(projectsDir, projectSlug, "project.md");
   if (await fileExists(projectPath)) {
-    const project = parseProject(await readFile14(projectPath, "utf-8"));
+    const project = parseProject(await readFile15(projectPath, "utf-8"));
     for (const raw2 of project.repositories) {
       const path = raw2.trim();
       if (!path) continue;
-      const abs = resolve17(path);
+      const abs = resolve18(path);
       if (seen.has(abs)) continue;
       seen.add(abs);
       out.push({ path: abs, source: "project", sourceAssignmentSlug: null });
     }
   }
-  const assignmentsDir2 = resolve17(projectsDir, projectSlug, "assignments");
+  const assignmentsDir2 = resolve18(projectsDir, projectSlug, "assignments");
   if (await fileExists(assignmentsDir2)) {
-    const entries = await readdir8(assignmentsDir2, { withFileTypes: true });
+    const entries = await readdir9(assignmentsDir2, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const assignmentMd = resolve17(assignmentsDir2, entry.name, "assignment.md");
+      const assignmentMd = resolve18(assignmentsDir2, entry.name, "assignment.md");
       if (!await fileExists(assignmentMd)) continue;
-      const parsed = parseAssignmentFull(await readFile14(assignmentMd, "utf-8"));
+      const parsed = parseAssignmentFull(await readFile15(assignmentMd, "utf-8"));
       const repo = parsed.workspace.repository?.trim();
       if (!repo) continue;
-      const abs = resolve17(repo);
+      const abs = resolve18(repo);
       if (seen.has(abs)) continue;
       seen.add(abs);
       out.push({ path: abs, source: "sibling", sourceAssignmentSlug: parsed.slug });
@@ -8591,16 +10310,16 @@ async function getStandaloneRepositoryCandidates(assignmentsDir2, excludeAssignm
   }
   const seen = /* @__PURE__ */ new Set();
   const out = [];
-  const entries = await readdir8(assignmentsDir2, { withFileTypes: true });
+  const entries = await readdir9(assignmentsDir2, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (entry.name === excludeAssignmentId) continue;
-    const assignmentMd = resolve17(assignmentsDir2, entry.name, "assignment.md");
+    const assignmentMd = resolve18(assignmentsDir2, entry.name, "assignment.md");
     if (!await fileExists(assignmentMd)) continue;
-    const parsed = parseAssignmentFull(await readFile14(assignmentMd, "utf-8"));
+    const parsed = parseAssignmentFull(await readFile15(assignmentMd, "utf-8"));
     const repo = parsed.workspace.repository?.trim();
     if (!repo) continue;
-    const abs = resolve17(repo);
+    const abs = resolve18(repo);
     if (seen.has(abs)) continue;
     seen.add(abs);
     out.push({ path: abs, source: "sibling", sourceAssignmentSlug: parsed.slug });
@@ -8608,17 +10327,17 @@ async function getStandaloneRepositoryCandidates(assignmentsDir2, excludeAssignm
   return out;
 }
 async function getProjectSourceAssignments(projectsDir, projectSlug, excludeSlug) {
-  const assignmentsDir2 = resolve17(projectsDir, projectSlug, "assignments");
+  const assignmentsDir2 = resolve18(projectsDir, projectSlug, "assignments");
   if (!await fileExists(assignmentsDir2)) return [];
   const seen = /* @__PURE__ */ new Set();
   const out = [];
-  const entries = await readdir8(assignmentsDir2, { withFileTypes: true });
+  const entries = await readdir9(assignmentsDir2, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (entry.name === excludeSlug) continue;
-    const assignmentMd = resolve17(assignmentsDir2, entry.name, "assignment.md");
+    const assignmentMd = resolve18(assignmentsDir2, entry.name, "assignment.md");
     if (!await fileExists(assignmentMd)) continue;
-    const parsed = parseAssignmentFull(await readFile14(assignmentMd, "utf-8"));
+    const parsed = parseAssignmentFull(await readFile15(assignmentMd, "utf-8"));
     const source = toSourceAssignment(parsed, entry.name);
     if (!source) continue;
     if (seen.has(entry.name)) continue;
@@ -8631,13 +10350,13 @@ async function getStandaloneSourceAssignments(assignmentsDir2, excludeAssignment
   if (!await fileExists(assignmentsDir2)) return [];
   const seen = /* @__PURE__ */ new Set();
   const out = [];
-  const entries = await readdir8(assignmentsDir2, { withFileTypes: true });
+  const entries = await readdir9(assignmentsDir2, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (entry.name === excludeAssignmentId) continue;
-    const assignmentMd = resolve17(assignmentsDir2, entry.name, "assignment.md");
+    const assignmentMd = resolve18(assignmentsDir2, entry.name, "assignment.md");
     if (!await fileExists(assignmentMd)) continue;
-    const parsed = parseAssignmentFull(await readFile14(assignmentMd, "utf-8"));
+    const parsed = parseAssignmentFull(await readFile15(assignmentMd, "utf-8"));
     const source = toSourceAssignment(parsed, entry.name);
     if (!source) continue;
     if (seen.has(entry.name)) continue;
@@ -8785,6 +10504,7 @@ function renderAssignment(params2) {
   const workspaceGroupLine = params2.workspaceGroup ? `
 workspaceGroup: ${params2.workspaceGroup}` : "";
   const typeYaml = `type: ${params2.type ?? "feature"}`;
+  const seedStatus = params2.status ?? "draft";
   const criteriaLines = params2.acceptanceCriteria && params2.acceptanceCriteria.length > 0 ? params2.acceptanceCriteria.map((c) => `- [ ] ${c.replace(/\n/g, " ").trim()}`).join("\n") : `- [ ] <!-- criterion 1 -->
 - [ ] <!-- criterion 2 -->
 - [ ] <!-- criterion 3 -->`;
@@ -8805,12 +10525,18 @@ slug: ${params2.slug}
 title: ${safeTitle}
 ${projectYaml}${workspaceGroupLine}
 ${typeYaml}
-status: ${params2.status ?? "draft"}
+status: ${seedStatus}
 priority: ${params2.priority}
 created: "${params2.timestamp}"
 updated: "${params2.timestamp}"
 assignee: null
 externalIds: []
+statusHistory:
+  - at: "${params2.timestamp}"
+    from: null
+    to: ${seedStatus}
+    command: create
+    by: null
 ${dependsOnYaml}
 ${linksYaml}
 blockedReason: null
@@ -9212,7 +10938,7 @@ async function readCurrentDocument(filePath) {
   if (!await fileExists(filePath)) {
     return null;
   }
-  return readFile15(filePath, "utf-8");
+  return readFile17(filePath, "utf-8");
 }
 var worktreeInFlight = /* @__PURE__ */ new Set();
 async function assertRepoRoot(repoInput) {
@@ -9266,7 +10992,7 @@ async function handleWorktreeCreate(req, res, ctx) {
   }
   worktreeInFlight.add(ctx.assignmentPath);
   try {
-    const parsed = parseAssignmentFull(await readFile15(ctx.assignmentPath, "utf-8"));
+    const parsed = parseAssignmentFull(await readFile17(ctx.assignmentPath, "utf-8"));
     if (parsed.workspace.worktreePath) {
       res.status(409).json({ error: "Worktree already configured for this assignment" });
       return;
@@ -9293,7 +11019,7 @@ async function handleWorktreeCreate(req, res, ctx) {
     });
     const branch = typeof bodyBranch === "string" && bodyBranch.trim() ? bodyBranch.trim() : defaults.branch;
     const parentBranch = typeof bodyParent === "string" && bodyParent.trim() ? bodyParent.trim() : defaults.parentBranch;
-    const worktreePath = resolve18(repo, ".worktrees", branch);
+    const worktreePath = resolve20(repo, ".worktrees", branch);
     const refCheck = spawnSync3("git", ["-C", repo, "check-ref-format", "--branch", branch], {
       encoding: "utf-8"
     });
@@ -9355,6 +11081,11 @@ async function handleWorktreeCreate(req, res, ctx) {
     worktreeInFlight.delete(ctx.assignmentPath);
   }
 }
+function unambiguousCommandTarget(transitions, command) {
+  const targets = new Set(transitions.filter((t) => t.command === command).map((t) => t.to));
+  if (targets.size === 1) return [...targets][0];
+  return void 0;
+}
 function createWriteRouter(projectsDir, assignmentsDir2, todosDir2) {
   const linkedTodosLookup = todosDir2 ? { todosDir: todosDir2, projectsDir } : void 0;
   const router = Router2();
@@ -9583,9 +11314,9 @@ ${body.startsWith("\n") ? body.slice(1) : body}${body.endsWith("\n") ? "" : "\n"
           });
           return;
         }
-        const folderPath = resolve18(projectDir, folder);
+        const folderPath = resolve20(projectDir, folder);
         await ensureDir(folderPath);
-        const filePath = resolve18(folderPath, `${requestedSlug}.md`);
+        const filePath = resolve20(folderPath, `${requestedSlug}.md`);
         const timestamp = nowTimestamp();
         let content = renderItemStub(kind, {
           slug: requestedSlug,
@@ -9629,14 +11360,14 @@ ${body.startsWith("\n") ? body.slice(1) : body}${body.endsWith("\n") ? "" : "\n"
           res.status(404).json({ error: `Project "${projectSlug}" not found` });
           return;
         }
-        const filePath = resolve18(projectDir, folder, `${itemSlug}.md`);
+        const filePath = resolve20(projectDir, folder, `${itemSlug}.md`);
         if (!await fileExists(filePath)) {
           res.status(404).json({ error: `${kind === "memory" ? "Memory" : "Resource"} not found` });
           return;
         }
         const nextContentRaw = requireContent(req, res);
         if (!nextContentRaw) return;
-        const currentContent = await readFile15(filePath, "utf-8");
+        const currentContent = await readFile17(filePath, "utf-8");
         const frontmatterBlock = extractFrontmatterBlock(currentContent);
         if (!frontmatterBlock) {
           res.status(500).json({ error: `${kind} file is malformed (no frontmatter)` });
@@ -9665,7 +11396,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
           res.status(404).json({ error: `Project "${projectSlug}" not found` });
           return;
         }
-        const filePath = resolve18(projectDir, folder, `${itemSlug}.md`);
+        const filePath = resolve20(projectDir, folder, `${itemSlug}.md`);
         if (!await fileExists(filePath)) {
           res.status(404).json({ error: `${kind === "memory" ? "Memory" : "Resource"} not found` });
           return;
@@ -9699,26 +11430,26 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
         res.status(400).json({ error: `Invalid slug "${slug}". Must be lowercase and hyphen-separated.` });
         return;
       }
-      const projectDir = resolve18(projectsDir, slug);
+      const projectDir = resolve20(projectsDir, slug);
       if (await fileExists(projectDir)) {
         res.status(409).json({ error: `Project "${slug}" already exists` });
         return;
       }
       const title = fields.title;
       const timestamp = fields.created || nowTimestamp();
-      await ensureDir(resolve18(projectDir, "assignments"));
-      await ensureDir(resolve18(projectDir, "resources"));
-      await ensureDir(resolve18(projectDir, "memories"));
-      await writeFileForce(resolve18(projectDir, "project.md"), content);
+      await ensureDir(resolve20(projectDir, "assignments"));
+      await ensureDir(resolve20(projectDir, "resources"));
+      await ensureDir(resolve20(projectDir, "memories"));
+      await writeFileForce(resolve20(projectDir, "project.md"), content);
       try {
         const companions = [
-          [resolve18(projectDir, "manifest.md"), renderManifest({ slug, timestamp })],
-          [resolve18(projectDir, "_index-assignments.md"), renderIndexAssignments({ slug, title, timestamp })],
-          [resolve18(projectDir, "_index-plans.md"), renderIndexPlans({ slug, title, timestamp })],
-          [resolve18(projectDir, "_index-decisions.md"), renderIndexDecisions({ slug, title, timestamp })],
-          [resolve18(projectDir, "_status.md"), renderStatus({ slug, title, timestamp })],
-          [resolve18(projectDir, "resources", "_index.md"), renderResourcesIndex({ slug, title, timestamp })],
-          [resolve18(projectDir, "memories", "_index.md"), renderMemoriesIndex({ slug, title, timestamp })]
+          [resolve20(projectDir, "manifest.md"), renderManifest({ slug, timestamp })],
+          [resolve20(projectDir, "_index-assignments.md"), renderIndexAssignments({ slug, title, timestamp })],
+          [resolve20(projectDir, "_index-plans.md"), renderIndexPlans({ slug, title, timestamp })],
+          [resolve20(projectDir, "_index-decisions.md"), renderIndexDecisions({ slug, title, timestamp })],
+          [resolve20(projectDir, "_status.md"), renderStatus({ slug, title, timestamp })],
+          [resolve20(projectDir, "resources", "_index.md"), renderResourcesIndex({ slug, title, timestamp })],
+          [resolve20(projectDir, "memories", "_index.md"), renderMemoriesIndex({ slug, title, timestamp })]
         ];
         for (const [filePath, fileContent] of companions) {
           await writeFileForce(filePath, fileContent);
@@ -9739,8 +11470,8 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
   router.post("/api/projects/:slug/assignments", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectDir = resolve18(projectsDir, projectSlug);
-      const projectMdPath = resolve18(projectDir, "project.md");
+      const projectDir = resolve20(projectsDir, projectSlug);
+      const projectMdPath = resolve20(projectDir, "project.md");
       if (!await fileExists(projectMdPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -9770,7 +11501,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
         res.status(400).json({ error: `Invalid priority "${priority}". Must be low, medium, high, or critical.` });
         return;
       }
-      const assignmentDir = resolve18(projectDir, "assignments", assignmentSlug);
+      const assignmentDir = resolve20(projectDir, "assignments", assignmentSlug);
       if (await fileExists(assignmentDir)) {
         res.status(409).json({
           error: `Assignment "${assignmentSlug}" already exists in project "${projectSlug}"`
@@ -9779,12 +11510,19 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
       }
       const timestamp = fields.created || nowTimestamp();
       await ensureDir(assignmentDir);
-      await writeFileForce(resolve18(assignmentDir, "assignment.md"), content);
+      const seededContent = parseAssignmentFull(content).statusHistory.length > 0 ? content : appendStatusHistoryEntry(content, {
+        at: timestamp,
+        from: null,
+        to: parseAssignmentFull(content).status,
+        command: "create",
+        by: null
+      });
+      await writeFileForce(resolve20(assignmentDir, "assignment.md"), seededContent);
       try {
         const companions = [
-          [resolve18(assignmentDir, "scratchpad.md"), renderScratchpad({ assignmentSlug, timestamp })],
-          [resolve18(assignmentDir, "handoff.md"), renderHandoff({ assignmentSlug, timestamp })],
-          [resolve18(assignmentDir, "decision-record.md"), renderDecisionRecord({ assignmentSlug, timestamp })]
+          [resolve20(assignmentDir, "scratchpad.md"), renderScratchpad({ assignmentSlug, timestamp })],
+          [resolve20(assignmentDir, "handoff.md"), renderHandoff({ assignmentSlug, timestamp })],
+          [resolve20(assignmentDir, "decision-record.md"), renderDecisionRecord({ assignmentSlug, timestamp })]
         ];
         for (const [filePath, fileContent] of companions) {
           await writeFileForce(filePath, fileContent);
@@ -9805,7 +11543,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
   router.patch("/api/projects/:slug", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve18(projectsDir, projectSlug, "project.md");
+      const projectPath = resolve20(projectsDir, projectSlug, "project.md");
       const currentContent = await readCurrentDocument(projectPath);
       if (!currentContent) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
@@ -9838,7 +11576,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve18(
+      const assignmentPath = resolve20(
         projectsDir,
         projectSlug,
         "assignments",
@@ -9865,10 +11603,20 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
         return;
       }
       let nextContent = nextContentRaw;
+      const now = nowTimestamp();
       if (next.status !== current.status && current.status === "blocked" && next.status !== "blocked") {
         nextContent = setTopLevelField(nextContent, "blockedReason", null);
       }
-      nextContent = setTopLevelField(nextContent, "updated", nowTimestamp());
+      nextContent = setTopLevelField(nextContent, "updated", now);
+      if (next.status !== current.status) {
+        nextContent = appendStatusHistoryEntry(nextContent, {
+          at: now,
+          from: current.status,
+          to: next.status,
+          command: "edit",
+          by: null
+        });
+      }
       await writeFileForce(assignmentPath, nextContent);
       const assignment = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
       res.json({ assignment, content: nextContent });
@@ -9881,7 +11629,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve18(
+      const assignmentPath = resolve20(
         projectsDir,
         projectSlug,
         "assignments",
@@ -9917,7 +11665,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const planPath = resolve18(
+      const planPath = resolve20(
         projectsDir,
         projectSlug,
         "assignments",
@@ -9955,7 +11703,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const scratchpadPath = resolve18(
+      const scratchpadPath = resolve20(
         projectsDir,
         projectSlug,
         "assignments",
@@ -9993,7 +11741,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const handoffPath = resolve18(
+      const handoffPath = resolve20(
         projectsDir,
         projectSlug,
         "assignments",
@@ -10031,7 +11779,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const decisionPath = resolve18(
+      const decisionPath = resolve20(
         projectsDir,
         projectSlug,
         "assignments",
@@ -10069,7 +11817,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const commentsPath = resolve18(
+      const commentsPath = resolve20(
         projectsDir,
         projectSlug,
         "assignments",
@@ -10087,7 +11835,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
       let currentContent;
       let currentCount = 0;
       if (await fileExists(commentsPath)) {
-        currentContent = await readFile15(commentsPath, "utf-8");
+        currentContent = await readFile17(commentsPath, "utf-8");
         const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
         if (countMatch) currentCount = parseInt(countMatch[1], 10);
       } else {
@@ -10128,7 +11876,7 @@ ${entry}`;
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
       const commentId = getParam(req.params.commentId);
-      const commentsPath = resolve18(
+      const commentsPath = resolve20(
         projectsDir,
         projectSlug,
         "assignments",
@@ -10144,7 +11892,7 @@ ${entry}`;
         res.status(400).json({ error: "resolved (boolean) is required" });
         return;
       }
-      const content = await readFile15(commentsPath, "utf-8");
+      const content = await readFile17(commentsPath, "utf-8");
       const parsed = parseComments(content);
       const target = parsed.entries.find((e) => e.id === commentId);
       if (!target) {
@@ -10179,7 +11927,7 @@ ${entry}`;
   router.post("/api/projects/:slug/move-workspace", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve18(projectsDir, projectSlug, "project.md");
+      const projectPath = resolve20(projectsDir, projectSlug, "project.md");
       if (!await fileExists(projectPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -10191,7 +11939,7 @@ ${entry}`;
         });
         return;
       }
-      let content = await readFile15(projectPath, "utf-8");
+      let content = await readFile17(projectPath, "utf-8");
       content = setTopLevelField(content, "workspace", workspace ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(projectPath, content);
@@ -10227,8 +11975,8 @@ ${entry}`;
         });
         return;
       }
-      const assignmentPath = resolve18(resolved.assignmentDir, "assignment.md");
-      let content = await readFile15(assignmentPath, "utf-8");
+      const assignmentPath = resolve20(resolved.assignmentDir, "assignment.md");
+      let content = await readFile17(assignmentPath, "utf-8");
       content = setTopLevelField(content, "workspaceGroup", workspaceGroup ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(assignmentPath, content);
@@ -10244,7 +11992,7 @@ ${entry}`;
     async (req, res) => {
       try {
         const projectSlug = getParam(req.params.slug);
-        const projectPath = resolve18(projectsDir, projectSlug, "project.md");
+        const projectPath = resolve20(projectsDir, projectSlug, "project.md");
         if (!await fileExists(projectPath)) {
           res.status(404).json({ error: `Project "${projectSlug}" not found` });
           return;
@@ -10303,7 +12051,7 @@ ${entry}`;
       try {
         const projectSlug = getParam(req.params.slug);
         const assignmentSlug = getParam(req.params.aslug);
-        const assignmentPath = resolve18(
+        const assignmentPath = resolve20(
           projectsDir,
           projectSlug,
           "assignments",
@@ -10352,7 +12100,7 @@ ${entry}`;
       try {
         const projectSlug = getParam(req.params.slug);
         const assignmentSlug = getParam(req.params.aslug);
-        const assignmentPath = resolve18(
+        const assignmentPath = resolve20(
           projectsDir,
           projectSlug,
           "assignments",
@@ -10411,7 +12159,7 @@ ${entry}`;
       try {
         const projectSlug = getParam(req.params.slug);
         const assignmentSlug = getParam(req.params.aslug);
-        const assignmentPath = resolve18(
+        const assignmentPath = resolve20(
           projectsDir,
           projectSlug,
           "assignments",
@@ -10444,8 +12192,8 @@ ${entry}`;
           res.status(404).json({ error: `Assignment "${id}" not found` });
           return;
         }
-        const assignmentPath = resolve18(resolved.assignmentDir, "assignment.md");
-        const parsedForSlug = parseAssignmentFull(await readFile15(assignmentPath, "utf-8"));
+        const assignmentPath = resolve20(resolved.assignmentDir, "assignment.md");
+        const parsedForSlug = parseAssignmentFull(await readFile17(assignmentPath, "utf-8"));
         const assignmentSlugForBranch = parsedForSlug.slug || resolved.id;
         await handleWorktreeCreate(req, res, {
           assignmentPath,
@@ -10501,7 +12249,7 @@ ${entry}`;
   router.post("/api/projects/:slug/status-override", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve18(projectsDir, projectSlug, "project.md");
+      const projectPath = resolve20(projectsDir, projectSlug, "project.md");
       if (!await fileExists(projectPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -10513,7 +12261,7 @@ ${entry}`;
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}, or null to clear.` });
         return;
       }
-      let content = await readFile15(projectPath, "utf-8");
+      let content = await readFile17(projectPath, "utf-8");
       content = setTopLevelField(content, "statusOverride", status ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(projectPath, content);
@@ -10528,7 +12276,7 @@ ${entry}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve18(
+      const assignmentPath = resolve20(
         projectsDir,
         projectSlug,
         "assignments",
@@ -10542,17 +12290,40 @@ ${entry}`;
       const { status } = req.body || {};
       const config = await getStatusConfig();
       const validStatuses = config.statuses.map((s) => s.id);
-      if (typeof status !== "string" || !validStatuses.includes(status)) {
+      const clearing = status === null;
+      if (!clearing && (typeof status !== "string" || !validStatuses.includes(status))) {
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}.` });
         return;
       }
-      let content = await readFile15(assignmentPath, "utf-8");
-      content = setTopLevelField(content, "status", status);
-      content = setTopLevelField(content, "updated", nowTimestamp());
-      if (status !== "blocked") {
-        content = setTopLevelField(content, "blockedReason", null);
+      if (!clearing && config.terminalStatuses.has(status)) {
+        res.status(400).json({
+          error: `"${status}" is terminal \u2014 use the complete/fail transition (gated), not an override.`
+        });
+        return;
+      }
+      const { recomputeAndWrite: recomputeAndWrite2, resolveDeriveContext: resolveDeriveContext2 } = await Promise.resolve().then(() => (init_recompute(), recompute_exports));
+      const { updateOverride: updateOverride2 } = await Promise.resolve().then(() => (init_frontmatter(), frontmatter_exports));
+      const context = await resolveDeriveContext2();
+      const result = await recomputeAndWrite2(assignmentPath, {
+        cause: clearing ? "unpin" : "pin",
+        by: "human",
+        projectDir: resolve20(projectsDir, projectSlug),
+        context,
+        mutate: (content) => {
+          if (clearing) return updateOverride2(content, null);
+          const current = parseAssignmentFull(content);
+          if (current.override?.status === status) return content;
+          return updateOverride2(content, { status, source: "human", reason: null, at: nowTimestamp() });
+        }
+      });
+      if (result.deferredTerminal) {
+        res.status(409).json({ error: "Assignment is terminal \u2014 reopen it first." });
+        return;
+      }
+      if (result.warning) {
+        res.status(503).json({ error: result.warning });
+        return;
       }
-      await writeFileForce(assignmentPath, content);
       const assignment = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
       res.json({ assignment });
     } catch (error) {
@@ -10567,12 +12338,12 @@ ${entry}`;
   router.post("/api/projects/:slug/archive", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve18(projectsDir, projectSlug, "project.md");
+      const projectPath = resolve20(projectsDir, projectSlug, "project.md");
       if (!await fileExists(projectPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
       }
-      const content = await readFile15(projectPath, "utf-8");
+      const content = await readFile17(projectPath, "utf-8");
       await writeFileForce(projectPath, applyArchiveFields(content, true, archiveReason(req.body)));
       const project = await getProjectDetail(projectsDir, projectSlug);
       res.json({ project });
@@ -10584,12 +12355,12 @@ ${entry}`;
   router.post("/api/projects/:slug/unarchive", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve18(projectsDir, projectSlug, "project.md");
+      const projectPath = resolve20(projectsDir, projectSlug, "project.md");
       if (!await fileExists(projectPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
       }
-      const content = await readFile15(projectPath, "utf-8");
+      const content = await readFile17(projectPath, "utf-8");
       await writeFileForce(projectPath, applyArchiveFields(content, false, null));
       const project = await getProjectDetail(projectsDir, projectSlug);
       res.json({ project });
@@ -10601,12 +12372,12 @@ ${entry}`;
   async function handleAssignmentArchive(req, res, archived) {
     const projectSlug = getParam(req.params.slug);
     const assignmentSlug = getParam(req.params.aslug);
-    const assignmentPath = resolve18(projectsDir, projectSlug, "assignments", assignmentSlug, "assignment.md");
+    const assignmentPath = resolve20(projectsDir, projectSlug, "assignments", assignmentSlug, "assignment.md");
     if (!await fileExists(assignmentPath)) {
       res.status(404).json({ error: "Assignment not found" });
       return;
     }
-    const content = await readFile15(assignmentPath, "utf-8");
+    const content = await readFile17(assignmentPath, "utf-8");
     await writeFileForce(assignmentPath, applyArchiveFields(content, archived, archived ? archiveReason(req.body) : null));
     const assignment = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
     res.json({ assignment });
@@ -10638,8 +12409,8 @@ ${entry}`;
       res.status(404).json({ error: `Assignment "${id}" not found` });
       return;
     }
-    const assignmentPath = resolve18(resolved.assignmentDir, "assignment.md");
-    const content = await readFile15(assignmentPath, "utf-8");
+    const assignmentPath = resolve20(resolved.assignmentDir, "assignment.md");
+    const content = await readFile17(assignmentPath, "utf-8");
     await writeFileForce(assignmentPath, applyArchiveFields(content, archived, archived ? archiveReason(req.body) : null));
     const assignment = await getAssignmentDetailById(projectsDir, assignmentsDir2, id);
     res.json({ assignment });
@@ -10664,7 +12435,7 @@ ${entry}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve18(
+      const assignmentPath = resolve20(
         projectsDir,
         projectSlug,
         "assignments",
@@ -10680,7 +12451,7 @@ ${entry}`;
         res.status(400).json({ error: validation.error });
         return;
       }
-      let content = await readFile15(assignmentPath, "utf-8");
+      let content = await readFile17(assignmentPath, "utf-8");
       content = setTopLevelField(content, "assignee", validation.value);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(assignmentPath, content);
@@ -10695,7 +12466,7 @@ ${entry}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve18(
+      const assignmentPath = resolve20(
         projectsDir,
         projectSlug,
         "assignments",
@@ -10711,7 +12482,7 @@ ${entry}`;
         res.status(400).json({ error: validation.error });
         return;
       }
-      let content = await readFile15(assignmentPath, "utf-8");
+      let content = await readFile17(assignmentPath, "utf-8");
       content = setTopLevelField(content, "title", validation.value);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(assignmentPath, content);
@@ -10733,16 +12504,49 @@ ${entry}`;
         res.status(400).json({ error: `Unsupported transition command "${req.params.command}"` });
         return;
       }
-      const projectDir = resolve18(projectsDir, projectSlug);
-      const assignmentPath = resolve18(projectDir, "assignments", assignmentSlug, "assignment.md");
+      const projectDir = resolve20(projectsDir, projectSlug);
+      const assignmentPath = resolve20(projectDir, "assignments", assignmentSlug, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: "Assignment not found" });
         return;
       }
       const { reason } = req.body || {};
+      const { recomputeAndWrite: recomputeAndWrite2, recomputeDependents: recomputeDependents2, resolveDeriveContext: resolveDeriveContext2 } = await Promise.resolve().then(() => (init_recompute(), recompute_exports));
+      const context = await resolveDeriveContext2();
+      if (command === "block" || command === "unblock") {
+        const { updateAssignmentFile: updateAssignmentFile2 } = await Promise.resolve().then(() => (init_frontmatter(), frontmatter_exports));
+        const result2 = await recomputeAndWrite2(assignmentPath, {
+          cause: command,
+          by: "human",
+          projectDir,
+          context,
+          reason: typeof reason === "string" ? reason : void 0,
+          mutate: (content) => updateAssignmentFile2(content, {
+            blockedReason: command === "block" ? typeof reason === "string" && reason ? reason : "(unspecified)" : null
+          })
+        });
+        if (result2.deferredTerminal) {
+          res.status(409).json({ error: "Assignment is terminal \u2014 reopen it first." });
+          return;
+        }
+        if (result2.warning) {
+          res.status(503).json({ error: result2.warning });
+          return;
+        }
+        const assignment2 = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
+        res.json({ assignment: assignment2, transition: { success: true, message: command, fromStatus: "", toStatus: result2.status } });
+        return;
+      }
+      const GATED_TERMINAL = /* @__PURE__ */ new Set(["complete", "fail", "reopen"]);
+      const gatedFallback = GATED_TERMINAL.has(command) ? unambiguousCommandTarget(config.transitions, command) : void 0;
       const result = await executeTransition(projectDir, assignmentSlug, command, {
         reason: typeof reason === "string" ? reason : void 0,
+        // Gated terminal commands: the from-specific custom mapping wins
+        // (passed via the table), with the unambiguous command target as the
+        // guard-free fallback for legacy/undefined statuses (codex r3
+        // finding 1 — ambiguous configs must not pick an arbitrary target).
         transitionTable: config.custom ? config.transitionTable : void 0,
+        commandTargets: config.custom && gatedFallback ? /* @__PURE__ */ new Map([[command, gatedFallback]]) : void 0,
         terminalStatuses: config.custom ? config.terminalStatuses : void 0,
         linkedTodosLookup
       });
@@ -10750,6 +12554,25 @@ ${entry}`;
         res.status(400).json({ error: result.message });
         return;
       }
+      const settled = await recomputeAndWrite2(assignmentPath, {
+        cause: command,
+        by: "human",
+        projectDir,
+        context
+      });
+      if (settled.warning) {
+        res.status(503).json({ error: settled.warning });
+        return;
+      }
+      const wasTerminal = config.terminalStatuses.has(result.fromStatus);
+      const isTerminal = result.toStatus ? config.terminalStatuses.has(result.toStatus) : false;
+      if (wasTerminal !== isTerminal) {
+        await recomputeDependents2(projectDir, assignmentSlug, {
+          cause: "dep-terminal",
+          by: "system",
+          context
+        });
+      }
       const assignment = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
       res.json({ assignment, transition: result });
     } catch (error) {
@@ -10761,8 +12584,8 @@ ${entry}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentDir = resolve18(projectsDir, projectSlug, "assignments", assignmentSlug);
-      const assignmentPath = resolve18(assignmentDir, "assignment.md");
+      const assignmentDir = resolve20(projectsDir, projectSlug, "assignments", assignmentSlug);
+      const assignmentPath = resolve20(assignmentDir, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: `Assignment "${assignmentSlug}" not found in project "${projectSlug}"` });
         return;
@@ -10817,33 +12640,42 @@ ${entry}`;
           return;
         }
         const id2 = generateId();
-        const assignmentDir2 = resolve18(assignmentsDir2, id2);
+        const assignmentDir2 = resolve20(assignmentsDir2, id2);
         if (await fileExists(assignmentDir2)) {
           res.status(500).json({ error: "UUID collision \u2014 try again" });
           return;
         }
         const timestamp2 = fields.created || nowTimestamp();
         await ensureDir(assignmentDir2);
-        const normalizedContent = setTopLevelField(rawContent, "id", id2);
-        await writeFileForce(resolve18(assignmentDir2, "assignment.md"), normalizedContent);
+        let normalizedContent = setTopLevelField(rawContent, "id", id2);
+        if (parseAssignmentFull(normalizedContent).statusHistory.length === 0) {
+          normalizedContent = appendStatusHistoryEntry(normalizedContent, {
+            at: timestamp2,
+            from: null,
+            to: parseAssignmentFull(normalizedContent).status,
+            command: "create",
+            by: null
+          });
+        }
+        await writeFileForce(resolve20(assignmentDir2, "assignment.md"), normalizedContent);
         await writeFileForce(
-          resolve18(assignmentDir2, "scratchpad.md"),
+          resolve20(assignmentDir2, "scratchpad.md"),
           renderScratchpad({ assignmentSlug: id2, timestamp: timestamp2 })
         );
         await writeFileForce(
-          resolve18(assignmentDir2, "handoff.md"),
+          resolve20(assignmentDir2, "handoff.md"),
           renderHandoff({ assignmentSlug: id2, timestamp: timestamp2 })
         );
         await writeFileForce(
-          resolve18(assignmentDir2, "decision-record.md"),
+          resolve20(assignmentDir2, "decision-record.md"),
           renderDecisionRecord({ assignmentSlug: id2, timestamp: timestamp2 })
         );
         await writeFileForce(
-          resolve18(assignmentDir2, "progress.md"),
+          resolve20(assignmentDir2, "progress.md"),
           renderProgress({ assignment: id2, timestamp: timestamp2 })
         );
         await writeFileForce(
-          resolve18(assignmentDir2, "comments.md"),
+          resolve20(assignmentDir2, "comments.md"),
           renderComments({ assignment: id2, timestamp: timestamp2 })
         );
         const detail2 = await getAssignmentDetailById(projectsDir, assignmentsDir2, id2);
@@ -10861,7 +12693,7 @@ ${entry}`;
         return;
       }
       const id = generateId();
-      const assignmentDir = resolve18(assignmentsDir2, id);
+      const assignmentDir = resolve20(assignmentsDir2, id);
       if (await fileExists(assignmentDir)) {
         res.status(500).json({ error: "UUID collision \u2014 try again" });
         return;
@@ -10881,25 +12713,25 @@ ${entry}`;
         project: null,
         type: typeof type === "string" ? type : void 0
       });
-      await writeFileForce(resolve18(assignmentDir, "assignment.md"), assignmentContent);
+      await writeFileForce(resolve20(assignmentDir, "assignment.md"), assignmentContent);
       await writeFileForce(
-        resolve18(assignmentDir, "scratchpad.md"),
+        resolve20(assignmentDir, "scratchpad.md"),
         renderScratchpad({ assignmentSlug: id, timestamp })
       );
       await writeFileForce(
-        resolve18(assignmentDir, "handoff.md"),
+        resolve20(assignmentDir, "handoff.md"),
         renderHandoff({ assignmentSlug: id, timestamp })
       );
       await writeFileForce(
-        resolve18(assignmentDir, "decision-record.md"),
+        resolve20(assignmentDir, "decision-record.md"),
         renderDecisionRecord({ assignmentSlug: id, timestamp })
       );
       await writeFileForce(
-        resolve18(assignmentDir, "progress.md"),
+        resolve20(assignmentDir, "progress.md"),
         renderProgress({ assignment: id, timestamp })
       );
       await writeFileForce(
-        resolve18(assignmentDir, "comments.md"),
+        resolve20(assignmentDir, "comments.md"),
         renderComments({ assignment: id, timestamp })
       );
       const detail = await getAssignmentDetailById(projectsDir, assignmentsDir2, id);
@@ -11027,7 +12859,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve18(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve20(resolved.assignmentDir, "assignment.md");
       const currentContent = await readCurrentDocument(assignmentPath);
       if (!currentContent) {
         res.status(404).json({ error: "Assignment not found" });
@@ -11045,10 +12877,20 @@ ${entry}`;
       if (current.id) nextContent = setTopLevelField(nextContent, "id", current.id);
       nextContent = setTopLevelField(nextContent, "project", null);
       if (current.slug) nextContent = setTopLevelField(nextContent, "slug", current.slug);
+      const now = nowTimestamp();
       if (next.status !== current.status && current.status === "blocked" && next.status !== "blocked") {
         nextContent = setTopLevelField(nextContent, "blockedReason", null);
       }
-      nextContent = setTopLevelField(nextContent, "updated", nowTimestamp());
+      nextContent = setTopLevelField(nextContent, "updated", now);
+      if (next.status !== current.status) {
+        nextContent = appendStatusHistoryEntry(nextContent, {
+          at: now,
+          from: current.status,
+          to: next.status,
+          command: "edit",
+          by: null
+        });
+      }
       await writeFileForce(assignmentPath, nextContent);
       const assignment = await getAssignmentDetailById(projectsDir, assignmentsDir2, id);
       res.json({ assignment, content: nextContent });
@@ -11069,7 +12911,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const planPath = resolve18(resolved.assignmentDir, "plan.md");
+      const planPath = resolve20(resolved.assignmentDir, "plan.md");
       const currentContent = await readCurrentDocument(planPath);
       if (!currentContent) {
         res.status(404).json({ error: "Plan not found" });
@@ -11103,7 +12945,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const scratchpadPath = resolve18(resolved.assignmentDir, "scratchpad.md");
+      const scratchpadPath = resolve20(resolved.assignmentDir, "scratchpad.md");
       const currentContent = await readCurrentDocument(scratchpadPath);
       if (!currentContent) {
         res.status(404).json({ error: "Scratchpad not found" });
@@ -11137,7 +12979,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const handoffPath = resolve18(resolved.assignmentDir, "handoff.md");
+      const handoffPath = resolve20(resolved.assignmentDir, "handoff.md");
       const currentContent = await readCurrentDocument(handoffPath);
       if (!currentContent) {
         res.status(404).json({ error: "Handoff log not found" });
@@ -11177,7 +13019,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const decisionPath = resolve18(resolved.assignmentDir, "decision-record.md");
+      const decisionPath = resolve20(resolved.assignmentDir, "decision-record.md");
       const currentContent = await readCurrentDocument(decisionPath);
       if (!currentContent) {
         res.status(404).json({ error: "Decision record not found" });
@@ -11217,7 +13059,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve18(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve20(resolved.assignmentDir, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: "Assignment not found" });
         return;
@@ -11225,17 +13067,41 @@ ${entry}`;
       const { status } = req.body || {};
       const config = await getStatusConfig();
       const validStatuses = config.statuses.map((s) => s.id);
-      if (typeof status !== "string" || !validStatuses.includes(status)) {
+      const clearing = status === null;
+      if (!clearing && (typeof status !== "string" || !validStatuses.includes(status))) {
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}.` });
         return;
       }
-      let content = await readFile15(assignmentPath, "utf-8");
-      content = setTopLevelField(content, "status", status);
-      content = setTopLevelField(content, "updated", nowTimestamp());
-      if (status !== "blocked") {
-        content = setTopLevelField(content, "blockedReason", null);
+      if (!clearing && config.terminalStatuses.has(status)) {
+        res.status(400).json({
+          error: `"${status}" is terminal \u2014 use the complete/fail transition (gated), not an override.`
+        });
+        return;
+      }
+      const { recomputeAndWrite: recomputeAndWrite2, resolveDeriveContext: resolveDeriveContext2 } = await Promise.resolve().then(() => (init_recompute(), recompute_exports));
+      const { updateOverride: updateOverride2 } = await Promise.resolve().then(() => (init_frontmatter(), frontmatter_exports));
+      const context = await resolveDeriveContext2();
+      const projectDirForId = resolved.standalone ? null : resolve20(resolved.assignmentDir, "..", "..");
+      const result = await recomputeAndWrite2(assignmentPath, {
+        cause: clearing ? "unpin" : "pin",
+        by: "human",
+        projectDir: projectDirForId,
+        context,
+        mutate: (content) => {
+          if (clearing) return updateOverride2(content, null);
+          const current = parseAssignmentFull(content);
+          if (current.override?.status === status) return content;
+          return updateOverride2(content, { status, source: "human", reason: null, at: nowTimestamp() });
+        }
+      });
+      if (result.deferredTerminal) {
+        res.status(409).json({ error: "Assignment is terminal \u2014 reopen it first." });
+        return;
+      }
+      if (result.warning) {
+        res.status(503).json({ error: result.warning });
+        return;
       }
-      await writeFileForce(assignmentPath, content);
       const assignment = await getAssignmentDetailById(projectsDir, assignmentsDir2, id);
       res.json({ assignment });
     } catch (error) {
@@ -11255,7 +13121,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve18(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve20(resolved.assignmentDir, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: "Assignment not found" });
         return;
@@ -11265,7 +13131,7 @@ ${entry}`;
         res.status(400).json({ error: validation.error });
         return;
       }
-      let content = await readFile15(assignmentPath, "utf-8");
+      let content = await readFile17(assignmentPath, "utf-8");
       content = setTopLevelField(content, "assignee", validation.value);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(assignmentPath, content);
@@ -11288,7 +13154,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve18(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve20(resolved.assignmentDir, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: "Assignment not found" });
         return;
@@ -11298,7 +13164,7 @@ ${entry}`;
         res.status(400).json({ error: validation.error });
         return;
       }
-      let content = await readFile15(assignmentPath, "utf-8");
+      let content = await readFile17(assignmentPath, "utf-8");
       content = setTopLevelField(content, "title", validation.value);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(assignmentPath, content);
@@ -11321,7 +13187,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve18(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve20(resolved.assignmentDir, "assignment.md");
       const currentContent = await readCurrentDocument(assignmentPath);
       if (!currentContent) {
         res.status(404).json({ error: "Assignment not found" });
@@ -11361,12 +13227,57 @@ ${entry}`;
         return;
       }
       const { reason } = req.body || {};
+      const config = await getStatusConfig();
+      const validCommandsById = [...new Set(config.transitions.map((t) => t.command))];
+      if (!validCommandsById.includes(command)) {
+        res.status(400).json({ error: `Unsupported transition command "${command}"` });
+        return;
+      }
+      const { recomputeAndWrite: recomputeAndWrite2, recomputeDependents: recomputeDependents2, resolveDeriveContext: resolveDeriveContext2 } = await Promise.resolve().then(() => (init_recompute(), recompute_exports));
+      const context = await resolveDeriveContext2();
+      const byIdPath = resolve20(resolved.assignmentDir, "assignment.md");
+      const byIdProjectDir = resolved.standalone ? null : resolve20(resolved.assignmentDir, "..", "..");
+      if (command === "block" || command === "unblock") {
+        const { updateAssignmentFile: updateAssignmentFile2 } = await Promise.resolve().then(() => (init_frontmatter(), frontmatter_exports));
+        const result = await recomputeAndWrite2(byIdPath, {
+          cause: command,
+          by: "human",
+          projectDir: byIdProjectDir,
+          context,
+          reason: typeof reason === "string" ? reason : void 0,
+          mutate: (content) => updateAssignmentFile2(content, {
+            blockedReason: command === "block" ? typeof reason === "string" && reason ? reason : "(unspecified)" : null
+          })
+        });
+        if (result.deferredTerminal) {
+          res.status(409).json({ error: "Assignment is terminal \u2014 reopen it first." });
+          return;
+        }
+        if (result.warning) {
+          res.status(503).json({ error: result.warning });
+          return;
+        }
+        const detail2 = resolved.standalone ? await getAssignmentDetailById(projectsDir, assignmentsDir2, id) : await getAssignmentDetail(projectsDir, resolved.projectSlug, resolved.assignmentSlug);
+        res.json({ assignment: detail2, warnings: [] });
+        return;
+      }
+      const GATED_TERMINAL = /* @__PURE__ */ new Set(["complete", "fail", "reopen"]);
+      const gatedFallbackById = GATED_TERMINAL.has(command) ? unambiguousCommandTarget(config.transitions, command) : void 0;
       const transitionResult = await executeTransitionByDir(
         resolved.assignmentDir,
         command,
         {
           standalone: resolved.standalone,
           reason: typeof reason === "string" ? reason : void 0,
+          // Same resolution as the project route: from-specific mapping wins,
+          // unambiguous command target as guard-free fallback for gated
+          // terminal commands. NOTE: by-id historically ran guard-free for
+          // all commands; the custom from-table now applies only to gated
+          // commands' resolution (their fallback), keeping non-terminal by-id
+          // behavior guard-free as before.
+          commandTargets: config.custom && gatedFallbackById ? /* @__PURE__ */ new Map([[command, gatedFallbackById]]) : void 0,
+          transitionTable: config.custom && GATED_TERMINAL.has(command) ? config.transitionTable : void 0,
+          terminalStatuses: config.custom ? config.terminalStatuses : void 0,
           linkedTodosLookup
         }
       );
@@ -11374,6 +13285,27 @@ ${entry}`;
         res.status(400).json({ error: transitionResult.message, fromStatus: transitionResult.fromStatus });
         return;
       }
+      const settledById = await recomputeAndWrite2(byIdPath, {
+        cause: command,
+        by: "human",
+        projectDir: byIdProjectDir,
+        context
+      });
+      if (settledById.warning) {
+        res.status(503).json({ error: settledById.warning });
+        return;
+      }
+      if (byIdProjectDir) {
+        const wasTerminal = config.terminalStatuses.has(transitionResult.fromStatus);
+        const isTerminal = transitionResult.toStatus ? config.terminalStatuses.has(transitionResult.toStatus) : false;
+        if (wasTerminal !== isTerminal) {
+          await recomputeDependents2(byIdProjectDir, resolved.assignmentSlug, {
+            cause: "dep-terminal",
+            by: "system",
+            context
+          });
+        }
+      }
       const detail = resolved.standalone ? await getAssignmentDetailById(projectsDir, assignmentsDir2, id) : await getAssignmentDetail(projectsDir, resolved.projectSlug, resolved.assignmentSlug);
       res.json({ assignment: detail, warnings: transitionResult.warnings ?? [] });
     } catch (error) {
@@ -11423,7 +13355,7 @@ function validateTitleBody(body) {
   return { ok: true, value: trimmed };
 }
 async function appendCommentTo(assignmentDir, assignmentRef, req, res, reloadDetail) {
-  const commentsPath = resolve18(assignmentDir, "comments.md");
+  const commentsPath = resolve20(assignmentDir, "comments.md");
   const { body, author, type, replyTo } = req.body || {};
   if (!body || typeof body !== "string" || !body.trim()) {
     res.status(400).json({ error: "body is required" });
@@ -11435,7 +13367,7 @@ async function appendCommentTo(assignmentDir, assignmentRef, req, res, reloadDet
   let currentContent;
   let currentCount = 0;
   if (await fileExists(commentsPath)) {
-    currentContent = await readFile15(commentsPath, "utf-8");
+    currentContent = await readFile17(commentsPath, "utf-8");
     const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
     if (countMatch) currentCount = parseInt(countMatch[1], 10);
   } else {
@@ -11465,7 +13397,7 @@ ${entry}`;
   res.status(201).json({ assignment, comment: { id: comment.id } });
 }
 async function toggleCommentResolvedAt(assignmentDir, commentId, req, res, reloadDetail) {
-  const commentsPath = resolve18(assignmentDir, "comments.md");
+  const commentsPath = resolve20(assignmentDir, "comments.md");
   if (!await fileExists(commentsPath)) {
     res.status(404).json({ error: "Comments file not found" });
     return;
@@ -11475,7 +13407,7 @@ async function toggleCommentResolvedAt(assignmentDir, commentId, req, res, reloa
     res.status(400).json({ error: "resolved (boolean) is required" });
     return;
   }
-  const content = await readFile15(commentsPath, "utf-8");
+  const content = await readFile17(commentsPath, "utf-8");
   const parsed = parseComments(content);
   const target = parsed.entries.find((e) => e.id === commentId);
   if (!target) {
@@ -11622,16 +13554,16 @@ function createServersRouter(serversDir2, projectsDir, assignmentsDir2) {
 init_agent_sessions();
 init_fs();
 import { Router as Router4 } from "express";
-import { resolve as resolve19 } from "path";
+import { resolve as resolve21 } from "path";
 
 // src/utils/transcript.ts
-import { open } from "fs/promises";
+import { open as open2 } from "fs/promises";
 var MAX_LINES_SCANNED = 50;
 async function derivePathFromTranscript(transcriptPath) {
   if (!transcriptPath) return null;
   let handle;
   try {
-    handle = await open(transcriptPath, "r");
+    handle = await open2(transcriptPath, "r");
   } catch {
     return null;
   }
@@ -11720,7 +13652,7 @@ function createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir2) {
     try {
       const { projectSlug } = req.params;
       const assignment = req.query.assignment;
-      const projectDir = resolve19(projectsDir, projectSlug);
+      const projectDir = resolve21(projectsDir, projectSlug);
       if (!await fileExists(projectDir)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -11750,7 +13682,7 @@ function createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir2) {
         return;
       }
       if (projectSlug) {
-        const projectDir = resolve19(projectsDir, projectSlug);
+        const projectDir = resolve21(projectsDir, projectSlug);
         if (!await fileExists(projectDir)) {
           res.status(404).json({ error: `Project "${projectSlug}" not found` });
           return;
@@ -12255,7 +14187,7 @@ init_api();
 init_agents_schema();
 import { spawn as spawn2 } from "child_process";
 import { mkdir as mkdir2, writeFile as writeFile4 } from "fs/promises";
-import { isAbsolute as isAbsolute5, resolve as resolve20 } from "path";
+import { isAbsolute as isAbsolute5, resolve as resolve22 } from "path";
 var INITIAL_PROMPT = (params2) => {
   const playbook = params2.playbook?.trim();
   if (!playbook) {
@@ -12516,7 +14448,7 @@ function buildShellCommandLine(plan) {
 init_paths();
 init_fs();
 import { fileURLToPath } from "url";
-import { dirname as dirname4, resolve as resolve21, join as join3 } from "path";
+import { dirname as dirname5, resolve as resolve23, join as join3 } from "path";
 import { realpathSync, readFileSync, mkdirSync } from "fs";
 
 // src/dashboard/api-launch-preflight.ts
@@ -12740,33 +14672,33 @@ import { Router as Router9 } from "express";
 
 // src/utils/status-config-resolution.ts
 init_frontmatter();
-import { readFile as readFile16, writeFile as writeFile5, rm as rm2 } from "fs/promises";
-import { dirname as dirname5 } from "path";
+import { readFile as readFile18, writeFile as writeFile5, rm as rm2 } from "fs/promises";
+import { dirname as dirname6 } from "path";
 
 // src/utils/assignment-walk.ts
 init_fs();
-import { resolve as resolve22 } from "path";
-import { readdir as readdir9 } from "fs/promises";
+import { resolve as resolve24 } from "path";
+import { readdir as readdir11 } from "fs/promises";
 async function listAssignmentsByProject(projectsDir, standaloneDir) {
   const result = {
     withAssignmentMd: [],
     orphanFolders: []
   };
   if (await fileExists(projectsDir)) {
-    const projects = await readdir9(projectsDir, { withFileTypes: true });
+    const projects = await readdir11(projectsDir, { withFileTypes: true });
     for (const m of projects) {
       if (!m.isDirectory()) continue;
       if (m.name.startsWith(".") || m.name.startsWith("_")) continue;
-      const assignmentsDir2 = resolve22(projectsDir, m.name, "assignments");
+      const assignmentsDir2 = resolve24(projectsDir, m.name, "assignments");
       if (!await fileExists(assignmentsDir2)) continue;
-      const entries = await readdir9(assignmentsDir2, { withFileTypes: true });
+      const entries = await readdir11(assignmentsDir2, { withFileTypes: true });
       for (const a of entries) {
         if (!a.isDirectory()) continue;
         if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
-        const assignmentDir = resolve22(assignmentsDir2, a.name);
-        const assignmentMd = resolve22(assignmentDir, "assignment.md");
+        const assignmentDir = resolve24(assignmentsDir2, a.name);
+        const assignmentMd = resolve24(assignmentDir, "assignment.md");
         const entry = {
-          projectDir: resolve22(projectsDir, m.name),
+          projectDir: resolve24(projectsDir, m.name),
           projectSlug: m.name,
           assignmentDir,
           assignmentSlug: a.name,
@@ -12781,12 +14713,12 @@ async function listAssignmentsByProject(projectsDir, standaloneDir) {
     }
   }
   if (standaloneDir !== null && await fileExists(standaloneDir)) {
-    const entries = await readdir9(standaloneDir, { withFileTypes: true });
+    const entries = await readdir11(standaloneDir, { withFileTypes: true });
     for (const a of entries) {
       if (!a.isDirectory()) continue;
       if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
-      const assignmentDir = resolve22(standaloneDir, a.name);
-      const assignmentMd = resolve22(assignmentDir, "assignment.md");
+      const assignmentDir = resolve24(standaloneDir, a.name);
+      const assignmentMd = resolve24(assignmentDir, "assignment.md");
       const entry = {
         projectDir: standaloneDir,
         projectSlug: null,
@@ -12823,7 +14755,7 @@ async function scanAssignmentsByStatus(projectsDir, standaloneDir, ids) {
     const assignmentPath = `${entry.assignmentDir}/assignment.md`;
     let content;
     try {
-      content = await readFile16(assignmentPath, "utf-8");
+      content = await readFile18(assignmentPath, "utf-8");
     } catch (err) {
       const code = err?.code;
       if (code === "ENOENT") {
@@ -12886,7 +14818,7 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
     const list = affected.get(r.id) ?? [];
     for (const a of list) {
       try {
-        const content = await readFile16(a.path, "utf-8");
+        const content = await readFile18(a.path, "utf-8");
         buffer.set(a.path, content);
       } catch (err) {
         const code = err?.code;
@@ -12914,7 +14846,7 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
       for (const a of list) {
         let current;
         try {
-          current = await readFile16(a.path, "utf-8");
+          current = await readFile18(a.path, "utf-8");
         } catch (err) {
           const code = err?.code;
           if (code === "ENOENT") {
@@ -12929,10 +14861,14 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
           );
           continue;
         }
-        const next = updateAssignmentFile(current, {
-          status: r.target,
-          updated: nowTimestamp()
-        });
+        const now = nowTimestamp();
+        const next = appendStatusHistoryEntry(
+          updateAssignmentFile(current, {
+            status: r.target,
+            updated: now
+          }),
+          { at: now, from: r.id, to: r.target, command: "remap", by: null }
+        );
         await writeFile5(a.path, next, "utf-8");
         writtenPaths.push(a.path);
         remapped++;
@@ -12963,7 +14899,7 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
     const list = affected.get(r.id) ?? [];
     for (const a of list) {
       try {
-        const current = await readFile16(a.path, "utf-8");
+        const current = await readFile18(a.path, "utf-8");
         const fm = parseAssignmentFrontmatter(current);
         if (fm.status !== r.id) {
           console.warn(
@@ -12974,7 +14910,7 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
       } catch {
         continue;
       }
-      const assignmentDir = dirname5(a.path);
+      const assignmentDir = dirname6(a.path);
       try {
         await rm2(assignmentDir, { recursive: true, force: true });
         deleted++;
@@ -13231,7 +15167,7 @@ function createStatusConfigRouter(projectsDir, assignmentsDir2) {
         throw err;
       }
       try {
-        await writeStatusConfig({ statuses, order, transitions });
+        await writeStatusConfig({ statuses, order, transitions, derive: currentConfig.derive ?? null });
       } catch (err) {
         console.error("Error saving status config after applying resolutions:", err);
         res.status(500).json({
@@ -13285,7 +15221,7 @@ import { Router as Router10 } from "express";
 init_paths();
 import Database2 from "better-sqlite3";
 import { randomUUID as randomUUID3 } from "crypto";
-import { resolve as resolve23 } from "path";
+import { resolve as resolve25 } from "path";
 var db2 = null;
 var LEASE_SCHEMA_VERSION = "1";
 var SCHEMA_SQL2 = `
@@ -13372,7 +15308,7 @@ function isBusyError(err) {
 }
 function initLeasesDb(dbPath) {
   if (db2) return db2;
-  const finalPath = dbPath ?? resolve23(syntaurRoot(), "syntaur.db");
+  const finalPath = dbPath ?? resolve25(syntaurRoot(), "syntaur.db");
   db2 = new Database2(finalPath);
   db2.pragma("journal_mode = WAL");
   db2.pragma("busy_timeout = 5000");
@@ -13521,7 +15457,7 @@ import { Router as Router11 } from "express";
 // src/db/usage-db.ts
 init_paths();
 import Database3 from "better-sqlite3";
-import { resolve as resolve24 } from "path";
+import { resolve as resolve26 } from "path";
 var db3 = null;
 var USAGE_SCHEMA_VERSION = "1";
 var SCHEMA_SQL3 = `
@@ -13578,7 +15514,7 @@ CREATE INDEX IF NOT EXISTS idx_usage_daily_day
 `;
 function initUsageDb(dbPath) {
   if (db3) return db3;
-  const finalPath = dbPath ?? resolve24(syntaurRoot(), "syntaur.db");
+  const finalPath = dbPath ?? resolve26(syntaurRoot(), "syntaur.db");
   db3 = new Database3(finalPath);
   db3.pragma("journal_mode = WAL");
   db3.pragma("busy_timeout = 5000");
@@ -13837,8 +15773,8 @@ init_slug();
 init_timestamp();
 init_fs();
 import { Router as Router12 } from "express";
-import { resolve as resolve25 } from "path";
-import { readFile as readFile17 } from "fs/promises";
+import { resolve as resolve27 } from "path";
+import { readFile as readFile19 } from "fs/promises";
 init_playbooks();
 function statusForPlaybookError(code) {
   switch (code) {
@@ -13920,8 +15856,8 @@ function createPlaybooksRouter(playbooksDir2) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
-      const filePath = resolve25(playbooksDir2, resolved.filename);
-      const content = await readFile17(filePath, "utf-8");
+      const filePath = resolve27(playbooksDir2, resolved.filename);
+      const content = await readFile19(filePath, "utf-8");
       res.json({
         documentType: "playbook",
         title: `Edit Playbook: ${resolved.slug}`,
@@ -13946,7 +15882,7 @@ function createPlaybooksRouter(playbooksDir2) {
         return;
       }
       await ensureDir(playbooksDir2);
-      const filePath = resolve25(playbooksDir2, `${slug}.md`);
+      const filePath = resolve27(playbooksDir2, `${slug}.md`);
       if (await fileExists(filePath)) {
         res.status(409).json({ error: `Playbook "${slug}" already exists` });
         return;
@@ -13970,7 +15906,7 @@ function createPlaybooksRouter(playbooksDir2) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
-      const filePath = resolve25(playbooksDir2, resolved.filename);
+      const filePath = resolve27(playbooksDir2, resolved.filename);
       await writeFileForce(filePath, content);
       await rebuildPlaybookManifest(playbooksDir2);
       res.json({ slug: resolved.slug, path: filePath });
@@ -14018,8 +15954,8 @@ init_parser2();
 init_fs();
 init_paths();
 import { Router as Router14 } from "express";
-import { readdir as readdir11 } from "fs/promises";
-import { resolve as resolvePath, dirname as dirname7 } from "path";
+import { readdir as readdir13 } from "fs/promises";
+import { resolve as resolvePath, dirname as dirname8 } from "path";
 import { rename as rename6, mkdir as mkdir4 } from "fs/promises";
 init_slug();
 
@@ -14029,7 +15965,7 @@ init_parser2();
 // src/commands/create-assignment.ts
 init_slug();
 init_timestamp();
-import { resolve as resolve26 } from "path";
+import { resolve as resolve28 } from "path";
 init_paths();
 init_fs();
 init_config2();
@@ -14107,14 +16043,14 @@ async function createAssignmentCommand(title, options) {
   if (options.oneOff) {
     const standaloneRoot = assignmentsDir();
     folderName = id;
-    assignmentDir = resolve26(standaloneRoot, folderName);
+    assignmentDir = resolve28(standaloneRoot, folderName);
     projectSlug = null;
     await ensureDir(standaloneRoot);
   } else {
     const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
     projectSlug = options.project;
-    const projectDir = resolve26(baseDir, projectSlug);
-    const projectMdPath = resolve26(projectDir, "project.md");
+    const projectDir = resolve28(baseDir, projectSlug);
+    const projectMdPath = resolve28(projectDir, "project.md");
     if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
       throw new Error(
         `Project "${projectSlug}" not found at ${projectDir}.
@@ -14122,9 +16058,9 @@ Run 'syntaur create-project' first or use --one-off.`
       );
     }
     if (dependsOn.length > 0) {
-      const depDirBase = resolve26(projectDir, "assignments");
+      const depDirBase = resolve28(projectDir, "assignments");
       for (const dep of dependsOn) {
-        const depDir = resolve26(depDirBase, dep);
+        const depDir = resolve28(depDirBase, dep);
         if (!await fileExists(depDir)) {
           console.warn(
             `Warning: dependency "${dep}" does not exist in project "${projectSlug}" yet.`
@@ -14133,7 +16069,7 @@ Run 'syntaur create-project' first or use --one-off.`
       }
     }
     folderName = assignmentSlug;
-    assignmentDir = resolve26(projectDir, "assignments", folderName);
+    assignmentDir = resolve28(projectDir, "assignments", folderName);
   }
   if (await fileExists(assignmentDir)) {
     throw new Error(
@@ -14145,7 +16081,7 @@ Use --slug to specify a different slug.`
   const companionAssignmentRef = projectSlug === null ? id : assignmentSlug;
   const files = [
     [
-      resolve26(assignmentDir, "assignment.md"),
+      resolve28(assignmentDir, "assignment.md"),
       renderAssignment({
         id,
         slug: assignmentSlug,
@@ -14163,35 +16099,35 @@ Use --slug to specify a different slug.`
       })
     ],
     [
-      resolve26(assignmentDir, "scratchpad.md"),
+      resolve28(assignmentDir, "scratchpad.md"),
       renderScratchpad({
         assignmentSlug: companionAssignmentRef,
         timestamp
       })
     ],
     [
-      resolve26(assignmentDir, "handoff.md"),
+      resolve28(assignmentDir, "handoff.md"),
       renderHandoff({
         assignmentSlug: companionAssignmentRef,
         timestamp
       })
     ],
     [
-      resolve26(assignmentDir, "decision-record.md"),
+      resolve28(assignmentDir, "decision-record.md"),
       renderDecisionRecord({
         assignmentSlug: companionAssignmentRef,
         timestamp
       })
     ],
     [
-      resolve26(assignmentDir, "progress.md"),
+      resolve28(assignmentDir, "progress.md"),
       renderProgress({
         assignment: companionAssignmentRef,
         timestamp
       })
     ],
     [
-      resolve26(assignmentDir, "comments.md"),
+      resolve28(assignmentDir, "comments.md"),
       renderComments({
         assignment: companionAssignmentRef,
         timestamp
@@ -14364,8 +16300,8 @@ init_api();
 import { raw } from "express";
 
 // src/todos/attachments.ts
-import { mkdir as mkdir3, readdir as readdir10, stat, rename as rename5, rm as rm3, unlink as unlink5, writeFile as writeFile6, cp } from "fs/promises";
-import { resolve as resolve27, basename as basename5, dirname as dirname6, extname } from "path";
+import { mkdir as mkdir3, readdir as readdir12, stat as stat2, rename as rename5, rm as rm3, unlink as unlink6, writeFile as writeFile6, cp } from "fs/promises";
+import { resolve as resolve29, basename as basename5, dirname as dirname7, extname } from "path";
 
 // src/utils/proof-artifact-id.ts
 import { randomBytes as randomBytes2 } from "crypto";
@@ -14452,16 +16388,16 @@ function sanitizeAttachmentName(name) {
   return n;
 }
 function attachmentsRootDir(todosDir2) {
-  return resolve27(todosDir2, "attachments");
+  return resolve29(todosDir2, "attachments");
 }
 function attachmentDirFor(todosDir2, scopeId, todoId) {
   assertScope(scopeId);
   assertTodoId(todoId);
-  return resolve27(attachmentsRootDir(todosDir2), scopeId, todoId);
+  return resolve29(attachmentsRootDir(todosDir2), scopeId, todoId);
 }
 async function dirExists(p) {
   try {
-    return (await stat(p)).isDirectory();
+    return (await stat2(p)).isDirectory();
   } catch {
     return false;
   }
@@ -14471,7 +16407,7 @@ async function writeAttachment(todosDir2, scopeId, todoId, originalName, bytes)
   await mkdir3(dir, { recursive: true });
   const id = generateArtifactId();
   const filename = sanitizeAttachmentName(originalName);
-  await writeFile6(resolve27(dir, `${id}__${filename}`), bytes);
+  await writeFile6(resolve29(dir, `${id}__${filename}`), bytes);
   return {
     id,
     filename,
@@ -14484,7 +16420,7 @@ async function listAttachments(todosDir2, scopeId, todoId) {
   const dir = attachmentDirFor(todosDir2, scopeId, todoId);
   let names;
   try {
-    names = await readdir10(dir);
+    names = await readdir12(dir);
   } catch {
     return [];
   }
@@ -14496,7 +16432,7 @@ async function listAttachments(todosDir2, scopeId, todoId) {
     if (!ATTACHMENT_ID_RE.test(id)) continue;
     const filename = stored.slice(sep2 + 2);
     try {
-      const st = await stat(resolve27(dir, stored));
+      const st = await stat2(resolve29(dir, stored));
       if (!st.isFile()) continue;
       out.push({ id, filename, mime: mimeForName(filename), size: st.size, createdAt: st.mtime.toISOString() });
     } catch {
@@ -14507,10 +16443,10 @@ async function listAttachments(todosDir2, scopeId, todoId) {
 }
 async function readScopeAttachments(todosDir2, scopeId) {
   assertScope(scopeId);
-  const scopeDir = resolve27(attachmentsRootDir(todosDir2), scopeId);
+  const scopeDir = resolve29(attachmentsRootDir(todosDir2), scopeId);
   let todoIds;
   try {
-    todoIds = await readdir10(scopeDir);
+    todoIds = await readdir12(scopeDir);
   } catch {
     return {};
   }
@@ -14527,7 +16463,7 @@ async function resolveAttachmentFile(todosDir2, scopeId, todoId, attachmentId) {
   const dir = attachmentDirFor(todosDir2, scopeId, todoId);
   let names;
   try {
-    names = await readdir10(dir);
+    names = await readdir12(dir);
   } catch {
     return null;
   }
@@ -14535,12 +16471,12 @@ async function resolveAttachmentFile(todosDir2, scopeId, todoId, attachmentId) {
   const stored = names.find((n) => n.startsWith(prefix));
   if (!stored) return null;
   const filename = stored.slice(prefix.length);
-  return { path: resolve27(dir, stored), filename, mime: mimeForName(filename) };
+  return { path: resolve29(dir, stored), filename, mime: mimeForName(filename) };
 }
 async function deleteAttachment(todosDir2, scopeId, todoId, attachmentId) {
   const resolved = await resolveAttachmentFile(todosDir2, scopeId, todoId, attachmentId);
   if (!resolved) return false;
-  await unlink5(resolved.path);
+  await unlink6(resolved.path);
   return true;
 }
 async function deleteAllAttachments(todosDir2, scopeId, todoId) {
@@ -14555,7 +16491,7 @@ async function moveAttachments(srcTodosDir, srcScopeId, dstTodosDir, dstScopeId,
   const src = attachmentDirFor(srcTodosDir, srcScopeId, todoId);
   if (!await dirExists(src)) return;
   const dst = attachmentDirFor(dstTodosDir, dstScopeId, todoId);
-  await mkdir3(dirname6(dst), { recursive: true });
+  await mkdir3(dirname7(dst), { recursive: true });
   try {
     await rename5(src, dst);
   } catch (err) {
@@ -14831,7 +16767,7 @@ function createTodosRouter(todosDir2, broadcast, projectsDir) {
   router.get("/", async (_req, res) => {
     try {
       await ensureDir(todosDir2);
-      const files = await readdir11(todosDir2).catch(() => []);
+      const files = await readdir13(todosDir2).catch(() => []);
       const workspaces = [];
       for (const file of files) {
         if (typeof file !== "string") continue;
@@ -14947,8 +16883,8 @@ function createTodosRouter(todosDir2, broadcast, projectsDir) {
   router.post("/:workspace/archive", async (req, res) => {
     try {
       const { archivePath: archivePath2 } = await Promise.resolve().then(() => (init_parser2(), parser_exports));
-      const { resolve: resolve32 } = await import("path");
-      const { readFile: readFile21 } = await import("fs/promises");
+      const { resolve: resolve34 } = await import("path");
+      const { readFile: readFile23 } = await import("fs/promises");
       const { writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
       const workspace = getWorkspaceParam(req.params.workspace);
       const outcome = await wsLock(workspace, async () => {
@@ -14964,10 +16900,10 @@ function createTodosRouter(todosDir2, broadcast, projectsDir) {
           (e) => e.itemIds.every((id) => completedIds.has(id))
         );
         const archFile = archivePath2(todosDir2, workspace, checklist.archiveInterval);
-        await ensureDir(resolve32(todosDir2, "archive"));
+        await ensureDir(resolve34(todosDir2, "archive"));
         let archContent = "";
         if (await fileExists(archFile)) {
-          archContent = await readFile21(archFile, "utf-8");
+          archContent = await readFile23(archFile, "utf-8");
           archContent = archContent.trimEnd() + "\n\n";
         } else {
           archContent = `---
@@ -15256,7 +17192,7 @@ workspace: ${workspace}
         const { readConfig: readConfig2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
         const { assignmentsDir: assignmentsDirFn } = await Promise.resolve().then(() => (init_paths(), paths_exports));
         const { fileExists: fileExists2, writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-        const { readFile: readFile21 } = await import("fs/promises");
+        const { readFile: readFile23 } = await import("fs/promises");
         const { appendTodosToAssignmentBody: appendTodosToAssignmentBody2, touchAssignmentUpdated: touchAssignmentUpdated2 } = await Promise.resolve().then(() => (init_assignment_todos(), assignment_todos_exports));
         const { nowTimestamp: nowTimestamp3 } = await Promise.resolve().then(() => (init_timestamp(), timestamp_exports));
         let assignmentRef;
@@ -15277,7 +17213,7 @@ workspace: ${workspace}
         }
         const assignmentMdPath = resolvePath2(assignmentDir, "assignment.md");
         if (!await fileExists2(assignmentMdPath)) return { error: `Target assignment not found: ${assignmentMdPath}` };
-        let content = await readFile21(assignmentMdPath, "utf-8");
+        let content = await readFile23(assignmentMdPath, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
           items.map((it) => ({
@@ -15394,7 +17330,7 @@ workspace: ${workspace}
           return { status: 409, error: "attachments already exist in target" };
         }
         if (item.planDir && newPlanDir) {
-          await mkdir4(dirname7(newPlanDir), { recursive: true });
+          await mkdir4(dirname8(newPlanDir), { recursive: true });
           await rename6(item.planDir, newPlanDir);
           item.planDir = newPlanDir;
         }
@@ -15472,8 +17408,8 @@ init_fs();
 init_paths();
 init_slug();
 import { Router as Router15 } from "express";
-import { mkdir as mkdir5, readFile as readFile18, rename as rename7 } from "fs/promises";
-import { resolve as resolve28, dirname as dirname8 } from "path";
+import { mkdir as mkdir5, readFile as readFile20, rename as rename7 } from "fs/promises";
+import { resolve as resolve30, dirname as dirname9 } from "path";
 init_api();
 var WORKSPACE_REGEX2 = /^[a-z0-9_][a-z0-9-]*$/;
 function touchItem4(item) {
@@ -15489,7 +17425,7 @@ function params(req) {
   return req.params;
 }
 async function projectExists(projectsDir, slug) {
-  return fileExists(resolve28(projectsDir, slug, "project.md"));
+  return fileExists(resolve30(projectsDir, slug, "project.md"));
 }
 async function ensureProjectTodosDir(projectsDir, slug) {
   const todosDir2 = projectTodosDir(projectsDir, slug);
@@ -15506,7 +17442,7 @@ async function ensureProjectTodosDir(projectsDir, slug) {
     throw err;
   }
   try {
-    await mkdir5(resolve28(todosDir2, "archive"), { recursive: false });
+    await mkdir5(resolve30(todosDir2, "archive"), { recursive: false });
   } catch (err) {
     const code = err.code;
     if (code === "EEXIST") return;
@@ -15710,7 +17646,7 @@ function createProjectTodosRouter(projectsDir, broadcast, workspaceTodosDir) {
         const archFile = archivePath(todosDir2, slug, checklist.archiveInterval);
         let archContent = "";
         if (await fileExists(archFile)) {
-          archContent = await readFile18(archFile, "utf-8");
+          archContent = await readFile20(archFile, "utf-8");
           archContent = archContent.trimEnd() + "\n\n";
         } else {
           archContent = `---
@@ -16169,17 +18105,17 @@ workspace: ${slug}
         if (tg.includes("/")) {
           const parts = tg.split("/");
           if (parts.length !== 2) return { error: `Invalid target.assignment "${tg}"` };
-          assignmentDir = resolve28(projectsDir, parts[0], "assignments", parts[1]);
+          assignmentDir = resolve30(projectsDir, parts[0], "assignments", parts[1]);
           assignmentRef = `${parts[0]}/${parts[1]}`;
         } else if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(tg)) {
-          assignmentDir = resolve28(assignmentsDirFn(), tg);
+          assignmentDir = resolve30(assignmentsDirFn(), tg);
           assignmentRef = tg;
         } else {
           return { error: `Invalid target.assignment "${tg}"` };
         }
-        const assignmentMdPath = resolve28(assignmentDir, "assignment.md");
+        const assignmentMdPath = resolve30(assignmentDir, "assignment.md");
         if (!await fileExists(assignmentMdPath)) return { error: `Target assignment not found: ${assignmentMdPath}` };
-        let content = await readFile18(assignmentMdPath, "utf-8");
+        let content = await readFile20(assignmentMdPath, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
           items.map((it) => ({
@@ -16318,7 +18254,7 @@ workspace: ${slug}
           return { status: 409, error: "attachments already exist in target" };
         }
         if (item.planDir && newPlanDir) {
-          await mkdir5(dirname8(newPlanDir), { recursive: true });
+          await mkdir5(dirname9(newPlanDir), { recursive: true });
           await rename7(item.planDir, newPlanDir);
           item.planDir = newPlanDir;
         }
@@ -16382,7 +18318,7 @@ workspace: ${slug}
 
 // src/dashboard/api-bundles.ts
 import { Router as Router16 } from "express";
-import { readdir as readdir12 } from "fs/promises";
+import { readdir as readdir14 } from "fs/promises";
 
 // src/todos/bundle-parser.ts
 init_parser();
@@ -16390,7 +18326,7 @@ init_fs();
 init_paths();
 init_parser2();
 import { randomBytes as randomBytes3 } from "crypto";
-import { readFile as readFile19 } from "fs/promises";
+import { readFile as readFile21 } from "fs/promises";
 var BUNDLE_ID_REGEX = /^[a-f0-9]{4}$/;
 var SCOPE_VALUES = /* @__PURE__ */ new Set(["workspace", "project", "global"]);
 var SCOPE_ID_REGEX = /^[a-z0-9_][a-z0-9_-]*$/;
@@ -16457,7 +18393,7 @@ function parseBundles(content) {
 async function readBundles(todosDir2) {
   const path = bundlesPath(todosDir2);
   if (!await fileExists(path)) return [];
-  const content = await readFile19(path, "utf-8");
+  const content = await readFile21(path, "utf-8");
   return parseBundles(content).bundles;
 }
 
@@ -16506,7 +18442,7 @@ function createBundlesRouter(todosDir2, broadcast) {
     try {
       await ensureDir(todosDir2);
       const bundles = await readBundles(todosDir2);
-      const workspaceFiles = await readdir12(todosDir2).catch(() => []);
+      const workspaceFiles = await readdir14(todosDir2).catch(() => []);
       const itemsByKey = /* @__PURE__ */ new Map();
       for (const f of workspaceFiles) {
         if (typeof f !== "string") continue;
@@ -16559,7 +18495,7 @@ init_fs();
 init_paths();
 init_slug();
 import { Router as Router17 } from "express";
-import { resolve as resolve29 } from "path";
+import { resolve as resolve31 } from "path";
 init_parser2();
 function deriveStatus2(bundle, items) {
   const members = bundle.todoIds.map((id) => items.find((i) => i.id === id)).filter((i) => i !== void 0);
@@ -16601,7 +18537,7 @@ function createProjectBundlesRouter(projectsDir, broadcast) {
   router.get("/", async (req, res) => {
     try {
       const slug = getProjectIdParam2(req.params.projectId);
-      const projectMd = resolve29(projectsDir, slug, "project.md");
+      const projectMd = resolve31(projectsDir, slug, "project.md");
       if (!await fileExists(projectMd)) {
         notFound2(res, slug);
         return;
@@ -16630,8 +18566,8 @@ init_fs();
 init_config2();
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { cp as cp2, mkdtemp, rm as rm4, readFile as readFile20, writeFile as writeFile7, unlink as unlink6, stat as stat2, open as open2, rename as rename8 } from "fs/promises";
-import { resolve as resolve30, join as join4 } from "path";
+import { cp as cp2, mkdtemp, rm as rm4, readFile as readFile22, writeFile as writeFile7, unlink as unlink7, stat as stat3, open as open3, rename as rename8 } from "fs/promises";
+import { resolve as resolve32, join as join4 } from "path";
 import { tmpdir } from "os";
 var exec2 = promisify2(execFile2);
 var VALID_CATEGORIES = ["projects", "playbooks", "todos", "servers", "config"];
@@ -16671,7 +18607,7 @@ async function resolveCategoryPath(category) {
     case "servers":
       return { sourcePath: serversDir(), repoPath: "servers", isFile: false };
     case "config":
-      return { sourcePath: resolve30(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
+      return { sourcePath: resolve32(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
   }
 }
 async function checkGitInstalled() {
@@ -16681,17 +18617,17 @@ async function checkGitInstalled() {
     throw new Error("git is not installed or not on PATH. Install git and try again.");
   }
 }
-async function acquireLock() {
-  const lockPath = resolve30(syntaurRoot(), LOCK_FILE_NAME);
+async function acquireLock2() {
+  const lockPath = resolve32(syntaurRoot(), LOCK_FILE_NAME);
   await ensureDir(syntaurRoot());
   try {
-    const handle = await open2(lockPath, "wx");
+    const handle = await open3(lockPath, "wx");
     await handle.write(String(process.pid));
     await handle.close();
     return lockPath;
   } catch (err) {
     if (err.code === "EEXIST") {
-      const pid = await readFile20(lockPath, "utf-8").catch(() => "");
+      const pid = await readFile22(lockPath, "utf-8").catch(() => "");
       throw new Error(
         `Backup operation already in progress (lock file at ${lockPath}, pid ${pid.trim() || "unknown"}). If stale, delete the file and retry.`
       );
@@ -16701,7 +18637,7 @@ async function acquireLock() {
 }
 async function releaseLock(lockPath) {
   try {
-    await unlink6(lockPath);
+    await unlink7(lockPath);
   } catch {
   }
 }
@@ -16724,12 +18660,12 @@ async function cloneOrInit(repoUrl, destDir) {
 }
 async function copyRecursive(src, dest) {
   if (!await fileExists(src)) return;
-  const s = await stat2(src);
+  const s = await stat3(src);
   if (s.isDirectory()) {
     await ensureDir(dest);
     await cp2(src, dest, { recursive: true, force: true });
   } else {
-    await ensureDir(resolve30(dest, ".."));
+    await ensureDir(resolve32(dest, ".."));
     await cp2(src, dest, { force: true });
   }
 }
@@ -16738,7 +18674,7 @@ function resolveCategoriesStrict(csv) {
   return parseCategoriesStrict(parts);
 }
 async function readSanitizedConfig(configPath) {
-  const content = await readFile20(configPath, "utf-8");
+  const content = await readFile22(configPath, "utf-8");
   return content.replace(/^(\s*lastBackup:\s*).*$/m, "$1null").replace(/^(\s*lastRestore:\s*).*$/m, "$1null");
 }
 async function backupToGithub(overrides) {
@@ -16757,7 +18693,7 @@ async function backupToGithub(overrides) {
   if (categories.length === 0) {
     throw new Error("No valid backup categories selected.");
   }
-  const lockPath = await acquireLock();
+  const lockPath = await acquireLock2();
   let tmpDir = null;
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   try {
@@ -16777,7 +18713,7 @@ async function backupToGithub(overrides) {
       }
       if (category === "config") {
         const sanitized = await readSanitizedConfig(sourcePath);
-        await ensureDir(resolve30(destPath, ".."));
+        await ensureDir(resolve32(destPath, ".."));
         await writeFile7(destPath, sanitized, "utf-8");
       } else {
         await copyRecursive(sourcePath, destPath);
@@ -16831,7 +18767,7 @@ async function backupToGithub(overrides) {
 }
 async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
   if (isFile) {
-    await ensureDir(resolve30(localPath, ".."));
+    await ensureDir(resolve32(localPath, ".."));
     await cp2(repoSrcPath, localPath, { force: true });
     return;
   }
@@ -16886,7 +18822,7 @@ async function restoreFromGithub(overrides) {
   if (categories.length === 0) {
     throw new Error("No valid restore categories selected.");
   }
-  const lockPath = await acquireLock();
+  const lockPath = await acquireLock2();
   let tmpDir = null;
   const restored = [];
   const failed = [];
@@ -16932,7 +18868,7 @@ async function restoreFromGithub(overrides) {
 }
 async function getBackupStatus() {
   const config = await readConfig();
-  const lockPath = resolve30(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve32(syntaurRoot(), LOCK_FILE_NAME);
   const locked = await fileExists(lockPath);
   return {
     repo: config.backup?.repo ?? null,
@@ -17280,7 +19216,7 @@ function createDashboardServer(options) {
   (async () => {
     try {
       const configResult = await migrateLegacyConfig(
-        resolve31(syntaurRoot(), "config.md")
+        resolve33(syntaurRoot(), "config.md")
       );
       const projectResult = await migrateLegacyProjectFiles(projectsDir);
       const summary = summarizeMigration(projectResult, configResult);
@@ -17798,14 +19734,14 @@ function createDashboardServer(options) {
   app.use("/api/backup", createBackupRouter());
   if (serveStaticUi && dashboardDistPath) {
     const sendOpts = { dotfiles: "allow" };
-    app.use("/assets", express.static(resolve31(dashboardDistPath, "assets"), sendOpts));
+    app.use("/assets", express.static(resolve33(dashboardDistPath, "assets"), sendOpts));
     app.use(express.static(dashboardDistPath, { ...sendOpts, index: false, fallthrough: true }));
     app.get("{*path}", async (req, res) => {
       if (req.path.startsWith("/api") || req.path === "/ws" || req.path.startsWith("/assets")) {
         res.status(404).json({ error: "Not Found" });
         return;
       }
-      const indexPath = resolve31(dashboardDistPath, "index.html");
+      const indexPath = resolve33(dashboardDistPath, "index.html");
       if (!await fileExists(indexPath)) {
         res.status(503).send(
           'Dashboard not built. Run "npm run build:dashboard" first.'
@@ -17823,15 +19759,71 @@ function createDashboardServer(options) {
   let watcherHandle = null;
   return {
     async start() {
+      const { recomputeAndWrite: recomputeAndWrite2, recomputeAll: recomputeAll2, resolveDeriveContext: resolveDeriveContext2, isDeriveMigrated: isDeriveMigrated2 } = await Promise.resolve().then(() => (init_recompute(), recompute_exports));
+      let warnedMigrationPending = false;
+      const migrationGate = async () => {
+        if (await isDeriveMigrated2()) return true;
+        if (!warnedMigrationPending) {
+          warnedMigrationPending = true;
+          console.log(
+            "derived-status: migration pending \u2014 implicit recomputes are dormant until `syntaur migrate-derive` runs."
+          );
+        }
+        return false;
+      };
+      const recomputeOne = async (projectSlug, assignmentSlug) => {
+        if (!await migrationGate()) return;
+        try {
+          const context = await resolveDeriveContext2();
+          const projectDir = projectSlug ? resolve33(projectsDir, projectSlug) : null;
+          const path = projectDir ? resolve33(projectDir, "assignments", assignmentSlug, "assignment.md") : resolve33(assignmentsDir2, assignmentSlug, "assignment.md");
+          if (!await fileExists(path)) return;
+          const result = await recomputeAndWrite2(path, {
+            cause: "derive",
+            by: "system",
+            projectDir,
+            context
+          });
+          if (result.warning) console.warn(result.warning);
+        } catch (err) {
+          console.error(`derive recompute failed for ${projectSlug ?? ""}/${assignmentSlug}:`, err);
+        }
+      };
+      const sweepAll = async (cause) => {
+        if (!await migrationGate()) return;
+        try {
+          const context = await resolveDeriveContext2();
+          const summary = await recomputeAll2(projectsDir, assignmentsDir2, {
+            cause,
+            by: "system",
+            context
+          });
+          if (summary.changed > 0) {
+            console.log(`derive ${cause}: ${summary.changed}/${summary.scanned} assignment(s) re-derived.`);
+          }
+          for (const w of summary.warnings) console.warn(w);
+        } catch (err) {
+          console.error(`derive ${cause} sweep failed:`, err);
+        }
+      };
       watcherHandle = createWatcher({
         projectsDir,
         assignmentsDir: assignmentsDir2,
         serversDir: serversDir2,
         playbooksDir: playbooksDir2,
         todosDir: todosDir2,
-        dbPath: resolve31(syntaurRoot(), "syntaur.db"),
-        onMessage: broadcast
+        dbPath: resolve33(syntaurRoot(), "syntaur.db"),
+        configPath: resolve33(syntaurRoot(), "config.md"),
+        onMessage: broadcast,
+        onAssignmentChanged: (projectSlug, assignmentSlug) => {
+          void recomputeOne(projectSlug, assignmentSlug);
+        },
+        onConfigChanged: () => {
+          clearStatusConfigCache();
+          void sweepAll("config-change");
+        }
       });
+      void sweepAll("boot-reconcile");
       startAutodiscovery({ serversDir: serversDir2, projectsDir, assignmentsDir: assignmentsDir2, excludePids: /* @__PURE__ */ new Set([process.pid]) });
       return new Promise((resolvePromise, reject) => {
         server.on("error", (err) => {
@@ -17844,7 +19836,7 @@ function createDashboardServer(options) {
           }
         });
         server.listen(port, () => {
-          const portFile = resolve31(syntaurRoot(), "dashboard-port");
+          const portFile = resolve33(syntaurRoot(), "dashboard-port");
           writeFile8(portFile, String(port), "utf-8").catch(() => {
           });
           resolvePromise();
@@ -17863,8 +19855,8 @@ function createDashboardServer(options) {
         client.terminate();
       }
       clients.clear();
-      const portFile = resolve31(syntaurRoot(), "dashboard-port");
-      await unlink7(portFile).catch(() => {
+      const portFile = resolve33(syntaurRoot(), "dashboard-port");
+      await unlink8(portFile).catch(() => {
       });
       server.closeAllConnections?.();
       return new Promise((resolvePromise) => {