@gobing-ai/spur 0.3.95 → 0.3.96

package/spur.js

@@ -14897,6 +14897,7 @@ var init_finding_codes = __esm(() => {
     "L2.disallowed-section",
     "L2.heading-level",
     "L2.section-order",
+    "L2.unclosed-code-fence",
     "L3.requirements-format",
     "L3.requirements-checkbox",
     "L3.requirements-empty",
@@ -14951,7 +14952,10 @@ var init_finding_codes = __esm(() => {
     "L4.feature-receipt-failed",
     "L4.feature-receipt-run",
     "L4.feature-receipt-stale",
-    "L4.feature-receipt-contract"
+    "L4.feature-receipt-contract",
+    "precheck-size",
+    "precheck-evidence",
+    "inventory-coverage"
   ];
   FINDING_CODES = {
     L1_MARKDOWN_PARSE: "L1.markdown-parse",
@@ -14961,6 +14965,7 @@ var init_finding_codes = __esm(() => {
     L2_DISALLOWED_SECTION: "L2.disallowed-section",
     L2_HEADING_LEVEL: "L2.heading-level",
     L2_SECTION_ORDER: "L2.section-order",
+    L2_UNCLOSED_CODE_FENCE: "L2.unclosed-code-fence",
     L3_REQUIREMENTS_FORMAT: "L3.requirements-format",
     L3_REQUIREMENTS_CHECKBOX: "L3.requirements-checkbox",
     L3_REQUIREMENTS_EMPTY: "L3.requirements-empty",
@@ -15015,7 +15020,10 @@ var init_finding_codes = __esm(() => {
     L4_FEATURE_RECEIPT_FAILED: "L4.feature-receipt-failed",
     L4_FEATURE_RECEIPT_RUN: "L4.feature-receipt-run",
     L4_FEATURE_RECEIPT_STALE: "L4.feature-receipt-stale",
-    L4_FEATURE_RECEIPT_CONTRACT: "L4.feature-receipt-contract"
+    L4_FEATURE_RECEIPT_CONTRACT: "L4.feature-receipt-contract",
+    PRECHECK_SIZE: "precheck-size",
+    PRECHECK_EVIDENCE: "precheck-evidence",
+    INVENTORY_COVERAGE: "inventory-coverage"
   };
 });
 
@@ -52233,6 +52241,10 @@ async function countToolCallsSince(db2, source, runStartedAt) {
   const row = await db2.queryFirst("SELECT COUNT(*) AS cnt FROM history_tool_call WHERE source = ? AND imported_at >= ?", source, runStartedAt);
   return row?.cnt ?? 0;
 }
+async function countToolCallArgsRaw(db2, source) {
+  const row = await db2.queryFirst("SELECT COUNT(*) AS cnt FROM history_tool_call WHERE args_raw IS NOT NULL AND source = ?", source);
+  return row?.cnt ?? 0;
+}
 function withStepPredicates(wmWhere, predicates) {
   return wmWhere === "" ? `WHERE ${predicates}` : `${wmWhere} AND ${predicates}`;
 }
@@ -73045,6 +73057,30 @@ function findHeadings(body, hashes) {
   }
   return hits;
 }
+function findUnclosedFenceLine(text4) {
+  let inCodeBlock = false;
+  let openLine = 0;
+  let lineNo = 0;
+  let lineStart = 0;
+  for (let i2 = 0;i2 <= text4.length; i2++) {
+    const atEnd = i2 === text4.length;
+    if (!atEnd && text4[i2] !== `
+`)
+      continue;
+    const line = text4.slice(lineStart, i2);
+    lineNo++;
+    if (line.startsWith("```")) {
+      if (inCodeBlock) {
+        inCodeBlock = false;
+      } else {
+        inCodeBlock = true;
+        openLine = lineNo;
+      }
+    }
+    lineStart = i2 + 1;
+  }
+  return inCodeBlock ? openLine : null;
+}
 function normalizeYamlScalars(data) {
   const out = {};
   for (const [key, value] of Object.entries(data)) {
@@ -73067,12 +73103,14 @@ class MarkdownDocument {
   _sections;
   _demotedHeadings = [];
   _duplicateSectionNames = [];
-  constructor(domain2, frontmatterBlock, frontmatter, preamble, sections) {
+  _unclosedFenceLine;
+  constructor(domain2, frontmatterBlock, frontmatter, preamble, sections, unclosedFenceLine) {
     this._domain = domain2;
     this._frontmatterBlock = frontmatterBlock;
     this._frontmatter = frontmatter;
     this._preamble = preamble;
     this._sections = sections;
+    this._unclosedFenceLine = unclosedFenceLine;
   }
   static parse(content, domain2) {
     const level = HEADING_LEVELS[domain2];
@@ -73095,6 +73133,8 @@ class MarkdownDocument {
       frontmatterBlock = fmMatch[0];
       body = content.slice(fmMatch[0].length);
     }
+    const bodyUnclosedFenceLine = findUnclosedFenceLine(body);
+    const unclosedFenceLine = bodyUnclosedFenceLine === null ? null : bodyUnclosedFenceLine + (frontmatterBlock.match(/\n/g) ?? []).length;
     const hits = findHeadings(body, hashes);
     const first = hits[0];
     const preamble = first !== undefined ? body.slice(0, first.index) : body;
@@ -73119,7 +73159,7 @@ class MarkdownDocument {
         sections.push(s2);
       }
     }
-    const doc2 = new MarkdownDocument(domain2, frontmatterBlock, frontmatter, preamble, sections);
+    const doc2 = new MarkdownDocument(domain2, frontmatterBlock, frontmatter, preamble, sections, unclosedFenceLine);
     doc2._duplicateSectionNames.push(...duplicateNames);
     return doc2;
   }
@@ -73154,6 +73194,23 @@ class MarkdownDocument {
   get duplicateSectionNames() {
     return this._duplicateSectionNames;
   }
+  unclosedFenceLine() {
+    return this._unclosedFenceLine;
+  }
+  assertFenceBalance(name, body) {
+    const docFenceLine = this._unclosedFenceLine;
+    if (docFenceLine !== null) {
+      throw new Error(`Cannot write section "${name}": the document has an unclosed code fence at line ${docFenceLine}; ` + "later sections are hidden and would be dropped by this write. Close the fence and re-parse.");
+    }
+    if (this._duplicateSectionNames.length > 0) {
+      const names = this._duplicateSectionNames.map((n2) => `"${n2}"`).join(", ");
+      throw new Error(`Cannot write section "${name}": the document has duplicate top-level sections (${names}); ` + "the serialized result would have fewer sections than the input and the duplicates would be dropped. " + "Merge or remove the duplicates and re-parse.");
+    }
+    const bodyFenceLine = findUnclosedFenceLine(body);
+    if (bodyFenceLine !== null) {
+      throw new Error(`Cannot write section "${name}": the new body has an unclosed code fence (opening at body line ${bodyFenceLine}); ` + "writing it would leave the document inside an open fence and hide later sections.");
+    }
+  }
   get canonicalSections() {
     const base2 = this._domain === "task" ? TASK_CANONICAL_SECTIONS : FEATURE_CANONICAL_SECTIONS;
     const extra = UNIVERSAL_SECTIONS.filter((s2) => !base2.includes(s2));
@@ -73182,6 +73239,7 @@ class MarkdownDocument {
   }
   replaceSection(name, body) {
     this.validateSectionName(name);
+    this.assertFenceBalance(name, body);
     const cleaned = this.stripSameLevelHeadings(body);
     const section = this.findSection(name);
     if (section !== undefined) {
@@ -73245,6 +73303,7 @@ ${body.trimEnd()}
   }
   replaceMarkerRegion(name, content) {
     this.validateSectionName(name);
+    this.assertFenceBalance(name, content);
     const section = this.findSection(name);
     if (section === undefined) {
       throw new Error(`Section "${name}" does not exist in this document.`);
@@ -74133,6 +74192,7 @@ __export(exports_src, {
   createDefaultRegistry: () => createDefaultRegistry,
   createBoundaryContext: () => createBoundaryContext,
   countToolCallsSince: () => countToolCallsSince,
+  countToolCallArgsRaw: () => countToolCallArgsRaw,
   countCheckpointsBySource: () => countCheckpointsBySource,
   consolidatedTimeline: () => consolidatedTimeline,
   computeSnapshotHash: () => computeSnapshotHash,
@@ -78315,7 +78375,8 @@ class AgentService {
         cacheInfo = { hit: true, ageMs: serveCached.ageMs, path: DOCTOR_CACHE_REL };
         return this.renderDoctor(serveCached.results, executors, args.json, undefined, cacheInfo, args.enveloped, usage);
       }
-      const probeResults = await doctorRunner.runAll();
+      const allDisabled = (executors?.length ?? 0) > 0 && enabledExecutors?.length === 0;
+      const probeResults = allDisabled ? [] : await doctorRunner.runAll();
       const results2 = withDisabledRows(probeResults, executors);
       if (cacheOn && !args.probeHealth) {
         const writeErr = await writeDoctorCacheFile(fileSystem, fingerprint2, results2, now2);
@@ -81511,6 +81572,82 @@ var init_finding_codes2 = __esm(() => {
   init_src();
 });
 
+// ../../packages/app/src/services/feature-inventory.ts
+function parseInventory(report) {
+  const lines = report.split(`
+`);
+  const start = lines.findIndex((line) => /^#{1,6}\s*Requirement inventory\s*$/i.test(line));
+  if (start === -1)
+    return { owing: new Set, deferred: new Set, hasSection: false };
+  const owing = new Set;
+  const deferred = new Set;
+  for (let i2 = start + 1;i2 < lines.length; i2++) {
+    if (/^#{1,6}\s/.test(lines[i2] ?? ""))
+      break;
+    const match = INVENTORY_ITEM_RE.exec(lines[i2] ?? "");
+    if (match === null)
+      continue;
+    const id = `I${match[1]}`;
+    if (/\[\s*deferred\s*:/i.test(match[2] ?? ""))
+      deferred.add(id);
+    else
+      owing.add(id);
+  }
+  return { owing, deferred, hasSection: true };
+}
+function parseCoverage(ac) {
+  const covered = new Map;
+  let inScenario = false;
+  for (const line of ac.split(`
+`)) {
+    if (SCENARIO_RE.test(line)) {
+      inScenario = true;
+      continue;
+    }
+    if (!inScenario)
+      continue;
+    const match = COVERS_RE.exec(line);
+    if (match === null)
+      continue;
+    for (const raw of (match[1] ?? "").split(",")) {
+      const id = raw.trim().toUpperCase();
+      if (/^I\d+$/.test(id))
+        covered.set(id, (covered.get(id) ?? 0) + 1);
+    }
+  }
+  return covered;
+}
+function checkInventoryCoverage(reportText, acText) {
+  const inventory = parseInventory(reportText);
+  if (!inventory.hasSection || inventory.owing.size + inventory.deferred.size === 0) {
+    return [
+      {
+        layer: "L3",
+        code: FINDING_CODES.INVENTORY_COVERAGE,
+        severity: "error",
+        section: "Requirements",
+        message: "inventory report has no `## Requirement inventory` items"
+      }
+    ];
+  }
+  const covered = parseCoverage(acText);
+  const uncovered = [...inventory.owing].filter((id) => (covered.get(id) ?? 0) === 0).sort();
+  return uncovered.map((id) => ({
+    layer: "L3",
+    code: FINDING_CODES.INVENTORY_COVERAGE,
+    severity: "error",
+    section: "Requirements",
+    message: `Requirement ${id} is not covered by any AC scenario and is not [deferred:]`
+  }));
+}
+var INVENTORY_ITEM_RE, COVERS_RE, SCENARIO_RE;
+var init_feature_inventory = __esm(() => {
+  init_finding_codes2();
+  INVENTORY_ITEM_RE = /^\s*[-*]\s+\**I(\d+)\**\s*[.:\u2014-]?\s+(.*)$/;
+  COVERS_RE = /^\s*#\s*covers:\s*(.+)$/i;
+  SCENARIO_RE = /^\s*Scenario(?:\s+Outline)?:/;
+});
+
 // ../../packages/app/src/services/structural-repair.ts
 function canonicalOrder(domain2) {
   return domain2 === "task" ? TASK_CANONICAL_SECTIONS : FEATURE_CANONICAL_SECTIONS;
@@ -81834,6 +81971,16 @@ class PlanningCheckService {
     return doc2;
   }
   runL2(doc2, entry, findings, raw) {
+    const fenceLine = doc2.unclosedFenceLine();
+    if (fenceLine !== null) {
+      findings.push({
+        layer: "L2",
+        code: FINDING_CODES.L2_UNCLOSED_CODE_FENCE,
+        severity: "error",
+        section: "",
+        message: `Unclosed code fence at line ${fenceLine}: all later sections are hidden from this check. Close the fence to restore them.`
+      });
+    }
     if (!entry)
       return;
     const sectionNames = doc2.sectionNames;
@@ -81984,6 +82131,7 @@ var init_planning_check_base = __esm(() => {
     FINDING_CODES.L1_MARKDOWN_PARSE,
     FINDING_CODES.L1_SCHEMA_VALIDATION,
     FINDING_CODES.L2_MISSING_REQUIRED_SECTION,
+    FINDING_CODES.L2_UNCLOSED_CODE_FENCE,
     FINDING_CODES.L3_AC_BDD_ERROR,
     FINDING_CODES.L3_AC_BDD_INVALID,
     FINDING_CODES.L3_REQUIREMENTS_EMPTY,
@@ -81991,7 +82139,10 @@ var init_planning_check_base = __esm(() => {
     FINDING_CODES.L3_REQUIRED_SECTION_PLACEHOLDER,
     ...REQUIRED_REFERENCE_CODES,
     FINDING_CODES.L4_PREREQUISITE_CYCLE,
-    ...COMPLETION_FINDING_CODES
+    ...COMPLETION_FINDING_CODES,
+    FINDING_CODES.PRECHECK_SIZE,
+    FINDING_CODES.PRECHECK_EVIDENCE,
+    FINDING_CODES.INVENTORY_COVERAGE
   ]);
 });
 
@@ -82049,20 +82200,21 @@ function prefixId(id) {
   const m = /^(?:AC|R)\d+/.exec(id);
   return m ? m[0] : id;
 }
-function acRowProves(rowId, items) {
-  const key2 = normalizeKey2(rowId);
+function acRowProves(rowId, items, scenarioTitles) {
+  const ordinal = /^AC-(\d+)$/.exec(rowId.trim());
+  const key2 = normalizeKey2(ordinal ? scenarioTitles[Number(ordinal[1]) - 1] ?? "" : rowId);
   for (const item of items) {
     if (!item.requirementId?.startsWith("AC"))
       continue;
     const alias3 = normalizeKey2(item.text.replace(/\s*\(req:[^)]*\)\s*$/, ""));
-    if (alias3 !== "" && (alias3 === key2 || alias3.endsWith(`\u2014 ${key2}`)))
+    if (alias3 !== "" && key2 !== "" && (alias3 === key2 || alias3.endsWith(`\u2014 ${key2}`)))
       return item.requirementId;
   }
-  if (/^R\d+\s*[\u2014-]\s*\S/.test(rowId.trim()))
+  if (ordinal || /^R\d+\s*[\u2014-]\s*\S/.test(rowId.trim()))
     return;
   return prefixId(rowId);
 }
-function flipVerifiedCheckboxes(body, verdict) {
+function flipVerifiedCheckboxes(body, verdict, scenarioTitles = []) {
   if (verdict.verdict === "FAIL" || verdict.verdict === "UNKNOWN")
     return body;
   const items = parseChecklist(body);
@@ -82070,13 +82222,16 @@ function flipVerifiedCheckboxes(body, verdict) {
     return body;
   const proven = new Set;
   for (const req of verdict.requirements) {
-    if (req.status === "MET")
-      proven.add(prefixId(req.id));
+    if (req.status !== "MET")
+      continue;
+    const id = /^AC-\d+$/.test(req.id.trim()) ? acRowProves(req.id, items, scenarioTitles) : prefixId(req.id);
+    if (id !== undefined)
+      proven.add(id);
   }
   for (const ac of verdict.acceptanceCriteria ?? []) {
     if (ac.status !== "MET")
       continue;
-    const id = acRowProves(ac.id, items);
+    const id = acRowProves(ac.id, items, scenarioTitles);
     if (id !== undefined)
       proven.add(id);
   }
@@ -82359,6 +82514,288 @@ var init_task_record = __esm(() => {
   };
 });
 
+// ../../packages/app/src/services/verify-answer-lint.ts
+function lintVerifyAnswer(answerText, taskContent, featureContent) {
+  const findings = [];
+  const add = (line, rule, message) => {
+    if (findings.length < ANSWER_LINT_MAX_FINDINGS)
+      findings.push({ line, rule, message });
+  };
+  const tables = parseAnswer(answerText);
+  if (tables.verdict === null) {
+    add(0, "verdict-missing", "no `Verdict:` line (expected exactly one `Verdict: PASS|PARTIAL|FAIL` line)");
+  } else if (!/^(PASS|PARTIAL|FAIL)$/i.test(tables.verdict.value)) {
+    add(tables.verdict.line, "verdict-value", `invalid Verdict value "${tables.verdict.value}" (PASS | PARTIAL | FAIL)`);
+  }
+  const reqIds = extractRequirementIds(taskContent);
+  const acIndex = buildAcIdentityIndex(taskContent, featureContent ?? null);
+  const seenReq = new Set;
+  for (const row of tables.reqs) {
+    if (!reqIds.includes(row.id))
+      add(row.line, "req-unknown", `unknown requirement ID "${row.id}" (task declares: ${reqIds.join(", ") || "none"})`);
+    else if (seenReq.has(row.id))
+      add(row.line, "req-duplicate", `duplicate requirement row "${row.id}"`);
+    seenReq.add(row.id);
+    if (normalizeReqStatus(row.status) === null)
+      add(row.line, "req-status", `"${row.id}" invalid status "${row.status}" (MET | PARTIAL | UNMET)`);
+    if (!row.evidence.trim())
+      add(row.line, "req-evidence", `"${row.id}" has empty evidence`);
+  }
+  for (const id of reqIds) {
+    if (!seenReq.has(id))
+      add(0, "req-missing", `missing requirement row for "${id}"`);
+  }
+  const seenAc = new Map;
+  for (const row of tables.acs) {
+    const resolution = resolveAcIdentity(row.id, acIndex);
+    const canonicalKey = resolution.ok ? normalizeAcTitle(resolution.canonical) : null;
+    if (!resolution.ok) {
+      if (resolution.error !== "")
+        add(row.line, "ac-ordinal", resolution.error);
+      else
+        add(row.line, "ac-identity", `AC ID "${row.id.slice(0, 60)}" matches no task AC checklist label or scenario title ` + "(accepted forms: exact title, bare title, a criterion bullet's bold head or full bold span, " + "`Scenario:` prefix, bracket tags, declared AC-N alias)");
+    } else if (canonicalKey !== null && seenAc.has(canonicalKey)) {
+      const first = seenAc.get(canonicalKey) ?? "";
+      add(row.line, "ac-duplicate", `duplicate AC row "${row.id.slice(0, 60)}" \u2014 alias-equivalent to "${first.slice(0, 60)}"`);
+    }
+    if (canonicalKey !== null && !seenAc.has(canonicalKey))
+      seenAc.set(canonicalKey, row.id);
+    if (normalizeAcStatus(row.status) === null)
+      add(row.line, "ac-status", `invalid AC status "${row.status}" (MET | PARTIAL | UNMET | N/A)`);
+    if (normalizeEvidenceType(row.evidenceType) === null)
+      add(row.line, "ac-evidence-type", `invalid evidence type "${row.evidenceType}" (test | command | static-ref | manual-review | llm-judge | n/a, or a + compound)`);
+    if (!row.evidence.trim())
+      add(row.line, "ac-evidence", `AC "${row.id.slice(0, 40)}" has empty evidence`);
+  }
+  return findings;
+}
+function splitTableCells(line) {
+  return line.split(/(?<!\\)\|/).map((c3) => c3.replace(/\\\|/g, "|").trim()).filter(Boolean);
+}
+function normalizeReqStatus(raw) {
+  if (/\bMET\b/.test(raw))
+    return "MET";
+  if (/\bPARTIAL\b/.test(raw))
+    return "PARTIAL";
+  if (/\bUNMET\b/.test(raw))
+    return "UNMET";
+  return null;
+}
+function normalizeAcStatus(raw) {
+  if (/\bMET\b/.test(raw))
+    return "MET";
+  if (/\bPARTIAL\b/.test(raw))
+    return "PARTIAL";
+  if (/\bUNMET\b/.test(raw))
+    return "UNMET";
+  if (/\bN\/A\b/.test(raw) || /\bNA\b/.test(raw))
+    return "N/A";
+  return null;
+}
+function normalizeEvidenceTypeToken(normalized) {
+  if (normalized === "test")
+    return "test";
+  if (normalized === "command")
+    return "command";
+  if (normalized === "static-ref" || normalized === "static" || normalized === "doc" || normalized === "docs" || normalized === "documentation") {
+    return "static-ref";
+  }
+  if (normalized === "manual-review" || normalized === "manual")
+    return "manual-review";
+  if (normalized === "llm-judge" || normalized === "judge")
+    return "llm-judge";
+  if (normalized === "n/a" || normalized === "na")
+    return "n/a";
+  return null;
+}
+function normalizeEvidenceType(raw) {
+  const normalized = raw.toLowerCase().trim();
+  const single = normalizeEvidenceTypeToken(normalized);
+  if (single !== null)
+    return single;
+  const parts = normalized.split(/[+,/]/).filter((p) => p.trim());
+  const tokens = parts.map((part) => normalizeEvidenceTypeToken(part.trim())).filter((t) => t !== null);
+  if (tokens.length < 2 || tokens.length !== parts.length)
+    return null;
+  return EVIDENCE_TYPE_PRECEDENCE.find((candidate) => tokens.includes(candidate)) ?? null;
+}
+function parseAnswer(text4) {
+  const out = { verdict: null, reqs: [], acs: [] };
+  const lines = text4.split(`
+`);
+  let reqTable = false;
+  let acTable = false;
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const trimmed = lines[i2]?.trim() ?? "";
+    const lineNo = i2 + 1;
+    if ((reqTable || acTable) && /^#{1,6}\s/.test(trimmed)) {
+      reqTable = false;
+      acTable = false;
+      continue;
+    }
+    if (!trimmed.startsWith("|"))
+      continue;
+    const cells = splitTableCells(trimmed);
+    if (/^[-:]+$/.test(cells[0] ?? ""))
+      continue;
+    const h0 = (cells[0] ?? "").toLowerCase();
+    const h1 = (cells[1] ?? "").toLowerCase();
+    if (!reqTable && !acTable && cells.length >= 2) {
+      const idLike = h0.includes("req") || h0 === "requirement" || h0 === "r#" || h0 === "r" || /^r\d+$/.test(h0);
+      if (idLike && (h1.includes("status") || h1 === "verdict")) {
+        reqTable = true;
+        continue;
+      }
+      if ((h0 === "ac" || h0.includes("acceptance")) && h1.includes("status") && (cells[2] ?? "").toLowerCase().includes("evidence")) {
+        acTable = true;
+        continue;
+      }
+    }
+    if (reqTable && cells.length >= 2) {
+      if ((h0 === "ac" || h0.includes("acceptance")) && h1.includes("status")) {
+        reqTable = false;
+        acTable = true;
+        continue;
+      }
+      out.reqs.push({
+        id: cells[0] ?? "",
+        status: (cells[1] ?? "").toUpperCase(),
+        evidence: cells[2] ?? "",
+        line: lineNo
+      });
+      continue;
+    }
+    if (acTable && cells.length >= 3) {
+      out.acs.push({
+        id: cells[0] ?? "",
+        status: cells[1] ?? "",
+        evidenceType: cells[2] ?? "",
+        evidence: cells[3] ?? "",
+        line: lineNo
+      });
+    }
+  }
+  const verdictMatches = [...text4.matchAll(/^\s*Verdict:\s*(\S+)\s*$/gim)];
+  if (verdictMatches.length === 1) {
+    out.verdict = {
+      value: verdictMatches[0]?.[1] ?? "",
+      line: text4.slice(0, verdictMatches[0]?.index ?? 0).split(`
+`).length
+    };
+  }
+  return out;
+}
+function sectionBetween(text4, heading) {
+  const marker = new RegExp(`^#{1,6}\\s+${heading}\\s*$`, "im");
+  const match = marker.exec(text4);
+  if (!match || match.index === undefined)
+    return "";
+  const rest = text4.slice(match.index);
+  const lineEnd = rest.indexOf(`
+`);
+  const afterHeading = lineEnd === -1 ? "" : rest.slice(lineEnd + 1);
+  const next = afterHeading.search(/^#{1,6}\s/m);
+  return next === -1 ? afterHeading : afterHeading.slice(0, next);
+}
+function extractRequirementIds(taskContent) {
+  const section = sectionBetween(taskContent, "Requirements");
+  const ids = new Set;
+  for (const m of section.matchAll(/\*\*(R\d+(?:\.\d+)*)\b/g))
+    ids.add(m[1] ?? "");
+  for (const m of section.matchAll(/^(?:[-*]\s+(?:\[[ xX]\]\s+)?|\[[ xX]\]\s+)(R\d+(?:\.\d+)*)/gm))
+    ids.add(m[1] ?? "");
+  for (const m of section.matchAll(/^(R\d+(?:\.\d+)*)\s*[.:]/gm))
+    ids.add(m[1] ?? "");
+  return [...ids];
+}
+function stripAcWrappers(title) {
+  let out = title.trim();
+  let prev;
+  do {
+    prev = out;
+    out = out.replace(/^\[[^\]]*\]\s*/, "").replace(/\s*\[[^\]]*\]\s*$/, "").replace(/^Scenario:\s*/i, "").trim();
+  } while (out !== prev);
+  return out;
+}
+function normalizeAcTitle(title) {
+  return stripAcWrappers(title).replace(/^R\d+\s*[:\-\u2014]?\s*/, "").toLowerCase().replace(/[\u0027\u2018\u2019\u201c\u201d]/g, "").replace(/\s+/g, " ").replace(/\s*\.+$/, "").trim();
+}
+function buildAcIdentityIndex(taskContent, featureContent) {
+  const byTitle = new Map;
+  const declareIdentity = (spelling) => {
+    const key2 = normalizeAcTitle(spelling);
+    if (key2 !== "" && !byTitle.has(key2))
+      byTitle.set(key2, spelling);
+  };
+  const section = sectionBetween(taskContent, "Acceptance Criteria");
+  for (const m of section.matchAll(/^[-*]\s+(?:\[[ xX]\]\s+)?(.+?)\s*(?::|$)/gm)) {
+    const label = (m[1] ?? "").trim();
+    if (!label)
+      continue;
+    declareIdentity(label);
+    const leading = label.split(/\s+/)[0] ?? "";
+    if (leading && leading !== label)
+      declareIdentity(leading);
+  }
+  for (const m of section.matchAll(/^[-*]\s+(?:\[[ xX]\]\s+)?\*\*(.+?)\*\*/gm)) {
+    const inner = (m[1] ?? "").trim();
+    if (!inner)
+      continue;
+    declareIdentity(inner);
+    const head = inner.split(/\s+[\u2014\u2013]\s+|:/)[0]?.trim() ?? "";
+    if (head && head !== inner)
+      declareIdentity(head);
+  }
+  for (const m of section.matchAll(/^\*\*(.+?)\*\*\s*$/gm)) {
+    const inner = (m[1] ?? "").trim();
+    if (!inner)
+      continue;
+    declareIdentity(inner);
+    const head = inner.split(":")[0]?.trim() ?? "";
+    if (head && head !== inner)
+      declareIdentity(head);
+  }
+  const scenarioTitles = (content) => [...content.matchAll(/^[ \t]*Scenario:\s*(.+)\s*$/gm)].map((m) => (m[1] ?? "").trim()).filter((t) => t !== "");
+  const taskScenarios = scenarioTitles(sectionBetween(taskContent, "Acceptance Criteria"));
+  const featureScenarios = featureContent !== null ? scenarioTitles(featureContent) : [];
+  for (const title of [...taskScenarios, ...featureScenarios])
+    declareIdentity(title);
+  return { byTitle, taskScenarios, featureScenarios };
+}
+function resolveAcIdentity(rowId, index2) {
+  const canonical = index2.byTitle.get(normalizeAcTitle(rowId));
+  if (canonical !== undefined)
+    return { ok: true, canonical };
+  const stripped = stripAcWrappers(rowId);
+  const ordinal = /^AC-(\d+)$/i.exec(stripped);
+  if (ordinal !== null) {
+    const n2 = Number(ordinal[1]);
+    const taskTitle = index2.taskScenarios[n2 - 1];
+    const featureTitle = index2.featureScenarios[n2 - 1];
+    const candidates = [...new Set([taskTitle, featureTitle].filter((t) => t !== undefined))];
+    if (candidates.length === 0) {
+      return {
+        ok: false,
+        error: `AC id "${rowId}" uses the AC-${n2} positional alias but no scenario exists at that ordinal ` + "(task scenario list and linked-feature scenario list) \u2014 cite the exact scenario title, checklist label, or a bare `**AC id**` paragraph"
+      };
+    }
+    if (candidates.length > 1) {
+      return {
+        ok: false,
+        error: `AC id "${rowId}" is ambiguous: task AC #${n2} ("${taskTitle}") and feature scenario #${n2} ` + `("${featureTitle}") are different scenarios with different ordering \u2014 cite the exact title`
+      };
+    }
+    const resolved = index2.byTitle.get(normalizeAcTitle(candidates[0] ?? ""));
+    if (resolved !== undefined)
+      return { ok: true, canonical: resolved };
+  }
+  return { ok: false, error: "" };
+}
+var ANSWER_LINT_MAX_FINDINGS = 10, EVIDENCE_TYPE_PRECEDENCE;
+var init_verify_answer_lint = __esm(() => {
+  EVIDENCE_TYPE_PRECEDENCE = ["test", "command", "static-ref", "manual-review", "llm-judge", "n/a"];
+});
+
 // ../../packages/app/src/services/feature-check.ts
 var exports_feature_check = {};
 __export(exports_feature_check, {
@@ -82366,9 +82803,13 @@ __export(exports_feature_check, {
   verdictRowsMatchScenarios: () => verdictRowsMatchScenarios,
   taskCoversAnyFeatureScenario: () => taskCoversAnyFeatureScenario,
   summarizeRowIds: () => summarizeRowIds,
+  readFeatureBody: () => readFeatureBody,
   readFeatureAcBody: () => readFeatureAcBody,
   matchedScenarioKeys: () => matchedScenarioKeys,
+  lintVerifyAnswerForTask: () => lintVerifyAnswerForTask,
+  isFeatureFile: () => isFeatureFile,
   findOtherP0InStatus: () => findOtherP0InStatus,
+  featureScenarioTitles: () => featureScenarioTitles,
   defaultVerdictRunDir: () => defaultVerdictRunDir,
   VERDICT_SCENARIO_KEY_FORMS: () => VERDICT_SCENARIO_KEY_FORMS,
   FeatureCheckService: () => FeatureCheckService,
@@ -82524,6 +82965,9 @@ function matchedScenarioKeys(rows, ac) {
   const met = rows.filter((r) => r.status === "MET");
   return scenarios.filter((sc) => met.some((r) => rowMatchesScenario(r.id, sc))).map((sc) => sc.title);
 }
+function featureScenarioTitles(ac) {
+  return indexScenarioAliases(ac).map((sc) => sc.title);
+}
 function indexScenarioAliases(ac) {
   const keys = [];
   let inDocString = false;
@@ -82601,28 +83045,63 @@ function taskCoversAnyFeatureScenario(taskAc, featureAc) {
     return false;
   return scenarioKeys(parsed.scenarios).some((sc) => taskCoversScenario(taskAc, sc));
 }
-async function readFeatureAcBody(fs3, featuresDir, featureId2) {
+function isFeatureFile(name, id) {
+  return name.startsWith(`${id}_`) && name.endsWith(".md") && name.length > id.length + 4;
+}
+async function readFeatureBody(fs3, featuresDir, featureId2) {
   try {
     for (const name of await fs3.readDir(featuresDir)) {
-      if (!name.startsWith(`${featureId2}_`) || !name.endsWith(".md"))
+      if (!isFeatureFile(name, featureId2))
         continue;
-      const doc2 = MarkdownDocument.parse(await fs3.readFile(`${featuresDir}/${name}`), "feature");
-      const ac = stripAcFence(doc2.getSection("Acceptance Criteria") ?? "");
-      return ac.trim().length > 0 ? ac : null;
+      return await fs3.readFile(`${featuresDir}/${name}`);
     }
   } catch {}
   return null;
 }
+async function readFeatureAcBody(fs3, featuresDir, featureId2) {
+  const raw = await readFeatureBody(fs3, featuresDir, featureId2);
+  if (raw === null)
+    return null;
+  try {
+    const doc2 = MarkdownDocument.parse(raw, "feature");
+    const ac = stripAcFence(doc2.getSection("Acceptance Criteria") ?? "");
+    return ac.trim().length > 0 ? ac : null;
+  } catch {
+    return null;
+  }
+}
+async function lintVerifyAnswerForTask(wbs, answerText, deps) {
+  let taskContent;
+  let featureId2 = "";
+  try {
+    const hit = await new TaskLocator({
+      fs: deps.fs,
+      tasksDir: deps.tasksDir,
+      ...deps.foldersConfig !== undefined ? { foldersConfig: deps.foldersConfig } : {}
+    }).findByWbs(wbs);
+    if (hit === null)
+      return [];
+    taskContent = await deps.fs.readFile(hit.filePath);
+    const tfm = MarkdownDocument.parse(taskContent, "task").frontmatterData ?? {};
+    featureId2 = tfm.feature_id ?? tfm["feature-id"] ?? "";
+  } catch {
+    return [];
+  }
+  const featureContent = featureId2 !== "" && deps.featuresDir !== undefined ? await readFeatureBody(deps.fs, deps.featuresDir, featureId2) : null;
+  return lintVerifyAnswer(answerText, taskContent, featureContent);
+}
 var DEFAULT_FEATURE_MATRIX, FeatureCheckService, EMBEDDED_SCENARIO_REF_RES, VERDICT_SCENARIO_KEY_FORMS = "scenario title, AC-N alias, (feature R<n>), (covers: R<n>), or [R<n>]";
 var init_feature_check = __esm(() => {
   init_src2();
   init_feature_verification_receipt();
   init_workflow_resolver();
   init_done_transition_guard();
+  init_feature_inventory();
   init_planning_check_base();
   init_structural_repair();
   init_task_locator();
   init_task_record();
+  init_verify_answer_lint();
   init_verify_verdict();
   DEFAULT_FEATURE_MATRIX = {
     variants: {
@@ -82737,6 +83216,10 @@ var init_feature_check = __esm(() => {
       const runDir = options?.runDir ?? (primaryTasksDir ? defaultVerdictRunDir(primaryTasksDir) : undefined);
       const taskScanDirs = options?.tasksDirs && options.tasksDirs.length > 0 ? options.tasksDirs : options?.tasksDir ? [options.tasksDir] : [];
       await this.runL4(doc2, featureId2, effectiveStatus, taskScanDirs, dogfoodDir, runDir, findings);
+      if (typeof options?.inventory === "string") {
+        const acText = doc2.getSection("Acceptance Criteria") ?? "";
+        findings.push(...checkInventoryCoverage(options.inventory, acText));
+      }
       return {
         id: featureId2,
         ...this.summarizeWithStatus(effectiveStatus, findings, strict, options?.severityOverrides),
@@ -83226,6 +83709,111 @@ var init_feature_check = __esm(() => {
   EMBEDDED_SCENARIO_REF_RES = [/\((?:feature|covers:)[ \t]*(R\d+)\b[^)]*\)/gi, /\[(R\d+)\]/gi];
 });
 
+// ../../packages/app/src/services/task-evidence-precheck.ts
+function parseEvidenceChannels(content) {
+  const channels = [];
+  for (const match of content.matchAll(/evidence-channel:\s*(\S+)/g)) {
+    channels.push(match[1] ?? "");
+  }
+  return channels;
+}
+async function evaluateTaskEvidence(content, deps) {
+  const declarations = parseEvidenceChannels(content);
+  const unknown2 = declarations.filter((d) => !ALLOWED_EVIDENCE_CHANNELS.includes(d));
+  if (unknown2.length > 0) {
+    return {
+      ok: false,
+      reasons: [
+        `unknown evidence-channel declaration(s): ${unknown2.join(", ")}`,
+        `allowlisted declaration: evidence-channel: ${ALLOWED_EVIDENCE_CHANNELS[0] ?? ""}`
+      ]
+    };
+  }
+  if (declarations.length === 0) {
+    return { ok: true, reasons: [] };
+  }
+  const channel = declarations[0] ?? "";
+  const source = /\[([a-z0-9-]+)\]$/.exec(channel)?.[1] ?? "";
+  let count3;
+  try {
+    count3 = await deps.countArgsRaw(source);
+  } catch {
+    count3 = null;
+  }
+  if (count3 === null) {
+    return {
+      ok: false,
+      reasons: [
+        `local spur database or history_tool_call table missing/unreadable for source '${source}' \u2014 run a real history import first`
+      ]
+    };
+  }
+  if (!(count3 > 0)) {
+    return {
+      ok: false,
+      reasons: [
+        `0 live ${source} rows with args_raw \u2014 run a non-dry-run ${source} history import with a safe importer before implementing`
+      ]
+    };
+  }
+  return { ok: true, reasons: [] };
+}
+var ALLOWED_EVIDENCE_CHANNELS;
+var init_task_evidence_precheck = __esm(() => {
+  init_src2();
+  ALLOWED_EVIDENCE_CHANNELS = ["history_tool_call.args_raw[pi]"];
+});
+
+// ../../packages/app/src/services/task-size-precheck.ts
+function sectionBody(content, headingPattern) {
+  const heading = content.match(new RegExp(headingPattern, "m"));
+  if (!heading)
+    return null;
+  const rest = content.slice((heading.index ?? 0) + heading[0].length);
+  const nextHeading = rest.match(/^#{2,3}\s+/m);
+  return nextHeading ? rest.slice(0, nextHeading.index ?? 0) : rest;
+}
+function countRItems(content) {
+  const body = sectionBody(content, "^#{2,3}\\s+Requirements\\s*$") ?? content;
+  const numbers = new Set;
+  for (const match of body.matchAll(new RegExp(R_ITEM_RE_SOURCE, "gm"))) {
+    numbers.add(match[1] ?? "");
+  }
+  return numbers.size;
+}
+function countPlanItems(content) {
+  const body = sectionBody(content, "^#{2,3}\\s+Plan\\s*$");
+  if (body === null)
+    return 0;
+  const numbered = body.match(new RegExp(NUMBERED_PLAN_ITEM_RE_SOURCE, "gm"))?.length ?? 0;
+  const checklist = body.match(new RegExp(CHECKLIST_ITEM_RE_SOURCE, "gm"))?.length ?? 0;
+  return numbered + checklist;
+}
+function evaluateTaskSize(content, limits = DEFAULT_TASK_SIZE_LIMITS) {
+  const reqCount = countRItems(content);
+  const planItemCount = countPlanItems(content);
+  const reasons = [];
+  if (reqCount > limits.maxReqs) {
+    reasons.push(`Task has ${reqCount} R-items (max ${limits.maxReqs}). Consider decomposing into smaller tasks.`);
+  }
+  if (planItemCount > limits.maxPlanItems) {
+    reasons.push(`Task has ${planItemCount} Plan items (max ${limits.maxPlanItems}). Consider simplifying the plan.`);
+  }
+  return {
+    reqCount,
+    planItemCount,
+    ok: reasons.length === 0,
+    reasons
+  };
+}
+var DEFAULT_TASK_SIZE_LIMITS, R_ITEM_RE_SOURCE = "^\\s*[-*]\\s+(?:\\[[ xX]\\]\\s*)?[*_]{0,2}R(\\d+)\\.?[*_]{0,2}(?:\\s|$)", NUMBERED_PLAN_ITEM_RE_SOURCE = "^\\d+\\.\\s", CHECKLIST_ITEM_RE_SOURCE = "^\\s*[-*]\\s+\\[[ xX]\\]";
+var init_task_size_precheck = __esm(() => {
+  DEFAULT_TASK_SIZE_LIMITS = {
+    maxReqs: 10,
+    maxPlanItems: 16
+  };
+});
+
 // ../../packages/app/src/services/task-check.ts
 import { basename as basename8, dirname as dirname14, join as join22 } from "path";
 function isPlaceholderBody(body) {
@@ -83430,9 +84018,12 @@ function hasSolutionFileLineCitation(body) {
 var TESTING_VERDICT_STUB_RE, EXTERNAL_EVIDENCE_RE, GATE_LANGUAGE_SECTIONS, TaskCheckService;
 var init_task_check = __esm(() => {
   init_src2();
+  init_feature_check();
   init_planning_check_base();
   init_structural_repair();
+  init_task_evidence_precheck();
   init_task_locator();
+  init_task_size_precheck();
   init_verify_verdict();
   TESTING_VERDICT_STUB_RE = /^\|\s*[\u2014\u2013-]+\s*\|\s*[\u2014\u2013-]+\s*\|\s*No requirements recorded; verify verdict\s+\S+\s*\|/m;
   EXTERNAL_EVIDENCE_RE = /`([^`\n]+?)`\s+(?:line|lines?)\s+(\d+)(?:-(\d+))?/g;
@@ -83497,6 +84088,29 @@ var init_task_check = __esm(() => {
       if (effectiveStatus !== "done" && effectiveStatus !== "cancelled") {
         await this.runL4Readiness(doc2, fm, wbs, effectiveStatus, findings, tasksDir);
       }
+      if (options?.precheck === true) {
+        const size = evaluateTaskSize(doc2.bodyWithoutFrontmatter);
+        for (const reason of size.reasons) {
+          findings.push({
+            layer: "L4",
+            code: FINDING_CODES.PRECHECK_SIZE,
+            severity: "error",
+            section: "",
+            message: reason
+          });
+        }
+        const deps = { countArgsRaw: options.countArgsRaw ?? (async () => null) };
+        const evidence = await evaluateTaskEvidence(doc2.bodyWithoutFrontmatter, deps);
+        for (const reason of evidence.reasons) {
+          findings.push({
+            layer: "L4",
+            code: FINDING_CODES.PRECHECK_EVIDENCE,
+            severity: "error",
+            section: "",
+            message: reason
+          });
+        }
+      }
       return {
         wbs,
         ...this.summarizeWithStatus(effectiveStatus, findings, strict, options?.severityOverrides, options?.accepted, wbs, entry?.required),
@@ -84192,7 +84806,7 @@ var init_task_check = __esm(() => {
       try {
         const entries = await this.fs.readDir(featuresDir);
         for (const name of entries) {
-          if (name.startsWith(`${id}_`) && name.endsWith(".md")) {
+          if (isFeatureFile(name, id)) {
             return `${featuresDir}/${name}`;
           }
         }
@@ -87183,7 +87797,60 @@ var init_execution_policy = __esm(() => {
   init_bounded_child_run();
 });
 
+// ../../packages/app/src/services/feature-sync-suppression.ts
+import { createHash as createHash9 } from "crypto";
+function computeSyncFingerprint(input) {
+  const material = [
+    input.featureContentHash,
+    ...[...input.taskStatusVector].sort(),
+    ...[...input.verdictMtimeVector].sort()
+  ].join(`
+`);
+  return createHash9("sha256").update(material).digest("hex").slice(0, 32);
+}
+function serializeBlockedState(state) {
+  return `${JSON.stringify(state)}
+`;
+}
+function parseBlockedState(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0)
+    return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed.featureId !== "string" || typeof parsed.inputFingerprint !== "string" || typeof parsed.proposal !== "object" || parsed.proposal === null) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function readVerdictMtimeVector(fs3, runDir) {
+  const dir = runDir.replace(/\/$/, "");
+  let entries;
+  try {
+    entries = await fs3.readDir(dir);
+  } catch {
+    return [];
+  }
+  const vector2 = [];
+  for (const entry of entries) {
+    if (!entry.endsWith("-verdict.json"))
+      continue;
+    try {
+      const stat2 = await fs3.stat(`${dir}/${entry}`);
+      if (stat2)
+        vector2.push(`${entry.replace("-verdict.json", "")}:${stat2.mtimeMs}`);
+    } catch {}
+  }
+  return vector2.sort();
+}
+var blockedStateFile = (featureId2, runDir) => `${runDir.replace(/\/$/, "")}/feature-sync-blocked-${featureId2}.json`;
+var init_feature_sync_suppression = () => {};
+
 // ../../packages/app/src/services/feature-service.ts
+import { createHash as createHash10 } from "crypto";
 function isFeatureActionName(action) {
   return FEATURE_ACTION_NAMES.includes(action);
 }
@@ -87327,16 +87994,30 @@ class FeatureService {
     const tasksByFeature = await this.collectTasksByFeature();
     const targets = options?.featureId ? features.filter((f) => f.id === options.featureId) : features;
     let tasksUpdated = 0;
+    const skipped = [];
     for (const feature of targets) {
       const rows = tasksByFeature.get(feature.id) ?? [];
       const table3 = renderTasksTable(rows);
       const raw = await this.ctx.fs.readFile(feature.filePath);
       const doc2 = MarkdownDocument.parse(raw, "feature");
-      if (!doc2.hasSection("Tasks"))
+      if (doc2.unclosedFenceLine() !== null) {
+        skipped.push({ id: feature.id, reason: "unclosed-code-fence" });
         continue;
+      }
+      if (doc2.duplicateSectionNames.length > 0) {
+        skipped.push({ id: feature.id, reason: "duplicate-sections" });
+        continue;
+      }
+      if (!doc2.hasSection("Tasks")) {
+        skipped.push({ id: feature.id, reason: "missing-tasks-section" });
+        continue;
+      }
       try {
         doc2.replaceMarkerRegion("Tasks", table3);
-      } catch {
+      } catch (err) {
+        if (!(err instanceof Error && err.message.startsWith("No marker region found")))
+          throw err;
+        skipped.push({ id: feature.id, reason: "no-tasks-marker-region" });
         continue;
       }
       const next = doc2.serialize();
@@ -87345,7 +88026,7 @@ class FeatureService {
       await atomicWriteAsync(feature.filePath, next, feature.id, this.ctx.fs, this.ctx.projectName ?? "spur");
       tasksUpdated += 1;
     }
-    return { index: index2, tasksUpdated };
+    return { index: index2, tasksUpdated, skipped };
   }
   async deriveFeatureStatus(featureId2) {
     const feature = await this.show(featureId2);
@@ -87465,6 +88146,18 @@ class FeatureService {
     };
   }
   async syncFeature(featureId2, options) {
+    const suppressible = options?.force !== true && options?.dryRun !== true && options?.forceConfirm !== true;
+    if (suppressible) {
+      const replay = await this.replaySuppressedBlocked(featureId2);
+      if (replay)
+        return { ...replay, suppressed: true };
+    }
+    const result = await this.runSyncFeature(featureId2, options);
+    if (options?.dryRun !== true)
+      await this.recordBlockedSyncState(featureId2, result);
+    return result;
+  }
+  async runSyncFeature(featureId2, options) {
     const proposal = await this.deriveFeatureStatus(featureId2);
     if (proposal.from === proposal.to) {
       return { proposal, applied: false, appliedHops: [] };
@@ -87506,6 +88199,60 @@ class FeatureService {
     }
     return { proposal, applied: true, appliedHops };
   }
+  async replaySuppressedBlocked(featureId2) {
+    const statePath = blockedStateFile(featureId2, defaultVerdictRunDir(this.ctx.tasksDir));
+    let prior = null;
+    try {
+      if (await this.ctx.fs.exists(statePath))
+        prior = parseBlockedState(await this.ctx.fs.readFile(statePath));
+    } catch {
+      return null;
+    }
+    if (!prior)
+      return null;
+    const inputs = await this.syncFingerprintInputs(featureId2);
+    if (inputs === null)
+      return null;
+    return computeSyncFingerprint(inputs) === prior.inputFingerprint ? prior.result : null;
+  }
+  async recordBlockedSyncState(featureId2, result) {
+    const runDir = defaultVerdictRunDir(this.ctx.tasksDir);
+    const statePath = blockedStateFile(featureId2, runDir);
+    const blocked = result.goalConflict === undefined && (result.proposal.gateBlocked === true || !result.applied && result.proposal.from !== result.proposal.to);
+    if (!blocked) {
+      try {
+        if (await this.ctx.fs.exists(statePath))
+          await this.ctx.fs.deleteFile(statePath);
+      } catch {}
+      return;
+    }
+    const inputs = await this.syncFingerprintInputs(featureId2);
+    if (inputs === null)
+      return;
+    const state = {
+      featureId: result.proposal.featureId,
+      inputFingerprint: computeSyncFingerprint(inputs),
+      proposal: result.proposal,
+      classification: "blocked",
+      result,
+      persistedAt: new Date().toISOString()
+    };
+    try {
+      await this.ctx.fs.ensureDir(runDir);
+      await this.ctx.fs.writeFile(statePath, serializeBlockedState(state));
+    } catch {}
+  }
+  async syncFingerprintInputs(featureId2) {
+    const feature = await this.show(featureId2);
+    if (!feature)
+      return null;
+    const tasks = (await this.collectTasksByFeature()).get(featureId2) ?? [];
+    return {
+      featureContentHash: createHash10("sha256").update(feature.content).digest("hex"),
+      taskStatusVector: tasks.map((t) => `${t.wbs}:${t.status}`),
+      verdictMtimeVector: await readVerdictMtimeVector(this.ctx.fs, defaultVerdictRunDir(this.ctx.tasksDir))
+    };
+  }
   async findOneActiveGoalConflict(featureId2) {
     const feature = await this.show(featureId2);
     if (feature === null || feature.frontmatter.priority !== "P0")
@@ -87900,6 +88647,7 @@ var FEATURE_ACTION_NAMES, FEATURE_ACTION_COMMANDS, FEATURE_FILE_RE;
 var init_feature_service = __esm(() => {
   init_src2();
   init_feature_check();
+  init_feature_sync_suppression();
   init_task_locator();
   FEATURE_ACTION_NAMES = ["brainstorm", "plan"];
   FEATURE_ACTION_COMMANDS = {
@@ -90846,8 +91594,182 @@ var init_history_service = __esm(() => {
   HISTORY_BUSY_ERROR_PATTERN = /database is locked|SQLITE_BUSY/i;
 });
 
+// ../../packages/app/src/workflow/action-trace.ts
+import { join as join26 } from "path";
+
+class WorkflowActionTraceWriter {
+  inner;
+  recordFailure;
+  db;
+  boundaries = new Map;
+  constructor(inner, recordFailure, db2) {
+    this.inner = inner;
+    this.recordFailure = recordFailure;
+    this.db = db2;
+  }
+  async saveActionStart(runId, node, kind, options) {
+    const outcome = await this.guard("action.start", { runId, node, kind }, () => this.inner.saveActionStart(runId, node, kind, options));
+    if (!outcome.ok) {
+      const syntheticId = `${UNPERSISTED_PREFIX}${crypto.randomUUID()}`;
+      this.boundaries.set(syntheticId, { runId, node, kind });
+      this.lastStart = { runId, node, kind };
+      return syntheticId;
+    }
+    this.boundaries.set(outcome.value, { runId, node, kind });
+    this.lastStart = { runId, node, kind };
+    return outcome.value;
+  }
+  lastStart;
+  async saveActionFinalize(actionId, status, durationMs, ok, kind, result, redactor) {
+    const boundary2 = this.boundaries.get(actionId);
+    const origin2 = boundary2 ?? this.lastStart;
+    await this.guard("action.finish", { runId: origin2?.runId ?? "", node: origin2?.node, kind }, () => this.inner.saveActionFinalize(actionId, status, durationMs, ok, kind, result, redactor));
+    this.boundaries.delete(actionId);
+  }
+  async finalizeRun(runId, status, completedAt, fence, reason) {
+    await this.inner.finalizeRun(runId, status, completedAt, fence, reason === undefined ? undefined : classifyTerminalReason({ status, engineReason: reason, errorText: reason }));
+  }
+  async claimRunOwnership(runId, owner, expectedStatuses) {
+    return this.inner.claimRunOwnership(runId, owner, expectedStatuses);
+  }
+  async interruptRun(runId, reason) {
+    return this.inner.interruptRun(runId, reason);
+  }
+  async recordAction(boundary2) {
+    const start = await this.guard("action.start", { runId: boundary2.runId, node: boundary2.node, kind: boundary2.kind }, () => this.inner.saveActionStart(boundary2.runId, boundary2.node, boundary2.kind));
+    if (!start.ok)
+      return start;
+    const finish = await this.guard("action.finish", { runId: boundary2.runId, node: boundary2.node, kind: boundary2.kind }, () => this.inner.saveActionFinalize(start.value, boundary2.status, boundary2.durationMs, boundary2.ok, boundary2.kind, boundary2.result, boundary2.redactor));
+    if (!finish.ok)
+      return finish;
+    await this.backdateStart(start.value, boundary2);
+    return { ok: true, actionId: start.value };
+  }
+  async backdateStart(actionId, boundary2) {
+    const db2 = this.db;
+    if (db2 === undefined || boundary2.durationMs <= 0)
+      return;
+    await this.guard("action.backdate", { runId: boundary2.runId, node: boundary2.node, kind: boundary2.kind }, async () => {
+      const dao2 = new ActionRunDao(db2);
+      const completedAt = await dao2.completedAtById(actionId);
+      if (completedAt === null)
+        return;
+      const startedAt = new Date(new Date(completedAt).getTime() - boundary2.durationMs).toISOString();
+      await dao2.setStartedAt(actionId, startedAt);
+    });
+  }
+  async closeRun(runId, status, completedAt, reason) {
+    const existing = await this.inner.loadRun(runId);
+    if (existing === undefined) {
+      throw new RunRowNotFoundError(runId);
+    }
+    await this.inner.finalizeRun(runId, status, completedAt ?? new Date().toISOString(), undefined, reason === undefined ? undefined : classifyTerminalReason({ status, engineReason: reason, errorText: reason }));
+    if (this.db === undefined)
+      return { ok: true };
+    const rows = await new ActionRunDao(this.db).actionRowsByRunId(runId);
+    return { ok: true, actionRows: rows.length };
+  }
+  async guard(operation, context4, emit) {
+    try {
+      return { ok: true, value: await emit() };
+    } catch (error51) {
+      const failure = {
+        operation,
+        runId: context4.runId,
+        ...context4.node !== undefined ? { node: context4.node } : {},
+        ...context4.kind !== undefined ? { kind: context4.kind } : {},
+        error: error51 instanceof Error ? error51.message : String(error51),
+        at: new Date().toISOString()
+      };
+      try {
+        this.recordFailure?.(failure);
+      } catch {}
+      return { ok: false, failure };
+    }
+  }
+  createRun(record3) {
+    return this.inner.createRun(record3);
+  }
+  savePhase(runId, phase, status) {
+    return this.inner.savePhase(runId, phase, status);
+  }
+  saveTransition(runId, from, to, trigger) {
+    return this.inner.saveTransition(runId, from, to, trigger);
+  }
+  saveWorkflowState(runId, state, data) {
+    return this.inner.saveWorkflowState(runId, state, data);
+  }
+  commitTransition(runId, from, to, trigger, state, data, phase) {
+    return this.inner.commitTransition(runId, from, to, trigger, state, data, phase);
+  }
+  loadRun(runId) {
+    return this.inner.loadRun(runId);
+  }
+  listRuns() {
+    return this.inner.listRuns();
+  }
+  findRunByKey(workflowName, externalKey) {
+    return this.inner.findRunByKey(workflowName, externalKey);
+  }
+  createOrAttachRun(record3) {
+    return this.inner.createOrAttachRun(record3);
+  }
+  reseedRun(runId, newState) {
+    return this.inner.reseedRun(runId, newState);
+  }
+  loadCurrentState(runId) {
+    return this.inner.loadCurrentState(runId);
+  }
+  loadLatestStateSnapshot(runId) {
+    return this.inner.loadLatestStateSnapshot(runId);
+  }
+  listPausedRuns(options) {
+    return this.inner.listPausedRuns(options);
+  }
+}
+function withActionTrace(persistence2, recordFailure) {
+  return new WorkflowActionTraceWriter(persistence2, recordFailure);
+}
+function createWorkflowActionTraceWriter(db2, recordFailure) {
+  return new WorkflowActionTraceWriter(new DbWorkflowPersistenceAdapter(db2), recordFailure, db2);
+}
+function createRunLogTraceFailureRecorder(cwd) {
+  const fileSystem = createNodeFileSystem3();
+  return (failure) => {
+    const safeRunId = failure.runId.replace(/[^A-Za-z0-9._-]/g, "_");
+    const dir = join26(cwd, ".spur", "run");
+    const location = [
+      failure.node !== undefined ? `node=${failure.node}` : "",
+      failure.kind !== undefined ? `kind=${failure.kind}` : ""
+    ].filter((part) => part !== "").join(" ");
+    const line = `[${failure.at.replace(/\.\d{3}Z$/, "Z")}] trace-emission-failed operation=${failure.operation} run=${failure.runId}${location === "" ? "" : ` ${location}`}: ${failure.error}
+`;
+    (async () => {
+      await fileSystem.ensureDir(dir);
+      await fileSystem.appendFile(join26(dir, `${safeRunId}.log`), line);
+    })().catch(() => {
+      return;
+    });
+  };
+}
+var UNPERSISTED_PREFIX = "trace-unpersisted:", RunRowNotFoundError;
+var init_action_trace = __esm(() => {
+  init_src2();
+  init_dist8();
+  init_dist5();
+  init_terminal_reason();
+  RunRowNotFoundError = class RunRowNotFoundError extends Error {
+    runId;
+    constructor(runId) {
+      super(`run row not found: ${runId}`);
+      this.name = "RunRowNotFoundError";
+      this.runId = runId;
+    }
+  };
+});
+
 // ../../packages/app/src/workflow/decision-evidence.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 function selectEvidence(allRows, producerNodes, cleaner) {
   if (producerNodes.length > MAX_EVIDENCE_ROWS) {
     return { ok: false, reason: "oversized-evidence" };
@@ -90926,7 +91848,7 @@ function parseSummaryEnvelope(raw, runId, evidenceNodes, selected, cleaner) {
   return { ok: true, summary };
 }
 function evidencePayloadDigest(payload) {
-  return `sha256:${createHash9("sha256").update(canonicalJsonStringify(payload), "utf8").digest("hex")}`;
+  return `sha256:${createHash11("sha256").update(canonicalJsonStringify(payload), "utf8").digest("hex")}`;
 }
 function outcomeText(raw, clean) {
   if (!raw)
@@ -91370,7 +92292,7 @@ var init_decide = __esm(() => {
 });
 
 // ../../packages/app/src/workflow/actions/decide.ts
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 
 class DecideActionRunner {
   fileSystem;
@@ -91392,15 +92314,15 @@ class DecideActionRunner {
     const workdir = context4.workdir ?? ".";
     const result = await runDecide({
       ...options,
-      ...options.evidence !== undefined ? { evidence: options.evidence.map((path9) => join26(workdir, path9)) } : {},
-      resultFile: join26(workdir, options.resultFile)
+      ...options.evidence !== undefined ? { evidence: options.evidence.map((path9) => join27(workdir, path9)) } : {},
+      resultFile: join27(workdir, options.resultFile)
     }, {
       enabled: this.deps.enabled,
       ...this.deps.decisionMaker !== undefined ? { decisionMaker: this.deps.decisionMaker } : {},
       readFile: async (path9) => await this.fileSystem.readFile(path9),
       now: Date.now.bind(Date)
     });
-    await this.fileSystem.writeFile(join26(workdir, options.resultFile), `${JSON.stringify(result, null, 2)}
+    await this.fileSystem.writeFile(join27(workdir, options.resultFile), `${JSON.stringify(result, null, 2)}
 `);
     return { ok: true, data: { value: result.value, decision: result } };
   }
@@ -91516,180 +92438,6 @@ function renderEventTrace(events2) {
 `);
 }
 
-// ../../packages/app/src/workflow/action-trace.ts
-import { join as join27 } from "path";
-
-class WorkflowActionTraceWriter {
-  inner;
-  recordFailure;
-  db;
-  boundaries = new Map;
-  constructor(inner, recordFailure, db2) {
-    this.inner = inner;
-    this.recordFailure = recordFailure;
-    this.db = db2;
-  }
-  async saveActionStart(runId, node, kind, options) {
-    const outcome = await this.guard("action.start", { runId, node, kind }, () => this.inner.saveActionStart(runId, node, kind, options));
-    if (!outcome.ok) {
-      const syntheticId = `${UNPERSISTED_PREFIX}${crypto.randomUUID()}`;
-      this.boundaries.set(syntheticId, { runId, node, kind });
-      this.lastStart = { runId, node, kind };
-      return syntheticId;
-    }
-    this.boundaries.set(outcome.value, { runId, node, kind });
-    this.lastStart = { runId, node, kind };
-    return outcome.value;
-  }
-  lastStart;
-  async saveActionFinalize(actionId, status, durationMs, ok, kind, result, redactor) {
-    const boundary2 = this.boundaries.get(actionId);
-    const origin2 = boundary2 ?? this.lastStart;
-    await this.guard("action.finish", { runId: origin2?.runId ?? "", node: origin2?.node, kind }, () => this.inner.saveActionFinalize(actionId, status, durationMs, ok, kind, result, redactor));
-    this.boundaries.delete(actionId);
-  }
-  async finalizeRun(runId, status, completedAt, fence, reason) {
-    await this.inner.finalizeRun(runId, status, completedAt, fence, reason === undefined ? undefined : classifyTerminalReason({ status, engineReason: reason, errorText: reason }));
-  }
-  async claimRunOwnership(runId, owner, expectedStatuses) {
-    return this.inner.claimRunOwnership(runId, owner, expectedStatuses);
-  }
-  async interruptRun(runId, reason) {
-    return this.inner.interruptRun(runId, reason);
-  }
-  async recordAction(boundary2) {
-    const start = await this.guard("action.start", { runId: boundary2.runId, node: boundary2.node, kind: boundary2.kind }, () => this.inner.saveActionStart(boundary2.runId, boundary2.node, boundary2.kind));
-    if (!start.ok)
-      return start;
-    const finish = await this.guard("action.finish", { runId: boundary2.runId, node: boundary2.node, kind: boundary2.kind }, () => this.inner.saveActionFinalize(start.value, boundary2.status, boundary2.durationMs, boundary2.ok, boundary2.kind, boundary2.result, boundary2.redactor));
-    if (!finish.ok)
-      return finish;
-    await this.backdateStart(start.value, boundary2);
-    return { ok: true, actionId: start.value };
-  }
-  async backdateStart(actionId, boundary2) {
-    const db2 = this.db;
-    if (db2 === undefined || boundary2.durationMs <= 0)
-      return;
-    await this.guard("action.backdate", { runId: boundary2.runId, node: boundary2.node, kind: boundary2.kind }, async () => {
-      const dao2 = new ActionRunDao(db2);
-      const completedAt = await dao2.completedAtById(actionId);
-      if (completedAt === null)
-        return;
-      const startedAt = new Date(new Date(completedAt).getTime() - boundary2.durationMs).toISOString();
-      await dao2.setStartedAt(actionId, startedAt);
-    });
-  }
-  async closeRun(runId, status, completedAt, reason) {
-    const existing = await this.inner.loadRun(runId);
-    if (existing === undefined) {
-      throw new RunRowNotFoundError(runId);
-    }
-    await this.inner.finalizeRun(runId, status, completedAt ?? new Date().toISOString(), undefined, reason === undefined ? undefined : classifyTerminalReason({ status, engineReason: reason, errorText: reason }));
-    if (this.db === undefined)
-      return { ok: true };
-    const rows = await new ActionRunDao(this.db).actionRowsByRunId(runId);
-    return { ok: true, actionRows: rows.length };
-  }
-  async guard(operation, context4, emit) {
-    try {
-      return { ok: true, value: await emit() };
-    } catch (error51) {
-      const failure = {
-        operation,
-        runId: context4.runId,
-        ...context4.node !== undefined ? { node: context4.node } : {},
-        ...context4.kind !== undefined ? { kind: context4.kind } : {},
-        error: error51 instanceof Error ? error51.message : String(error51),
-        at: new Date().toISOString()
-      };
-      try {
-        this.recordFailure?.(failure);
-      } catch {}
-      return { ok: false, failure };
-    }
-  }
-  createRun(record3) {
-    return this.inner.createRun(record3);
-  }
-  savePhase(runId, phase, status) {
-    return this.inner.savePhase(runId, phase, status);
-  }
-  saveTransition(runId, from, to, trigger) {
-    return this.inner.saveTransition(runId, from, to, trigger);
-  }
-  saveWorkflowState(runId, state, data) {
-    return this.inner.saveWorkflowState(runId, state, data);
-  }
-  commitTransition(runId, from, to, trigger, state, data, phase) {
-    return this.inner.commitTransition(runId, from, to, trigger, state, data, phase);
-  }
-  loadRun(runId) {
-    return this.inner.loadRun(runId);
-  }
-  listRuns() {
-    return this.inner.listRuns();
-  }
-  findRunByKey(workflowName, externalKey) {
-    return this.inner.findRunByKey(workflowName, externalKey);
-  }
-  createOrAttachRun(record3) {
-    return this.inner.createOrAttachRun(record3);
-  }
-  reseedRun(runId, newState) {
-    return this.inner.reseedRun(runId, newState);
-  }
-  loadCurrentState(runId) {
-    return this.inner.loadCurrentState(runId);
-  }
-  loadLatestStateSnapshot(runId) {
-    return this.inner.loadLatestStateSnapshot(runId);
-  }
-  listPausedRuns(options) {
-    return this.inner.listPausedRuns(options);
-  }
-}
-function withActionTrace(persistence2, recordFailure) {
-  return new WorkflowActionTraceWriter(persistence2, recordFailure);
-}
-function createWorkflowActionTraceWriter(db2, recordFailure) {
-  return new WorkflowActionTraceWriter(new DbWorkflowPersistenceAdapter(db2), recordFailure, db2);
-}
-function createRunLogTraceFailureRecorder(cwd) {
-  const fileSystem = createNodeFileSystem3();
-  return (failure) => {
-    const safeRunId = failure.runId.replace(/[^A-Za-z0-9._-]/g, "_");
-    const dir = join27(cwd, ".spur", "run");
-    const location = [
-      failure.node !== undefined ? `node=${failure.node}` : "",
-      failure.kind !== undefined ? `kind=${failure.kind}` : ""
-    ].filter((part) => part !== "").join(" ");
-    const line = `[${failure.at.replace(/\.\d{3}Z$/, "Z")}] trace-emission-failed operation=${failure.operation} run=${failure.runId}${location === "" ? "" : ` ${location}`}: ${failure.error}
-`;
-    (async () => {
-      await fileSystem.ensureDir(dir);
-      await fileSystem.appendFile(join27(dir, `${safeRunId}.log`), line);
-    })().catch(() => {
-      return;
-    });
-  };
-}
-var UNPERSISTED_PREFIX = "trace-unpersisted:", RunRowNotFoundError;
-var init_action_trace = __esm(() => {
-  init_src2();
-  init_dist8();
-  init_dist5();
-  init_terminal_reason();
-  RunRowNotFoundError = class RunRowNotFoundError extends Error {
-    runId;
-    constructor(runId) {
-      super(`run row not found: ${runId}`);
-      this.name = "RunRowNotFoundError";
-      this.runId = runId;
-    }
-  };
-});
-
 // ../../packages/app/src/workflow/actions/run-path.ts
 import { dirname as dirname17, join as join28, normalize, relative as relative4, resolve as resolve10, sep as sep5 } from "path";
 function within(child, ancestor) {
@@ -97171,7 +97919,7 @@ var init_workflow_service = __esm(() => {
 });
 
 // ../../packages/app/src/services/inline-run-setup.ts
-import { join as join33, resolve as resolve14 } from "path";
+import { basename as basename12, join as join33, resolve as resolve14 } from "path";
 function parseIdentityMetadata(raw) {
   if (raw.trim() === "")
     return {};
@@ -97219,6 +97967,43 @@ async function persistWorktreeRuns(input) {
       citedNames.add(name);
     }
   }
+  if ((input.taskFiles ?? []).length > 0) {
+    const prefixes = (input.taskFiles ?? []).flatMap((taskFile) => {
+      const wbs = /^(\d{4})_/.exec(basename12(taskFile))?.[1];
+      return wbs === undefined ? [] : [`${wbs}-`];
+    });
+    const recordNames = new Set;
+    const owner = await openInlineRunProjectDb(fromDir);
+    try {
+      for (const row of await listRunIdRows(owner.adapter)) {
+        if (!SAFE_RUN_ID_RE.test(row.id))
+          throw new InvalidWorkflowRunIdError(row.id);
+        prefixes.push(`${row.id}-`);
+        recordNames.add(`${row.id}.md`).add(`${row.id}.state.json`);
+      }
+    } finally {
+      owner.close();
+    }
+    const entries = await readdir2(fromRunDir).catch((error51) => {
+      if (error51.code === "ENOENT")
+        return [];
+      throw error51;
+    });
+    const ownedCounts = new Map;
+    for (const name of entries.sort()) {
+      if (citedNames.has(name) || recordNames.has(name))
+        continue;
+      const owner2 = prefixes.find((prefix) => name.startsWith(prefix));
+      if (owner2 === undefined)
+        continue;
+      const count3 = (ownedCounts.get(owner2) ?? 0) + 1;
+      if (count3 > MAX_CITED_RUN_FILES) {
+        throw new Error(`persist-out: owner ${owner2} owns more than ${MAX_CITED_RUN_FILES} .spur/run/ files ` + "\u2014 over the per-owner evidence cap (1012 R1, 1034 R1); split the batch or prune the evidence");
+      }
+      ownedCounts.set(owner2, count3);
+      citedNames.add(name);
+    }
+  }
   const citedCopies = [];
   const citedSkips = [];
   for (const name of citedNames) {
@@ -97488,20 +98273,334 @@ async function runDecideForInlineRun(input) {
     durationMs: decision.durationMs
   };
 }
-var mkdirSync8, writeFileSync7, lstat2, readFile3, SAFE_RUN_ID_RE, MAX_CITED_RUN_FILES = 64, RUN_CITATION_RE;
+function writeInlineRunOutcome(runId, outcome) {
+  const runDir = join33(process.cwd(), ".spur", "run");
+  if (!existsSync8(runDir))
+    mkdirSync8(runDir, { recursive: true });
+  const statePath = join33(runDir, `${runId}.state.json`);
+  const markdownPath = join33(runDir, `${runId}.md`);
+  let prior = {};
+  try {
+    const parsed = JSON.parse(readFileSync12(statePath, "utf8"));
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      prior = parsed;
+    }
+  } catch {}
+  const at2 = new Date().toISOString();
+  const state = {
+    schemaVersion: 1,
+    runId,
+    ...outcome.workflowName !== undefined ? { workflowName: outcome.workflowName } : {},
+    ...outcome.status !== undefined ? { status: outcome.status } : {},
+    startedAt: typeof prior.startedAt === "string" ? prior.startedAt : at2,
+    updatedAt: at2,
+    ...outcome.attached !== undefined ? { attached: outcome.attached } : {},
+    ...outcome.definitionDigest !== undefined ? { definitionDigest: outcome.definitionDigest } : {},
+    ...outcome.workflowVersion !== undefined ? { workflowVersion: outcome.workflowVersion } : {},
+    ...outcome.resolvedPath !== undefined ? { resolvedPath: outcome.resolvedPath } : {},
+    ...outcome.layer !== undefined ? { layer: outcome.layer } : {},
+    ...outcome.workdir !== undefined ? { workdir: outcome.workdir } : {},
+    ok: outcome.ok,
+    ...outcome.ok === false && outcome.error !== undefined ? { error: outcome.error } : {}
+  };
+  const temp = `${statePath}.tmp`;
+  try {
+    writeFileSync7(temp, `${JSON.stringify(state, null, 4)}
+`);
+    renameSync6(temp, statePath);
+  } catch {
+    try {
+      unlinkSync4(temp);
+    } catch {}
+  }
+  let headerFd;
+  try {
+    headerFd = openSync4(markdownPath, "wx");
+    writeSync3(headerFd, `# spur inline run ${runId} \u2014 ${outcome.workflowName ?? "unknown workflow"} \u2014 setup ${at2}
+`);
+  } catch {} finally {
+    if (headerFd !== undefined)
+      closeSync4(headerFd);
+  }
+}
+function isInlineRunCloseStatus(status) {
+  return CLOSE_STATUSES.has(status);
+}
+function isInlineRunActionStatus(status) {
+  return ACTION_STATUSES.has(status);
+}
+function inlineRunRecordLogPath(runDir, runId) {
+  const markdownPath = join33(runDir, `${runId}.md`);
+  const legacyLogPath = join33(runDir, `${runId}.log`);
+  if (existsSync8(legacyLogPath) && !existsSync8(markdownPath))
+    return legacyLogPath;
+  return markdownPath;
+}
+function appendInlineRunLogLine(runId, detail) {
+  try {
+    const runDir = join33(process.cwd(), ".spur", "run");
+    if (!existsSync8(runDir))
+      mkdirSync8(runDir, { recursive: true });
+    const safeRunId = runId.replace(/[^A-Za-z0-9._-]/g, "_");
+    const stamp = new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+    appendFileSync5(inlineRunRecordLogPath(runDir, safeRunId), `[${stamp}] ${detail}
+`);
+  } catch {}
+}
+async function runInlineRunTrace(input) {
+  const operation = input.close ? "run.close" : "action.finish";
+  const fail = (error51) => {
+    appendInlineRunLogLine(input.runId, `trace-emission-failed operation=${operation} run=${input.runId}${input.node === "" ? "" : ` node=${input.node}`}${input.kind === "" ? "" : ` kind=${input.kind}`}: ${error51}`);
+    process.stdout.write(`${JSON.stringify({ ok: false, runId: input.runId, error: error51 })}
+`);
+    return input.close ? 1 : 0;
+  };
+  let projectDb;
+  try {
+    projectDb = await openInlineRunProjectDb(process.cwd());
+    const writer = createWorkflowActionTraceWriter(projectDb.adapter, (failure) => {
+      const detail = failure;
+      appendInlineRunLogLine(input.runId, `trace-emission-failed operation=${detail.operation ?? operation} run=${input.runId}: ${detail.error ?? "unknown error"}`);
+    });
+    const result = input.close ? await writer.closeRun(input.runId, input.status, undefined, input.reason) : await writer.recordAction({
+      runId: input.runId,
+      node: input.node,
+      kind: input.kind,
+      status: input.status,
+      ok: input.ok,
+      durationMs: input.durationMs
+    });
+    if (result.ok !== true && result.failure !== undefined) {
+      const failure = result.failure;
+      return fail(failure.error ?? "unknown trace emission failure");
+    }
+    if (input.close && input.status === "done" && result.actionRows === 0) {
+      const error51 = `run ${input.runId} closed done with zero action_runs rows`;
+      appendInlineRunLogLine(input.runId, `trace-close-failed run=${input.runId}: ${error51}`);
+      process.stdout.write(`${JSON.stringify({ ok: false, runId: input.runId, error: error51, code: "NO_ACTION_ROWS", actionRows: 0 })}
+`);
+      return 1;
+    }
+    process.stdout.write(`${JSON.stringify({ ...result, runId: input.runId })}
+`);
+    return 0;
+  } catch (error51) {
+    if (input.close && error51.name === "RunRowNotFoundError") {
+      const message = error51 instanceof Error ? error51.message : String(error51);
+      appendInlineRunLogLine(input.runId, `trace-close-failed run=${input.runId}: ${message}`);
+      process.stdout.write(`${JSON.stringify({ ok: false, runId: input.runId, error: message, code: "RUN_NOT_FOUND" })}
+`);
+      return 1;
+    }
+    return fail(error51 instanceof Error ? error51.message : String(error51));
+  } finally {
+    projectDb?.close();
+  }
+}
+async function runInlineRunTraceBatch(input) {
+  const batchFailed = (error51) => {
+    process.stdout.write(`${JSON.stringify({ ok: false, runId: input.runId, error: error51 })}
+`);
+    return 1;
+  };
+  let rows;
+  try {
+    rows = JSON.parse(readFileSync12(input.actionsFile, "utf8"));
+  } catch (error51) {
+    return batchFailed(`cannot read actions file ${input.actionsFile}: ${error51 instanceof Error ? error51.message : String(error51)}`);
+  }
+  if (!Array.isArray(rows)) {
+    return batchFailed("actions file must be a JSON array of {node,kind,status,ok,durationMs}");
+  }
+  const entries = [];
+  const rowError = (index2, error51) => `actions[${index2}]: ${error51}`;
+  for (const [index2, row] of rows.entries()) {
+    if (row === null || typeof row !== "object" || Array.isArray(row)) {
+      return batchFailed(rowError(index2, "entry must be a JSON object"));
+    }
+    const record3 = row;
+    const { node, kind, status, ok, durationMs } = record3;
+    if (typeof node !== "string" || node.trim() === "") {
+      return batchFailed(rowError(index2, "node must be a non-empty string"));
+    }
+    if (typeof kind !== "string" || kind.trim() === "") {
+      return batchFailed(rowError(index2, "kind must be a non-empty string"));
+    }
+    if (typeof status !== "string" || !isInlineRunActionStatus(status)) {
+      return batchFailed(rowError(index2, 'status must be "done" or "failed"'));
+    }
+    if (typeof ok !== "boolean")
+      return batchFailed(rowError(index2, "ok must be a boolean"));
+    if (typeof durationMs !== "number" || !Number.isFinite(durationMs) || durationMs < 0) {
+      return batchFailed(rowError(index2, "durationMs must be a finite non-negative number"));
+    }
+    entries.push({ node, kind, status, ok, durationMs });
+  }
+  let projectDb;
+  let recorded = 0;
+  const reportEmissionFailure = (node, kind, error51) => {
+    appendInlineRunLogLine(input.runId, `trace-emission-failed operation=action.finish run=${input.runId} node=${node} kind=${kind}: ${error51}`);
+    process.stdout.write(`${JSON.stringify({ ok: false, runId: input.runId, recorded, error: error51 })}
+`);
+  };
+  try {
+    projectDb = await openInlineRunProjectDb(process.cwd());
+    const writer = createWorkflowActionTraceWriter(projectDb.adapter, (failure) => {
+      const detail = failure;
+      appendInlineRunLogLine(input.runId, `trace-emission-failed operation=${detail.operation ?? "action.finish"} run=${input.runId}: ${detail.error ?? "unknown error"}`);
+    });
+    for (const entry of entries) {
+      const result = await writer.recordAction({
+        runId: input.runId,
+        node: entry.node,
+        kind: entry.kind,
+        status: entry.status,
+        ok: entry.ok,
+        durationMs: entry.durationMs
+      });
+      if (result.ok === true) {
+        recorded += 1;
+        continue;
+      }
+      const failure = result.failure;
+      reportEmissionFailure(entry.node, entry.kind, failure?.error ?? "unknown trace emission failure");
+      return 0;
+    }
+    process.stdout.write(`${JSON.stringify({ ok: true, runId: input.runId, recorded })}
+`);
+    return 0;
+  } catch (error51) {
+    const message = error51 instanceof Error ? error51.message : String(error51);
+    appendInlineRunLogLine(input.runId, `trace-emission-failed run=${input.runId}: ${message}`);
+    process.stdout.write(`${JSON.stringify({ ok: false, runId: input.runId, recorded, error: message })}
+`);
+    return 0;
+  } finally {
+    projectDb?.close();
+  }
+}
+async function runInlineRunFingerprint(input) {
+  const workdir = process.cwd();
+  const contents = await readProofInputContents(undefined, workdir, {
+    taskFile: input.taskFile,
+    ...input.featureFile !== undefined && input.featureFile.trim() !== "" ? { featureFile: input.featureFile } : {}
+  });
+  if (!contents.ok) {
+    console.error(`inline-run-setup: FAIL \u2014 ${contents.error}`);
+    return 1;
+  }
+  const digest = await computeProofInputFingerprint({
+    cwd: workdir,
+    ...contents.taskContent !== undefined ? { taskContent: contents.taskContent } : {},
+    ...contents.featureContent !== undefined ? { featureContent: contents.featureContent } : {}
+  });
+  process.stdout.write(`${digest}
+`);
+  return 0;
+}
+async function runInlineRunDecide(input) {
+  const decideFailed = (error51) => {
+    process.stdout.write(`${JSON.stringify({ ok: false, runId: input.runId, error: error51 })}
+`);
+    return 1;
+  };
+  let outcome;
+  try {
+    outcome = await runDecideForInlineRun({
+      workdir: process.cwd(),
+      optionsFile: input.optionsFile,
+      enabled: input.enabled
+    });
+  } catch (error51) {
+    return decideFailed(error51 instanceof Error ? error51.message : String(error51));
+  }
+  if (!outcome.ok)
+    return decideFailed(outcome.error ?? "decide failed without an error message");
+  process.stdout.write(`${JSON.stringify({ runId: input.runId, node: input.node, ...outcome, ok: true })}
+`);
+  appendInlineRunLogLine(input.runId, `decide node=${input.node} value=${outcome.value ?? ""} source=${outcome.source ?? "default"} reason=${outcome.reason ?? ""}`);
+  return runInlineRunTrace({
+    runId: input.runId,
+    close: false,
+    node: input.node,
+    kind: "decide",
+    status: "done",
+    ok: true,
+    durationMs: outcome.durationMs ?? 0
+  });
+}
+async function runInlineRunPersistOut(input) {
+  try {
+    const result = await persistWorktreeRuns({
+      fromWorkdir: input.from,
+      toWorkdir: process.cwd(),
+      ...input.taskFiles.length > 0 ? { taskFiles: input.taskFiles } : {}
+    });
+    process.stdout.write(`${JSON.stringify({ ok: true, persisted: result.persisted, skipped: result.skipped })}
+`);
+    return 0;
+  } catch (error51) {
+    const message = error51 instanceof Error ? error51.message : String(error51);
+    process.stdout.write(`${JSON.stringify({ ok: false, error: message })}
+`);
+    return 1;
+  }
+}
+async function runInlineRunSetup(input) {
+  const workdir = process.cwd();
+  const projectDb = await openInlineRunProjectDb(workdir);
+  let exitCode = 0;
+  try {
+    const result = await createOrAttachInlineRun({
+      workdir,
+      getDb: async () => projectDb.adapter,
+      file: input.file,
+      runId: input.runId,
+      inventory: input.inventory,
+      ...input.embeddedSchemas !== undefined ? { embeddedSchemas: input.embeddedSchemas } : {}
+    });
+    writeInlineRunOutcome(input.runId, result);
+    if (!result.ok) {
+      console.error(`inline-run-setup: FAIL for run ${input.runId}`);
+      console.error(`  ${result.error}`);
+      exitCode = 1;
+    } else {
+      console.error(`inline-run-setup: ${result.attached ? "attached" : "created"} run ${input.runId} (${result.workflowName}, layer ${result.layer}, digest ${result.definitionDigest}, status ${result.status})`);
+    }
+  } finally {
+    projectDb.close();
+  }
+  return exitCode;
+}
+var appendFileSync5, closeSync4, existsSync8, mkdirSync8, openSync4, readFileSync12, renameSync6, unlinkSync4, writeFileSync7, writeSync3, lstat2, readdir2, readFile3, SAFE_RUN_ID_RE, MAX_CITED_RUN_FILES = 64, RUN_CITATION_RE, CLOSE_STATUSES, ACTION_STATUSES;
 var init_inline_run_setup = __esm(async () => {
   init_src2();
   init_dist8();
   init_dist5();
+  init_action_trace();
   init_decide2();
+  init_proof_input_fingerprint();
   init_run_record();
   init_terminal_reason();
   init_workflow_resolver();
   init_workflow_service();
-  ({ mkdirSync: mkdirSync8, writeFileSync: writeFileSync7 } = await import("fs"));
-  ({ lstat: lstat2, readFile: readFile3 } = await import("fs/promises"));
+  ({
+    appendFileSync: appendFileSync5,
+    closeSync: closeSync4,
+    existsSync: existsSync8,
+    mkdirSync: mkdirSync8,
+    openSync: openSync4,
+    readFileSync: readFileSync12,
+    renameSync: renameSync6,
+    unlinkSync: unlinkSync4,
+    writeFileSync: writeFileSync7,
+    writeSync: writeSync3
+  } = await import("fs"));
+  ({ lstat: lstat2, readdir: readdir2, readFile: readFile3 } = await import("fs/promises"));
   SAFE_RUN_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
   RUN_CITATION_RE = /(?<![\w~:-]|[\w~:-]\/)\.spur\/run\/([A-Za-z0-9][A-Za-z0-9._*?<>{}|,\u2026-]*)/g;
+  CLOSE_STATUSES = new Set(["done", "failed", "paused"]);
+  ACTION_STATUSES = new Set(["done", "failed"]);
 });
 
 // ../../packages/app/src/services/job-worker-service.ts
@@ -98198,8 +99297,8 @@ var init_process_inventory_service = __esm(() => {
 });
 
 // ../../packages/app/src/services/project-start.ts
-import { existsSync as existsSync8 } from "fs";
-import { basename as basename12, resolve as resolve15 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { basename as basename13, resolve as resolve15 } from "path";
 function shQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -98244,7 +99343,7 @@ function setDetachedServeSpawnForTests(spawn2) {
 }
 function resolveSpurServeCommand() {
   const cliPath = getEnvVar("SPUR_CLI_PATH");
-  if (cliPath !== undefined && existsSync8(cliPath)) {
+  if (cliPath !== undefined && existsSync9(cliPath)) {
     return [process.execPath, cliPath];
   }
   const argv1 = process.argv[1];
@@ -98255,7 +99354,7 @@ function resolveSpurServeCommand() {
     }
   }
   const monorepoCli = resolve15(process.cwd(), "apps/cli/src/index.ts");
-  if (existsSync8(monorepoCli)) {
+  if (existsSync9(monorepoCli)) {
     return [process.execPath, monorepoCli];
   }
   const fromPath = typeof Bun !== "undefined" && typeof Bun.which === "function" ? Bun.which("spur") : null;
@@ -98268,14 +99367,14 @@ async function startRegisteredProject(registry2, target, options = {}) {
   let entry = await registry2.getByName(target) ?? await registry2.getByPath(target);
   if (!entry) {
     const absPath = normalizeProjectPath(target);
-    if (existsSync8(absPath)) {
-      entry = await registry2.upsert({ path: absPath, name: basename12(absPath), port: 0 });
+    if (existsSync9(absPath)) {
+      entry = await registry2.upsert({ path: absPath, name: basename13(absPath), port: 0 });
     } else {
       throw new Error(`Project not found in registry: "${target}"`);
     }
   }
   const projectPath = normalizeProjectPath(entry.path);
-  if (!existsSync8(projectPath)) {
+  if (!existsSync9(projectPath)) {
     throw new Error(`Project path does not exist: "${entry.path}" (resolved to ${projectPath}). Update ~/.config/spur/projects.json.`);
   }
   if (projectPath !== entry.path) {
@@ -99313,9 +100412,9 @@ var init_section_matrix_loader = __esm(() => {
 });
 
 // ../../packages/app/src/services/slash-commands-service.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync9, readdirSync as readdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync9, readdirSync as readdirSync7, readFileSync as readFileSync13, writeFileSync as writeFileSync8 } from "fs";
 import { homedir as homedir9 } from "os";
-import { basename as basename13, dirname as dirname20, join as join36, resolve as resolve17 } from "path";
+import { basename as basename14, dirname as dirname20, join as join36, resolve as resolve17 } from "path";
 function getBuiltinClaudeCommands() {
   return BUILTIN_CLAUDE_COMMANDS.map((cmd) => ({ ...cmd }));
 }
@@ -99337,7 +100436,7 @@ function findPluginsSpCommandsDir(startDir = process.cwd()) {
   while (true) {
     try {
       const candidate = join36(current, "plugins", "sp", "commands");
-      if (existsSync9(candidate)) {
+      if (existsSync10(candidate)) {
         return candidate;
       }
     } catch {
@@ -99356,7 +100455,7 @@ function findProjectClaudeCommandsDir(startDir = process.cwd()) {
   while (true) {
     try {
       const candidate = join36(current, ".claude", "commands");
-      if (existsSync9(candidate)) {
+      if (existsSync10(candidate)) {
         return candidate;
       }
     } catch {
@@ -99390,7 +100489,7 @@ function parseMarkdownFrontmatter(rawContent) {
   }
 }
 function scanMarkdownCommands(dirPath, options = {}) {
-  if (!existsSync9(dirPath)) {
+  if (!existsSync10(dirPath)) {
     return [];
   }
   const { prefix = "/", source = "plugin:sp", defaultCategory, pluginId } = options;
@@ -99402,8 +100501,8 @@ function scanMarkdownCommands(dirPath, options = {}) {
         continue;
       }
       const fullPath = join36(dirPath, entry.name);
-      const stem = basename13(entry.name, ".md");
-      const fileContent = readFileSync12(fullPath, "utf-8");
+      const stem = basename14(entry.name, ".md");
+      const fileContent = readFileSync13(fullPath, "utf-8");
       const { frontmatter, body } = parseMarkdownFrontmatter(fileContent);
       const cleanPrefix = prefix.endsWith(":") ? prefix : prefix.endsWith("/") ? prefix : `${prefix}:`;
       const name = prefix === "/" ? `/${stem}` : `${cleanPrefix}${stem}`;
@@ -99493,15 +100592,15 @@ function discoverEnabledClaudePlugins(options = {}) {
   const projectSettingsPath = join36(projectRoot, ".claude", "settings.json");
   const installedPath = join36(claudeDir, "plugins", "installed_plugins.json");
   let userSettings = {};
-  if (existsSync9(userSettingsPath)) {
+  if (existsSync10(userSettingsPath)) {
     try {
-      userSettings = JSON.parse(readFileSync12(userSettingsPath, "utf-8"));
+      userSettings = JSON.parse(readFileSync13(userSettingsPath, "utf-8"));
     } catch {}
   }
   let projectSettings = {};
-  if (existsSync9(projectSettingsPath)) {
+  if (existsSync10(projectSettingsPath)) {
     try {
-      projectSettings = JSON.parse(readFileSync12(projectSettingsPath, "utf-8"));
+      projectSettings = JSON.parse(readFileSync13(projectSettingsPath, "utf-8"));
     } catch {}
   }
   const enabledPlugins = {
@@ -99513,9 +100612,9 @@ function discoverEnabledClaudePlugins(options = {}) {
     ...projectSettings.extraKnownMarketplaces ?? {}
   };
   let installedManifest = { plugins: {} };
-  if (existsSync9(installedPath)) {
+  if (existsSync10(installedPath)) {
     try {
-      installedManifest = JSON.parse(readFileSync12(installedPath, "utf-8"));
+      installedManifest = JSON.parse(readFileSync13(installedPath, "utf-8"));
     } catch {}
   }
   const installedPlugins = installedManifest.plugins ?? {};
@@ -99544,7 +100643,7 @@ function discoverEnabledClaudePlugins(options = {}) {
     const installs = installedPlugins[pluginKey];
     if (Array.isArray(installs)) {
       for (const inst of installs) {
-        if (typeof inst.installPath === "string" && existsSync9(inst.installPath)) {
+        if (typeof inst.installPath === "string" && existsSync10(inst.installPath)) {
           resolvedDir = inst.installPath;
           break;
         }
@@ -99555,16 +100654,16 @@ function discoverEnabledClaudePlugins(options = {}) {
       if (mSrc?.source === "directory" && typeof mSrc.path === "string") {
         const cand1 = join36(mSrc.path, "plugins", pluginName);
         const cand2 = join36(mSrc.path, pluginName);
-        if (existsSync9(cand1)) {
+        if (existsSync10(cand1)) {
           resolvedDir = cand1;
-        } else if (existsSync9(cand2)) {
+        } else if (existsSync10(cand2)) {
           resolvedDir = cand2;
         }
       }
     }
     if (!resolvedDir && marketplaceName) {
       const cacheDir = join36(claudeDir, "plugins", "cache", marketplaceName, pluginName);
-      if (existsSync9(cacheDir)) {
+      if (existsSync10(cacheDir)) {
         try {
           const entries = readdirSync7(cacheDir, { withFileTypes: true });
           const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
@@ -99577,20 +100676,20 @@ function discoverEnabledClaudePlugins(options = {}) {
     }
     if (!resolvedDir && marketplaceName) {
       const mpDir = join36(claudeDir, "plugins", "marketplaces", marketplaceName, "plugins", pluginName);
-      if (existsSync9(mpDir)) {
+      if (existsSync10(mpDir)) {
         resolvedDir = mpDir;
       }
     }
     if (!resolvedDir) {
       const localPlugin = resolve17(projectRoot, "plugins", pluginName);
-      if (existsSync9(localPlugin)) {
+      if (existsSync10(localPlugin)) {
         resolvedDir = localPlugin;
       }
     }
     let commandsDir;
     if (resolvedDir) {
       const candidateCommands = join36(resolvedDir, "commands");
-      if (existsSync9(candidateCommands)) {
+      if (existsSync10(candidateCommands)) {
         commandsDir = candidateCommands;
       }
     }
@@ -99639,7 +100738,7 @@ function generateSlashCommands(options = {}) {
   }
   if (includePluginSp) {
     const spCommandsDir = findPluginsSpCommandsDir(projectRoot) ?? resolve17(projectRoot, "plugins", "sp", "commands");
-    if (existsSync9(spCommandsDir)) {
+    if (existsSync10(spCommandsDir)) {
       const spCommands = scanMarkdownCommands(spCommandsDir, {
         prefix: "/sp:",
         source: "plugin:sp",
@@ -99694,7 +100793,7 @@ function generateSlashCommandsFile(targetPath = getSlashCommandsFilePath(), opti
   };
   try {
     const dir = dirname20(targetPath);
-    if (!existsSync9(dir)) {
+    if (!existsSync10(dir)) {
       mkdirSync9(dir, { recursive: true });
     }
     writeFileSync8(targetPath, JSON.stringify(filePayload, null, 2), "utf-8");
@@ -99706,7 +100805,7 @@ function generateSlashCommandsFile(targetPath = getSlashCommandsFilePath(), opti
   };
 }
 function loadSlashCommands(filePath = getSlashCommandsFilePath(), autoGenerateIfMissing = true, options = {}) {
-  if (!existsSync9(filePath)) {
+  if (!existsSync10(filePath)) {
     if (autoGenerateIfMissing) {
       const generated = generateSlashCommandsFile(filePath, options);
       return generated.commands;
@@ -99714,7 +100813,7 @@ function loadSlashCommands(filePath = getSlashCommandsFilePath(), autoGenerateIf
     return getBuiltinClaudeCommands();
   }
   try {
-    const content = readFileSync12(filePath, "utf-8");
+    const content = readFileSync13(filePath, "utf-8");
     const raw = JSON.parse(content);
     const parsed = slashCommandsFileSchema.safeParse(raw);
     if (parsed.success && parsed.data.commands.length > 0) {
@@ -100763,7 +101862,7 @@ var init_system_event_emitter = __esm(() => {
 });
 
 // ../../packages/app/src/services/task-readiness.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 function readyRefineCommand(wbs) {
   return `/sp:dev-refine ${wbs} --auto --depth ready`;
 }
@@ -100951,7 +102050,7 @@ function computePlanningDigest(raw) {
     featureId: typeof fm.feature_id === "string" ? fm.feature_id : null,
     template: typeof fm.template === "string" ? fm.template : null
   };
-  return createHash10("sha256").update(JSON.stringify(payload)).digest("hex");
+  return createHash12("sha256").update(JSON.stringify(payload)).digest("hex");
 }
 function verifyReadyChecks(checks4) {
   if (checks4 === undefined || checks4.length === 0) {
@@ -101100,56 +102199,6 @@ var init_task_scaffold = __esm(() => {
   init_task_locator();
 });
 
-// ../../packages/app/src/services/task-size-precheck.ts
-function sectionBody(content, headingPattern) {
-  const heading = content.match(new RegExp(headingPattern, "m"));
-  if (!heading)
-    return null;
-  const rest = content.slice((heading.index ?? 0) + heading[0].length);
-  const nextHeading = rest.match(/^#{2,3}\s+/m);
-  return nextHeading ? rest.slice(0, nextHeading.index ?? 0) : rest;
-}
-function countRItems(content) {
-  const body = sectionBody(content, "^#{2,3}\\s+Requirements\\s*$") ?? content;
-  const numbers = new Set;
-  for (const match of body.matchAll(new RegExp(R_ITEM_RE_SOURCE, "gm"))) {
-    numbers.add(match[1] ?? "");
-  }
-  return numbers.size;
-}
-function countPlanItems(content) {
-  const body = sectionBody(content, "^#{2,3}\\s+Plan\\s*$");
-  if (body === null)
-    return 0;
-  const numbered = body.match(new RegExp(NUMBERED_PLAN_ITEM_RE_SOURCE, "gm"))?.length ?? 0;
-  const checklist = body.match(new RegExp(CHECKLIST_ITEM_RE_SOURCE, "gm"))?.length ?? 0;
-  return numbered + checklist;
-}
-function evaluateTaskSize(content, limits = DEFAULT_TASK_SIZE_LIMITS) {
-  const reqCount = countRItems(content);
-  const planItemCount = countPlanItems(content);
-  const reasons = [];
-  if (reqCount > limits.maxReqs) {
-    reasons.push(`Task has ${reqCount} R-items (max ${limits.maxReqs}). ` + `Consider decomposing into smaller tasks or raise maxImplementReqs via --vars.`);
-  }
-  if (planItemCount > limits.maxPlanItems) {
-    reasons.push(`Task has ${planItemCount} Plan items (max ${limits.maxPlanItems}). ` + `Consider simplifying the plan or raise maxImplementPlanItems via --vars.`);
-  }
-  return {
-    reqCount,
-    planItemCount,
-    ok: reasons.length === 0,
-    reasons
-  };
-}
-var DEFAULT_TASK_SIZE_LIMITS, R_ITEM_RE_SOURCE = "^\\s*[-*]\\s+(?:\\[[ xX]\\]\\s*)?[*_]{0,2}R(\\d+)\\.?[*_]{0,2}(?:\\s|$)", NUMBERED_PLAN_ITEM_RE_SOURCE = "^\\d+\\.\\s", CHECKLIST_ITEM_RE_SOURCE = "^\\s*[-*]\\s+\\[[ xX]\\]";
-var init_task_size_precheck = __esm(() => {
-  DEFAULT_TASK_SIZE_LIMITS = {
-    maxReqs: 10,
-    maxPlanItems: 16
-  };
-});
-
 // ../../packages/app/src/services/task-transition.ts
 async function runTransitionCheckGate(gate, wbs, filePath, target) {
   const result = await gate.service.check(filePath, wbs, {
@@ -101831,11 +102880,13 @@ ${templateBackground}`;
       await this.writeService.updateSection(ref, "Solution", solutionBody);
       result.solutionBackfilled = true;
     }
+    const featureAc = await this.resolveFeatureAcBody(filePath).catch(() => null);
+    const scenarioTitles = featureScenarioTitles(featureAc?.ac ?? "");
     for (const section of ["Requirements", "Acceptance Criteria"]) {
       const body = doc2.getSection(section);
       if (body === null || body.trim().length === 0)
         continue;
-      const flipped = flipVerifiedCheckboxes(body, verdict);
+      const flipped = flipVerifiedCheckboxes(body, verdict, scenarioTitles);
       if (flipped !== body) {
         await this.writeService.updateSection(ref, section, flipped);
       }
@@ -102087,8 +103138,8 @@ ${block}` : block);
       return { wbs: hit.wbs, filePath: hit.filePath };
     if (opts.strict === true)
       return null;
-    const basename14 = filePath.split("/").pop() ?? "";
-    const capturedWbs = /^(\d{4})_.+\.md$/.exec(basename14)?.[1];
+    const basename15 = filePath.split("/").pop() ?? "";
+    const capturedWbs = /^(\d{4})_.+\.md$/.exec(basename15)?.[1];
     if (capturedWbs) {
       const taskPath = await this.locator.findPathByWbs(capturedWbs);
       if (taskPath !== null)
@@ -102305,7 +103356,7 @@ function extractRequirements(text4) {
     }
     if (!trimmed.startsWith("|"))
       continue;
-    const cells = splitTableCells(trimmed);
+    const cells = splitTableCells2(trimmed);
     if (!inTable && cells.length >= 2) {
       const h0 = (cells[0] ?? "").toLowerCase().trim();
       const h0IsId = h0.includes("req") || h0 === "requirement" || h0 === "r#" || h0 === "r" || /^r\d+$/.test(h0);
@@ -102356,7 +103407,7 @@ function normalizeStatus(raw) {
     return "UNMET";
   return null;
 }
-function splitTableCells(row) {
+function splitTableCells2(row) {
   return row.split(/(?<!\\)\|/).map((c3) => c3.replace(/\\\|/g, "|").trim()).filter(Boolean);
 }
 function extractAcceptanceCriteria(text4) {
@@ -102373,7 +103424,7 @@ function extractAcceptanceCriteria(text4) {
     }
     if (!trimmed.startsWith("|"))
       continue;
-    const cells = splitTableCells(trimmed);
+    const cells = splitTableCells2(trimmed);
     if (!inTable && cells.length >= 4) {
       const h0 = (cells[0] ?? "").toLowerCase();
       const h1 = (cells[1] ?? "").toLowerCase();
@@ -102390,7 +103441,7 @@ function extractAcceptanceCriteria(text4) {
       const statusRaw = cells[1] ?? "";
       const evidenceTypeRaw = cells[2] ?? "";
       const status = normalizeAcceptanceCriteriaStatus(statusRaw);
-      const evidenceType = normalizeEvidenceType(evidenceTypeRaw);
+      const evidenceType = normalizeEvidenceType2(evidenceTypeRaw);
       const acShaped = cells.length >= 4 || id.length > 0 && status !== null;
       const evidence = cells[3] ?? "";
       if (acShaped && status !== null && evidenceType !== null && id.length > 0) {
@@ -102414,7 +103465,7 @@ function normalizeAcceptanceCriteriaStatus(raw) {
     return "N/A";
   return null;
 }
-function normalizeEvidenceTypeToken(normalized) {
+function normalizeEvidenceTypeToken2(normalized) {
   if (normalized === "test")
     return "test";
   if (normalized === "command")
@@ -102430,16 +103481,16 @@ function normalizeEvidenceTypeToken(normalized) {
     return "n/a";
   return null;
 }
-function normalizeEvidenceType(raw) {
+function normalizeEvidenceType2(raw) {
   const normalized = raw.toLowerCase().trim();
-  const single = normalizeEvidenceTypeToken(normalized);
+  const single = normalizeEvidenceTypeToken2(normalized);
   if (single !== null)
     return single;
-  const tokens = normalized.split(/[+,/]/).map((part) => normalizeEvidenceTypeToken(part.trim())).filter((token) => token !== null);
+  const tokens = normalized.split(/[+,/]/).map((part) => normalizeEvidenceTypeToken2(part.trim())).filter((token) => token !== null);
   if (tokens.length < 2 || tokens.length !== normalized.split(/[+,/]/).filter((p) => p.trim()).length) {
     return null;
   }
-  return EVIDENCE_TYPE_PRECEDENCE.find((candidate) => tokens.includes(candidate)) ?? null;
+  return EVIDENCE_TYPE_PRECEDENCE2.find((candidate) => tokens.includes(candidate)) ?? null;
 }
 function applyAcceptanceCriteriaEvidenceRule(rows) {
   return rows.map((row) => {
@@ -102470,7 +103521,7 @@ function extractChecks(_text, taskCheckPassed, requirements, acceptanceCriteria,
     const trimmed = line.trim();
     if (!trimmed.startsWith("|"))
       continue;
-    const cells = splitTableCells(trimmed);
+    const cells = splitTableCells2(trimmed);
     if (cells.length >= 2) {
       const h0 = (cells[0] ?? "").toLowerCase();
       const h1 = (cells[1] ?? "").toLowerCase();
@@ -102548,10 +103599,10 @@ function aggregateBatchVerdicts(results) {
   const summary = `${counts.PASS} PASS, ${counts.PARTIAL} PARTIAL, ${counts.FAIL} FAIL, ${notStarted.length} NOT-STARTED (excluded)`;
   return { verdict, rolledUp, notStarted, summary };
 }
-var EVIDENCE_TYPE_PRECEDENCE, NOT_STARTED_STATUSES;
+var EVIDENCE_TYPE_PRECEDENCE2, NOT_STARTED_STATUSES;
 var init_task_verdict = __esm(() => {
   init_verify_verdict();
-  EVIDENCE_TYPE_PRECEDENCE = ["test", "command", "static-ref", "manual-review", "llm-judge", "n/a"];
+  EVIDENCE_TYPE_PRECEDENCE2 = ["test", "command", "static-ref", "manual-review", "llm-judge", "n/a"];
   NOT_STARTED_STATUSES = {
     backlog: true,
     todo: true,
@@ -102564,7 +103615,7 @@ var init_task_verdict = __esm(() => {
 });
 
 // ../../packages/app/src/services/token-ledger-service.ts
-import { closeSync as closeSync4, existsSync as existsSync10, fstatSync as fstatSync2, openSync as openSync4, readSync } from "fs";
+import { closeSync as closeSync5, existsSync as existsSync11, fstatSync as fstatSync2, openSync as openSync5, readSync } from "fs";
 import { join as join38 } from "path";
 function isSparseToolActivity(events2) {
   return events2.length === 0 || !events2.some((e) => TOOL_ACTIVITY_TYPES.has(e.type));
@@ -102616,11 +103667,11 @@ function parseLedgerLine(line) {
   }
 }
 function tailTokenLedgerFile(filePath, limit, chunkSize = DEFAULT_CHUNK, before) {
-  if (!existsSync10(filePath)) {
+  if (!existsSync11(filePath)) {
     return { events: [], truncated: false };
   }
   const target = limit + 1;
-  const fd = openSync4(filePath, "r");
+  const fd = openSync5(filePath, "r");
   try {
     const { size } = fstatSync2(fd);
     if (size === 0)
@@ -102658,7 +103709,7 @@ function tailTokenLedgerFile(filePath, limit, chunkSize = DEFAULT_CHUNK, before)
       truncated
     };
   } finally {
-    closeSync4(fd);
+    closeSync5(fd);
   }
 }
 
@@ -102712,7 +103763,7 @@ var init_token_ledger_service = __esm(() => {
 });
 
 // ../../packages/app/src/services/token-ledger-watcher.ts
-import { closeSync as closeSync5, existsSync as existsSync11, fstatSync as fstatSync3, openSync as openSync5, readSync as readSync2, watch } from "fs";
+import { closeSync as closeSync6, existsSync as existsSync12, fstatSync as fstatSync3, openSync as openSync6, readSync as readSync2, watch } from "fs";
 
 class TokenLedgerWatcher {
   ledgerPath;
@@ -102733,7 +103784,7 @@ class TokenLedgerWatcher {
     this.started = true;
     this.offset = this.currentSize();
     try {
-      const target = existsSync11(this.ledgerPath) ? this.ledgerPath : this.parentDir();
+      const target = existsSync12(this.ledgerPath) ? this.ledgerPath : this.parentDir();
       this.watcher = watch(target, () => this.schedulePoll());
     } catch {
       this.watcher = undefined;
@@ -102768,14 +103819,14 @@ class TokenLedgerWatcher {
     return idx > 0 ? this.ledgerPath.slice(0, idx) : ".";
   }
   currentSize() {
-    if (!existsSync11(this.ledgerPath))
+    if (!existsSync12(this.ledgerPath))
       return 0;
     try {
-      const fd = openSync5(this.ledgerPath, "r");
+      const fd = openSync6(this.ledgerPath, "r");
       try {
         return fstatSync3(fd).size;
       } finally {
-        closeSync5(fd);
+        closeSync6(fd);
       }
     } catch {
       return 0;
@@ -102790,14 +103841,14 @@ class TokenLedgerWatcher {
     }, this.debounceMs);
   }
   pollNewBytes() {
-    if (!existsSync11(this.ledgerPath)) {
+    if (!existsSync12(this.ledgerPath)) {
       this.offset = 0;
       this.carry = "";
       return;
     }
     let size;
     try {
-      const fd = openSync5(this.ledgerPath, "r");
+      const fd = openSync6(this.ledgerPath, "r");
       try {
         size = fstatSync3(fd).size;
         if (size < this.offset) {
@@ -102825,7 +103876,7 @@ class TokenLedgerWatcher {
           }
         }
       } finally {
-        closeSync5(fd);
+        closeSync6(fd);
       }
     } catch {}
   }
@@ -103277,7 +104328,10 @@ class LifecycleAdapter {
       });
     }
     await svc.reseedRun(workflow, runId, currentStatus);
-    const result = await svc.requestTransition(workflow, runId, to, { workdir: this.opts.cwd });
+    const result = await svc.requestTransition(workflow, runId, to, {
+      workdir: this.opts.cwd,
+      vars: { [profile.varKey]: ref.id, spurBin: this.opts.spurBin }
+    });
     if (result.allowed) {
       const enterFailure = await this.runTargetEnterActions(workflow, to, runId);
       if (enterFailure !== null) {
@@ -103768,6 +104822,7 @@ var init_trace_writer = __esm(() => {
 var exports_src2 = {};
 __export(exports_src2, {
   writeJsonError: () => writeJsonError,
+  writeInlineRunOutcome: () => writeInlineRunOutcome,
   workflowLayers: () => workflowLayers,
   withActionTrace: () => withActionTrace,
   waitForOccupant: () => waitForOccupant,
@@ -103799,6 +104854,12 @@ __export(exports_src2, {
   schedulerJobTimeoutEnvName: () => schedulerJobTimeoutEnvName,
   scanMarkdownCommands: () => scanMarkdownCommands,
   satisfies: () => satisfies,
+  runInlineRunTraceBatch: () => runInlineRunTraceBatch,
+  runInlineRunTrace: () => runInlineRunTrace,
+  runInlineRunSetup: () => runInlineRunSetup,
+  runInlineRunPersistOut: () => runInlineRunPersistOut,
+  runInlineRunFingerprint: () => runInlineRunFingerprint,
+  runInlineRunDecide: () => runInlineRunDecide,
   runIdeaHandoffCli: () => runIdeaHandoffCli,
   runHistoryReport: () => runHistoryReport,
   runDecideForInlineRun: () => runDecideForInlineRun,
@@ -103850,6 +104911,7 @@ __export(exports_src2, {
   readVerdictArtifact: () => readVerdictArtifact,
   readVerdict: () => readVerdict,
   readProofInputContents: () => readProofInputContents,
+  readFeatureBody: () => readFeatureBody,
   qualifySectionBody: () => qualifySectionBody,
   qualifyAnchors: () => qualifyAnchors,
   pruneReports: () => pruneReports,
@@ -103884,6 +104946,8 @@ __export(exports_src2, {
   looksLikeOpaqueId: () => looksLikeOpaqueId,
   loadSlashCommands: () => loadSlashCommands,
   loadSectionMatrix: () => loadSectionMatrix,
+  lintVerifyAnswerForTask: () => lintVerifyAnswerForTask,
+  lintVerifyAnswer: () => lintVerifyAnswer,
   isTerminalReason: () => isTerminalReason,
   isSystemEventEnvelopeV2: () => isSystemEventEnvelopeV2,
   isSchedulerCustomActiveConflict: () => isSchedulerCustomActiveConflict,
@@ -103892,11 +104956,15 @@ __export(exports_src2, {
   isPortLive: () => isPortLive,
   isPortAvailable: () => isPortAvailable,
   isInsideRoot: () => isInsideRoot,
+  isInlineRunCloseStatus: () => isInlineRunCloseStatus,
+  isInlineRunActionStatus: () => isInlineRunActionStatus,
   isFindingCode: () => isFindingCode,
+  isFeatureFile: () => isFeatureFile,
   isFeatureActionName: () => isFeatureActionName,
   isExclusiveJobActive: () => isExclusiveJobActive,
   isBookkeepingWorkflow: () => isBookkeepingWorkflow,
   installSystemEventCatchAll: () => installSystemEventCatchAll,
+  inlineRunRecordLogPath: () => inlineRunRecordLogPath,
   humanWorkflowTitle: () => humanWorkflowTitle,
   humanStepLabel: () => humanStepLabel,
   hitlConfirmDefault: () => hitlConfirmDefault,
@@ -103983,6 +105051,7 @@ __export(exports_src2, {
   assertPiImporterSafe: () => assertPiImporterSafe,
   assertInventoryIdentity: () => assertInventoryIdentity,
   assertCanonicalTimeoutMs: () => assertCanonicalTimeoutMs,
+  appendInlineRunLogLine: () => appendInlineRunLogLine,
   anchorQualify: () => anchorQualify,
   aggregateBatchVerdicts: () => aggregateBatchVerdicts,
   acquireExclusiveJob: () => acquireExclusiveJob,
@@ -104129,6 +105198,7 @@ __export(exports_src2, {
   AgentRunActionRunner: () => AgentRunActionRunner,
   AgentExecutionLifecycle: () => AgentExecutionLifecycle,
   AgentCoordinationService: () => AgentCoordinationService,
+  ANSWER_LINT_MAX_FINDINGS: () => ANSWER_LINT_MAX_FINDINGS,
   ALL_FINDING_CODES: () => ALL_FINDING_CODES,
   AGENT_SESSION_SOURCES: () => AGENT_SESSION_SOURCES
 });
@@ -104201,6 +105271,7 @@ var init_src3 = __esm(async () => {
   init_task_verdict();
   init_token_ledger_service();
   init_token_ledger_watcher();
+  init_verify_answer_lint();
   init_workflow_service();
   init_write_slot_service();
   init_action_trace();
@@ -112043,7 +113114,10 @@ var SHARED_OPTIONS = {
   fileRuleAdhocPath: ["--file <path>", "Ad-hoc rule file path"],
   fileTaskBatch: ["--file <path>", "Path to the batch JSON file validated against task-batch.schema.json"],
   fileTaskTest: ["--file <path>", "Custom target test file path"],
-  forceFeatureReopen: ["--force", "Force applying reopen proposals without confirmation"],
+  forceFeatureReopen: [
+    "--force",
+    "Force applying reopen proposals without confirmation; also bypasses repeated-BLOCKED suppression"
+  ],
   forceInitRecreate: ["--force", "Recreate files that already exist"],
   forceWorkflowClean: ["--force", "Clean ALL non-terminal runs regardless of age (overrides --older-than)"],
   forceWorkflowContinue: ["--force", "Proceed with resume even if workflow definition drift is detected"],
@@ -112059,7 +113133,7 @@ init_loader();
 init_src2();
 init_dist7();
 await init_src3();
-import { existsSync as existsSync12, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync14 } from "fs";
 import { rm, writeFile as writeFile2 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
 import { dirname as dirname25, join as join41 } from "path";
@@ -113053,9 +114127,9 @@ init_src2();
 await init_src3();
 
 // src/workflow/resolve-spur-bin.ts
-import { basename as basename14 } from "path";
+import { basename as basename15 } from "path";
 function resolveSpurBinFrom(launch) {
-  const runtime = basename14(launch.execPath).toLowerCase().replace(/\.exe$/, "");
+  const runtime = basename15(launch.execPath).toLowerCase().replace(/\.exe$/, "");
   const isJsRuntime = runtime === "bun" || runtime === "node";
   if (isJsRuntime && launch.mainModule) {
     return `${launch.execPath} ${launch.mainModule}`;
@@ -113804,7 +114878,14 @@ Recover with: ${err.recoveryCommand}` : err.message;
     }
   });
   task.command("verdict").summary("Derive PASS/PARTIAL/FAIL/UNKNOWN verdict from verify answer text (replaces pipeline grep/shell).").argument("<wbs>", "Task WBS number").option("--from-answer <path>", "Path to verify answer text file").option(...SHARED_OPTIONS.folderTasks).option(...SHARED_OPTIONS.json).option(...SHARED_OPTIONS.jsonEnvelope).action(async (wbs, options) => {
-    const { deriveVerdict: deriveVerdict2, summarizeRowIds: summarizeRowIds2, VERDICT_SCENARIO_KEY_FORMS: VERDICT_SCENARIO_KEY_FORMS2, verdictScenarioKeyGap: verdictScenarioKeyGap2 } = await init_src3().then(() => exports_src2);
+    const {
+      ANSWER_LINT_MAX_FINDINGS: ANSWER_LINT_MAX_FINDINGS2,
+      deriveVerdict: deriveVerdict2,
+      lintVerifyAnswerForTask: lintVerifyAnswerForTask2,
+      summarizeRowIds: summarizeRowIds2,
+      VERDICT_SCENARIO_KEY_FORMS: VERDICT_SCENARIO_KEY_FORMS2,
+      verdictScenarioKeyGap: verdictScenarioKeyGap2
+    } = await init_src3().then(() => exports_src2);
     const answerPath = options.fromAnswer ?? `.spur/run/${wbs}-verify-answer.txt`;
     let answerText;
     try {
@@ -113814,15 +114895,28 @@ Recover with: ${err.recoveryCommand}` : err.message;
       context4.setExitCode(1);
       return;
     }
-    const taskCheckPassed = true;
-    const result = deriveVerdict2(answerText, taskCheckPassed);
     const { foldersConfig, featuresDir } = await resolvePlanningFolders(context4.fs);
-    const gap = await verdictScenarioKeyGap2(wbs, [...result.requirements, ...result.acceptanceCriteria ?? []], {
+    const corpusDeps = {
       fs: context4.fs,
       tasksDir: context4.fs.resolve(options.folder ?? foldersConfig.active_folder),
       foldersConfig,
       featuresDir: context4.fs.resolve(featuresDir)
-    });
+    };
+    const lintFindings = await lintVerifyAnswerForTask2(wbs, answerText, corpusDeps);
+    if (lintFindings.length > 0) {
+      if (options.json) {
+        context4.output.write(JSON.stringify({ wbs, lintFindings }, null, 2));
+      } else {
+        context4.output.error(`task verdict: answer lint failed \u2014 ${lintFindings.length}${lintFindings.length >= ANSWER_LINT_MAX_FINDINGS2 ? "+" : ""} finding(s) in ${answerPath}`);
+        for (const f of lintFindings)
+          context4.output.error(`  line ${f.line}: ${f.message}`);
+      }
+      context4.setExitCode(1);
+      return;
+    }
+    const taskCheckPassed = true;
+    const result = deriveVerdict2(answerText, taskCheckPassed);
+    const gap = await verdictScenarioKeyGap2(wbs, [...result.requirements, ...result.acceptanceCriteria ?? []], corpusDeps);
     if (gap !== null) {
       writeJsonError(context4.output, options, `Verdict rows key to no scenario of linked feature ${gap.featureId}: ${summarizeRowIds2(gap.offendingIds)}. Key each row by ${VERDICT_SCENARIO_KEY_FORMS2} (repair: /sp:dev-verify ${wbs})`);
       context4.setExitCode(1);
@@ -113888,9 +114982,14 @@ Recover with: ${err.recoveryCommand}` : err.message;
       context4.setExitCode(1);
     }
   });
-  task.command("check").summary("Validate a task file through the four-layer check (design \xA73).").argument("[wbs]", "Task WBS number (validates all tasks in the folder when omitted)").option("--corpus", "Explicit unsuppressed audit of active tasks and features; warnings are advisory").option("--since <ref>", "Scope the corpus fog comparison to changes since a git ref (requires --corpus)").option(...SHARED_OPTIONS.strictTaskAll).option("--strict-core", "Compatibility alias (F92 R2): historically the done-gate label; kept so installed plugins/workflows that call it keep working. No longer meaningful on its own \u2014 target-state selection (`--as`) supplies the real done semantics.").option(...SHARED_OPTIONS.asTaskF92).option("--fix", "repair structural findings in place (heading presence/level/order; adds missing R-item checkbox markers \u2014 flipping verified boxes is task record's job, not --fix)").option(...SHARED_OPTIONS.folderTasks).option(...SHARED_OPTIONS.json).option(...SHARED_OPTIONS.jsonEnvelope).action(async (wbs, options) => {
+  task.command("check").summary("Validate a task file through the four-layer check (design \xA73).").argument("[wbs]", "Task WBS number (validates all tasks in the folder when omitted)").option("--corpus", "Explicit unsuppressed audit of active tasks and features; warnings are advisory").option("--precheck", "Also run the implement-readiness prechecks (size, evidence channel); failures are errors.").option("--since <ref>", "Scope the corpus fog comparison to changes since a git ref (requires --corpus)").option(...SHARED_OPTIONS.strictTaskAll).option("--strict-core", "Compatibility alias (F92 R2): historically the done-gate label; kept so installed plugins/workflows that call it keep working. No longer meaningful on its own \u2014 target-state selection (`--as`) supplies the real done semantics.").option(...SHARED_OPTIONS.asTaskF92).option("--fix", "repair structural findings in place (heading presence/level/order; adds missing R-item checkbox markers \u2014 flipping verified boxes is task record's job, not --fix)").option(...SHARED_OPTIONS.folderTasks).option(...SHARED_OPTIONS.json).option(...SHARED_OPTIONS.jsonEnvelope).action(async (wbs, options) => {
     const json4 = options.json === true;
     const strict = options.strict === true;
+    if (options.precheck === true && (options.corpus || !wbs)) {
+      writeJsonError(context4.output, options, "--precheck requires a <wbs> argument and cannot be combined with --corpus", "VALIDATION_FAILED");
+      context4.setExitCode(2);
+      return;
+    }
     if (options.since !== undefined && !options.corpus || options.corpus && (wbs || options.as || options.fix || options.folder || strict || options.strictCore) || options.since?.startsWith("-")) {
       writeJsonError(context4.output, options, "--corpus accepts only --since and JSON output options; --since requires --corpus and a git ref", "VALIDATION_FAILED");
       context4.setExitCode(2);
@@ -113957,7 +115056,17 @@ ${result.wbs} (${result.status}): ${result.pass ? "PASS" : "FAIL"}`);
             strict,
             asStatus,
             severityOverrides: planningFolders.severityOverrides,
-            fix: options.fix === true
+            fix: options.fix === true,
+            ...options.precheck === true ? {
+              precheck: true,
+              countArgsRaw: async (source) => {
+                try {
+                  return await countToolCallArgsRaw(await context4.getDb(), source);
+                } catch {
+                  return null;
+                }
+              }
+            } : {}
           });
           results.push(result);
           printResult(result);
@@ -114145,14 +115254,14 @@ function loadTemplateBodies(projectRoot, variant) {
     return cached2;
   let bodies = {};
   const localPath = join41(projectRoot, ".spur", "tasks", "templates", `${variant}.md`);
-  if (existsSync12(localPath)) {
-    bodies = extractTemplateBodies(readFileSync13(localPath, "utf8"));
+  if (existsSync13(localPath)) {
+    bodies = extractTemplateBodies(readFileSync14(localPath, "utf8"));
   } else {
     const root = bundledConfigRoot();
     if (root !== null) {
       const templatePath = join41(root, "templates", "task", `${variant}.md`);
-      if (existsSync12(templatePath)) {
-        bodies = extractTemplateBodies(readFileSync13(templatePath, "utf8"));
+      if (existsSync13(templatePath)) {
+        bodies = extractTemplateBodies(readFileSync14(templatePath, "utf8"));
       }
     }
   }
@@ -114860,12 +115969,12 @@ function waitFail(context4, options, code, message) {
 // src/release-ops.ts
 init_src();
 init_dist5();
-import { existsSync as existsSync14, readdirSync as readdirSync8, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync15, readdirSync as readdirSync8, readFileSync as readFileSync15 } from "fs";
 import { join as join43 } from "path";
 
 // src/version-carriers.ts
 init_zod();
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import { join as join42 } from "path";
 var defaultLiteralProbe = { file: "src/config.ts", identifier: "binaryVersion" };
 var registry2 = new Map;
@@ -114902,7 +116011,7 @@ function findLiteralProbe(carriers, packageDir) {
   return;
 }
 async function readJson(path9) {
-  if (!existsSync13(path9))
+  if (!existsSync14(path9))
     return null;
   try {
     return JSON.parse(await Bun.file(path9).text());
@@ -114977,7 +116086,7 @@ async function run(repoRoot, cmd) {
 }
 async function verifyLockfile(ctx, output2) {
   const lockPath = join43(ctx.repoRoot, "bun.lock");
-  if (!existsSync14(lockPath) || Bun.file(lockPath).size === 0)
+  if (!existsSync15(lockPath) || Bun.file(lockPath).size === 0)
     return;
   const result = await run(ctx.repoRoot, ["bun", "install", "--frozen-lockfile"]);
   if (!result.ok) {
@@ -114987,7 +116096,7 @@ async function verifyLockfile(ctx, output2) {
 }
 async function assertPluginInstallable(ctx, output2) {
   const smokePath = join43(ctx.repoRoot, "scripts", "commands", "plugin-install-smoke.ts");
-  if (!existsSync14(smokePath)) {
+  if (!existsSync15(smokePath)) {
     output2.write("  \u21B3 plugin-install-smoke: gate script not present in this repo \u2014 skipped");
     return;
   }
@@ -115028,7 +116137,7 @@ async function readJson2(path9) {
 function rootWorkspaceGlobs(repoRoot) {
   let root;
   try {
-    root = JSON.parse(readFileSync14(join43(repoRoot, "package.json"), "utf8"));
+    root = JSON.parse(readFileSync15(join43(repoRoot, "package.json"), "utf8"));
   } catch {
     return [];
   }
@@ -115046,10 +116155,10 @@ function workspaceDirs(repoRoot) {
       continue;
     const parent = glob.slice(0, -2);
     const parentAbs = join43(repoRoot, parent);
-    if (!existsSync14(parentAbs))
+    if (!existsSync15(parentAbs))
       continue;
     for (const entry of readdirSync8(parentAbs, { withFileTypes: true })) {
-      if (entry.isDirectory() && existsSync14(join43(parentAbs, entry.name, "package.json"))) {
+      if (entry.isDirectory() && existsSync15(join43(parentAbs, entry.name, "package.json"))) {
         dirs.push(`${parent}/${entry.name}`);
       }
     }
@@ -115080,7 +116189,7 @@ async function releaseContext(repoRoot, bumpVerConfig = resolveBuilderBumpVerCon
   for (const ws of workspaces2) {
     const probe = findLiteralProbe(versionCarriers, ws.dir) ?? defaultLiteralProbe;
     const literalProbe = join43(ws.dir, probe.file);
-    const versionSourceFile = existsSync14(join43(repoRoot, literalProbe)) ? literalProbe : undefined;
+    const versionSourceFile = existsSync15(join43(repoRoot, literalProbe)) ? literalProbe : undefined;
     packages.set(shortName(ws.name), {
       packageDir: ws.dir,
       packageName: ws.name,
@@ -115144,7 +116253,7 @@ async function updateWorkspacePins(ctx, pkgName, oldVersion, newVersion, output2
   if (changed.length === 0)
     return changed;
   const lockPath = join43(ctx.repoRoot, "bun.lock");
-  if (existsSync14(lockPath)) {
+  if (existsSync15(lockPath)) {
     const lock = await Bun.file(lockPath).text();
     const staleSpec = `"${pkgName}": "workspace:${oldVersion}"`;
     if (lock.includes(staleSpec)) {
@@ -115272,7 +116381,7 @@ async function bumpVersion(ctx, config4, version3, options, output2) {
   await syncExtraCarriers(ctx, version3, staged, output2);
   await verifyLockfile(ctx, output2);
   const lockPath = join43(ctx.repoRoot, "bun.lock");
-  if (existsSync14(lockPath) && Bun.file(lockPath).size > 0)
+  if (existsSync15(lockPath) && Bun.file(lockPath).size > 0)
     staged.push("bun.lock");
   await git2(ctx.repoRoot, ["add", ...staged]);
   const message = `${config4.releaseCommitType}(${config4.releaseCommitScope}): ${config4.releaseCommitSubject(version3)}`;
@@ -115350,7 +116459,7 @@ async function bumpAll(ctx, version3, options, output2) {
   await syncExtraCarriers(ctx, version3, staged, output2);
   await verifyLockfile(ctx, output2);
   const lockPath = join43(ctx.repoRoot, "bun.lock");
-  if (existsSync14(lockPath) && Bun.file(lockPath).size > 0)
+  if (existsSync15(lockPath) && Bun.file(lockPath).size > 0)
     staged.push("bun.lock");
   await git2(ctx.repoRoot, ["add", ...staged]);
   const shortNames = configs.map((c3) => c3.packageName.split("/").pop() ?? c3.packageName).join(" + ");
@@ -115787,8 +116896,15 @@ function registerFeatureCommand(program2, context4) {
       const result = await svc.refresh({ featureId: options.feature });
       if (options.json) {
         const featuresDir = options.folder ?? (await resolvePlanningFolders(context4.fs)).featuresDir;
-        context4.output.write(toEnvelopeJson({ index_path: `${featuresDir}/INDEX.md`, tasksUpdated: result.tasksUpdated }, { enveloped: options.jsonEnvelope }));
+        context4.output.write(toEnvelopeJson({
+          index_path: `${featuresDir}/INDEX.md`,
+          tasksUpdated: result.tasksUpdated,
+          skipped: result.skipped
+        }, { enveloped: options.jsonEnvelope }));
       } else {
+        for (const s3 of result.skipped) {
+          context4.output.write(`Skipped ${s3.id} (${s3.reason})`);
+        }
         context4.output.write(`INDEX.md regenerated (${result.index.split(`
 `).length} lines); ${result.tasksUpdated} feature Tasks region(s) updated`);
       }
@@ -115797,7 +116913,7 @@ function registerFeatureCommand(program2, context4) {
       context4.setExitCode(1);
     }
   });
-  feature.command("check").summary("Validate feature file(s) through the four-layer check (design \xA73).").argument("[id]", "Feature ID (validates all features in the folder when omitted)").option(...SHARED_OPTIONS.strictFeature).option(...SHARED_OPTIONS.asFeature0418).option(...SHARED_OPTIONS.folderFeatures).option("--fix", "repair structural findings in place (heading presence/level/order, R-item checkboxes)").option(...SHARED_OPTIONS.json).option(...SHARED_OPTIONS.jsonEnvelope).action(async (id, options) => {
+  feature.command("check").summary("Validate feature file(s) through the four-layer check (design \xA73).").argument("[id]", "Feature ID (validates all features in the folder when omitted)").option(...SHARED_OPTIONS.strictFeature).option(...SHARED_OPTIONS.asFeature0418).option(...SHARED_OPTIONS.folderFeatures).option("--fix", "repair structural findings in place (heading presence/level/order, R-item checkboxes)").option("--inventory <report>", "Cross-check the report requirement inventory against the AC covers lines (errors on uncovered items)").option(...SHARED_OPTIONS.json).option(...SHARED_OPTIONS.jsonEnvelope).action(async (id, options) => {
     const resolved = await resolvePlanningFolders(context4.fs);
     const featuresDir = options.folder ?? context4.fs.resolve(resolved.featuresDir);
     const tasksDir = context4.fs.resolve(resolved.tasksDir);
@@ -115807,6 +116923,7 @@ function registerFeatureCommand(program2, context4) {
     const svc = new FeatureCheckService(context4.fs);
     const json4 = options.json === true;
     const strict = options.strict === true;
+    const inventoryText = typeof options.inventory === "string" ? await Promise.resolve(context4.fs.readFile(context4.fs.resolve(options.inventory))).catch(() => "") : undefined;
     try {
       const entries = await context4.fs.readDir(featuresDir);
       const ids = id ? [id] : entries.map((n3) => n3.match(/^([A-Z][1-9]*)_.+\.md$/)?.[1]).filter((n3) => n3 !== undefined);
@@ -115827,7 +116944,8 @@ function registerFeatureCommand(program2, context4) {
           receiptRunPort: await makeReceiptRunPort(context4),
           severityOverrides: resolved.severityOverrides,
           asStatus: options.as,
-          fix: options.fix === true
+          fix: options.fix === true,
+          inventory: inventoryText
         });
         results.push(result);
         if (!json4) {
@@ -115874,7 +116992,8 @@ ${result.id} (${result.status}): ${result.pass ? "PASS" : "FAIL"}`);
       if (options.all) {
         const result = await svc.syncAllFeatures({
           dryRun: options.dryRun,
-          forceConfirm: options.force
+          forceConfirm: options.force,
+          force: options.force
         });
         if (options.json) {
           context4.output.write(toEnvelopeJson(result, { enveloped: options.jsonEnvelope }));
@@ -115888,7 +117007,8 @@ ${result.id} (${result.status}): ${result.pass ? "PASS" : "FAIL"}`);
       } else if (id) {
         const result = await svc.syncFeature(id, {
           dryRun: options.dryRun,
-          forceConfirm: options.force
+          forceConfirm: options.force,
+          force: options.force
         });
         if (options.json) {
           context4.output.write(toEnvelopeJson(result, { enveloped: options.jsonEnvelope }));
@@ -115903,9 +117023,6 @@ ${result.id} (${result.status}): ${result.pass ? "PASS" : "FAIL"}`);
     }
   });
 }
-function isFeatureFile(name, id) {
-  return name.startsWith(`${id}_`) && name.endsWith(".md") && name.length > id.length + 4;
-}
 async function makeReceiptRunPort(context4) {
   const db2 = await context4.getDb();
   const runs2 = new RunDao(db2);
@@ -115993,7 +117110,7 @@ import { createRequire } from "module";
 var CLI_CONFIG = {
   binaryName: "spur",
   binaryLabel: "spur",
-  binaryVersion: "0.3.95",
+  binaryVersion: "0.3.96",
   configDir: ".spur",
   configFile: ".spur/config.yaml",
   databaseFile: ".spur/spur.db"
@@ -117184,7 +118301,7 @@ function registerMigrateCommand(program2, context4, options = {}) {
 init_src2();
 init_dist5();
 await init_src3();
-import { basename as basename15, dirname as dirname26, join as join47, resolve as resolve20 } from "path";
+import { basename as basename16, dirname as dirname26, join as join47, resolve as resolve20 } from "path";
 function registerProjectsCommand(program2, context4) {
   const projectsCmd = program2.command("projects").summary("manage the Spur multi-project registry");
   projectsCmd.command("add").argument("<path>", "Project root directory path").option(...SHARED_OPTIONS.nameProjectDisplay).option(...SHARED_OPTIONS.jsonProjectsResponse).option(...SHARED_OPTIONS.jsonEnvelope).action(async (pathArg, options) => {
@@ -117193,7 +118310,7 @@ function registerProjectsCommand(program2, context4) {
       if (!await context4.fs.exists(absolutePath)) {
         throw new Error(`Directory does not exist: ${absolutePath}`);
       }
-      const name = options.name ?? basename15(absolutePath);
+      const name = options.name ?? basename16(absolutePath);
       const registry3 = new ProjectRegistry;
       const entry = await registry3.upsert({ path: absolutePath, name, port: 0 });
       if (options.json) {
@@ -117732,7 +118849,7 @@ init_src();
 init_loader();
 init_src2();
 await init_src3();
-import { basename as basename17, dirname as dirname28, isAbsolute as isAbsolute9, join as join51 } from "path";
+import { basename as basename18, dirname as dirname28, isAbsolute as isAbsolute9, join as join51 } from "path";
 init_dist5();
 
 // ../server/src/bootstrap.ts
@@ -123750,7 +124867,8 @@ var featureContract = {
     summary: "Refresh feature index and kanban",
     tags: ["feature"]
   }).output(apiSuccessSchema(exports_external.object({
-    rebuilt: exports_external.number().int().nonnegative()
+    rebuilt: exports_external.number().int().nonnegative(),
+    skipped: exports_external.array(exports_external.object({ id: exports_external.string(), reason: exports_external.string() }))
   }))),
   check: oc.route({
     method: "POST",
@@ -124451,6 +125569,9 @@ var taskSummarySchema = exports_external.object({
   featureId: exports_external.string().nullable().optional(),
   parentWbs: exports_external.string().regex(/^\d{4}$/).nullable().optional(),
   type: exports_external.enum(TASK_TYPES).optional(),
+  template: exports_external.string().optional(),
+  estimateHours: exports_external.number().optional(),
+  dependencyCount: exports_external.number().optional(),
   filePath: exports_external.string(),
   updatedAt: exports_external.string().optional()
 });
@@ -124731,8 +125852,8 @@ function createFeatureHandlers(ctx) {
       return { ok: true, data: { id: input.id, status: input.toStatus } };
     }),
     refresh: os2.feature.refresh.handler(async () => {
-      const { tasksUpdated } = await ctx.featureService().refresh();
-      return { ok: true, data: { rebuilt: tasksUpdated } };
+      const { tasksUpdated, skipped } = await ctx.featureService().refresh();
+      return { ok: true, data: { rebuilt: tasksUpdated, skipped } };
     }),
     check: os2.feature.check.handler(async ({ input }) => {
       const folders = ctx.planningFolders();
@@ -124814,7 +125935,7 @@ init_src2();
 init_dist5();
 await init_src3();
 import { homedir as homedir12 } from "os";
-import { basename as basename16, join as join48, relative as relative7, resolve as resolve22 } from "path";
+import { basename as basename17, join as join48, relative as relative7, resolve as resolve22 } from "path";
 var startedAt = Date.now();
 var OPERATOR_AGENT_ID = "board-operator";
 var healthModule = {
@@ -124841,7 +125962,7 @@ var healthModule = {
       return c3.json({ status: "error", db: "unreachable" }, 503);
     });
     app.get("/api/project", (c3) => {
-      return c3.json({ name: ctx ? basename16(ctx.cwd) : null, path: ctx ? normalizeProjectPath(ctx.cwd) : null });
+      return c3.json({ name: ctx ? basename17(ctx.cwd) : null, path: ctx ? normalizeProjectPath(ctx.cwd) : null });
     });
     app.get("/api/project/fleet", async (c3) => {
       if (!ctx) {
@@ -125473,7 +126594,7 @@ var healthModule = {
           return c3.json({ ok: false, error: "File not found" }, 404);
         }
         const content = await fs3.readFile(fullPath);
-        let title2 = basename16(reqPath, ".md");
+        let title2 = basename17(reqPath, ".md");
         const match2 = content.match(/^#\s+(.+)$/m);
         if (match2?.[1])
           title2 = match2[1].trim();
@@ -125563,7 +126684,7 @@ var healthModule = {
           return c3.json({ ok: false, error: "File not found" }, 404);
         }
         const content = await fs3.readFile(fullPath);
-        let title2 = basename16(reqPath, ".md");
+        let title2 = basename17(reqPath, ".md");
         const match2 = content.match(/^#\s+(.+)$/m);
         if (match2?.[1])
           title2 = match2[1].trim();
@@ -126419,6 +127540,8 @@ function createTaskHandlers(ctx) {
       const tasks = await ctx.taskService().list(filters);
       const data = tasks.map((t) => {
         const fm = t.frontmatter ?? {};
+        const estimateHours = typeof fm.estimate_hours === "number" ? fm.estimate_hours : typeof fm.estimated_hours === "number" ? fm.estimated_hours : undefined;
+        const deps = Array.isArray(fm.dependencies) ? fm.dependencies : [];
         return {
           wbs: t.wbs,
           name: t.name,
@@ -126427,6 +127550,9 @@ function createTaskHandlers(ctx) {
           featureId: fm.feature_id ?? undefined,
           parentWbs: fm.parent_wbs ?? undefined,
           type: TASK_TYPES.includes(fm.type) ? fm.type : undefined,
+          template: typeof fm.template === "string" ? fm.template : undefined,
+          estimateHours,
+          dependencyCount: deps.length > 0 ? deps.length : undefined,
           filePath: t.filePath,
           updatedAt: fm.updated_at
         };
@@ -129453,7 +130579,7 @@ async function startServer(options, deps = defaultDeps) {
       });
       const projectRegistry = new ProjectRegistry;
       const projectCwd = projectRoot;
-      const projectName = basename17(projectCwd);
+      const projectName = basename18(projectCwd);
       try {
         const existingProject = await projectRegistry.getByPath(projectCwd);
         await projectRegistry.upsert({
@@ -129732,7 +130858,7 @@ init_src();
 init_dist7();
 init_dist5();
 await init_src3();
-import { closeSync as closeSync6, fstatSync as fstatSync4, openSync as openSync6, readFileSync as readFileSync15, readSync as readSync3 } from "fs";
+import { closeSync as closeSync7, fstatSync as fstatSync4, openSync as openSync7, readFileSync as readFileSync16, readSync as readSync3 } from "fs";
 import { join as join54 } from "path";
 import { createInterface } from "readline";
 import { setTimeout as sleep6 } from "timers/promises";
@@ -130860,7 +131986,7 @@ function isTerminalTraceStatus(status) {
 function readRunLogChunk(logPath, offset) {
   let fd;
   try {
-    fd = openSync6(logPath, "r");
+    fd = openSync7(logPath, "r");
   } catch {
     return { exists: false, lines: [], offset };
   }
@@ -130879,7 +132005,7 @@ function readRunLogChunk(logPath, offset) {
     const lines = parts.length > 0 && parts.at(-1) === "" ? parts.slice(0, -1) : parts;
     return { exists: true, lines, offset: offset + consumed };
   } finally {
-    closeSync6(fd);
+    closeSync7(fd);
   }
 }
 async function followRunLog(service, runId, dir, pollMs, write, wait = (ms) => sleep6(ms), now2 = Date.now, deadlineMs) {
@@ -130901,7 +132027,7 @@ async function followRunLog(service, runId, dir, pollMs, write, wait = (ms) => s
       offset = 0;
       if (carried !== "") {
         try {
-          const nextText = readFileSync15(target, "utf8");
+          const nextText = readFileSync16(target, "utf8");
           if (nextText.startsWith(carried))
             offset = Buffer.byteLength(carried);
         } catch {