@gobing-ai/spur 0.3.86 → 0.3.87

package/plugins/sp/skills/taste-refactoring-api/SKILL.md

@@ -1,6 +1,18 @@
 ---
 name: taste-refactoring-api
 description: Design, review, and refactor REST/HTTP, RPC/gRPC, GraphQL, and event API contracts safely.
+license: Apache-2.0
+metadata:
+  author: spur
+  version: "1.0"
+  platforms: "claude-code,codex,openclaw,opencode,antigravity"
+  category: execution
+  interactions:
+    - technique
+  operations:
+    - refactor-apis
+  openclaw:
+    emoji: "🔌"
 ---
 
 # taste-refactoring-api
@@ -174,7 +186,7 @@ The goal is to eliminate repeated low-level API decisions, not to create bureauc
 
 ## Protocol-specific review
 
-After classifying the API, read the matching REST/HTTP, RPC/gRPC, GraphQL, or event/webhook section in [references/protocol-modes.md](references/protocol-modes.md). Apply that checklist before continuing with the refactoring strategy.
+After classifying the API, read the matching REST/HTTP, RPC/gRPC, GraphQL, or event/webhook section in [references/protocol-modes.md](references/protocol-modes.md). Apply that checklist before continuing with the refactoring strategy. For command-line surface work (designing or reviewing a CLI), read the [CLI mode](references/protocol-modes.md) section instead — a CLI is a contract surface with the same compatibility duties as any wire protocol.
 
 ## Refactoring strategy
 
@@ -332,3 +344,34 @@ Specify the tests/checks needed: contract tests, schema validation, compatibilit
 ## Decision rule
 
 A “better” API is not the one with the prettiest route names. It is the one that makes common client code obvious, predictable, safe under failure, compatible over time, secure by default, and operable in production.
+
+## Spur contract
+
+Machine-facing adapter for `sp:code-refactoring` dispatch (feature H13). Everything above is the
+lens's native output and is unchanged; this section only maps it to the shared finding schema.
+
+**Inputs received:** a scope path, an optional change description, and the `api` focus. Read
+first: the classification and protocol section above (plus [references/protocol-modes.md](references/protocol-modes.md)),
+then `../code-refactoring/references/finding-schema.md` for shared field semantics.
+
+**Native finding → schema mapping:** each “Highest-impact refactor” item → `id` as
+`RF-api-<nnn>`; the item's compatibility label → `rung` verbatim (`additive` | `risky` |
+`breaking`); consumer impact → `title` and `proposal` (imperative); cited routes/lines →
+`evidence` as `{file, line}` entries inside scope; `Verification` items → `verify`; the
+“Proposed contract” snippets stay in `proposal`; new findings start at `status: open`.
+
+**Severity mapping (design §5):** a `breaking` change already shipped, or contract ambiguity that
+corrupts data → `P1`; a `risky` inconsistency across ≥2 endpoints → `P2`; `additive` cleanups →
+`P3`; naming/docs → `P4`.
+
+**Preserved-behavior inventory (required before proposals):** emit the consumer contract —
+audience (public/partner/internal/service-to-service), endpoints/operations in scope, existing
+clients that must remain compatible, and the compatibility promise — before the first finding.
+
+**Preservation class (reuses the native classification):** `additive` → `preserving`; `risky`
+and `breaking` → `breaking`; removal of an endpoint, field, or code path with callers →
+`cutting` even when the change reads additive to remaining consumers.
+
+**Stop rules:** an established style guide or public compatibility promise is a constraint, not
+suggestion; `cutting`/`breaking` is never below `P2` and never `fix_eligibility: auto`; risky and
+breaking changes carry a migration strategy; anything outside the scope path is not a finding.

package/plugins/sp/skills/taste-refactoring-api/references/protocol-modes.md

@@ -77,3 +77,34 @@ For mutation races, prefer explicit optimistic concurrency such as ETags / `If-M
 - Make consumers tolerant of additive fields.
 - Do not use events as disguised synchronous RPC responses when the caller needs an immediate result.
 
+## CLI mode
+
+A command-line interface is a contract surface with consumers (scripts, other agents, CI), not a
+collection of convenience shortcuts. Review it with the same compatibility discipline as REST or
+gRPC. Spur's own `apps/cli` is the first target.
+
+**Noun/verb grammar:** keep one noun per domain and verbs per action (`spur task show`, not
+`spur showTaskForTask`). Do not introduce a second grammar for the same concept — one spelling per
+noun, one verb per operation, consistent object order.
+
+**Flag vocabulary consistency:** shared flags (`--json`, `--scope`, `--agent`, `--fix`) keep the
+same name, arity, and semantics everywhere they appear. A flag that means something new per
+command is a defect; declare a new flag instead.
+
+**Exit codes:** `0` = success, nonzero = failure, deterministic and machine-checkable. Never
+swallow failures into `0`; never return nonzero for advisory output. Validation errors and
+runtime failures should be distinguishable from output where practical.
+
+**`--json` envelope stability:** `--json` output is a public schema. Add fields additively; never
+remove or rename existing fields, never change a field's type, and emit no human decoration
+(banners, progress text) on the JSON stream. Machine consumers parse the documented envelope only.
+
+**Help-text parity:** every accepted flag appears in `--help` with its real arity and default;
+every documented example runs as printed. A flag that works but is not documented, or documented
+but rejected, is a parity break.
+
+**Additive vs breaking:** adding a noun, verb, flag, or output field is additive. Renaming or
+removing any of them, re-purposing a flag, changing a default, or altering existing output shape
+is breaking — it requires a migration path and a deprecation window, and it never rides in a
+patch release.
+

package/plugins/sp/skills/taste-refactoring-architect/SKILL.md

@@ -1,6 +1,18 @@
 ---
 name: taste-refactoring-architect
 description: Review, simplify, and refactor system architecture toward minimum sufficient architecture while preserving required capabilities, quality attributes, delivery safety, and data invariants. Backs architectural refactoring and boundary reviews.
+license: Apache-2.0
+metadata:
+  author: spur
+  version: "1.0"
+  platforms: "claude-code,codex,openclaw,opencode,antigravity"
+  category: execution
+  interactions:
+    - technique
+  operations:
+    - refactor-architecture
+  openclaw:
+    emoji: "🏛️"
 ---
 
 # taste-refactoring-architect
@@ -469,3 +481,34 @@ Do not block on perfect documentation. Produce:
 - decisions that can safely proceed now.
 
 Use A7 DEFER/OBSERVE when evidence is too weak for a structural change.
+
+## Spur contract
+
+Machine-facing adapter for `sp:code-refactoring` dispatch (feature H13). Everything above is the
+lens's native output and is unchanged; this section only maps it to the shared finding schema.
+
+**Inputs received:** a scope path, an optional change description, and the `architect` focus.
+Read first: the intervention ladder and workflow above, then
+`../code-refactoring/references/finding-schema.md` for shared field semantics.
+
+**Native finding → schema mapping:** `ID` → `id` as `RF-architect-<nnn>`; `Action` (A0–A7) →
+`rung` verbatim; `Observation`/`Why it matters` → `title` plus `proposal` (imperative); `Evidence`
+→ `evidence` as `{file, line}` entries inside scope; `Fitness functions` → `verify`; new findings
+start at `status: open`. ADR candidates and migration plans stay prose findings with
+`fix_eligibility: suggest`.
+
+**Severity mapping (design §5):** any axis ≤1 with a correctness/safety consequence → `P1`; axis
+≤2 or A5–A7 seam problems → `P2`; A3–A4 → `P3`; A0–A2, ADR candidates, deferred questions → `P4`.
+
+**Preserved-behavior inventory (required before proposals):** emit the Preservation Contract
+table — capabilities, quality attributes, data invariants, and their thresholds — for everything
+in scope before the first finding.
+
+**Preservation class:** A0/A3/A4 mechanical consolidations with identical behavior →
+`preserving`; A1/A2 removal of a live service, endpoint, queue, or code path with callers →
+`cutting`; A5–A7 seam or behavior changes → `breaking`; migration plans and ADR candidates →
+`preserving` prose with `fix_eligibility: suggest`.
+
+**Stop rules:** no removal without dependency/traffic/contract evidence; `cutting`/`breaking` is
+never below `P2` and never `fix_eligibility: auto`; multi-task migrations are `suggest`, applied
+only after an explicit operator answer; anything outside the scope path is not a finding.

package/plugins/sp/skills/taste-refactoring-tests/SKILL.md

@@ -1,6 +1,18 @@
 ---
 name: taste-refactoring-tests
 description: Refactor unit tests for failure sensitivity, deterministic confidence, and regression protection without mock-heavy brittle tests or vanity coverage. Backs test suite quality audits.
+license: Apache-2.0
+metadata:
+  author: spur
+  version: "1.0"
+  platforms: "claude-code,codex,openclaw,opencode,antigravity"
+  category: execution
+  interactions:
+    - technique
+  operations:
+    - refactor-tests
+  openclaw:
+    emoji: "🧪"
 ---
 
 # taste-refactoring-tests
@@ -480,3 +492,33 @@ A test refactor is complete only when:
 - delivery speed is not degraded without a justified risk trade-off.
 
 The goal is **earned confidence**: green means something because the suite has demonstrated that it can turn red when the product is wrong.
+
+## Spur contract
+
+Machine-facing adapter for `sp:code-refactoring` dispatch (feature H13). Everything above is the
+lens's native output and is unchanged; this section only maps it to the shared finding schema.
+
+**Inputs received:** a scope path, an optional change description, and the `tests` focus. Read
+first: the intervention ladder, Confidence Contract, and review severity above, then
+`../code-refactoring/references/finding-schema.md` for shared field semantics.
+
+**Native finding → schema mapping:** `ID` → `id` as `RF-tests-<nnn>`; `Action` (T0–T7) → `rung`
+verbatim; `Severity` → `severity` via the map below; `Evidence` → `evidence` as `{file, line}`
+entries inside scope; `Why it matters` → `title`; `Proposed change` → `proposal` (imperative);
+`Expected regression-detection improvement` → folded into `proposal`; new findings start at
+`status: open`.
+
+**Severity mapping (design §5):** native P0 → `P1`; P1 → `P2`; P2 → `P3`; P3 → `P4`.
+
+**Preserved-behavior inventory (required before proposals):** emit the Confidence Contract —
+critical business rules, compatibility contracts, authorization/security decisions, data
+integrity invariants, error semantics, and incident regressions the suite must keep protecting —
+before the first finding.
+
+**Preservation class:** T0 and rungs that keep or add protection (fixture cleanup, adding a
+missing test) → `preserving`; removing a test or test file (T1) → `cutting`; weakening or
+semantically changing existing assertions → `breaking`.
+
+**Stop rules:** unknown protection is a risk, never permission to delete; a `cutting`/`breaking`
+finding is never `fix_eligibility: auto` and never below `P2`; tests are never removed or
+weakened by an `auto` fix; anything outside the scope path is not a finding.

package/plugins/sp/skills/taste-refactoring-ui/SKILL.md

@@ -1,6 +1,18 @@
 ---
 name: taste-refactoring-ui
 description: Design, review, and refactor UI hierarchy, layout, typography, spacing, color, and interactions.
+license: Apache-2.0
+metadata:
+  author: spur
+  version: "1.0"
+  platforms: "claude-code,codex,openclaw,opencode,antigravity"
+  category: execution
+  interactions:
+    - technique
+  operations:
+    - refactor-ui
+  openclaw:
+    emoji: "🎨"
 ---
 
 # taste-refactoring-ui
@@ -288,3 +300,34 @@ For deeper reasoning and daily use, read:
 - `references/refactoring-ui-playbook.md` — chapter-by-chapter distilled guidance.
 - `checklists/daily-ui-review.md` — fast audit and ship checklist.
 - `examples/review-template.md` — reusable UI critique response structure.
+
+## Spur contract
+
+Machine-facing adapter for `sp:code-refactoring` dispatch (feature H13). Everything above is the
+lens's native output and is unchanged; this section only maps it to the shared finding schema.
+
+**Inputs received:** a scope path, an optional change description, and the `ui` focus. Read
+first: the refactoring protocol and output contract above, then
+`../code-refactoring/references/finding-schema.md` for shared field semantics.
+
+**Native finding → schema mapping:** each issue → `id` as `RF-ui-<nnn>`; the pass that owns it
+(hierarchy, spacing, typography, color, states) → `rung`; `Observation` + `Refactor` → `title`
+and `proposal` (imperative); the cited component/file and line → `evidence` as `{file, line}`
+entries inside scope; the `System rule` → folded into `proposal`; new findings start at
+`status: open`.
+
+**Severity mapping (design §5):** native P0 (task failure) → `P1`; P1 (hierarchy/structure) →
+`P2`; P2 (system inconsistency) → `P3`; P3 (polish) → `P4`.
+
+**Preserved-behavior inventory (required before proposals):** emit the controls and interactions
+in scope — primary/secondary actions, navigation, form semantics, accessible names, states —
+before the first finding.
+
+**Preservation class:** token normalization and layout/typography consolidation with identical
+function → `preserving`; adding a missing state or a11y attribute → `preserving`; removing or
+merging a control or interaction → `cutting`; changes to user-visible flows or behavior →
+`breaking`.
+
+**Stop rules:** meaning is never carried by color alone; preserve component semantics and
+accessibility; a `cutting`/`breaking` finding is never `fix_eligibility: auto` and never below
+`P2`; anything outside the scope path is not a finding.

package/schemas/task-batch.schema.json

@@ -20,7 +20,7 @@
             },
             "requirements": {
                 "type": "string",
-                "description": "R-numbered requirement items (R1. R2. …) — a referenceable list."
+                "description": "Pre-filled ### Requirements body: one R-item per line, exactly `- [ ] R1. <text>` (checkbox + `R<n>.`); any other form fails `spur task check`."
             },
             "design": {
                 "type": "string",
@@ -32,7 +32,7 @@
             },
             "acceptance_criteria": {
                 "type": "string",
-                "description": "Pre-filled ### Acceptance Criteria body (Gherkin or checklist)."
+                "description": "Pre-filled ### Acceptance Criteria body: items numbered AC1, AC2, … (never R<n>, the Requirements namespace): `- [ ] AC1 — <feature scenario title without its R-number>` bullets or `Scenario: AC1 — <title>` blocks (L4.uncovered-task-scenario matches the title after the prefix); `(req: R<n>)` binds a task requirement; task-only checks go in prose after the bullets."
             },
             "feature_id": {
                 "type": "string",

package/spur.js

@@ -60176,12 +60176,12 @@ function stripScenarioPrefixes(title) {
   let previous;
   do {
     previous = out;
-    out = out.replace(/^\[[^\]]*\]\s*/, "").replace(/\s*\[[^\]]*\]\s*$/, "").replace(/^Scenario:\s*/i, "").replace(/^R\d+\s*[:\-\u2014]?\s*/, "").trim();
+    out = out.replace(/^\[[^\]]*\]\s*/, "").replace(/\s*\[[^\]]*\]\s*$/, "").replace(/^Scenario:\s*/i, "").replace(/^(?:AC|R)\d+\.?\s*[:\-\u2014]?\s*/, "").replace(/\s*\(req:[^)]*\)/i, " ").trim();
   } while (out !== previous);
   return out;
 }
 function normalizeTitle(title) {
-  return stripScenarioPrefixes(title).replace(/^(R\d+)\s*[:\-\u2014]?\s*/, "").trim().toLowerCase().replace(/[\u0027\u2018\u2019\u201c\u201d]/g, "").replace(/\s+/g, " ").trim();
+  return stripScenarioPrefixes(title).replace(/^(?:AC|R)\d+\.?\s*[:\-\u2014]?\s*/, "").trim().toLowerCase().replace(/[\u0027\u2018\u2019\u201c\u201d]/g, "").replace(/\s+/g, " ").trim();
 }
 function stripCoversClause(text3) {
   return text3.replace(new RegExp(COVERS_RE_SOURCE, "gi"), " ").replace(/\s+/g, " ").trim();
@@ -60680,6 +60680,13 @@ class ActionRunDao {
   constructor(db2) {
     this.db = db2;
   }
+  async completedAtById(id) {
+    const row = await this.db.queryFirst("SELECT completed_at FROM action_runs WHERE id = ?", id);
+    return row?.completed_at ?? null;
+  }
+  async setStartedAt(id, startedAt) {
+    await this.db.run("UPDATE action_runs SET started_at = ? WHERE id = ?", startedAt, id);
+  }
   async actionRowsByRunId(runId) {
     try {
       return await this.db.queryAll("SELECT id, node, kind, status, duration_ms, ok, result_json, started_at, completed_at, created_at FROM action_runs WHERE run_id = ? ORDER BY created_at", runId);
@@ -79285,11 +79292,14 @@ function hasAdjacentFileLineColumns(body) {
   }
   return false;
 }
+function hasGateLanguage(body) {
+  return /(?<![\w-])(HITL|human[- ]in[- ]the-loop|approval|approved|merge event|merged|content-gate|GATED|capstone)(?![\w-])/i.test(body);
+}
 function hasSolutionFileLineCitation(body) {
   const hasFileLine = /`[^`]+?:\d+(-\d+)?`/.test(body) || /[^\s`]\.\w+:\d+/.test(body);
   return hasFileLine || hasAdjacentFileLineColumns(body);
 }
-var TESTING_VERDICT_STUB_RE, EXTERNAL_EVIDENCE_RE, TaskCheckService;
+var TESTING_VERDICT_STUB_RE, EXTERNAL_EVIDENCE_RE, GATE_LANGUAGE_SECTIONS, TaskCheckService;
 var init_task_check = __esm(() => {
   init_src2();
   init_planning_check_base();
@@ -79298,6 +79308,7 @@ var init_task_check = __esm(() => {
   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;
+  GATE_LANGUAGE_SECTIONS = ["Background", "Requirements", "Design", "Acceptance Criteria", "Plan"];
   TaskCheckService = class TaskCheckService extends PlanningCheckService {
     locator;
     constructor(fs3, matrix, locator) {
@@ -79449,9 +79460,17 @@ var init_task_check = __esm(() => {
           if (s2 === null)
             continue;
           scenarioCount++;
-          const id = /^R(\d+)\b/.exec((s2[1] ?? "").trim());
-          if (id?.[1] !== undefined)
-            acIds.add(id[1]);
+          const title = (s2[1] ?? "").trim();
+          const req = /\(req:\s*([^)]*)\)/i.exec(title);
+          if (req?.[1] !== undefined) {
+            for (const m of req[1].matchAll(/\bR(\d+)\b/g))
+              if (m[1] !== undefined)
+                acIds.add(m[1]);
+          } else {
+            const id = /^R(\d+)\b/.exec(title);
+            if (id?.[1] !== undefined)
+              acIds.add(id[1]);
+          }
         }
         const byNumber = (a2, b) => Number(a2) - Number(b);
         if (reqIds.size > 0 && scenarioCount > 0 && acIds.size === 0) {
@@ -79460,7 +79479,7 @@ var init_task_check = __esm(() => {
             code: FINDING_CODES.L3_AC_REQUIREMENT_COVERAGE,
             severity: "warning",
             section: "Acceptance Criteria",
-            message: "ac_numbering is task-local but no scenario is R-numbered \u2014 prefix each scenario with the requirement it covers (Scenario: R1 \u2014 \u2026)"
+            message: "ac_numbering is task-local but no scenario binds a requirement \u2014 add `(req: R1)` to each `Scenario: AC<n> \u2014 \u2026` title (legacy: `Scenario: R1 \u2014 \u2026`)"
           });
         } else if (reqIds.size > 0 && acIds.size > 0) {
           const uncovered = [...reqIds].filter((id) => !acIds.has(id)).sort(byNumber);
@@ -79856,11 +79875,11 @@ var init_task_check = __esm(() => {
       const declaredDeps = doc2.frontmatterData?.dependencies;
       if (Array.isArray(declaredDeps) && declaredDeps.length > 0)
         return;
-      for (const section of ["Background", "Requirements", "Design", "Acceptance Criteria", "Plan"]) {
+      for (const section of GATE_LANGUAGE_SECTIONS) {
         const body = doc2.getSection(section);
         if (body === null)
           continue;
-        if (/(?<![\w-])(HITL|human[- ]in[- ]the-loop|approval|approved|merge event|merged|content-gate|GATED|capstone)(?![\w-])/i.test(body)) {
+        if (hasGateLanguage(body)) {
           findings.push({
             layer: "L4",
             code: FINDING_CODES.L4_GATE_LANGUAGE,
@@ -83097,7 +83116,17 @@ class FeatureService {
     }
     const raw = await this.ctx.fs.readFile(sourceFile);
     const body = stripLeadingSectionHeader(raw, sectionName);
-    return this.ctx.writeService.updateSection(ref, sectionName, body);
+    let result = await this.ctx.writeService.updateSection(ref, sectionName, body);
+    if (sectionName === "Acceptance Criteria" && body.trim().length > 0) {
+      const acBody = stripAcFence(body);
+      const looksGherkin = /^\s*(Feature:|Scenario:|Scenario Outline:)/m.test(acBody);
+      if (looksGherkin || parseChecklist(acBody).length === 0) {
+        const errors6 = validateAcceptanceCriteria(acBody).errors.map((e) => `L3.ac-bdd-error: BDD: ${e.message}`);
+        if (errors6.length > 0)
+          result = { ...result, warnings: [...result.warnings ?? [], ...errors6] };
+      }
+    }
+    return result;
   }
   async updateBody(id, body) {
     const ref = await this.refFor(id);
@@ -83649,6 +83678,8 @@ updated_at: "${now2}"
 ## Acceptance Criteria
 
 \`\`\`gherkin
+# Keep the Feature: line (feature check L3.ac-bdd-error without it). Each Scenario: title is the
+# identity key tasks reference verbatim ("- [ ] AC1 \u2014 <title>"); number R1, R2, \u2026; never rename after tasks link.
 Feature: ${name}
 
   Scenario: Basic acceptance
@@ -88049,24 +88080,30 @@ import { join as join22 } from "path";
 class WorkflowActionTraceWriter {
   inner;
   recordFailure;
+  db;
   boundaries = new Map;
-  constructor(inner, recordFailure) {
+  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);
-    await this.guard("action.finish", { runId: boundary2?.runId ?? "", node: boundary2?.node, kind }, () => this.inner.saveActionFinalize(actionId, status, durationMs, ok, kind, result, redactor));
+    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) {
@@ -88077,7 +88114,23 @@ class WorkflowActionTraceWriter {
     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));
-    return finish.ok ? { ok: true, actionId: start.value } : finish;
+    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) {
     const existing = await this.inner.loadRun(runId);
@@ -88149,7 +88202,7 @@ function withActionTrace(persistence2, recordFailure) {
   return new WorkflowActionTraceWriter(persistence2, recordFailure);
 }
 function createWorkflowActionTraceWriter(db2, recordFailure) {
-  return new WorkflowActionTraceWriter(new DbWorkflowPersistenceAdapter(db2), recordFailure);
+  return new WorkflowActionTraceWriter(new DbWorkflowPersistenceAdapter(db2), recordFailure, db2);
 }
 function createRunLogTraceFailureRecorder(cwd) {
   const fileSystem = createNodeFileSystem3();
@@ -88160,7 +88213,7 @@ function createRunLogTraceFailureRecorder(cwd) {
       failure.node !== undefined ? `node=${failure.node}` : "",
       failure.kind !== undefined ? `kind=${failure.kind}` : ""
     ].filter((part) => part !== "").join(" ");
-    const line = `[${failure.at}] trace-emission-failed operation=${failure.operation} run=${failure.runId}${location === "" ? "" : ` ${location}`}: ${failure.error}
+    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);
@@ -88172,6 +88225,7 @@ function createRunLogTraceFailureRecorder(cwd) {
 }
 var UNPERSISTED_PREFIX = "trace-unpersisted:", RunRowNotFoundError;
 var init_action_trace = __esm(() => {
+  init_src2();
   init_dist8();
   init_dist5();
   RunRowNotFoundError = class RunRowNotFoundError extends Error {
@@ -96514,7 +96568,16 @@ ${templateBackground}`;
     }
     const filePath = await this.resolveTaskFile(wbs);
     const ref = { kind: "task", id: wbs, filePath, folder: this.ctx.tasksDir };
-    return this.writeService.updateFrontmatter(ref, key2, value);
+    let result = await this.writeService.updateFrontmatter(ref, key2, value);
+    if (key2 === "feature_id") {
+      const ac = MarkdownDocument.parse(await this.ctx.fs.readFile(filePath), "task").getSection("Acceptance Criteria");
+      if (ac !== null && ac.trim().length > 0) {
+        const warnings = await this.checkAcSubsetWarning(filePath, ac);
+        if (warnings.length > 0)
+          result = { ...result, warnings: [...result.warnings ?? [], ...warnings] };
+      }
+    }
+    return result;
   }
   async mutateDependencies(wbs, op, values = []) {
     if (op === "clear") {
@@ -96728,22 +96791,41 @@ ${templateBackground}`;
       throw new SectionMutationError("invalid-solution", "Solution must contain at least one `file:line` citation");
     }
     const ref = { kind: "task", id: wbs, filePath, folder: this.ctx.tasksDir };
-    const result = await this.writeService.updateSection(ref, sectionName, body);
+    let result = await this.writeService.updateSection(ref, sectionName, body);
     if (sectionName === "Acceptance Criteria") {
       const warnings = await this.checkAcSubsetWarning(filePath, body);
       if (warnings.length > 0) {
-        return {
+        result = { ...result, warnings: [...result.warnings ?? [], ...warnings] };
+      }
+    }
+    if (GATE_LANGUAGE_SECTIONS.includes(sectionName) && hasGateLanguage(body)) {
+      const deps = MarkdownDocument.parse(await this.ctx.fs.readFile(filePath), "task").frontmatterData?.dependencies;
+      if (!Array.isArray(deps) || deps.length === 0) {
+        result = {
           ...result,
-          warnings: [...result.warnings ?? [], ...warnings]
+          warnings: [
+            ...result.warnings ?? [],
+            `L4.gate-language: ${sectionName} contains gate language (HITL/approval/approved/merged/\u2026) \u2014 say "operator answer"/"accepted", or model the gate as a frontmatter dependency`
+          ]
         };
       }
     }
     if (sectionName === "Requirements" || sectionName === "Plan") {
-      const report = evaluateTaskSize(await this.ctx.fs.readFile(filePath));
-      if (!report.ok) {
+      const written = await this.ctx.fs.readFile(filePath);
+      const warnings = [];
+      if (sectionName === "Requirements") {
+        for (const f of structuralFindings(written, "task")) {
+          if (f.code === FINDING_CODES.L3_REQUIREMENTS_CHECKBOX)
+            warnings.push(`${f.code}: ${f.message}`);
+        }
+      }
+      const report = evaluateTaskSize(written);
+      if (!report.ok)
+        warnings.push(...report.reasons);
+      if (warnings.length > 0) {
         return {
           ...result,
-          warnings: [...result.warnings ?? [], ...report.reasons]
+          warnings: [...result.warnings ?? [], ...warnings]
         };
       }
     }
@@ -97187,6 +97269,8 @@ var init_task_service = __esm(() => {
   init_dist();
   init_errors7();
   init_pipeline_run_link();
+  init_planning_check_base();
+  init_structural_repair();
   init_task_check();
   init_task_locator();
   init_task_record();
@@ -98439,6 +98523,7 @@ async function projectWorkflowProgress(runId, options) {
     group.push(row);
     actionsByNode[row.node] = group;
   }
+  const matchedActionRowIds = new Set;
   for (const { state: stateId, visit: visit2 } of stateVisits) {
     const defState = defStates.find((s3) => s3.id === stateId);
     const onEnterActions = Array.isArray(defState?.onEnter) ? defState.onEnter : [];
@@ -98474,6 +98559,8 @@ async function projectWorkflowProgress(runId, options) {
       const stateEffect = "may-write";
       const evidenceEffect = "none";
       const candidateRows = stateActionRows.filter((r) => r.kind === kind && !usedActionRowIds.has(r.id));
+      for (const r of candidateRows)
+        matchedActionRowIds.add(r.id);
       let actionStatus = "pending";
       const attempts = [];
       if (!isVisited) {
@@ -98550,6 +98637,14 @@ async function projectWorkflowProgress(runId, options) {
       });
     }
   }
+  for (const row of actionRows) {
+    if (!matchedActionRowIds.has(row.id)) {
+      diagnostics.push({
+        code: "orphan-action-row",
+        message: `Action row ${row.id} (node ${row.node}, kind ${row.kind}) matches no declared state action`
+      });
+    }
+  }
   return {
     schemaVersion: 1,
     runId,
@@ -108124,6 +108219,9 @@ ${result.content}`);
     '`spur task update <wbs> done --force-done --provenance-bypass --reason "\u2026"`.',
     "See the gate checklist (spur-dev/references/gate-checklists.md).",
     "Valid section names (no failed write): `spur task sections <wbs> list`.",
+    "Requirements body: one `- [ ] R1. <text>` per line. Acceptance Criteria body: `- [ ] AC1 \u2014 <feature",
+    "scenario title>` bullets or `Scenario: AC1 \u2014 <title>` blocks (AC<n> is task-local, never R<n>);",
+    "`(req: R<n>)` binds a requirement; `ac_altitude: task-local` exempts task-only AC.",
     'Sections replace, with one exception: `--section "Q&A"` APPENDS a timestamped',
     "`#### Q&A entry \u2014 <ISO>` block. Start the body with `<!-- qa:replace -->` to replace it wholesale."
   ].join(`
@@ -108172,6 +108270,9 @@ ${result.content}`);
         if (options.json) {
           context4.output.write(toEnvelopeJson(result, { enveloped: options.jsonEnvelope }));
         } else {
+          for (const warning of result.warnings ?? []) {
+            context4.output.error(warning);
+          }
           context4.output.write(`Set ${key2}=${value} on task ${result.ref.id}`);
         }
       } else if (status !== undefined) {
@@ -110776,7 +110877,7 @@ import { createRequire } from "module";
 var CLI_CONFIG = {
   binaryName: "spur",
   binaryLabel: "spur",
-  binaryVersion: "0.3.86",
+  binaryVersion: "0.3.87",
   configDir: ".spur",
   configFile: ".spur/config.yaml",
   databaseFile: ".spur/spur.db"