@gobing-ai/spur 0.3.60 → 0.3.62

package/config/plugin-scripts.json

@@ -32,9 +32,9 @@
             "twin": "feature-sync-bounded.mjs"
         },
         {
-            "rel": "history-load.ts",
+            "rel": "history-anatomy-cache.ts",
             "contract": "standard",
-            "twin": "history-load.mjs"
+            "twin": "history-anatomy-cache.mjs"
         },
         {
             "rel": "pr-reviewing.ts",

package/config/rules/boundary/config-loading-ownership.yaml

@@ -52,3 +52,24 @@ rules:
     exclude:
       - "**/node_modules/**"
       - "**/tests/**"
+
+  - id: spur-config-loader-only-at-composition-roots
+    description: >
+      `loadSpurConfig` is called at the composition roots only (ADR-082). Every other
+      surface consumes the merged result threaded through its context — a per-slice load
+      re-reads a single layer's view and reintroduces the split-brain A5 removed.
+    severity: error
+    evaluator:
+      type: rg
+      config:
+        pattern: "loadSpurConfig\\("
+    include:
+      - "apps/**/src/**/*.ts"
+      - "packages/**/src/**/*.ts"
+    exclude:
+      - "packages/config/src/**"
+      - "apps/cli/src/index.ts"
+      - "apps/server/src/serve.ts"
+      - "apps/server/src/context.ts"
+      - "**/node_modules/**"
+      - "**/tests/**"

package/config/workflow-composition-baseline.json

@@ -719,7 +719,7 @@
                 },
                 "collect:onEnter:1": {
                     "kind": "shell",
-                    "invocation": "$spurBin workflow validate .spur/workflows/wayfinder-resolution.yaml > .spur/run/wayfinder/$wbs-workflow-check.txt",
+                    "invocation": "$spurBin workflow validate wayfinder-resolution.yaml > .spur/run/wayfinder/$wbs-workflow-check.txt",
                     "stateEffect": "read",
                     "evidenceEffect": "write",
                     "disposition": "SIMPLE"

package/config/workflows/history-anatomy.yaml

@@ -0,0 +1,366 @@
+# History-anatomy pipeline — daily/ad-hoc diagnostic report over already-imported history
+# (feature I8, HA-S1 0660 / ADR-079).
+#
+# Orchestration is configuration (ADR-022): a state machine over the existing dual-workflow
+# engine. The YAML owns ONLY the cache branch, deterministic stage ordering, executor dispatch,
+# bounded correction, and atomic publication sequencing. The deterministic cache/digest/
+# structure/publish work is 0659's dependency-free helper script; the judgment (mode validity,
+# what counts as evidence, the report contract, enrich/validate rubrics) is 0658's skill. Per
+# ADR-069 R1, cache-decide / digest / structure-check / publish must NOT be inline shell — every
+# shell action here is glue length (a single helper invocation), because each of those programs
+# would exceed the shell composition threshold and be flagged as an owned-capability candidate.
+#
+# Shape:
+#   start -> resolve-scope -> resolve-paths -> analyze -> cache-probe
+#            (hit  -> refresh-provenance -> publish -> published)
+#            (miss -> render -> enrich -> structure-gate -> validate -> stamp -> publish)
+#            (validate FAIL -> correct (max 1) -> structure-gate ...; exhausted -> failed)
+#            (any all-paths failure -> failed)
+#
+# `analyze` precedes `cache-probe` deliberately: ADR-079 makes cache validity a DERIVED fact, so
+# the semantic digest must come from a fresh analyze, never from the cached report being judged.
+# The deterministic half is therefore never cached — only the model-authored half is reused.
+#
+# terminalStates: [published, failed]. Publication is reachable ONLY via `stamp` (guarded on a
+# passing validation) or `refresh-provenance` (whose model half was itself published through a
+# passing validation) — there is no edge into `publish` from structure-gate or enrich directly.
+#
+# Vars (all must be declared here — the vars: block is the only safe shape; `spur workflow
+# validate` and the skill-structure test enforce it):
+#   mode      — "daily" (default) | "ad-hoc" (validated in resolve-scope)
+#   date      — YYYY-MM-DD for --date (daily); empty for ad-hoc
+#   since     — inclusive ISO lower bound (ad-hoc; also normalizes daily via the DST-aware rule)
+#   until     — inclusive ISO upper bound (ad-hoc)
+#   focus     — ad-hoc focus string (required in ad-hoc mode, rejected in daily)
+#   recompute — "true" forces the full analyze/render/enrich/validate path (cache disposition
+#               forced-recompute)
+#   output    — explicit report output path; default run directory
+#   agent     — executor for the agent.run stages (enrich/validate)
+#   spurBin   — PATH-independent spur invocation (overridden by CLI at run start)
+#   __runId   — run-scoped id for explicit artifact paths (allocated in start)
+#   stepTimeoutMs — agent.run budget for enrich/validate
+#   correctionCount — bounded correction loop counter file path bits (name resolved in correct)
+
+"$schema": "@gobing-ai/spur/schemas/state-machine-workflow.schema.json"
+kind: state-machine
+name: history-anatomy
+description: "Daily/ad-hoc history-anatomy report: cache branch, deterministic analyze/render, skill enrichment, deterministic structure gate, independent evidence validation, bounded correction, atomic publication"
+iterationBound: 20
+initialState: start
+terminalStates:
+  - published
+  - failed
+failureStates:
+  - failed
+vars:
+  mode: "daily"
+  date: ""
+  since: ""
+  until: ""
+  focus: ""
+  recompute: "false"
+  output: ""
+  agent: "omp"
+  spurBin: "spur"
+  __runId: ""
+  stepTimeoutMs: "1800000"
+  correctionCount: "0"
+  workflowFile: "config/workflows/history-anatomy.yaml"
+  contractVersion: "1"
+  reportDir: "docs/report"
+
+states:
+  - id: start
+    description: >
+      Allocate the run-scoped id and root. Every analyze/render path in this workflow writes to
+      an explicit unique path under this run id — no stage reads the mutable latest.json pointer.
+    onEnter:
+      - kind: shell
+        options:
+          command: >-
+            mkdir -p .spur/run;
+            if [ -z "$__runId" ]; then __runId=$(uuidgen | tr 'A-Z' 'a-z' | cut -c1-8); fi;
+            echo "$__runId" > .spur/run/history-anatomy-run.id
+
+  - id: resolve-scope
+    description: >
+      Dispatch the skill's mode validation (0658 references/modes.md): daily is the default and
+      rejects focus/since/until/output; ad-hoc requires a non-empty focus plus two ordered
+      inclusive bounds and rejects --date/--recompute. Writes the normalized selector artifact.
+    onEnter:
+      - kind: agent.run
+        options:
+          agent: ${vars.agent}
+          input: "Validate the mode arguments per sp:history-anatomy references/modes.md and write the normalized selector to .spur/run/${vars.__runId}-selector.json. mode=${vars.mode} date=${vars.date} since=${vars.since} until=${vars.until} focus=${vars.focus}. Reject conflicting arguments, naming the offending one; a rejection marks the run failed."
+          # Declared Layer-1 role (0538 R2): mode validation is a reviewer-standard judgment.
+          role: reviewer
+          expectFile: .spur/run/${vars.__runId}-selector.json
+          timeoutMs: ${vars.stepTimeoutMs}
+
+  - id: resolve-paths
+    description: >
+      Resolve the helper, the skill/contract logic paths, and the publication target once, into a
+      run-scoped env file every later stage sources. Keeps each downstream shell action at glue
+      length (ADR-069 R1) instead of repeating path arithmetic per stage.
+    onEnter:
+      - kind: shell
+        options:
+          # Path arithmetic lives in the helper (ADR-069 R1); the shell only locates it. Avoid
+          # `${...}` here — that syntax collides with the engine's own template interpolation.
+          command: >-
+            h=$(superskill script path sp history-anatomy-cache.mjs);
+            node "$h" paths --helper "$h" --report-dir "$reportDir" --date "$date"
+            --output "$output" --out .spur/run/$__runId-paths.env
+
+  - id: analyze
+    description: >
+      Deterministic analyze of the current window and the immediately preceding comparable
+      window, each to an explicit run-scoped path. Always reruns — the deterministic half is
+      never cached (ADR-079).
+    onEnter:
+      - kind: shell
+        options:
+          command: >-
+            mkdir -p .spur/run;
+            $spurBin history analyze --out .spur/run/$__runId-history-anatomy-current.json --since "$since" --until "$until" --json
+      - kind: shell
+        options:
+          command: >-
+            $spurBin history analyze --out .spur/run/$__runId-history-anatomy-baseline.json --since "$baselineSince" --until "$until" --json 2>/dev/null || true
+
+  - id: cache-probe
+    description: >
+      Deterministic cache probe via the helper (0659). Runs AFTER analyze because ADR-079 makes
+      validity a derived fact: the semantic digest must come from the fresh artifact, never from
+      the cached report being judged. A hit skips only enrichment, never the probe. Daily only;
+      ad-hoc always reports miss (`ad-hoc-never-cached`). Also writes the run's full provenance.
+    onEnter:
+      - kind: shell
+        options:
+          command: >-
+            . .spur/run/$__runId-paths.env;
+            node "$HA_HELPER" probe --artifact .spur/run/$__runId-history-anatomy-current.json
+            --baseline .spur/run/$__runId-history-anatomy-baseline.json --target "$HA_TARGET"
+            --mode "$mode" --date "$HA_DATE" --recompute "$recompute" --executor "$agent"
+            --skill-dir "$HA_SKILL" --contract "$HA_SKILL/references/report-contract.md"
+            --workflow "$workflowFile" --contract-version "$contractVersion" --run-id "$__runId"
+            --out .spur/run/$__runId-provenance.json
+            > .spur/run/$__runId-cache-disposition.txt
+
+  - id: render
+    description: >
+      Render both artifacts with report --mode forensics, naming the exact analyze paths.
+    onEnter:
+      - kind: shell
+        options:
+          command: >-
+            mkdir -p .spur/run;
+            $spurBin history report .spur/run/$__runId-history-anatomy-current.json --mode forensics > .spur/run/$__runId-history-anatomy-current.md;
+            $spurBin history report .spur/run/$__runId-history-anatomy-baseline.json --mode forensics > .spur/run/$__runId-history-anatomy-baseline.md || true
+
+  - id: enrich
+    description: >
+      Model enrichment via the skill operation sp:history-anatomy enrich (0658 operations.md).
+      Consumes the two artifacts; authors the model half of the report.
+    onEnter:
+      - kind: agent.run
+        options:
+          agent: ${vars.agent}
+          input: "Run sp:history-anatomy enrich: given .spur/run/${vars.__runId}-history-anatomy-current.json and -baseline.json, author the model half of the report (Baseline comparison, Findings, Recurrence ledger, Remediation options, Performance analysis, Workflow/process improvements, Positive patterns) to .spur/run/${vars.__runId}-candidate.md per references/report-contract.md. This operation never launches a workflow."
+          # Declared Layer-1 role (0538 R2): enrichment is model judgment.
+          role: reviewer
+          expectFile: .spur/run/${vars.__runId}-candidate.md
+          timeoutMs: ${vars.stepTimeoutMs}
+
+  - id: structure-gate
+    description: >
+      Deterministic structure gate via the helper (0659). Asserts the eleven sections in order,
+      per-finding fields, no placeholders, evidence anchors. Not reachable on the hit path from
+      enrich — always gated before validation.
+    onEnter:
+      - kind: shell
+        options:
+          command: >-
+            node "$(superskill script path sp history-anatomy-cache.mjs)" check \
+              .spur/run/$__runId-candidate.md > .spur/run/$__runId-structure-gate.txt 2>&1 || true
+
+  - id: validate
+    description: >
+      Independent evidence validation via the skill operation sp:history-anatomy validate.
+      Publication is reachable only from a PASS here.
+    onEnter:
+      - kind: agent.run
+        options:
+          agent: ${vars.agent}
+          input: "Run sp:history-anatomy validate: independently check .spur/run/${vars.__runId}-candidate.md against the two artifacts per references/operations.md; write Verdict: PASS or FAIL to .spur/run/${vars.__runId}-validation.txt. This operation never launches a workflow."
+          # Declared Layer-1 role (0538 R2): independent verification.
+          role: reviewer
+          expectFile: .spur/run/${vars.__runId}-validation.txt
+          timeoutMs: ${vars.stepTimeoutMs}
+
+  - id: correct
+    description: >
+      One bounded correction pass. onEnter increments the counter; the retry edge guards on
+      correctionCount < 1, the second failure takes the -> failed edge.
+    onEnter:
+      - kind: shell
+        options:
+          command: >-
+            n=$(cat .spur/run/$__runId-correction-count 2>/dev/null || echo 0) &&
+            printf '%s\n' "$((n + 1))" > .spur/run/$__runId-correction-count
+
+  - id: refresh-provenance
+    description: >
+      Cache-hit path. Keeps the published model half verbatim and refreshes only validated_at,
+      the cache disposition, and the imported-snapshot banner — which is the EARLIEST per-source
+      lastImportedAt, so the report never claims a source was imported after its own recorded
+      timestamp. Emits the publishable artifact the shared publish state consumes.
+    onEnter:
+      - kind: shell
+        options:
+          command: >-
+            . .spur/run/$__runId-paths.env;
+            node "$HA_HELPER" refresh --report "$HA_TARGET"
+            --out .spur/run/$__runId-publishable.md --disposition hit
+
+  - id: stamp
+    description: >
+      Cache-miss path. Attaches the full R7 frontmatter provenance block (identity tuple, window
+      state, generated/validated timestamps, artifact paths + digests, contract/skill/workflow
+      digests, per-source coverage + last_imported_at, spur/schema version, executor, run id,
+      cache disposition) and the freshness banner to the validated candidate.
+    onEnter:
+      - kind: shell
+        options:
+          command: >-
+            . .spur/run/$__runId-paths.env;
+            node "$HA_HELPER" stamp --candidate .spur/run/$__runId-candidate.md
+            --provenance .spur/run/$__runId-provenance.json
+            --out .spur/run/$__runId-publishable.md
+
+  - id: publish
+    description: >
+      Atomic publication via the helper (0659). Reachable only from `stamp` (which is reachable
+      only from a passing validate) or from `refresh-provenance` on the cache-hit path — the
+      model half a hit reuses was itself published through a passing validation.
+    onEnter:
+      - kind: shell
+        options:
+          command: >-
+            . .spur/run/$__runId-paths.env;
+            mkdir -p "$(dirname "$HA_TARGET")";
+            node "$HA_HELPER" publish .spur/run/$__runId-publishable.md "$HA_TARGET"
+
+  - id: published
+    description: Terminal — report published atomically after a passing validation.
+
+  - id: failed
+    description: Terminal — mode rejection, gate failure, or validation failure not corrected.
+
+transitions:
+  - from: start
+    to: resolve-scope
+    description: Scope resolved.
+    guard:
+      kind: always
+
+  - from: resolve-scope
+    to: resolve-paths
+    description: Mode valid — resolve helper/skill/target paths once.
+    guard:
+      kind: always
+
+  - from: resolve-paths
+    to: analyze
+    description: Paths resolved — always rerun the deterministic half (ADR-079).
+    guard:
+      kind: always
+
+  - from: analyze
+    to: cache-probe
+    description: Fresh artifacts on disk — derive the digest and decide reuse.
+    guard:
+      kind: always
+
+  # Daily only takes the hit branch; ad-hoc always regenerates.
+  - from: cache-probe
+    to: refresh-provenance
+    description: Cache hit (daily) — refresh provenance and publish without re-enrichment.
+    guard:
+      kind: shell
+      options:
+        command: 'test "$mode" = daily && grep -q "^hit$" .spur/run/$__runId-cache-disposition.txt 2>/dev/null'
+  - from: cache-probe
+    to: render
+    description: Cache miss, forced recompute, or ad-hoc — render and re-enrich.
+    guard:
+      kind: always
+
+  - from: refresh-provenance
+    to: publish
+    description: Provenance refreshed — publish the cached model half.
+    guard:
+      kind: always
+
+  - from: render
+    to: enrich
+    description: Both artifacts rendered — enrich.
+    guard:
+      kind: always
+
+  - from: enrich
+    to: structure-gate
+    description: Candidate authored — deterministic structure gate.
+    guard:
+      kind: always
+
+  - from: structure-gate
+    to: validate
+    description: Candidate structurally sound — independent evidence validation.
+    guard:
+      kind: shell
+      options:
+        command: 'grep -q "^PASS$" .spur/run/$__runId-structure-gate.txt 2>/dev/null'
+  - from: structure-gate
+    to: failed
+    description: Structure gate FAIL — never publish a malformed candidate.
+    guard:
+      kind: always
+
+  - from: validate
+    to: stamp
+    description: Independent validation PASS — stamp provenance, then publish atomically.
+    guard:
+      kind: shell
+      options:
+        command: 'grep -q "Verdict: PASS" .spur/run/$__runId-validation.txt 2>/dev/null'
+  - from: validate
+    to: correct
+    description: Validation FAIL under the correction cap — one bounded pass.
+    guard:
+      kind: shell
+      options:
+        command: '! grep -q "Verdict: PASS" .spur/run/$__runId-validation.txt 2>/dev/null && test "$(cat .spur/run/$__runId-correction-count 2>/dev/null || echo 0)" -lt 1'
+  - from: validate
+    to: failed
+    description: Validation FAIL with the correction cap exhausted — terminate without publishing.
+    guard:
+      kind: always
+
+  - from: correct
+    to: structure-gate
+    description: Corrected candidate re-enters the deterministic gate, then re-validates.
+    guard:
+      kind: always
+
+  - from: stamp
+    to: publish
+    description: Provenance stamped — publish atomically.
+    guard:
+      kind: always
+
+  - from: publish
+    to: published
+    description: Report published.
+    guard:
+      kind: always

package/config/workflows/wayfinder-resolution.yaml

@@ -64,13 +64,11 @@ states:
       - kind: shell
         options:
           command: "mkdir -p .spur/run/wayfinder && $spurBin task show $wbs --json > .spur/run/wayfinder/$wbs-input.json"
-      # `.spur/workflows/` is the runtime read path in every layout — a symlink to
-      # config/workflows/ inside the Spur monorepo, a real directory in a seeded
-      # project. The previous `config/workflows/…` literal only resolved in the
-      # monorepo and hard-failed `collect` anywhere else.
+      # `wayfinder-resolution.yaml` uses the project→bundled resolver (tasks 0648/0650):
+      # a bare name falls back to the bundled tree; an explicit project path wins.
       - kind: shell
         options:
-          command: "$spurBin workflow validate .spur/workflows/wayfinder-resolution.yaml > .spur/run/wayfinder/$wbs-workflow-check.txt"
+          command: "$spurBin workflow validate wayfinder-resolution.yaml > .spur/run/wayfinder/$wbs-workflow-check.txt"
       - kind: shell
         options:
           command: "$spurBin task check $wbs > .spur/run/wayfinder/$wbs-precheck.txt"
@@ -112,7 +110,7 @@ states:
     onEnter:
       - kind: shell
         options:
-          command: 'rm -f .spur/run/wayfinder/$wbs-resolution-verdict.txt'
+          command: "rm -f .spur/run/wayfinder/$wbs-resolution-verdict.txt"
       - kind: agent.run
         options:
           agent: ${vars.agent}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gobing-ai/spur",
-    "version": "0.3.60",
+    "version": "0.3.62",
     "description": "Spur CLI — local-first harness for mainstream coding agents: constraint checking, workflow orchestration, agent health, and history analytics. Bun-native; exposes the `spur` command.",
     "keywords": [
         "spur",

package/plugins/README.md

@@ -228,7 +228,7 @@ graph TB
     subgraph "Corpus Layer"
         CORPUS["docs/tasks/ + docs/features/<br/>Markdown planning corpus"]
         RULES[".spur/rules/<br/>YAML constraint rules"]
-        WFS[".spur/workflows/<br/>YAML workflow definitions"]
+        WFS["bundled workflows tree<br/>YAML workflow definitions"]
     end
 
     %% Command → Skill delegations
@@ -309,7 +309,7 @@ Tier 3 — Execution Layer (spur CLI + Guard Scripts)
 
 1. User types `/sp:dev-run 0090`
 2. **Command** delegates to `sp:spur-dev` skill (execution half)
-3. **Skill** reads the task, loads `.spur/workflows/task-pipeline.yaml`, and runs `spur workflow run` with HITL surfacing
+3. **Skill** reads the task, loads `task-pipeline.yaml`, and runs `spur workflow run` with HITL surfacing
 4. **CLI** executes the workflow engine (`@gobing-ai/ts-dual-workflow-engine`), pauses at HITL gates, persists run state
 5. Result: task driven through implement → check → fix → verify lifecycle
 
@@ -351,8 +351,9 @@ The **workflow** and **rule** engines have their own lifecycles (author → vali
 
 ## Workflow Pipelines
 
-The plugin ships workflow YAMLs under `.spur/workflows/`.
-Each pipeline owns one lifecycle phase:
+The plugin references workflow YAMLs by bare name; the CLI resolves them through the
+bundled tree (two-tier model, task 0648/0650) — a project-local override wins when
+present, otherwise the bundled copy is used. Each pipeline owns one lifecycle phase:
 
 | Workflow                 | Phase                             | Entry command                     | Status        |
 | ------------------------ | --------------------------------- | --------------------------------- | ------------- |

package/plugins/sp/README.md

@@ -127,9 +127,8 @@ list this README is checked against.
 | `dev-handover`      | Generate a structured handover document when blocked — captures goal, progress, blocker, rejected approaches, and next steps                                                                      |
 | `dev-debug`         | Systematic debugging protocol — reproduce, isolate, diagnose root cause, apply minimal fix, and verify with regression tests                                                                      |
 | `dev-daily`         | Generate a daily summary report from agent usage data, git history, and notes                                                                                                                     |
-| `dev-history-load`  | On-demand cumulative history load + narrowed analyze — import (checkpoint-resume) then analyze, optionally by session/task/window, with optional forensics render                                     |
 | `dev-dogfood`       | Dogfood an agent skill/command/CLI — drive it end-to-end with bounded auto-fix, self-monitor, and emit a comprehensive report                                                                     |
-| `dev-find-issue`    | Review agent session logs, identify performance bottlenecks and behavioral anti-patterns, and generate a structured task file with proposed fixes                                                 |
+| `dev-find-issue`    | Generate the daily/ad-hoc history-anatomy diagnostic report over already-imported history — mode contract, closed finding taxonomy, eleven-section report contract, cache branch, atomic publication; forwards to sp:history-anatomy                               |
 | `dev-find-conflict` | Authority-aware semantic audit across source, task, feature, and project authority files — detect conflicts, resolve claim-specific authority, and route confirmed repairs through owner surfaces |
 | `dev-find-next`     | Prompt-first feature frontier prioritizer — ranks the open feature frontier by derived importance/urgency with per-candidate evidence; gates unactionable features; emits tree defects as proposals only     |
 | `dev-fixall`        | Fix all lint, type, and test errors systematically across the working tree                                                                                                                        |
@@ -240,6 +239,8 @@ plugins/sp/
 │   │   └── references/{authority-resolution.md, comparison-protocol.md, finding-contract.md, remediation-routing.md}
 │   ├── next-feature/                # Prompt-first feature frontier prioritizer (backs /sp:dev-find-next)
 │   │   └── references/{signal-derivation.md, ranking-rubric.md, proposal-contract.md, handoff-routing.md}
+│   ├── history-anatomy/             # Diagnostic interpretation owner over already-imported history (backs /sp:dev-find-issue)
+│   │   └── references/{modes.md, report-contract.md, operations.md}
 │   ├── sys-architecture/            # Architecture / ADR judgment competency
 │   │   └── references/decision-method.md
 │   ├── sys-debugging/               # Structured debugging protocol
@@ -312,11 +313,23 @@ surface or run one workflow. All skills target the same five core platforms: `cl
 | `daily-summary`             | 1.0.0 | Daily summary report generator — orchestrates ccusage CLI + git history into structured markdown summaries                                                                                                                                 |
 | `doc-evolve`                | 1.0   | Key-document evolution per `docs/99_PROJECT_CONSTITUTION.md` — drift audits, same-commit sync checks, frontmatter-contract verification, machine-appended lessons                                                                          |
 | `reverse-engineering`       | 1.1   | Codebase analysis / HLD generation / audit — depth-driven reverse engineering with orthogonal mode, focus, and format controls; backs `/sp:dev-reverse`                                                                                    |
-| `issue-finding`             | 1.1   | Session-log forensics — multi-source discovery, bottleneck ranking, optional topic focus, CLI-gated fix task generation; backs `/sp:dev-find-issue`                                                                                        |
+| `issue-finding`             | 1.1   | Session-log forensics — multi-source discovery, bottleneck ranking, optional topic focus, CLI-gated fix task generation; **legacy path** — superseded by `history-anatomy` for indexed reporting; backs no current command; directly invocable as sp:issue-finding |
 | `conflict-finding`          | 1.0   | Authority-aware semantic audit — four-pillar (source/task/feature/authority) conflict discovery, claim-specific authority resolution, reproducible evidence, confirmed owner-routed remediation; backs `/sp:dev-find-conflict`             |
 | `next-feature`              | 1.0   | Prompt-first feature frontier prioritizer — sync-first precondition, B3 actionability gate (cited, never restated), tiered rubric over measured signals, D1–D4 defect proposals conforming to the restructure map schema; backs `/sp:dev-find-next` |
 | `pr-reviewing`              | 1.0   | GitHub Codex PR review — PR prepare/reuse, `@codex review` request with per-HEAD dedupe, bounded polling, findings normalization, validated fix + re-review; spine SSOT `pr-review.yaml` + `scripts/pr-reviewing.ts`; backs `/sp:dev-pr-review`     |
 | `indexed-context`           | 1.0   | Cross-agent project context — anatomy/learnings/pitfalls/buglog/memory in `.spur/context/`; hook-tracked token-ledger; graceful degradation on agents without hooks                                                                        |
+| `history-anatomy`           | 1.0   | Diagnostic interpretation owner over already-imported history — daily/ad-hoc mode contract, closed finding taxonomy, eleven-section report contract, `enrich`/`validate` rubrics; no workflow launch, no JSONL fallback, no corpus mutation                                                                   |
+
+#### Bounded coexistence and retirement gate — `sp:issue-finding` (HA-S1 0661)
+
+`sp:issue-finding` remains packaged and directly invocable as the **legacy path**; `/sp:dev-find-issue` resolves to `sp:history-anatomy`. No logic is shared between them. This coexistence is _bounded_, not permanent — the retirement gate below is the contract:
+
+- **Parity fixtures** the new contract must cover before retirement is considered: typed history analysis; daily and focused range selection; repeated-work and error reporting; evidence and confidence; remediation proposals; performance analysis; process observations; positive patterns.
+- **Intentional exclusions, not gaps:** raw history-file parsing and task creation are deliberately out of scope for `history-anatomy`; a missing parity item is checked against this list before it counts as a gap.
+- **Adoption evidence:** successful `history-anatomy.yaml` workflow run records across both modes (`daily`, `ad-hoc`) and the available source families. No bespoke telemetry is added to count adoption.
+- **Review point:** one minor release or 30 days after this feature ships, whichever is later.
+- **Gate:** parity PASS + demonstrated use of both modes + no open high-impact regression + explicit operator approval. A failed gate records the missing evidence and one dated extension.
+- **Retirement is a separate change.** This feature removes nothing; `sp:issue-finding` stays until the operator approves a dedicated retirement change.
 
 Each skill directory contains:
 
@@ -338,11 +351,11 @@ Skills contain zero validation logic — the CLI is the gate.
 
 Thin slash-command wrappers that parse user arguments and delegate to the corresponding skill. Each
 command is a user-facing entry point that bridges natural language to skill invocation. There are
-**39 commands** (see the Command index above for the full list), organized by the surface they wrap:
+**38 commands** (see the Command index above for the full list), organized by the surface they wrap:
 
 | Prefix       | Count | Delegates to                                                                                                                                                                                                                                                                                                        | Purpose                                                                                |
 | ------------ | ----- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
-| `dev-*`      | 33    | `sp:spur-dev`, `sp:code-implementation`, `sp:code-testing`, `sp:code-verification`, `sp:code-simplification`, `sp:next-router`, `sp:brainstorm`, `sp:dogfood-testing`, `sp:parallel-execution`, `sp:sys-debugging`, `sp:daily-summary`, `sp:issue-finding`, `sp:conflict-finding`, `sp:reverse-engineering`, `sp:pr-reviewing`, inline | The dev-workflow surface — planning, execution, batch, wrap-up, review/verify, hygiene |
+| `dev-*`      | 32    | `sp:spur-dev`, `sp:code-implementation`, `sp:code-testing`, `sp:code-verification`, `sp:code-simplification`, `sp:next-router`, `sp:brainstorm`, `sp:dogfood-testing`, `sp:parallel-execution`, `sp:sys-debugging`, `sp:daily-summary`, `sp:history-anatomy`, `sp:conflict-finding`, `sp:reverse-engineering`, `sp:pr-reviewing`, inline | The dev-workflow surface — planning, execution, batch, wrap-up, review/verify, hygiene |
 | `rule-*`     | 3     | `sp:spur-cli`                                                                                                                                                                                                                                                                                                       | The rule surface — `rule-add`, `rule-refine`, `rule-scan`                              |
 | `workflow-*` | 2     | `sp:spur-cli`                                                                                                                                                                                                                                                                                                       | The workflow surface — `workflow-add`, `workflow-refine`                               |
 | `spur-init`  | 1     | `sp:doc-evolve`                                                                                                                                                                                                                                                                                                     | Project bootstrap (`spur init`) with doc-evolve integration                            |
@@ -352,7 +365,7 @@ Each command file contains:
 - YAML frontmatter (`description`, `argument-hint`, `allowed-tools`).
 - A delegation block: `Skill(skill="sp:<skill-name>", args="<operation> $ARGUMENTS")`.
 
-**Commands as SSOT (ADR-032).** The 39 `.md` files in `commands/` are the authoritative,
+**Commands as SSOT (ADR-032).** The 38 `.md` files in `commands/` are the authoritative,
 hand-editable source for the operator command surface. Per-platform adapters are **install-time
 output** owned by `superskill` (`superskill install sp`) and never committed here. Plugin `sp` ships
 no per-platform artifacts — only the platform-independent thin wrappers.
@@ -509,7 +522,7 @@ graph TB
     subgraph "Corpus layer"
         CORPUS["docs/tasks/ + docs/features/<br/>markdown planning corpus"]
         RULES[".spur/rules/<br/>YAML constraint rules"]
-        WFS[".spur/workflows/<br/>YAML workflow definitions"]
+        WFS["bundled workflows tree<br/>YAML workflow definitions"]
     end
 
     CMD -->|"Skill(sp:spur-dev, ...)"| SKILL_DEV
@@ -557,7 +570,7 @@ graph TB
 
 1. User types `/sp:dev-run 0090`.
 2. **Command** delegates to `sp:spur-dev` skill (execution half).
-3. **Skill** reads the task, loads `.spur/workflows/task-pipeline.yaml`, and runs
+3. **Skill** reads the task, loads `task-pipeline.yaml`, and runs
    `spur workflow run` with HITL surfacing.
 4. **CLI** executes the workflow engine (`@gobing-ai/ts-dual-workflow-engine`), pauses at HITL gates,
    persists run state.
@@ -575,7 +588,7 @@ graph TB
 
 ### Workflow pipelines
 
-The plugin ships workflow YAMLs under `.spur/workflows/`. Each
+The plugin references workflow YAMLs by bare name; the CLI resolves them through the bundled tree (two-tier model, task 0648/0650) — project-local overrides win when present. Each
 pipeline owns one lifecycle phase:
 
 | Workflow                    | Phase                             | Entry command                     |

package/plugins/sp/agents/super-planner.md

@@ -78,7 +78,7 @@ You own the spaces **between** task runs:
 - **Preflight (Step 2.5 / 3.0)** - before each pipeline launch, evaluate TABLE A STOP rows
   (`batch-preflight.ts` or equivalent). Skip A2/A7/A8/A9; still **launch `task-pipeline.yaml`** for
   ready WBS (never substitute a `dev-next` loop for the happy path).
-- **Run each ready task** through `.spur/workflows/task-pipeline.yaml` via `spur workflow run --async`
+- **Run each ready task** through `task-pipeline.yaml` via `spur workflow run --async`
   (Step 3). The command/script layer polls `spur workflow trace` to terminal state - polling is
   transport, not planner reasoning (R3: the poll loop must not live in this agent's body; the planner
   inspects the terminal verdict, not the poll iterations). Follow the