@gobing-ai/spur 0.3.60 → 0.3.62

package/plugins/sp/scripts/surface-drift-inventory.ts

@@ -1,9 +1,8 @@
 #!/usr/bin/env bun
 /**
  * surface-drift-inventory — re-runnable drift inventory for `plugins/sp` and
- * the tracked workflow-YAML SSOT tree (`.spur/workflows` symlink target)
- * against the live source-local `spur` CLI
- * (feature I3, task 0539 R1/R2).
+ * the tracked workflow-YAML SSOT tree against the live
+ * source-local `spur` CLI (feature I3, task 0539 R1/R2).
  *
  * Method (mechanical first, prose second — task 0539 Design):
  *   A. Plugin assertions: extract every `spur`-invocation (backticked spans, fenced
@@ -19,7 +18,7 @@
  *      in this repo — recorded unverified.
  *   D. Workflows: `spur workflow validate` (live engine, schema + semantic) and a
  *      `--dry-run` transition walk for all ten definitions; `.spur/workflows`
- *      symlink realpath vs its tracked SSOT target tree.
+ *      symlink is asserted absent (two-tier project→bundled model, task 0650).
  *
  * Output: markdown inventory on stdout-path via `--out`; exit 1 when any
  * CONFIRMED mismatch remains (ok after repair); unverified entries never fail.
@@ -35,7 +34,6 @@ import {
     mkdtempSync,
     readdirSync,
     readFileSync,
-    realpathSync,
     rmSync,
     writeFileSync,
 } from 'node:fs';
@@ -130,6 +128,7 @@ interface Parsed {
 }
 
 const PLACEHOLDER = /^([<[{($#"'`]|…|\.\.\.)/;
+const LEGACY_SELF_ALIASES = new Set(['init', 'migrate', 'serve', 'status']);
 
 /** Normalize an asserted invocation span into nouns / verbs / flags. Null when it asserts nothing. */
 export function parseInvocation(spanRaw: string): Parsed | null {
@@ -259,6 +258,32 @@ export function checkNounVerbFlags(
     const root = surface([]);
     for (const noun of nouns) {
         if (noun === 'help' || /^(foo|bar|baz)$/.test(noun)) continue;
+        if (LEGACY_SELF_ALIASES.has(noun)) {
+            const self = surface(['self']);
+            const command = surface(['self', noun]);
+            const present = self.commands.includes(noun);
+            record(
+                `spur ${noun}`,
+                'help-capture(spur self; hidden root alias)',
+                present ? 'ok' : 'mismatch',
+                present
+                    ? `legacy alias; canonical self/${noun} command is present`
+                    : `canonical self/${noun} command is absent`,
+                occ,
+            );
+            for (const f of flags) {
+                record(
+                    `spur ${noun} ${f}`,
+                    `help-capture(spur self ${noun}; hidden root alias)`,
+                    present && command.flags.includes(f) ? 'ok' : 'mismatch',
+                    command.flags.includes(f)
+                        ? 'flag present on canonical command'
+                        : `flag absent (${command.flags.join(', ')})`,
+                    occ,
+                );
+            }
+            continue;
+        }
         if (!root.commands.includes(noun)) {
             record(
                 `spur ${noun}`,
@@ -315,6 +340,10 @@ export function checkNounVerbFlags(
         }
     }
     for (const verb of verbs) {
+        if (nouns.length === 0 && LEGACY_SELF_ALIASES.has(verb)) {
+            checkNounVerbFlags([verb], [], flags, occ);
+            continue;
+        }
         if (nouns.length === 0 && root.commands.includes(verb)) {
             record(`spur ${verb}`, 'help-capture(root)', 'ok', 'root verb present', occ);
         }
@@ -383,7 +412,10 @@ export function sweepPluginTrees(root: string = PLUGIN_ROOT): void {
                     const cells = line.split('|').map((c) => c.trim());
                     const lastCell = cells[cells.length - 2] ?? line;
                     if (first && first !== 'Verb' && first !== 'spur') {
-                        if (rootCommands.includes(first)) {
+                        const nounCommands = surface([refNoun]).commands;
+                        if (nounCommands.includes(first)) {
+                            checkNounVerbFlags([refNoun], [first], flagNames(lastCell), occ);
+                        } else if (rootCommands.includes(first) || LEGACY_SELF_ALIASES.has(first)) {
                             checkNounVerbFlags([], [first], flagNames(lastCell), occ);
                         } else {
                             checkNounVerbFlags([refNoun], [first], flagNames(lastCell), occ);
@@ -611,7 +643,7 @@ const JSON_PROBES: string[][] = [
     ['agent', 'list', '--json'],
     ['agent', 'doctor', 'omp', '--json'],
     ['workflow', 'list', '--json'],
-    ['workflow', 'validate', '.spur/workflows/basic.yaml', '--json'],
+    ['workflow', 'validate', 'basic.yaml', '--json'],
     ['status', '--json'],
     ['team', 'status', '--json'],
     ['projects', 'list', '--json'],
@@ -758,18 +790,20 @@ export function sweepWorkflows(opts: { run?: CliRunner; wfDir?: string; link?: s
                 }
             });
     }
+    // Two-tier model (task 0648/0650): `.spur/workflows` is no longer a symlink and
+    // must not exist — the CLI resolves an explicit project path, then bundled fallback. Assert absence.
     const link = opts.link ?? join(REPO_ROOT, '.spur', 'workflows');
-    let status: Row['status'] = 'mismatch';
-    let actual = '';
+    let status: Row['status'] = 'ok';
+    let actual = 'absent (two-tier project→bundled model, task 0650)';
     try {
-        const rp = realpathSync(link);
-        const tracked = realpathSync(wfDir);
-        status = rp === tracked ? 'ok' : 'mismatch';
-        actual = `resolves to ${rel(rp)}${status === 'ok' ? ' (== tracked SSOT target)' : ` — expected ${rel(tracked)}`}`;
+        if (existsSync(link)) {
+            status = 'mismatch';
+            actual = 'still present — should be removed (task 0650 R3)';
+        }
     } catch (e) {
-        actual = `cannot resolve .spur/workflows: ${String(e).slice(0, 120)}`;
+        actual = `exists-check failed: ${String(e).slice(0, 120)}`;
     }
-    record('.spur/workflows symlink', 'symlink-realpath', status, actual, { file: '.spur/workflows', line: 1 });
+    record('.spur/workflows symlink', 'symlink-absent', status, actual, { file: '.spur/workflows', line: 1 });
 }
 
 // ─── Report ─────────────────────────────────────────────────────────────────
@@ -805,7 +839,7 @@ export function render(): string {
     L.push(
         "R1 scope: `plugins/sp/{commands,skills,scripts,hooks}` (tests/ and evals/ are the harness itself; agents/ prose is outside R1's named surface list).",
     );
-    L.push('R2 scope: all workflow YAML via the `.spur/workflows` runtime symlink (tracked SSOT tree).');
+    L.push('R2 scope: all workflow YAML via the bundled tree (two-tier project→bundled model since task 0648/0650).');
     L.push('');
     L.push('## Check methods');
     L.push('');
@@ -825,7 +859,7 @@ export function render(): string {
     L.push(
         '| `workflow-validate` / `workflow-dry-run` | Live engine: schema+semantic validate; `--dry-run` transition walk |',
     );
-    L.push('| `symlink-realpath` | realpath of `.spur/workflows` vs its tracked SSOT target |');
+    L.push('| `symlink-absent` | `.spur/workflows` is asserted absent (two-tier project→bundled model, task 0650) |');
     L.push('');
     for (const [method, list] of byMethod) {
         const mm = list.filter((r) => r.status === 'mismatch').length;

package/plugins/sp/scripts/validate-commands.ts

@@ -281,15 +281,22 @@ function checkTargetResolution(cmd: ParsedCommand, skillsDir: string, root: stri
         }
     }
 
-    // Workflow file refs — patterns like .spur/workflows/<name>.yaml
-    const workflowRefs = [...implSection.matchAll(/\.spur\/workflows\/([^\s)"\]]+\.yaml)/g)];
+    // Workflow file refs — bare names (`spur workflow run <name>.yaml`, two-tier model
+    // 0648/0650) resolve against the bundled workflow-definition asset tree; legacy
+    // `.spur/workflows/<name>.yaml` paths are also caught as unification drift.
+    const wfDir = join(root, 'config', 'workflows');
+    const workflowRefs = [
+        ...[...implSection.matchAll(/\.spur\/workflows\/([^\s)"\]]+\.yaml)/g)],
+        ...[...implSection.matchAll(/spur workflow (?:run|validate) ([a-z0-9-]+\.yaml)/g)],
+    ];
     for (const ref of workflowRefs) {
-        const wfPath = join(root, '.spur', 'workflows', ref[1]);
+        const bare = (ref[1] ?? '').split('/').pop() ?? '';
+        const wfPath = join(wfDir, bare);
         if (!existsSync(wfPath)) {
             violations.push({
                 command: cmd.name,
                 gate: 'c',
-                message: `unresolved workflow file ${ref[0]} (missing ${wfPath})`,
+                message: `unresolved workflow file ${bare} (missing ${wfPath})`,
             });
         }
     }

package/plugins/sp/skills/code-verification/SKILL.md

@@ -521,7 +521,7 @@ Do **not** use this skill for:
   rubric.
 - `plugins/sp/references/roles.md` — the Layer-1 role→tier table; this skill's verify/review modes
   run under the `reviewer` role (0538 R4: this file points at roles.md, it does not restate tiers).
-- `.spur/workflows/task-pipeline.yaml` — the `verify → record` gate that consumes the verdict.
+- `task-pipeline.yaml` — the `verify → record` gate that consumes the verdict.
 - **`sp:spur-dev`** — the execution-half umbrella that drives the pipeline this skill gates.
 - [references/code-improvement.md](references/code-improvement.md) — architecture-improvement lens
   for module depth, seam placement, locality, coupling, and testability.

package/plugins/sp/skills/code-verification/references/verdict-schema.md

@@ -120,7 +120,7 @@ Wave C verification can emit the following additive `checks[]` rows:
 
 ## How the gate reads it
 
-`.spur/workflows/task-pipeline.yaml`, transition `verify → record`:
+`task-pipeline.yaml`, transition `verify → record`:
 
 ```yaml
 guard:

package/plugins/sp/skills/history-anatomy/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: history-anatomy
+description: "Independent owner of diagnostic interpretation over already-imported history — the daily/ad-hoc mode contract, a closed finding taxonomy, the eleven-section report contract, and the enrich/validate rubrics. Triggers: history-anatomy, run the daily report, ad-hoc diagnosis, find issues over history."
+license: Apache-2.0
+version: 1.0.0
+metadata:
+  author: spur
+  platforms: "claude-code,codex,openclaw,opencode,antigravity,pi"
+  category: analysis-core
+  interactions:
+    - pipeline
+    - inversion
+  pipeline_steps:
+    - report
+    - identify
+    - propose
+    - generate
+  openclaw:
+    emoji: "🩺"
+see_also:
+  - sp:issue-finding
+  - sp:spur-cli
+  - sp:spur-dev
+---
+
+# sp:history-anatomy
+
+Owns **interpretation only** over already-imported history. It decides which arguments are legal
+in which mode, what counts as evidence, how findings are keyed and graded, and what a published
+report must contain, plus the rubrics its `enrich` and `validate` operations follow. It never
+launches a workflow, never reprocesses raw history files, and never mutates the corpus, docs, or sources —
+all orchestration lives in `history-anatomy.yaml` (0660), not here.
+
+This body routes to the three references; the procedure lives there (the BODY_BUDGET shape — a
+fresh skill cannot be added to the BASELINE exemption map).
+
+**Choose the mode first.** The single entry is `--mode daily|ad-hoc` (default `daily`):
+`references/modes.md`.
+
+**Then hold the report to the contract.** Every report must contain the eleven sections and every
+finding the full field set, with evidence rules and an explicit comparability verdict:
+`references/report-contract.md`.
+
+**Then apply the operations.** The workflow calls `enrich` to author the model half, and
+`validate` to gate a candidate report; neither operation launches a workflow:
+`references/operations.md`.
+
+## Primary directive
+
+- The artifact is the only evidence plane. A dimension the forensics artifact cannot support is a
+  **telemetry gap** reported as `not available` — never a raw history-file fallback.
+- Every causal claim needs **two independent signals** (or one labelled hypothesis with a
+  confirmation path). Every finding carries at least one evidence anchor. No anchor, no finding.
+- The report never states a trend, delta, or percentage it cannot support — an insufficient or
+  materially different baseline renders `not comparable`, with no fabricated comparison.
+- Findings are keyed on a **stable key**, never the prose title, so rewording never reclassifies
+  recurrence.
+- Remediation options are **proposals only**: an owner surface, expected impact, a verification
+  method, and reversibility. No applied change, diff, or command the report claims to have run.
+
+## Read the references
+
+| Reference | Owns |
+| --- | --- |
+| [`references/modes.md`](references/modes.md) | The daily/ad-hoc mode matrix, bounds normalization, the DST-aware calendar-day rule, and the fail-loud message shape. |
+| [`references/report-contract.md`](references/report-contract.md) | The eleven sections (in order), the per-finding field set, the closed category vocabulary, the stable-key grammar, the evidence rules, comparison semantics, recurrence classes, and the positive-pattern / remediation standards. |
+| [`references/operations.md`](references/operations.md) | The `enrich` and `validate` operation rubrics; neither launches a workflow. |

package/plugins/sp/skills/history-anatomy/references/modes.md

@@ -0,0 +1,82 @@
+# Mode contract — `sp:history-anatomy` (HA-S1, 0658)
+
+The skill resolves exactly two modes. Everything else fails loud. This matrix is the enforcement
+surface the workflow (0660) and the skill share; keep the vocabulary frozen.
+
+## Mode vocabulary (frozen)
+
+- Modes: `daily` | `ad-hoc`.
+- Unsupported value literal: `not available`.
+
+## Resolution rule
+
+`--mode <value>` selects the mode. If `--mode` is omitted, the resolved mode is **`daily`** and the
+resolved window is the **current local calendar day**.
+
+## `--mode daily` (default)
+
+| Allowed | Behavior |
+| --- | --- |
+| (none) | Default window = the current local calendar day. |
+| `--date <YYYY-MM-DD>` | Selects that local calendar day as the window. |
+
+Rejected arguments (each fails loud, naming the offending argument):
+
+| Argument | Why rejected |
+| --- | --- |
+| focus text (positional) | Daily mode has no focus string. |
+| `--since` / `--until` | Daily always uses the calendar-day window. |
+| `--output` | Daily always writes to the run directory (see 0660). |
+
+A daily invocation must print the normalized **inclusive ISO bounds** and the timezone used, so the
+wall-clock window is auditable.
+
+## `--mode ad-hoc`
+
+Requires a **non-empty focus** and **two ordered inclusive bounds**.
+
+| Argument | Rule |
+| --- | --- |
+| focus (positional) | Required; a missing or empty focus fails loud. |
+| `--since <iso>` | Required; the inclusive lower bound. |
+| `--until <iso>` | Required; must be present with `--since`; must not be earlier than `--since`. |
+| `--output <path>` | Optional; when present, writes to that explicit path. When absent, writes to the run directory. |
+
+Rejected arguments (each fails loud, naming the offending argument):
+
+| Argument | Why rejected |
+| --- | --- |
+| `--date` | Ad-hoc windows are explicit bounds, not a single date. |
+| `--recompute` | Ad-hoc never recomputes a cache (0660 owns the cache branch). |
+
+## Bounds normalization
+
+Normalize both bounds to inclusive ISO-8601 instants. The report prints the normalized bounds and
+the timezone used.
+
+## DST-aware calendar-day rule
+
+`--date <YYYY-MM-DD>` must span the **full local calendar day including any DST shift** — it is
+never a fixed 24-hour offset from local midnight.
+
+- Resolve the local timezone (the operator's configured zone; state it in the report).
+- The interval runs from the day's first local instant to the day's last local instant.
+- On a 23-hour or 25-hour daylight-saving day, the interval is that actual length, not 24 hours.
+- The bounds are NOT computed as `midnight + 24h`.
+
+This is what makes a daily report's window reproducible across DST transitions.
+
+## Fail-loud message shape
+
+Every rejection names the offending argument and the rule it violated, e.g.:
+
+```
+--mode daily rejects "focus text" (daily mode has no focus string)
+--mode ad-hoc requires a non-empty focus
+--mode ad-hoc: --until is missing --since
+--mode ad-hoc: --until (2026-08-01T00:00:00Z) is earlier than --since (2026-08-02T00:00:00Z)
+--mode ad-hoc rejects --date (ad-hoc uses explicit --since/--until bounds)
+```
+
+A combined conflict (e.g. `--mode daily --since X`) reports **each** offending argument it can
+attribute; at minimum it names the first conflicting one.

package/plugins/sp/skills/history-anatomy/references/operations.md

@@ -0,0 +1,67 @@
+# Operations — `sp:history-anatomy` (HA-S1, 0658)
+
+The skill exposes exactly two operations, invoked by `history-anatomy.yaml` (0660):
+
+- `enrich` — the model is given the rendered forensics artifacts (current + baseline) and authors
+  the model half of the report.
+- `validate` — the model is given a candidate report and independently checks its evidence claims
+  against the artifacts.
+
+Both are **skill operations**, not workflows. **Neither operation launches a workflow** — that is
+the recursion guard. This is why the rubric lives here, single-sourced, rather than being
+duplicated into the YAML: the rubric cannot recurse.
+
+## Invocation contract
+
+| Operation | Input | Output |
+| --- | --- | --- |
+| `enrich` | current forensics artifact + baseline artifact (plain `HistoryArtifact` JSON) | the model-authored report sections (Baseline comparison, Findings, Recurrence ledger, Remediation options, Performance analysis, Workflow and process improvements, Positive patterns) meeting the report contract |
+| `validate` | a candidate report + the current/baseline artifacts | a PASS / FAIL verdict with per-finding and per-section evidence checks, naming any failing rule |
+
+Freeze these operation names and this input/output contract — 0660 consumes them verbatim.
+
+## `enrich` rubric
+
+Given the current and baseline artifacts, author the model half of the report. Apply, in order:
+
+1. **Scope and provenance** + **Executive summary** + **Evidence ledger** are populated from the
+   artifact and rendered deterministically (or stated as the artifact's own data). The model
+   authors only the sections listed as model-authored.
+2. **Baseline comparison** — apply the comparison semantics: daily → immediately preceding local
+   calendar day; ad-hoc → immediately preceding equal-duration window. If baseline coverage is
+   insufficient or materially different, emit `not comparable` and **no** trend/delta/percentage.
+3. **Findings** — each with the full per-finding field set (key, category, impact, trend,
+   observation, inference, confidence, contradictions, evidenceAnchor). Categories from the closed
+   vocabulary; stable keys of the form `<category>:<owner-surface>:<signal>`.
+4. **Recurrence ledger** — classify every finding against the baseline on the **stable key**.
+5. **Telemetry gaps** — every dimension the artifact cannot support, rendered `not available`.
+6. **Remediation options** — proposals only (owner surface, expected impact, verification method,
+   reversibility). No applied change/diff/command.
+7. **Positive patterns** — same evidence standard as problems.
+
+Never fabricate a value, a trend, an anchor, or an applied fix. Never launch a workflow.
+
+## `validate` rubric
+
+Given a candidate report and the artifacts, independently verify:
+
+- **Eleven-section completeness and order** — all eleven section names present in the frozen
+  order; none renamed/omitted.
+- **Per-finding fields** — every finding (problem and positive) carries key, category, impact,
+  trend, observation, inference, confidence, contradictions, evidenceAnchor; category in the closed
+  vocabulary; stable-key grammar.
+- **Evidence anchors** — every finding has at least one verifiable anchor; no anchor → FAIL.
+- **Causality gate** — a causal claim with one signal must be labelled a hypothesis with a
+  confirmation path; otherwise FAIL.
+- **Inference names observations** — an inference that does not name its supporting observations
+  FAILs.
+- **Comparability** — a `not comparable` baseline must state no trend/delta/percentage; a stated
+  trend must be supported by a comparable baseline.
+- **Recurrence integrity** — classification is consistent with the stable keys (a rewording must
+  not flip a recurring finding to new).
+- **Positive patterns** — held to the same standard; an anchor-less entry FAILs.
+- **Remediation** — proposals only; any applied change, diff, or command the report claims to have
+  run FAILs.
+
+Emit `PASS` only when every rule holds. On FAIL, name the section, the finding key, and the rule
+violated. Never launch a workflow.

package/plugins/sp/skills/history-anatomy/references/report-contract.md

@@ -0,0 +1,133 @@
+# Report contract — `sp:history-anatomy` (HA-S1, 0658)
+
+The published report is the skill's contract. This reference owns the eleven sections (in order),
+the per-finding field set, the closed category vocabulary, the stable-key grammar, the evidence
+rules, comparison semantics, recurrence classes, and the positive-pattern / remediation standards.
+
+## Eleven required sections (in order, frozen)
+
+1. Scope and provenance
+2. Executive summary
+3. Baseline comparison
+4. Findings
+5. Recurrence ledger
+6. Telemetry gaps
+7. Remediation options
+8. Performance analysis
+9. Workflow and process improvements
+10. Positive patterns
+11. Evidence ledger
+
+These names are consumed verbatim by 0659's structure gate and 0660's validation stage. Do not
+rename, reorder, omit, or restate them.
+
+## Closed category vocabulary (frozen)
+
+- Categories: `reliability` | `repetition` | `workflow` | `performance` | `coverage` |
+  `telemetry` | `positive`.
+
+Every finding's category is drawn from this closed set. No category is invented.
+
+## Stable finding key (frozen)
+
+Each finding carries a stable key of the form:
+
+```
+<category>:<owner-surface>:<signal>
+```
+
+- `category` — one of the closed vocabulary above.
+- `owner-surface` — the surface that would own a change (e.g. a module, command, or skill; free
+  text is allowed but must be stable across runs).
+- `signal` — a concise, stable machine-readable identifier of the finding.
+
+The key is the recurrence identity. Rewording a finding's title must **never** reclassify it.
+
+## Per-finding field set
+
+Every finding — problem and positive alike — carries the full field set:
+
+| Field | Requirement |
+| --- | --- |
+| `key` | Stable `<category>:<owner-surface>:<signal>` key. |
+| `category` | From the closed vocabulary, matching the key's first segment. |
+| `impact` | What the situation costs or enables (qualitative, or a concrete number where supported). |
+| `trend` | `new` / `recurring` / `regressed` / `improved` / `resolved` / `not-comparable` (see recurrence). |
+| `observation` | What the artifacts show — evidence, not interpretation. |
+| `inference` | What the observation is reasoned to mean; names its supporting observations. |
+| `confidence` | Per-finding: `high` / `medium` / `low`. Never one blanket report-level score. |
+| `contradictions` | Any contradicting signal shown beside the finding, not silently reconciled. |
+| `evidenceAnchor` | At least one anchor to the forensics artifact or cited `file:line`. An entry with no anchor is invalid. |
+
+## Evidence rules
+
+Enforcement rail for every claim:
+
+1. **Causality needs two independent signals.** A causal claim supported by two or more
+   independent signals passes. Exactly one signal is not causation — it must be labelled a
+   **hypothesis** with a stated confirmation path.
+2. **A process/workflow change needs recurrence** across two independent sessions, or a single
+   **high-impact contract violation cited at `file:line`**.
+3. **Unsupported dimensions read `not available`** and are mirrored into the telemetry-gaps
+   section. Never a fabricated value, never a raw history-file fallback.
+4. **Focus biases ranking, not collection.** A focus string changes finding ranking and emphasis;
+   it never suppresses material off-topic findings within the window.
+5. **Every inference names its supporting observations.** An inference that does not name its
+   observations fails validation.
+6. **Every finding has an evidence anchor.** No anchor, no finding — no row may be dropped because
+   it "lacks evidence" while still appearing in a summary.
+
+## Comparison semantics
+
+The baseline comparison states an explicit comparability verdict.
+
+- **Daily** compares against the **immediately preceding local calendar day**.
+- **Ad-hoc** compares against the **immediately preceding equal-duration window**.
+- **Insufficient or materially different coverage** renders **`not comparable`**.
+- A `not comparable` baseline states no trend, no delta, and no percentage. An unsupported
+  comparison is never fabricated.
+
+## Recurrence ledger
+
+Every finding is classified against the baseline using the **stable key**:
+
+- `new` — not present in the baseline.
+- `recurring` — present in the baseline with comparable severity.
+- `regressed` — present but worse (severity, count, or impact increased).
+- `improved` — present but better.
+- `resolved` — present in the baseline but absent now.
+- `not-comparable` — the baseline was `not comparable`.
+
+Matching is on the stable key, never the prose title. Rewording a title between two runs must not
+reclassify a recurring finding as new.
+
+## Positive patterns
+
+Positive entries are held to the **same evidence standard as problems**: they carry observation,
+inference, confidence, and at least one evidence anchor. An entry without an anchor is invalid. The
+section renders successful workflows, resolved past issues that stay resolved, and healthy,
+repeating behavior worth keeping.
+
+## Remediation options (proposals only)
+
+Each option is a **proposal** that names:
+
+- **owner surface** — who would apply it.
+- **expected impact** — what it is expected to change.
+- **verification method** — how the change would be confirmed.
+- **reversibility** — whether and how it can be rolled back.
+
+The report must contain **no applied change, no diff, and no command it claims to have run**. The
+skill never applies a fix; it proposes one.
+
+## Evidence ledger
+
+The final section lists, for every finding, the artifact anchor(s) and any cited `file:line`,
+so a reader can verify the report's claims against the evidence plane.
+
+## Truthfulness invariants
+
+- `not available` is the true rendering for an unsupported dimension, never a masked gap.
+- `not comparable` is the true rendering for an unsupported comparison, never a computed delta.
+- No bounded leaderboard length is presented as a population total (see 0657 / ADR-080: the
+  coverage section reads `artifact.population` and renders `top N of M`).

package/plugins/sp/skills/issue-finding/SKILL.md

@@ -233,7 +233,7 @@ Also note **what worked well** so efficient patterns are preserved.
 1. **Fix description** — documentation, skill reference, pipeline comment, hook, etc.
 2. **Target location** — exact file path
    - Skill guidance: `skills/<skill-name>/SKILL.md` or `references/<name>.md`
-   - Pipeline comments: runtime workflow under `.spur/workflows/` (e.g. `task-pipeline.yaml`)
+   - Pipeline comments: runtime workflow resolves by bare name (`task-pipeline.yaml`)
    - CLI reference: `skills/spur-cli/references/tasks/…`
 3. **Proposed content** — text or code block to add
 4. **Expected impact** — estimated time saved per future run

package/plugins/sp/skills/next-router/references/routing-table.md

@@ -212,5 +212,5 @@ A6 → C5/C3 → unit first if verdict says so; else verify.
 - Dev operations map: `plugins/sp/skills/spur-dev/references/dev-operations.md:37-56`
 - `--next` chain on run: `plugins/sp/commands/dev-run.md:104-127`
 - Refine skip-gate sections: `plugins/sp/skills/spur-dev/references/dev-operations.md:114-128`
-- Task lifecycle wip→testing guard: `.spur/workflows/task-lifecycle.yaml:48-54`
+- Task lifecycle wip→testing guard: `task-lifecycle.yaml:48-54`
 - Decision-brief format: `plugins/sp/skills/spur-dev/references/decision-brief.md`

package/plugins/sp/skills/pr-reviewing/SKILL.md

@@ -39,7 +39,7 @@ that review effort happens on the PR, through Codex — not in the local session
 sp:pr-reviewing (this skill — mode routing, triage, fix, rules)
       │  deterministic spine, state order + guards:
       ▼
-.spur/workflows/pr-review.yaml ← workflow SSOT (seeded by spur init; project-tunable)
+pr-review.yaml ← workflow SSOT (seeded by spur init; project-tunable)
       │  every state resolves with `superskill script path` and shells out to:
       ▼
 staged pr-reviewing.ts         ← Bun entrypoint for the tested git/gh core
@@ -280,7 +280,7 @@ or review requests.
 
 ## Additional Resources
 
-- **Workflow SSOT:** `.spur/workflows/pr-review.yaml` (seeded by `spur init`; tune per project —
+- **Workflow SSOT:** `pr-review.yaml` (seeded by `spur init`; tune per project —
   wait budget, `preReviewCmd`, dedupe policy)
 - **Script source:** [scripts/pr-reviewing.ts](../../scripts/pr-reviewing.ts) — subcommand CLI
 - **Tests:** [tests/pr-reviewing.test.ts](../../tests/pr-reviewing.test.ts) — stubbed git/gh suites

package/plugins/sp/skills/spec-decomposition/references/decomposition.md

@@ -146,7 +146,7 @@ blank Design before implement (`/sp:dev-refine` / `dev-refineall`).
 
 The `template` field is the **single variant axis** (TASK_VARIANTS): it selects the section
 layout (the `section-matrix.yaml` variant), the scaffold body file
-(`.spur/templates/task/<variant>.md`), and is written to the task's `template:` frontmatter.
+(`.spur/tasks/templates/<variant>.md`), and is written to the task's `template:` frontmatter.
 Which sections actually appear is **status-driven** by the runtime matrix — query
 `spur task sections <wbs> list --json` rather than assuming a fixed list — pick the variant by
 *purpose*, not by a section checklist.

package/plugins/sp/skills/spur-cli/references/init.md

@@ -64,7 +64,7 @@ fails, STOP and report the gap rather than papering over it with customization:
 ```
 spur status
 spur task create "__probe__" --template standard   # confirms task template + matrix resolve
-spur workflow validate .spur/workflows/task-pipeline.yaml
+spur workflow validate task-pipeline.yaml
 ```
 
 ### Phase 1.6 — Rule glob adaptation (LLM-as-judge)

package/plugins/sp/skills/spur-cli/references/tasks/l3-guard-cheatsheet.md

@@ -12,7 +12,7 @@ Read this before writing `Solution`, `Testing`, or `Review`. Section **writers**
 evidence section (F92 0593 R1): implement owns `Solution`, the review coordinator
 (`/sp:dev-review`) owns `Review`, and `spur task record` owns `Testing` (bare-`## Review`
 backfill is fallback-only). The owning implementations are
-`.spur/workflows/task-lifecycle.yaml`, `hasPopulatedPriorityTable()` in
+`task-lifecycle.yaml`, `hasPopulatedPriorityTable()` in
 `packages/app/src/services/task-check.ts`, the verdict normalizers in
 `packages/app/src/services/task-record.ts`, and `TASK_CANONICAL_SECTIONS` in
 `packages/domain/src/planning/markdown-document.ts`.

package/plugins/sp/skills/spur-cli/references/workflows/operations.md

@@ -29,7 +29,7 @@ Authored workflows default to a project-local directory, grouped by purpose:
 
 A `--file <path>` argument overrides the default. Keep one workflow per file, named for what it does
 (`approval.yaml`, `import-file.yaml`), not for its mode. The canonical example
-(`.spur/workflows/basic.yaml`) lives here; copy real schema shapes from it rather than from a
+(`basic.yaml`) lives here; copy real schema shapes from it rather than from a
 half-remembered snippet.
 
 ## Sub-procedure: mode-selection gate