@gobing-ai/spur 0.3.50 → 0.3.52

package/spur.js

@@ -62573,7 +62573,7 @@ var init_schema4 = __esm(() => {
   init_zod();
   STAGE_REGISTRY_SCHEMA_VERSION = {
     major: 1,
-    minor: 2
+    minor: 3
   };
   stageSchemaVersionSchema = exports_external.object({
     major: exports_external.number().int().nonnegative(),
@@ -62628,6 +62628,7 @@ var init_schema4 = __esm(() => {
   stageArtifactSchema = exports_external.object({
     kind: exports_external.string().min(1),
     direction: exports_external.enum(ARTIFACT_DIRECTIONS),
+    identity: exports_external.string().optional(),
     description: exports_external.string().optional(),
     required: exports_external.boolean().optional().default(true)
   }).strict();
@@ -62719,7 +62720,15 @@ var init_schema4 = __esm(() => {
       id: "refine",
       aliases: ["dev-refine"],
       description: "dev-refine: Q&A refinement, section filling, AC tightening",
-      artifacts: [{ kind: "task-section", direction: "output", required: true }],
+      artifacts: [
+        {
+          kind: "task-section",
+          direction: "input",
+          required: true,
+          description: "Background/Requirements sections"
+        },
+        { kind: "task-section", direction: "output", required: true, description: "Q&A/Design/Plan/AC sections" }
+      ],
       reasoning_skill: "sp:spur-dev",
       required_references: [],
       gates: [],
@@ -62742,10 +62751,16 @@ var init_schema4 = __esm(() => {
       id: "plan",
       aliases: ["dev-plan"],
       description: "dev-plan: feature intake -> AC generation -> decomposition",
-      artifacts: [{ kind: "task-batch", direction: "output", required: true }],
+      artifacts: [
+        { kind: "feature-frontmatter", direction: "input", required: true },
+        { kind: "task-batch", direction: "output", required: true }
+      ],
       reasoning_skill: "sp:spur-dev",
       required_references: [],
-      gates: [],
+      gates: [
+        { name: "feature-check", timing: "post", min_verdict: "pass" },
+        { name: "batch-create", timing: "post", min_verdict: "pass" }
+      ],
       mutation_class: "corpus",
       retry: { max_attempts: 3, terminal_stop: "block" },
       model_policy: {
@@ -62765,7 +62780,10 @@ var init_schema4 = __esm(() => {
       id: "implement",
       aliases: ["dev-run"],
       description: "dev-run --mode implement: code edits in worktree",
-      artifacts: [{ kind: "worktree-diff", direction: "output", required: true }],
+      artifacts: [
+        { kind: "worktree-diff", direction: "output", required: true },
+        { kind: "task-section", direction: "output", required: true, identity: "Solution" }
+      ],
       reasoning_skill: "sp:code-implementation",
       required_references: [],
       gates: [],
@@ -62789,7 +62807,10 @@ var init_schema4 = __esm(() => {
       id: "test",
       aliases: ["dev-unit", "dev-fixall"],
       description: "dev-unit: generate/extend tests to coverage target",
-      artifacts: [{ kind: "test-file", direction: "output", required: true }],
+      artifacts: [
+        { kind: "test-file", direction: "output", required: true },
+        { kind: "coverage-report", direction: "output", required: false }
+      ],
       reasoning_skill: "sp:code-testing",
       required_references: [],
       gates: [],
@@ -62812,10 +62833,16 @@ var init_schema4 = __esm(() => {
       id: "verify",
       aliases: ["dev-verify"],
       description: "dev-verify: SECUA review + requirements traceability",
-      artifacts: [{ kind: "verdict-artifact", direction: "output", required: true }],
+      artifacts: [
+        { kind: "worktree-diff", direction: "input", required: true },
+        { kind: "verdict-artifact", direction: "output", required: true, identity: "<wbs>-verdict.json" }
+      ],
       reasoning_skill: "sp:code-verification",
       required_references: [],
-      gates: [],
+      gates: [
+        { name: "verdict-artifact", timing: "post", min_verdict: "pass" },
+        { name: "strict-core", timing: "post", min_verdict: "pass" }
+      ],
       mutation_class: "verdict",
       retry: { max_attempts: 2, terminal_stop: "escalate" },
       model_policy: {
@@ -62838,7 +62865,7 @@ var init_schema4 = __esm(() => {
       artifacts: [{ kind: "learning-entry", direction: "output", required: true }],
       reasoning_skill: "sp:spur-dev",
       required_references: [],
-      gates: [],
+      gates: [{ name: "task-check", timing: "pre", min_verdict: "pass" }],
       mutation_class: "learnings",
       retry: { max_attempts: 2, terminal_stop: "block" },
       model_policy: {
@@ -62851,14 +62878,14 @@ var init_schema4 = __esm(() => {
       },
       context_layers: [],
       observability: [],
-      execution: { kind: "inline", current_agent_allowed: true }
+      execution: { kind: "hitl", current_agent_allowed: true, gate_timing: "both" }
     },
     {
       schema_version: STAGE_REGISTRY_SCHEMA_VERSION,
       id: "review",
       aliases: ["dev-review"],
-      description: "dev-review: multi-dimensional code review",
-      artifacts: [{ kind: "review-findings", direction: "output", required: true }],
+      description: "dev-review: multi-dimensional code review (coordinator writes the combined Review)",
+      artifacts: [{ kind: "review-findings", direction: "output", required: true, identity: "Review" }],
       reasoning_skill: "sp:code-verification",
       required_references: [],
       gates: [],
@@ -62876,12 +62903,41 @@ var init_schema4 = __esm(() => {
       observability: [],
       execution: { kind: "inline", current_agent_allowed: true }
     },
+    {
+      schema_version: STAGE_REGISTRY_SCHEMA_VERSION,
+      id: "record",
+      aliases: ["dev-record"],
+      description: "record: deterministic Testing write-back from the verdict artifact; bare-Review fallback only",
+      artifacts: [
+        { kind: "verdict-artifact", direction: "input", required: true, identity: "<wbs>-verdict.json" },
+        { kind: "task-section", direction: "output", required: true, identity: "Testing" },
+        {
+          kind: "task-section",
+          direction: "output",
+          required: false,
+          identity: "Review",
+          description: "fallback-only: backfills Review only when the section is bare; never overwrites authored Review"
+        }
+      ],
+      reasoning_skill: "inline",
+      required_references: [],
+      gates: [],
+      mutation_class: "corpus",
+      retry: { max_attempts: 1, terminal_stop: "block" },
+      model_policy: { min_tier: "cheap", fallback: [] },
+      context_layers: [],
+      observability: [],
+      execution: { kind: "deterministic", current_agent_allowed: false, executor: "cli" }
+    },
     {
       schema_version: STAGE_REGISTRY_SCHEMA_VERSION,
       id: "dogfood",
       aliases: ["dev-dogfood"],
       description: "dev-dogfood: end-to-end driver test",
-      artifacts: [{ kind: "dogfood-report", direction: "output", required: true }],
+      artifacts: [
+        { kind: "dogfood-report", direction: "output", required: true },
+        { kind: "monitor-ledger", direction: "output", required: false }
+      ],
       reasoning_skill: "sp:dogfood-testing",
       required_references: [],
       gates: [],
@@ -67031,6 +67087,142 @@ var init_anchor_qualifier = __esm(() => {
   ANCHOR_RE = /`([^`\n]+?):(\d+)(?:-(\d+))?`/g;
 });
 
+// ../../packages/app/src/services/verify-verdict.ts
+function parseVerifyVerdict(raw, fallbackWbs) {
+  const wbs = fallbackWbs ?? "";
+  if (raw.trim() === "")
+    return { kind: "missing", wbs };
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    return { kind: "malformed", wbs, message: err.message };
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { kind: "invalid", wbs, reason: "root must be a JSON object" };
+  }
+  const result = verifyVerdictSchema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((i2) => `${i2.path.join(".")}: ${i2.message}`);
+    return { kind: "invalid", wbs, reason: issues.join("; "), issues };
+  }
+  const verdict = { ...result.data, wbs: result.data.wbs !== "" ? result.data.wbs : wbs };
+  return { kind: "valid", wbs, verdict };
+}
+async function readVerifyVerdict(fs3, path9, fallbackWbs) {
+  let raw;
+  try {
+    raw = await fs3.readFile(path9);
+  } catch {
+    return { kind: "missing", wbs: fallbackWbs ?? "" };
+  }
+  return parseVerifyVerdict(raw, fallbackWbs);
+}
+function checkRowName(row) {
+  for (const v of [row.name, row.check, row.id]) {
+    if (typeof v === "string" && v.trim() !== "")
+      return v.trim();
+  }
+  return "";
+}
+function isTaskCheckRow(row) {
+  return /task[ _-]?check/i.test(checkRowName(row));
+}
+function aggregateVerifyVerdict(input) {
+  const reqs = Array.isArray(input.requirements) ? input.requirements : [];
+  const acs = Array.isArray(input.acceptanceCriteria) ? input.acceptanceCriteria : [];
+  const checks4 = Array.isArray(input.checks) ? input.checks : [];
+  if (reqs.length === 0 && acs.length === 0)
+    return "UNKNOWN";
+  if (reqs.some((r) => NORM(r.status) === "UNMET") || acs.some((a2) => NORM(a2.status) === "UNMET"))
+    return "FAIL";
+  let majorBlocked = false;
+  for (const c3 of checks4) {
+    if (isTaskCheckRow(c3))
+      continue;
+    const status = NORM(c3.status);
+    if (status === "PASS" || status === "")
+      continue;
+    const severity = NORM(c3.severity);
+    if (severity === "BLOCKER" || severity === "" && status === "FAIL")
+      return "FAIL";
+    if (severity === "MAJOR" || severity === "" && status === "WARN")
+      majorBlocked = true;
+  }
+  if (majorBlocked)
+    return "PARTIAL";
+  if (reqs.some((r) => NORM(r.status) === "PARTIAL") || acs.some((a2) => NORM(a2.status) === "PARTIAL"))
+    return "PARTIAL";
+  if (input.taskCheckPassed === false)
+    return "PARTIAL";
+  return "PASS";
+}
+var VERDICT_AGGREGATES, ROW_STATUSES, CHECK_SEVERITIES, verdictSchema, coverageRowSchema, checkSchema, verifyVerdictSchema, NORM = (s2) => String(s2 ?? "").toUpperCase();
+var init_verify_verdict = __esm(() => {
+  init_zod();
+  VERDICT_AGGREGATES = ["PASS", "PARTIAL", "FAIL", "UNKNOWN"];
+  ROW_STATUSES = ["MET", "PARTIAL", "UNMET", "N/A"];
+  CHECK_SEVERITIES = ["blocker", "major", "minor", "advisory"];
+  verdictSchema = exports_external.string().transform((v, ctx) => {
+    const up = v.toUpperCase();
+    if (!VERDICT_AGGREGATES.includes(up)) {
+      ctx.addIssue({ code: "custom", message: `invalid verdict "${v}" (expected PASS|PARTIAL|FAIL|UNKNOWN)` });
+      return "UNKNOWN";
+    }
+    return up;
+  });
+  coverageRowSchema = exports_external.object({
+    id: exports_external.string().optional(),
+    scenario: exports_external.string().optional(),
+    status: exports_external.string(),
+    evidenceType: exports_external.string().optional(),
+    evidence: exports_external.string().optional()
+  }).superRefine((r, ctx) => {
+    if (r.id !== undefined && r.scenario !== undefined && r.id !== r.scenario) {
+      ctx.addIssue({
+        code: "custom",
+        message: `id/scenario conflict ("${r.id}" vs "${r.scenario}")`,
+        path: ["scenario"]
+      });
+    }
+    if (!ROW_STATUSES.includes(r.status.toUpperCase())) {
+      ctx.addIssue({ code: "custom", message: `invalid row status "${r.status}"`, path: ["status"] });
+    }
+  }).transform((r) => ({
+    id: r.id ?? r.scenario ?? "",
+    status: r.status.toUpperCase(),
+    evidenceType: r.evidenceType ?? "",
+    evidence: r.evidence ?? ""
+  }));
+  checkSchema = exports_external.object({
+    name: exports_external.string().optional(),
+    check: exports_external.string().optional(),
+    id: exports_external.string().optional(),
+    status: exports_external.string(),
+    evidence: exports_external.string().optional().default(""),
+    severity: exports_external.enum(CHECK_SEVERITIES).optional()
+  }).superRefine((c3, ctx) => {
+    if (c3.name === undefined && c3.check === undefined && c3.id === undefined) {
+      ctx.addIssue({ code: "custom", message: "check row needs one of name/check/id", path: ["name"] });
+    }
+  }).transform((c3) => ({
+    name: c3.name ?? c3.check ?? c3.id ?? "",
+    status: c3.status,
+    evidence: c3.evidence,
+    severity: c3.severity
+  }));
+  verifyVerdictSchema = exports_external.object({
+    wbs: exports_external.string().optional().default(""),
+    verdict: verdictSchema,
+    requirements: exports_external.array(coverageRowSchema).optional().default([]),
+    acceptanceCriteria: exports_external.array(coverageRowSchema).optional().default([]),
+    checks: exports_external.array(checkSchema).optional().default([]),
+    source: exports_external.string().optional(),
+    pipelineRunId: exports_external.string().optional(),
+    recordedAt: exports_external.string().optional()
+  });
+});
+
 // ../../packages/app/src/services/done-transition-guard.ts
 async function readVerdictArtifact(fs3, runDir, wbs) {
   const path9 = `${runDir}/${wbs}-verdict.json`;
@@ -67066,13 +67258,14 @@ function computeAggregate(artifact) {
   if (reqs.length === 0 && acs.length === 0) {
     return artifact.verdict;
   }
-  if (reqs.some((r) => r.status === "UNMET") || acs.some((a2) => a2.status === "UNMET")) {
-    return "FAIL";
-  }
-  if (reqs.some((r) => r.status === "PARTIAL") || acs.some((a2) => a2.status === "PARTIAL")) {
-    return "PARTIAL";
-  }
-  return "PASS";
+  const taskCheck = (artifact.checks ?? []).find((c3) => /task[ _-]?check/i.test(checkRowName(c3)));
+  const taskCheckPassed = taskCheck === undefined ? true : String(taskCheck.status).toLowerCase() !== "fail";
+  return aggregateVerifyVerdict({
+    requirements: reqs,
+    acceptanceCriteria: acs,
+    checks: artifact.checks ?? [],
+    taskCheckPassed
+  });
 }
 function formatDenialMessage(args) {
   const { wbs, taskFilePath, verdictPath, verdict, inconsistency, artifact } = args;
@@ -67122,7 +67315,10 @@ function evaluateDoneTransition(input) {
     };
   }
   const computed = computeAggregate(artifact);
-  const effective = harshnessMax(artifact.verdict, computed);
+  const reqs = artifact.requirements ?? [];
+  const acs = artifact.acceptanceCriteria ?? [];
+  const internallyConsistentPass = artifact.verdict !== "PASS" || reqs.length > 0 || acs.length > 0;
+  const effective = internallyConsistentPass ? harshnessMax(artifact.verdict, computed) : "UNKNOWN";
   if (effective === "PASS") {
     return { kind: "allow", reason: "pass" };
   }
@@ -67145,6 +67341,9 @@ function harshnessMax(a2, b) {
   const rank = { PASS: 0, UNKNOWN: 1, PARTIAL: 2, FAIL: 3 };
   return rank[a2] >= rank[b] ? a2 : b;
 }
+var init_done_transition_guard = __esm(() => {
+  init_verify_verdict();
+});
 
 // ../../packages/app/src/services/finding-codes.ts
 var init_finding_codes2 = __esm(() => {
@@ -67152,6 +67351,10 @@ var init_finding_codes2 = __esm(() => {
 });
 
 // ../../packages/app/src/services/planning-check-base.ts
+function key(e) {
+  return `${e.kind}:${e.id}:${e.code}`;
+}
+
 class PlanningCheckService {
   fs;
   matrix;
@@ -67244,7 +67447,7 @@ class PlanningCheckService {
       }
     }
   }
-  summarizeWithStatus(status, findings, strict, overrides) {
+  summarizeWithStatus(status, findings, strict, overrides, accepted, id) {
     const effectiveFindings = [];
     for (const f of findings) {
       const override = overrides?.[f.code];
@@ -67257,6 +67460,13 @@ class PlanningCheckService {
       if (strict && f.severity === "warning") {
         f.severity = "error";
       }
+      if (accepted && id) {
+        const k = key({ kind: this.docKind, id, code: f.code });
+        const acceptedSev = accepted.get(k);
+        if (acceptedSev !== undefined && acceptedSev === f.severity) {
+          continue;
+        }
+      }
       effectiveFindings.push(f);
     }
     let hasError = false;
@@ -67411,6 +67621,7 @@ function verdictRowsMatchScenarios(rows, ac) {
 var DEFAULT_FEATURE_MATRIX, FeatureCheckService;
 var init_feature_check = __esm(() => {
   init_src2();
+  init_done_transition_guard();
   init_planning_check_base();
   DEFAULT_FEATURE_MATRIX = {
     variants: {
@@ -67877,7 +68088,7 @@ class TaskLocator {
       return;
     }
     const folderKeys = source.foldersConfig ? Object.keys(source.foldersConfig.folders) : [];
-    this.dirs = [...new Set([source.tasksDir, ...folderKeys.map((key) => source.fs.resolve(key))])];
+    this.dirs = [...new Set([source.tasksDir, ...folderKeys.map((key2) => source.fs.resolve(key2))])];
   }
   static forSingleDir(fs3, dir) {
     return new TaskLocator({ fs: fs3, tasksDir: dir });
@@ -68146,6 +68357,7 @@ var init_task_check = __esm(() => {
   init_src2();
   init_planning_check_base();
   init_task_locator();
+  init_verify_verdict();
   EXTERNAL_EVIDENCE_RE = /`([^`\n]+?)`\s+(?:line|lines?)\s+(\d+)(?:-(\d+))?/g;
   TaskCheckService = class TaskCheckService extends PlanningCheckService {
     locator;
@@ -68171,22 +68383,29 @@ var init_task_check = __esm(() => {
       const findings = [];
       const doc2 = this.runL1(raw, wbs, findings);
       if (doc2 === null) {
-        return { wbs, ...this.summarizeWithStatus("", findings, strict, options?.severityOverrides) };
+        return {
+          wbs,
+          ...this.summarizeWithStatus("", findings, strict, options?.severityOverrides, options?.accepted, wbs)
+        };
       }
       const fm = doc2.frontmatterData ?? {};
       const status = fm.status ?? "backlog";
+      const effectiveStatus = options?.asStatus ?? status;
       const variant = fm.template ?? DEFAULT_TASK_VARIANT;
-      const entry = this.resolveMatrixEntry(variant, status);
+      const entry = this.resolveMatrixEntry(variant, effectiveStatus);
       this.runL2(doc2, entry, findings);
-      this.runL3(doc2, entry, status, findings);
+      this.runL3(doc2, entry, effectiveStatus, findings);
       const tasksDir = dirname9(filePath);
       const featuresDir = join10(dirname9(tasksDir), "features");
-      await this.runL4(doc2, fm, status, findings, featuresDir, tasksDir, wbs);
-      await this.runL4Rollup(doc2, wbs, status, findings, tasksDir);
-      if (status !== "done" && status !== "cancelled") {
-        await this.runL4Readiness(doc2, fm, wbs, status, findings, tasksDir);
+      await this.runL4(doc2, fm, effectiveStatus, findings, featuresDir, tasksDir, wbs);
+      await this.runL4Rollup(doc2, wbs, effectiveStatus, findings, tasksDir);
+      if (effectiveStatus !== "done" && effectiveStatus !== "cancelled") {
+        await this.runL4Readiness(doc2, fm, wbs, effectiveStatus, findings, tasksDir);
       }
-      return { wbs, ...this.summarizeWithStatus(status, findings, strict, options?.severityOverrides) };
+      return {
+        wbs,
+        ...this.summarizeWithStatus(effectiveStatus, findings, strict, options?.severityOverrides, options?.accepted, wbs)
+      };
     }
     runL3(doc2, entry, status, findings) {
       const reqBodyRaw = doc2.getSection("Requirements");
@@ -68846,22 +69065,33 @@ var init_task_check = __esm(() => {
     async checkVerdictArtifact(wbs, tasksDir, findings) {
       const projectRoot = resolveProjectRootFromTasksDir(tasksDir);
       const runDir = join10(projectRoot, ".spur", "run");
-      const loaded = await readVerdictArtifact(this.fs, runDir, wbs);
-      if (loaded.artifact === undefined) {
-        if (loaded.readError && loaded.readError !== "artifact is missing") {
-          findings.push({
-            layer: "L4",
-            code: FINDING_CODES.L4_MALFORMED_VERDICT_ARTIFACT,
-            severity: "error",
-            section: "Testing",
-            message: `Verdict artifact at ${loaded.path} is malformed: ${loaded.readError}`
-          });
-        }
+      const verdictPath = `${runDir}/${wbs}-verdict.json`;
+      const outcome = await readVerifyVerdict(this.fs, verdictPath, wbs);
+      if (outcome.kind === "missing")
+        return;
+      if (outcome.kind === "malformed") {
+        findings.push({
+          layer: "L4",
+          code: FINDING_CODES.L4_MALFORMED_VERDICT_ARTIFACT,
+          severity: "error",
+          section: "Testing",
+          message: `Verdict artifact at ${verdictPath} is malformed: ${outcome.message}`
+        });
+        return;
+      }
+      if (outcome.kind === "invalid") {
+        findings.push({
+          layer: "L4",
+          code: FINDING_CODES.L4_MALFORMED_VERDICT_ARTIFACT,
+          severity: "error",
+          section: "Testing",
+          message: `Verdict artifact at ${verdictPath} is invalid: ${outcome.reason}`
+        });
         return;
       }
-      const artifact = loaded.artifact;
-      const reqs = artifact.requirements ?? [];
-      const acs = artifact.acceptanceCriteria ?? [];
+      const artifact = outcome.verdict;
+      const reqs = artifact.requirements;
+      const acs = artifact.acceptanceCriteria;
       const isUnknown = artifact.verdict === "UNKNOWN";
       const isEmpty = reqs.length === 0 && acs.length === 0;
       if (isUnknown || isEmpty) {
@@ -68871,7 +69101,7 @@ var init_task_check = __esm(() => {
           code: FINDING_CODES.L4_MALFORMED_VERDICT_ARTIFACT,
           severity: "error",
           section: "Testing",
-          message: `Verdict artifact at ${loaded.path} is malformed: ${reason}`
+          message: `Verdict artifact at ${verdictPath} is malformed: ${reason}`
         });
       }
     }
@@ -68883,9 +69113,6 @@ import { basename as basename4, dirname as dirname10, join as join11, relative,
 function baselineSeverity(e) {
   return e.severity ?? "error";
 }
-function key(e) {
-  return `${e.kind}:${e.id}:${e.code}`;
-}
 function resolveProjectRoot(cwd) {
   const fs3 = createNodeFileSystem3(cwd);
   let current = resolve3(cwd);
@@ -69253,12 +69480,29 @@ async function runCorpusCheck(cwd, since) {
   }
   return result;
 }
+async function loadAcceptedFindings(cwd) {
+  const projectRoot = resolveProjectRoot(cwd);
+  const baselineFile = join11(projectRoot, "config", "corpus-baseline.json");
+  const accepted = new Map;
+  try {
+    if (await Bun.file(baselineFile).exists()) {
+      const baseline = await Bun.file(baselineFile).json();
+      if (Array.isArray(baseline?.entries)) {
+        for (const e of baseline.entries) {
+          accepted.set(key(e), baselineSeverity(e));
+        }
+      }
+    }
+  } catch {}
+  return accepted;
+}
 var FOG_HEADING, OUT_OF_SCOPE_HEADING, FEATURE_ID, DEFAULT_BRANCHES;
 var init_corpus_check = __esm(() => {
   init_loader();
   init_dist5();
   init_dist2();
   init_feature_check();
+  init_planning_check_base();
   init_task_check();
   init_task_locator();
   FOG_HEADING = /^###\s+Not yet specified\b/;
@@ -74731,78 +74975,6 @@ var init_task_size_precheck = __esm(() => {
 
 // ../../packages/app/src/services/task-service.ts
 import { dirname as dirname14, isAbsolute as isAbsolute4, join as join16, relative as relative4 } from "path";
-function patchFrontmatterField(rendered, key2, value) {
-  const openIdx = rendered.indexOf("---");
-  if (openIdx === -1)
-    return rendered;
-  let fmStart = openIdx + 3;
-  if (rendered[fmStart] === "\r")
-    fmStart += 1;
-  if (rendered[fmStart] === `
-`)
-    fmStart += 1;
-  const closeRel = rendered.indexOf(`
----`, fmStart);
-  if (closeRel === -1)
-    return rendered;
-  const before = rendered.slice(0, fmStart);
-  const fm = rendered.slice(fmStart, closeRel);
-  const after = rendered.slice(closeRel);
-  const existingRe = new RegExp(`^${escapeRegex2(key2)}:.*$`, "m");
-  if (existingRe.test(fm)) {
-    const newFm = fm.replace(existingRe, () => `${key2}: ${value}`);
-    return before + newFm + after;
-  }
-  return `${before}${key2}: ${value}
-${fm}${after}`;
-}
-function escapeRegex2(s2) {
-  return s2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function renderCreatedTaskContent(params) {
-  let content = renderTaskTemplate(params.rawTemplate, {
-    NAME: params.name,
-    WBS: params.wbs,
-    BACKGROUND: params.background,
-    CREATED_AT: params.createdAt,
-    ...params.featureId !== undefined ? { FEATURE_ID: params.featureId } : {}
-  });
-  content = patchFrontmatterField(content, "status", params.status);
-  content = patchFrontmatterField(content, "template", params.variant);
-  if (params.featureId !== undefined) {
-    content = patchFrontmatterField(content, "feature_id", escapeYamlValue(params.featureId));
-  }
-  if (params.parentWbs !== undefined) {
-    content = patchFrontmatterField(content, "parent_wbs", escapeYamlValue(params.parentWbs));
-  }
-  if (params.priority !== undefined) {
-    content = patchFrontmatterField(content, "priority", params.priority);
-  }
-  if (params.tags !== undefined && params.tags.length > 0) {
-    content = patchFrontmatterField(content, "tags", `[${params.tags.map((tag) => JSON.stringify(tag)).join(", ")}]`);
-  }
-  const sectionPatches = {};
-  if ((params.requirements ?? "").trim() !== "") {
-    sectionPatches.Requirements = bulletizeRequirements(params.requirements ?? "");
-  }
-  if ((params.design ?? "").trim() !== "") {
-    sectionPatches.Design = (params.design ?? "").trim();
-  }
-  if ((params.plan ?? "").trim() !== "") {
-    sectionPatches.Plan = (params.plan ?? "").trim();
-  }
-  if ((params.acceptanceCriteria ?? "").trim() !== "") {
-    sectionPatches["Acceptance Criteria"] = normalizeAcFence((params.acceptanceCriteria ?? "").trim());
-  }
-  if (Object.keys(sectionPatches).length > 0) {
-    const doc2 = MarkdownDocument.parse(content, "task");
-    for (const [section, body] of Object.entries(sectionPatches)) {
-      doc2.replaceSection(section, body);
-    }
-    content = doc2.serialize();
-  }
-  return content;
-}
 function renderRosterTable(rows) {
   const header = `| WBS | Sub-task | Status |
 | --- | -------- | ------ |`;
@@ -74868,12 +75040,14 @@ class TaskService {
   }
   sectionsForStatus(variant, status) {
     const matrix = this.ctx.sectionMatrix;
-    const entry = matrix?.variants[variant]?.[status] ?? matrix?.variants.standard?.[status];
-    if (entry !== undefined) {
-      return [...entry.required ?? [], ...entry.optional ?? [], "History"];
+    if (matrix === undefined) {
+      throw new Error(`no section-matrix available for create (variant=${variant}, status=${status}); ` + "a canonical section-matrix.yaml is required for task creation (F92 R1)");
     }
-    const fallback = DEFAULT_CREATION_SECTIONS[status] ?? ["Background"];
-    return [...fallback, "History"];
+    const entry = matrix.variants[variant]?.[status] ?? matrix.variants.standard?.[status];
+    if (entry === undefined) {
+      throw new Error(`no section-matrix entry for variant="${variant}" status="${status}" during create; ` + "resolve the canonical section-matrix.yaml");
+    }
+    return [...entry.required ?? [], ...entry.optional ?? [], "References", "History"];
   }
   bodiesFor(variant, taskBodies) {
     const templateBodies = this.ctx.resolveTemplateBodies?.(variant) ?? {};
@@ -74918,22 +75092,6 @@ class TaskService {
       const slug = this.slugify(params.title);
       const { wbs, filePath } = await this.allocateWbsChecked(slug);
       const now2 = new Date().toISOString();
-      const rawTemplate = this.ctx.resolveTemplate?.(variant);
-      if (rawTemplate !== undefined) {
-        const content2 = renderCreatedTaskContent({
-          rawTemplate,
-          name: params.title,
-          wbs,
-          background,
-          createdAt: now2,
-          status,
-          variant,
-          featureId: params.featureId,
-          parentWbs: params.parentWbs
-        });
-        const ref2 = { kind: "task", id: wbs, filePath, folder };
-        return { ref: ref2, content: content2 };
-      }
       const frontmatter = [
         "schema_version: 1",
         `name: "${params.title}"`,
@@ -75431,28 +75589,6 @@ ${issues}`);
       const slug = this.slugify(item.name);
       const { wbs, filePath } = await this.allocateWbsChecked(slug);
       const now2 = new Date().toISOString();
-      const rawTemplate = this.ctx.resolveTemplate?.(variant);
-      if (rawTemplate !== undefined) {
-        const content2 = renderCreatedTaskContent({
-          rawTemplate,
-          name: item.name,
-          wbs,
-          background,
-          createdAt: now2,
-          status,
-          variant,
-          featureId: item.feature_id ?? undefined,
-          parentWbs: item.parent_wbs ?? undefined,
-          priority: item.priority,
-          tags: item.tags,
-          requirements: item.requirements,
-          design: item.design,
-          plan: item.plan,
-          acceptanceCriteria: item.acceptance_criteria
-        });
-        const ref2 = { kind: "task", id: wbs, filePath, folder };
-        return { ref: ref2, content: content2 };
-      }
       const fmLines = [
         "schema_version: 1",
         `name: "${item.name}"`,
@@ -75676,7 +75812,7 @@ ${block}` : block);
     return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
   }
 }
-var DependencyMutationError, SectionMutationError, DuplicateFollowUpError, WbsCollisionError, ROSTER_START = "<!-- AUTO-GENERATED by spur task refresh-roster -->", ROSTER_END = "<!-- END AUTO-GENERATED -->", ROSTER_REGION_RE, TASK_ACTION_COMMANDS, DEFAULT_CREATION_SECTIONS;
+var DependencyMutationError, SectionMutationError, DuplicateFollowUpError, WbsCollisionError, ROSTER_START = "<!-- AUTO-GENERATED by spur task refresh-roster -->", ROSTER_END = "<!-- END AUTO-GENERATED -->", ROSTER_REGION_RE, TASK_ACTION_COMMANDS;
 var init_task_service = __esm(() => {
   init_src2();
   init_errors7();
@@ -75734,10 +75870,6 @@ var init_task_service = __esm(() => {
     decompose: (wbs) => `/sp:dev-plan "Decompose task ${wbs} into implementation subtasks" --auto`,
     evaluate: (wbs) => `/sp:dev-review ${wbs} --auto`
   };
-  DEFAULT_CREATION_SECTIONS = {
-    backlog: ["Background"],
-    todo: ["Background", "Requirements", "Acceptance Criteria", "Q&A", "Design", "Plan"]
-  };
 });
 
 // ../../packages/app/src/services/task-verdict.ts
@@ -75749,20 +75881,13 @@ function deriveVerdict(answerText, taskCheckPassed) {
   if (requirements.length === 0) {
     return { verdict: "UNKNOWN", requirements, acceptanceCriteria, checks: checks4 };
   }
-  const hasUnmet = requirements.some((r) => r.status === "UNMET");
-  const hasUnmetAc = acceptanceCriteria.some((ac) => ac.status === "UNMET");
-  if (hasUnmet || hasUnmetAc) {
-    return { verdict: "FAIL", requirements, acceptanceCriteria, checks: checks4 };
-  }
-  const hasPartial = requirements.some((r) => r.status === "PARTIAL");
-  const hasPartialAc = acceptanceCriteria.some((ac) => ac.status === "PARTIAL");
-  if (hasPartial || hasPartialAc) {
-    return { verdict: "PARTIAL", requirements, acceptanceCriteria, checks: checks4 };
-  }
-  if (!taskCheckPassed) {
-    return { verdict: "PARTIAL", requirements, acceptanceCriteria, checks: checks4 };
-  }
-  return { verdict: "PASS", requirements, acceptanceCriteria, checks: checks4 };
+  const aggregate2 = aggregateVerifyVerdict({
+    requirements,
+    acceptanceCriteria,
+    checks: [],
+    taskCheckPassed
+  });
+  return { verdict: aggregate2, requirements, acceptanceCriteria, checks: checks4 };
 }
 function extractRequirements(text4) {
   const reqs = [];
@@ -75774,7 +75899,7 @@ function extractRequirements(text4) {
     const trimmed = line.trim();
     if (!trimmed.startsWith("|"))
       continue;
-    const cells = trimmed.split("|").map((c3) => c3.trim()).filter(Boolean);
+    const cells = splitTableCells(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);
@@ -75825,6 +75950,9 @@ function normalizeStatus(raw) {
     return "UNMET";
   return null;
 }
+function splitTableCells(row) {
+  return row.split(/(?<!\\)\|/).map((c3) => c3.replace(/\\\|/g, "|").trim()).filter(Boolean);
+}
 function extractAcceptanceCriteria(text4) {
   const rows = [];
   const dropped = [];
@@ -75833,9 +75961,13 @@ function extractAcceptanceCriteria(text4) {
   let inTable = false;
   for (const line of lines) {
     const trimmed = line.trim();
+    if (inTable && /^#{1,6}\s/.test(trimmed)) {
+      inTable = false;
+      continue;
+    }
     if (!trimmed.startsWith("|"))
       continue;
-    const cells = trimmed.split("|").map((c3) => c3.trim()).filter(Boolean);
+    const cells = splitTableCells(trimmed);
     if (!inTable && cells.length >= 4) {
       const h0 = (cells[0] ?? "").toLowerCase();
       const h1 = (cells[1] ?? "").toLowerCase();
@@ -75931,7 +76063,7 @@ function extractChecks(_text, taskCheckPassed, acceptanceCriteria, droppedAcRows
     const trimmed = line.trim();
     if (!trimmed.startsWith("|"))
       continue;
-    const cells = trimmed.split("|").map((c3) => c3.trim()).filter(Boolean);
+    const cells = splitTableCells(trimmed);
     if (cells.length >= 2) {
       const h0 = (cells[0] ?? "").toLowerCase();
       const h1 = (cells[1] ?? "").toLowerCase();
@@ -75999,6 +76131,7 @@ function aggregateBatchVerdicts(results) {
 }
 var EVIDENCE_TYPE_PRECEDENCE, NOT_STARTED_STATUSES;
 var init_task_verdict = __esm(() => {
+  init_verify_verdict();
   EVIDENCE_TYPE_PRECEDENCE = ["test", "command", "static-ref", "manual-review", "llm-judge", "n/a"];
   NOT_STARTED_STATUSES = {
     backlog: true,
@@ -79461,6 +79594,7 @@ __export(exports_src2, {
   parseEtimeToSeconds: () => parseEtimeToSeconds,
   normalizeSystemEventPayload: () => normalizeSystemEventPayload,
   normalizeProjectPath: () => normalizeProjectPath,
+  loadAcceptedFindings: () => loadAcceptedFindings,
   isSystemEventEnvelopeV2: () => isSystemEventEnvelopeV2,
   isPortLive: () => isPortLive,
   isPortAvailable: () => isPortAvailable,
@@ -79594,6 +79728,7 @@ var init_src3 = __esm(() => {
   init_anchor_qualifier();
   init_corpus_check();
   init_corpus_migrator();
+  init_done_transition_guard();
   init_event_names();
   init_failure_classification();
   init_feature_check();
@@ -87871,7 +88006,7 @@ import { createRequire } from "module";
 var CLI_CONFIG = {
   binaryName: "spur",
   binaryLabel: "spur",
-  binaryVersion: "0.3.50",
+  binaryVersion: "0.3.52",
   configDir: ".spur",
   configFile: ".spur/config.yaml",
   databaseFile: ".spur/spur.db"
@@ -98238,7 +98373,8 @@ function createServerContext(appRt, options) {
           writeService: new PlanningWriteService({ fs: fs3, projectName: "spur", emitter: lazyEmitter }),
           tasksDir: folders.tasksDir,
           foldersConfig: folders.foldersConfig,
-          projectName: "spur"
+          projectName: "spur",
+          ...options.sectionMatrix !== undefined ? { sectionMatrix: options.sectionMatrix } : {}
         });
       }
       return taskSvc;
@@ -98418,6 +98554,27 @@ async function openUrl(url2, deps = {}) {
 
 // ../server/src/serve.ts
 init_src3();
+async function loadServerSectionMatrix() {
+  const cwd = process.cwd();
+  const nodeFs = createNodeFileSystem3(cwd);
+  const localPath = nodeFs.resolve(".spur", "tasks", "section-matrix.yaml");
+  if (await nodeFs.exists(localPath)) {
+    return await loadStructuredSpurConfig(localPath, { validateJsonSchema: false });
+  }
+  const root = bundledConfigRoot();
+  if (root !== null) {
+    const matrixPath = join27(root, "tasks", "section-matrix.yaml");
+    if (await nodeFs.exists(matrixPath)) {
+      return await loadStructuredSpurConfig(matrixPath, {
+        validateJsonSchema: false
+      });
+    }
+  }
+  throw new Error(`no canonical section-matrix found for task creation (F92 R1); tried:
+` + `  - ${localPath}
+` + (root !== null ? `  - ${join27(root, "tasks", "section-matrix.yaml")}
+` : "") + "copy/generate section-matrix.yaml from the canonical build-time matrix asset (repo `config` `tasks` tree) into one of those paths");
+}
 var SYSTEM_EVENTS_PRUNE_JOB = "system-events-prune";
 var SMOKE_JOB = "smoke";
 var TASK_ACTION_JOB = "task-action";
@@ -98589,6 +98746,7 @@ async function startServer(options, deps = defaultDeps) {
         fs: fs3,
         dbUrl: options.dbUrl,
         folders: await resolvePlanningFolders(fs3),
+        sectionMatrix: await loadServerSectionMatrix(),
         webDistPath,
         jobQueueEnabled: bootConfig.jobqueue.enabled,
         scheduler: scheduler3,
@@ -99871,7 +100029,8 @@ ${result.content}`);
   task.command("update").summary("Update a task status or replace a section.").argument("<wbs>", "Task WBS number").argument("[status]", "New status (for lifecycle transition)").addHelpText("after", [
     "Lifecycle: `task update <wbs> <status>` moves a task through",
     "backlog \u2192 todo \u2192 wip \u2192 testing \u2192 done, running the lifecycle guards on",
-    "`wip \u2192 testing` (`spur task check`) and `testing \u2192 done` (`--strict-core`).",
+    "`wip \u2192 testing` (`spur task check --as testing`) and `testing \u2192 done`",
+    "(`spur task check --as done`) \u2014 each guard evaluates the transition target (F92 R3).",
     "A GuardDeniedError on `testing \u2192 done` means no pipeline run is recorded for the",
     "task: run `/sp:dev-verify <wbs> --next` to PASS it, or record the audited bypass with",
     '`SPUR_PROVENANCE_OVERRIDE=1 spur task update <wbs> done --force-done --reason "\u2026"`.',
@@ -99913,7 +100072,7 @@ ${result.content}`);
             if (options.lifecycle !== false) {
               context4.output.error(`warning: lifecycle adapter unavailable \u2014 running \`spur task check\` inline as the ${status} gate. ` + "Restore the bundled task-lifecycle workflow to re-enable the real guard.");
             }
-            const ok = await runDoneGateCheck(context4, wbs, options.folder);
+            const ok = await runDoneGateCheck(context4, wbs, options.folder, status);
             if (!ok) {
               context4.output.error(`Lifecycle transition blocked: \`spur task check ${wbs}\` failed. Fix the findings before transitioning to ${status}.`);
               context4.setExitCode(1);
@@ -100376,9 +100535,20 @@ ${result.content}`);
       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("--strict", "Elevate ALL warnings to failures").option("--strict-core", "Gate variant: fail only on hard-core errors (the testing\u2192done guard)").option("--corpus", "Sweep every task and feature against config/corpus-baseline.json").option("--since <ref>", "Scope the corpus fog check to changes since a git ref (requires --corpus)").option("--folder <path>", "Custom tasks folder").option("--json", "Output machine-readable JSON").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("--strict", "Elevate ALL warnings to failures").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("--as <status>", "Evaluate the task AS if it were in <status> (F92 R2): the lifecycle guards pass the transition target so testing\u2192done checks the done row. Validate against canonical task statuses. Omitted \u2192 current-status diagnostics.").option("--corpus", "Sweep every task and feature against config/corpus-baseline.json").option("--since <ref>", "Scope the corpus fog check to changes since a git ref (requires --corpus)").option("--folder <path>", "Custom tasks folder").option("--json", "Output machine-readable JSON").action(async (wbs, options) => {
     const json3 = options.json === true;
     const strict = options.strict === true;
+    const asStatus = options.as === undefined ? undefined : canonicalStatusOrRaw(options.as);
+    if (options.as !== undefined && !TASK_STATUSES.includes(asStatus ?? "")) {
+      context4.output.error(`invalid --as status "${options.as}" (canonical: ${TASK_STATUSES.join(", ")})`);
+      context4.setExitCode(2);
+      return;
+    }
+    if (asStatus !== undefined && options.corpus === true) {
+      context4.output.error("--as <status> is a single-task target projection and cannot be combined with --corpus");
+      context4.setExitCode(2);
+      return;
+    }
     try {
       if (options.corpus === true) {
         if (wbs !== undefined) {
@@ -100429,6 +100599,7 @@ ${result.content}`);
       }
       const svc = await makeCheckService(context4);
       const planningFolders = await resolvePlanningFolders(context4.fs);
+      const accepted = await loadAcceptedFindings(context4.cwd);
       const activeFolder = planningFolders.foldersConfig.active_folder;
       const tasksDir = context4.fs.resolve(options.folder ?? activeFolder);
       const printResult = (result) => {
@@ -100454,7 +100625,9 @@ ${result.wbs} (${result.status}): ${result.pass ? "PASS" : "FAIL"}`);
         } else {
           const result = await svc.check(hit.filePath, wbs, {
             strict,
-            severityOverrides: planningFolders.severityOverrides
+            asStatus,
+            severityOverrides: planningFolders.severityOverrides,
+            accepted
           });
           results.push(result);
           printResult(result);
@@ -100471,7 +100644,9 @@ ${result.wbs} (${result.status}): ${result.pass ? "PASS" : "FAIL"}`);
           }
           const result = await svc.check(`${tasksDir}/${fileName}`, w, {
             strict,
-            severityOverrides: planningFolders.severityOverrides
+            asStatus,
+            severityOverrides: planningFolders.severityOverrides,
+            accepted
           });
           results.push(result);
           printResult(result);
@@ -100610,36 +100785,10 @@ async function makeService2(context4, folderOverride, noLifecycle = false) {
     writeService,
     getDb: () => context4.getDb(),
     sectionMatrix: await loadSectionMatrix(context4.cwd),
-    resolveTemplate: (variant) => loadTemplateContent(context4.cwd, variant),
     resolveTemplateBodies: (variant) => loadTemplateBodies(context4.cwd, variant),
     foldersConfig
   });
 }
-var templateContentCache = new Map;
-var templateMissSet = new Set;
-function loadTemplateContent(projectRoot, variant) {
-  if (templateContentCache.has(variant))
-    return templateContentCache.get(variant);
-  if (templateMissSet.has(variant))
-    return;
-  const localPath = join30(projectRoot, ".spur", "tasks", "templates", `${variant}.md`);
-  if (existsSync11(localPath)) {
-    const content = readFileSync10(localPath, "utf8");
-    templateContentCache.set(variant, content);
-    return content;
-  }
-  const root = bundledConfigRoot();
-  if (root !== null) {
-    const templatePath = join30(root, "templates", "task", `${variant}.md`);
-    if (existsSync11(templatePath)) {
-      const content = readFileSync10(templatePath, "utf8");
-      templateContentCache.set(variant, content);
-      return content;
-    }
-  }
-  templateMissSet.add(variant);
-  return;
-}
 var templateBodiesCache = new Map;
 function loadTemplateBodies(projectRoot, variant) {
   const cached2 = templateBodiesCache.get(variant);
@@ -100672,15 +100821,22 @@ async function makeTaskLocator(context4) {
 async function makeCheckService(context4) {
   return new TaskCheckService(context4.fs, await loadSectionMatrix(context4.cwd), await makeTaskLocator(context4));
 }
-async function runDoneGateCheck(context4, wbs, folderOverride) {
-  const foldersConfig = (await resolvePlanningFolders(context4.fs)).foldersConfig;
+async function runDoneGateCheck(context4, wbs, folderOverride, targetStatus) {
+  const planningFolders = await resolvePlanningFolders(context4.fs);
+  const foldersConfig = planningFolders.foldersConfig;
   const tasksDir = folderOverride ?? context4.fs.resolve(foldersConfig.active_folder);
   const hit = await new TaskLocator({ fs: context4.fs, tasksDir, foldersConfig }).findByWbs(wbs);
   if (!hit) {
     return false;
   }
   const svc = new TaskCheckService(context4.fs, await loadSectionMatrix(context4.cwd), await makeTaskLocator(context4));
-  const result = await svc.check(hit.filePath, wbs, { strict: false });
+  const accepted = await loadAcceptedFindings(context4.cwd);
+  const result = await svc.check(hit.filePath, wbs, {
+    strict: false,
+    asStatus: targetStatus,
+    severityOverrides: planningFolders.severityOverrides,
+    accepted
+  });
   return result.pass;
 }
 var sectionMatrixCache = new Map;
@@ -100714,16 +100870,11 @@ async function loadSectionMatrixUncached(projectRoot) {
       return data;
     }
   }
-  return FALLBACK_MATRIX;
+  throw new Error(`no canonical section-matrix found for task section authority (F92 R1); tried:
+` + `  - ${localPath}
+` + (root !== null ? `  - ${join30(root, "tasks", "section-matrix.yaml")}
+` : "") + "copy/generate section-matrix.yaml from the canonical build-time matrix asset (repo `config` `tasks` tree) into one of those paths");
 }
-var FALLBACK_MATRIX = {
-  variants: {
-    standard: {
-      backlog: { required: ["Background"], forbidden: ["Solution", "Review", "Testing"] },
-      done: { required: ["Solution", "Testing", "Review"], gate: true }
-    }
-  }
-};
 
 // src/commands/team.ts
 init_src3();