@gobing-ai/spur 0.4.14 → 0.4.16

package/config/workflows/pr-review.yaml

@@ -1,209 +0,0 @@
-# PR-review workflow: deterministic spine for /sp:dev-pr-review (skill sp:pr-reviewing).
-# Authored for the @gobing-ai/ts-dual-workflow-engine state-machine schema
-# (initialState / states[].id / onEnter / top-level transitions), same family as
-# basic.yaml / task-pipeline.yaml. Seeded into projects by `spur init` (scaffold manifest).
-#
-# Shape: check → precheck → open → review → done
-#        (soft probes everywhere: red gates route to `failed`/`pending` via transitions,
-#         never a raw lifecycle abort — same reliability contract as basic.yaml)
-#
-# This YAML is the SSOT for the review spine's state order and guards. Every state shells out to
-# the four flat `spur builder pr-<verb>` verbs (task 1219); the op sequencing
-# (preflight→hygiene, push→ensure, request→wait→collect) lives in `runPrVerb`, not in this file's
-# shell, and no gh/git logic lives in this file. All model-bearing work — finding triage, `fix`
-# mode — stays in the sp:pr-reviewing skill and never enters this machine.
-#
-# Non-negotiable: the external review goes through the GitHub PR + an `@codex review`
-# comment. Never substitute a local Codex review mechanism.
-#
-# Vars (override per run: --vars '{"mode":"submit","focus":"migration safety"}'):
-#   mode             — full (default) | submit | rerun
-#                        full:   dedupe an up-to-date Codex review, else request + wait + collect
-#                        submit: request and stop at `pending` (no wait)
-#                        rerun:  request with --force even when HEAD is already reviewed
-#   baseBranch       — base for a newly created PR (default: existing PR base, else repo default)
-#   focus            — extra review focus appended to the @codex review request
-#   noWait           — "true" returns pending right after the request instead of polling
-#   waitTimeoutSec   — poll budget for Codex output (default 600)
-#   waitIntervalSec  — poll interval (default 30; do not poll aggressively)
-#   preReviewCmd     — project fast check run before requesting (empty = skipped).
-#                      TRUSTED CONFIG ONLY — executed via `sh -c` (task 0436 SECUA residual).
-#                      Never interpolate untrusted operator/LLM input into it.
-#   __runId          — injected by WorkflowAppService.run(); scopes .spur/run artifacts.
-
-"$schema": "@gobing-ai/spur/schemas/state-machine-workflow.schema.json"
-version: "1"
-name: pr-review
-kind: state-machine
-description: GitHub Codex PR-review spine — check → precheck → open → review
-iterationBound: 16
-initialState: check
-terminalStates:
-  - done
-  - pending
-  - failed
-failureStates:
-  - failed
-vars:
-  mode: "full"
-  baseBranch: ""
-  focus: ""
-  noWait: "false"
-  waitTimeoutSec: "600"
-  waitIntervalSec: "30"
-  spurBin: "spur"
-  preReviewCmd: ""
-  __runId: ""
-
-states:
-  - id: check
-    description: >
-      Soft probe: preflight (git/gh/repo checks, detached HEAD, dirty tree, base-branch refusal —
-      refused before any push can publish it) followed by the hygiene scan of base...HEAD
-      (secrets/.env/conflict markers BLOCK; debug residue WARNs). A preflight failure stops before
-      hygiene. Writes PASS|WARN|BLOCK|FAIL to .spur/run/${vars.__runId}-pr-check.status; always
-      exit 0, so a red gate routes through the transitions below.
-    onEnter:
-      # script-root retired for this workflow: actions call `$spurBin builder pr-<verb>` directly.
-      - kind: shell
-        options:
-          # (e) 0825: 7 lines — preflight+hygiene and their status fallback must land together
-          # (one verb now owns the whole probe; a split would half-probe the submission gate).
-          command: >-
-            STATUS_FILE=".spur/run/$__runId-pr-check.status";
-            mkdir -p .spur/run;
-            $spurBin builder pr-check --base "$baseBranch" --json --status-file "$STATUS_FILE"
-            > ".spur/run/$__runId-pr-check.json";
-            if [ ! -f "$STATUS_FILE" ]; then printf 'FAIL\n' > "$STATUS_FILE"; fi;
-            exit 0
-
-  - id: precheck
-    description: >
-      Optional project fast check (vars.preReviewCmd) before spending a review request.
-      Empty command records SKIP; a red check stops the run before request (fail loud).
-    onEnter:
-      - kind: shell
-        options:
-          # (e) 0825: 7 lines — unchanged shape (optional preReviewCmd probe, SKIP/PASS/FAIL)
-          # condensed onto folded one-liners to hold the §1.2 budget.
-          command: >-
-            mkdir -p .spur/run; if [ -z "$preReviewCmd" ]; then R=SKIP; elif sh -c "$preReviewCmd"; then R=PASS; else R=FAIL; fi; printf '%s\n' "$R" > ".spur/run/$__runId-pr-precheck.status"
-
-  - id: open
-    description: >
-      Publish the branch (normal push only, never force; sets upstream when missing) and reuse or
-      create its PR — a rejected push stops before any PR work. Writes FOUND|CREATED|FAIL to
-      .spur/run/${vars.__runId}-pr-open.status and the composed record (push + pr) to
-      .spur/run/${vars.__runId}-pr-open.json.
-    onEnter:
-      - kind: shell
-        options:
-          # (e) 0825: 7 lines — publish + PR dedupe are one verb now; the status fallback keeps a
-          # silent driver from passing the gate.
-          command: >-
-            STATUS_FILE=".spur/run/$__runId-pr-open.status";
-            mkdir -p .spur/run;
-            $spurBin builder pr-open --base "$baseBranch" --json --status-file "$STATUS_FILE"
-            > ".spur/run/$__runId-pr-open.json";
-            if [ ! -f "$STATUS_FILE" ]; then printf 'FAIL\n' > "$STATUS_FILE"; fi;
-            exit 0
-
-  - id: review
-    description: >
-      Request, wait for and collect the `@codex review` result on the current pushed HEAD
-      (per-HEAD dedupe unless mode=rerun; mode=submit or noWait=true stop at PENDING). Writes
-      CLEAN|FINDINGS|PENDING|FAIL to .spur/run/${vars.__runId}-pr-review.status — a wait timeout
-      is PENDING, never a failure — plus the composed findings record and the composite status.
-    onEnter:
-      - kind: shell
-        options:
-          # (e) 0825: 10 lines — request/wait/collect are one verb now, so their result lands
-          # atomically; the status fallback covers a crashed driver. `mode=submit` or `noWait=true`
-          # pass --no-wait and `mode=rerun` passes --force, each as its own space-separated word
-          # (two substitutions, never concatenated). `/bin/sh -c` carries no `-e`, so a failed
-          # substitution is ignored.
-          command: >-
-            O="$([ "$mode" = submit ] || [ "$noWait" = "true" ] && echo --no-wait) $([ "$mode" = rerun ] && echo --force)";
-            STATUS_FILE=".spur/run/$__runId-pr-review.status";
-            mkdir -p .spur/run;
-            $spurBin builder pr-review --focus "$focus" $O --timeout "$waitTimeoutSec" --interval "$waitIntervalSec"
-            --json --status-file "$STATUS_FILE" > ".spur/run/$__runId-pr-findings.json";
-            if [ ! -f "$STATUS_FILE" ]; then printf 'FAIL\n' > "$STATUS_FILE"; fi;
-            exit 0
-      - kind: shell
-        options:
-          # The report reads the same composite PR/CI/Codex artifact as before (read-only, so a
-          # failed probe records its own error object instead of failing the collected run).
-          command: >-
-            $spurBin builder pr-status --json > ".spur/run/$__runId-pr-status.json" || true
-
-  - id: done
-    description: Terminal — review collected; findings artifact at .spur/run/${vars.__runId}-pr-findings.json
-  - id: pending
-    description: Terminal — review requested (or timed out) but not yet collected; run /sp:dev-pr-review status later
-  - id: failed
-    description: Terminal — a gate went red; the stage .status/.json artifacts under .spur/run name the blocker
-
-transitions:
-  - from: check
-    to: precheck
-    description: Clean or warn-only — warnings ride along to the report
-    guard:
-      kind: shell
-      options:
-        command: 'grep -qE "^(PASS|WARN)$" .spur/run/$__runId-pr-check.status 2>/dev/null'
-  - from: check
-    to: failed
-    terminalReason: failed-check
-    description: BLOCK (secrets/.env/conflict markers), a preflight failure (detached HEAD, dirty tree, gh auth, no GitHub remote, or the current branch being the base branch), or a probe failure — stop before any publishing
-    guard:
-      kind: always
-
-  - from: precheck
-    to: open
-    description: Project fast check passed or was skipped
-    guard:
-      kind: shell
-      options:
-        command: 'grep -qE "^(PASS|SKIP)$" .spur/run/$__runId-pr-precheck.status 2>/dev/null'
-  - from: precheck
-    to: failed
-    terminalReason: failed-check
-    description: Project checks red — do not spend a review request on code that fails its own gate
-    guard:
-      kind: always
-
-  - from: open
-    to: review
-    description: Branch published and PR found or created
-    guard:
-      kind: shell
-      options:
-        command: 'grep -qE "^(FOUND|CREATED)$" .spur/run/$__runId-pr-open.status 2>/dev/null'
-  - from: open
-    to: failed
-    terminalReason: failed-check
-    description: Push rejected (e.g. non-fast-forward — report; never force-push as a workaround) or no reviewable delta or PR creation failed
-    guard:
-      kind: always
-
-  - from: review
-    to: done
-    description: Current-HEAD review collected (CLEAN/FINDINGS)
-    guard:
-      kind: shell
-      options:
-        command: 'grep -qE "^(FINDINGS|CLEAN)$" .spur/run/$__runId-pr-review.status 2>/dev/null'
-  - from: review
-    to: pending
-    description: Request in flight, mode=submit/noWait, or a wait timeout — pending, not failed (collect later)
-    guard:
-      kind: shell
-      options:
-        command: 'test "$(cat .spur/run/$__runId-pr-review.status 2>/dev/null)" = PENDING'
-  - from: review
-    to: failed
-    terminalReason: failed-check
-    description: Review probe itself failed (no PR, gh error, moved HEAD)
-    guard:
-      kind: always

package/config/workflows/wayfinder-resolution.yaml

@@ -1,302 +0,0 @@
-# Wayfinder resolution pipeline — research/specification tasks without the code
-# implementation pipeline (no task-pipeline / /sp:dev-run recursion).
-#
-# Reliability (aligned with task-pipeline / ADR-043):
-#   - Soft precheck (task check + show) → failed via transitions (status file, always exit 0);
-#     the show capture doubles as the investigate input bundle (0769: the separate collect
-#     state re-ran the same CLI reads with no write in between — deleted)
-#   - investigate→verify passes only on a non-empty answer capture (fail-closed both ways)
-#   - verify is an independent fresh-session observe-only reviewer over the standard verdict
-#     contract (`spur task verdict --from-answer` + proof digest bracket + verify-verdict
-#     artifact) — 0769 retires the ad-hoc PASS-word file and the >5-line/>60-word padding
-#     metrics; evidence citations must still be truthful (grep -n anchors)
-#   - HITL approve routing is exhaustive (yes/no/cancel)
-#   - record captures `task record` → `task update done --no-lifecycle` into a status file;
-#     record → done is fail-closed on the captured result + persisted status readback — an
-#     exit 0 never converts a denied record into success (0769)
-#   - Free-form agent inputs are intentional: no pure-slash research surface yet
-
-"$schema": "@gobing-ai/spur/schemas/state-machine-workflow.schema.json"
-version: "1"
-kind: state-machine
-name: wayfinder-resolution
-description: "Reusable resolution pipeline for research/specification tasks without invoking the code implementation pipeline"
-iterationBound: 20
-initialState: precheck
-terminalStates:
-  - done
-  - failed
-  - cancelled
-failureStates:
-  - failed
-  - cancelled
-vars:
-  wbs: "0000"
-  profile: "standard"
-  spurBin: "spur"
-  agent: "auto"
-  stepTimeoutMs: "1800000"
-  approval: "required"
-  # Accepted/deferred status the approve gate's decision binding writes (1236 R2).
-  approvalStatus: ""
-  resolutionMode: "research"
-  evidencePolicy: "spur-cli-first"
-  __hitlAnswer: ""
-  # R8 (0366): injected by WorkflowAppService.run(); run-scopes every capture.
-  __runId: ""
-  # Resolved per-run by the verify state's taskpath shell step; folded into the proof
-  # digest via taskFile (docs/tasks* is excluded from the digest's git-tree half).
-  taskSpecPath: ""
-  # Proof-state bracket (docs-pipeline precedent): canonical capture at verify entry,
-  # live re-capture after the verifier; the verify → record guard compares them.
-  proofDigest: ""
-  proofDigestNow: ""
-
-states:
-  - id: precheck
-    description: >
-      Soft precheck: task check + show, status file, always exit 0 so failures
-      route to `failed` via transitions (not a raw lifecycle abort). The `task show`
-      capture is reused as the investigate input bundle — no separate collect state
-      (0769: same reads, no intervening write, no re-run).
-    onEnter:
-      - kind: shell
-        options:
-          # (e) 0825: 8 lines — task check + show capture the investigate input bundle in the
-          # same soft probe; show must stay verbatim (it IS the bundle downstream reads).
-          command: >-
-            mkdir -p .spur/run; $spurBin task check $wbs; c=$?; $spurBin task show $wbs --json > .spur/run/$__runId-wayfinder-input.json && [ "$c" -eq 0 ] && printf 'PASS\n' > .spur/run/$__runId-wayfinder-precheck.status || printf 'FAIL\n' > .spur/run/$__runId-wayfinder-precheck.status; exit 0
-      - kind: note
-        options:
-          message: "Wayfinder resolution started for task ${vars.wbs} (mode=${vars.resolutionMode}, evidence=${vars.evidencePolicy}); no code implementation pipeline is permitted."
-
-  - id: investigate
-    description: "Resolve the task's research/specification requirements and author evidence-backed sections through Spur CLI."
-    onEnter:
-      - kind: agent.run
-        options:
-          agent: ${vars.agent}
-          capture: true
-          # Declared Layer-1 role (0538 R2): routing reason beside the agent: pin.
-          role: planner
-          mode: text
-          # (e) 0825: bounded reference-reading prompt (260 chars) — the authoring contract
-          # lives in the skill reference sp:wayfinder references/pipeline-resolution.md.
-          input: >-
-            Resolve wayfinder task ${vars.wbs} per the sp:wayfinder skill (references/pipeline-resolution.md). Mode ${vars.resolutionMode}; evidence policy ${vars.evidencePolicy}; bundle .spur/run/${vars.__runId}-wayfinder-input.json. Finish with a short summary and stop.
-          answerFile: .spur/run/${vars.__runId}-wayfinder-answer.md
-          expectFile: .spur/run/${vars.__runId}-wayfinder-answer.md
-          timeoutMs: ${vars.stepTimeoutMs}
-
-  - id: verify
-    description: >
-      Independent, observe-only measured verification (0769): a fresh-session reviewer runs
-      /sp:dev-verify --fix none, the standard `spur task verdict` contract derives ONE verdict,
-      and a proof-input digest bracket fails closed on verifier-time mutation. Retires the
-      ad-hoc resolution-verdict PASS-word file. The verifier never repairs and never edits
-      task sections.
-    onEnter:
-      - kind: shell
-        options:
-          command: "mkdir -p .spur/run && rm -f .spur/run/$__runId-wayfinder-verify-answer.txt .spur/run/$wbs-verdict.json"
-      # Fail-closed task-path lookup (0760 R1 pattern): the resolved path folds into the
-      # proof digest via taskFile; a silent miss would degrade the proof to tree-only.
-      - kind: shell
-        options:
-          # (e) 0825: 6 lines — fail-closed lookup feeds every downstream artifact name;
-          # folding a silent miss into the digest would fake tree coverage.
-          command: >-
-            set -e;
-            task_path="$($spurBin task path $wbs --json | jq -r '.path // .filePath // empty')";
-            if [ -z "$task_path" ]; then echo "wayfinder-resolution: task path did not resolve for wbs $wbs" >&2; exit 1; fi;
-            printf '%s' "$task_path" > ".spur/run/$__runId-wayfinder-taskpath.txt"
-      - kind: file.read.into-var
-        options:
-          path: .spur/run/${vars.__runId}-wayfinder-taskpath.txt
-          var: taskSpecPath
-      - kind: proof.fingerprint
-        options:
-          var: proofDigest
-          taskFile: ${vars.taskSpecPath}
-          input: /sp:dev-verify ${vars.wbs} --auto --fix none --focus all
-          timeoutMs: ${vars.stepTimeoutMs}
-      - kind: agent.run
-        options:
-          agent: ${vars.agent}
-          capture: true
-          # Declared Layer-1 role (0538 R2): routing reason beside the agent: pin.
-          role: reviewer
-          mode: text
-          # Observe-only + fresh session (ADR-071 / 0710 R2 precedent): the verifier
-          # certifies, it never repairs and never inherits the investigate session.
-          freshSession: true
-          input: /sp:dev-verify ${vars.wbs} --auto --fix none --focus all
-          answerFile: .spur/run/${vars.__runId}-wayfinder-verify-answer.txt
-          expectFile: .spur/run/${vars.__runId}-wayfinder-verify-answer.txt
-          timeoutMs: ${vars.stepTimeoutMs}
-      - kind: shell
-        options:
-          command: "$spurBin task verdict $wbs --from-answer .spur/run/$__runId-wayfinder-verify-answer.txt"
-      - kind: shell
-        options:
-          # (e) 0825: 6 lines — stamp shell freezes the proof digest + capture point into the
-          # verdict before it is registered; the closing guard compares against this stamp.
-          command: >-
-            V=".spur/run/$wbs-verdict.json";
-            if [ -f "$V" ] && [ -n "$proofDigest" ]; then
-              jq --arg d "$proofDigest" --arg r "$__runId" '. + {proof: {digest: $d, capturePoint: "wayfinder-verify-entry", runId: $r}}' "$V" > "$V.tmp" && mv "$V.tmp" "$V";
-            fi;
-            exit 0
-      - kind: run.artifact
-        options:
-          path: .spur/run/${vars.wbs}-verdict.json
-          artifactKind: verify-verdict
-      - kind: proof.fingerprint
-        options:
-          var: proofDigestNow
-          taskFile: ${vars.taskSpecPath}
-          input: /sp:dev-verify ${vars.wbs} --auto --fix none --focus all
-          timeoutMs: ${vars.stepTimeoutMs}
-
-  - id: approve
-    description: "Human review gate unless the caller explicitly selects auto approval (vars.approval=auto)."
-    onEnter:
-      - kind: hitl.confirm
-        options:
-          prompt: "Approve research resolution for task ${vars.wbs}?"
-          # Interactive always prompts the operator; profile=auto answers from the
-          # verifier's recorded evidence (1236 R1/R2). No `pause: true` — an evidence
-          # binding cannot live in a paused state (0911 D2).
-          decision:
-            mode: evidence
-            statusVar: approvalStatus
-            evidenceNodes:
-              - verify
-      # A deferred/absent answer is the denial today's headless responder gave.
-      - kind: shell
-        options:
-          command: >-
-            mkdir -p .spur/run; a="$__hitlAnswer"; [ -n "$a" ] || a=no;
-            printf '%s\n' "$a" > ".spur/run/$__runId-wayfinder-approve-answer.txt"
-      - kind: file.read.into-var
-        options:
-          path: .spur/run/${vars.__runId}-wayfinder-approve-answer.txt
-          var: __hitlAnswer
-
-  - id: record
-    description: >
-      Record the resolution AFTER measured verification (0769). The `task record` verb
-      backfills Solution from the diff and moves the task to testing; `task update done
-      --no-lifecycle` then completes it (this pipeline's own verify already produced the
-      standard verdict evidence). Both results are captured to a run-scoped status file and
-      the persisted status is read back — a denied record or a task that never reached done
-      routes to `failed` via the guards below and is never converted to success by exit 0.
-    onEnter:
-      - kind: shell
-        options:
-          command: >-
-            if $spurBin task record $wbs --solution-from-diff --transition testing &&
-               $spurBin task update $wbs done --no-lifecycle; then
-              printf 'PASS\n' > ".spur/run/$__runId-wayfinder-final.status";
-            else
-              printf 'FAIL\n' > ".spur/run/$__runId-wayfinder-final.status";
-            fi;
-            $spurBin task show $wbs --json | jq -r '.status // empty' > ".spur/run/$__runId-wayfinder-status.txt"
-
-  - id: done
-    description: "Research task resolved and ready to feed the implementation backlog."
-    onEnter:
-      - kind: note
-        options:
-          message: "Wayfinder research task ${vars.wbs} resolved; implementation remains deferred to the synthesized build backlog."
-
-  - id: failed
-    description: "Research resolution failed a gate; no completion transition is attempted."
-
-  - id: cancelled
-    description: "Operator cancelled the research resolution."
-
-transitions:
-  - from: precheck
-    to: investigate
-    description: "Precheck PASS — resolve the research task (input bundle captured at precheck)."
-    guard:
-      kind: shell
-      options:
-        command: 'test "$(cat .spur/run/$__runId-wayfinder-precheck.status 2>/dev/null)" = PASS'
-  - from: precheck
-    to: failed
-    terminalReason: failed-check
-    description: "Precheck FAIL — stop before delegation."
-    guard:
-      kind: always
-  - from: investigate
-    to: verify
-    description: "Research resolution authored — verify evidence and traceability. Guard enforces a non-empty answer capture (fail-closed both ways)."
-    guard:
-      kind: shell
-      options:
-        command: 'test -s .spur/run/$__runId-wayfinder-answer.md'
-  - from: investigate
-    to: failed
-    terminalReason: failed-agent
-    description: "Empty answer capture — investigate produced nothing to verify; stop rather than certify hollow evidence."
-    guard:
-      kind: shell
-      options:
-        command: '! test -s .spur/run/$__runId-wayfinder-answer.md'
-  - from: verify
-    to: record
-    description: "Auto profile — record only on a measured PASS verdict with the proof bracket intact (fail-closed to the approve gate otherwise)."
-    guard:
-      kind: shell
-      options:
-        # (e) 0825: 5-line guard — approval + digest-bracket + verdict PASS must all hold
-        # before record; dropping any operand would let a stale proof auto-record.
-        command: >-
-          test "$approval" = auto &&
-          test -n "$proofDigest" &&
-          test "$proofDigestNow" = "$proofDigest" &&
-          test -f ".spur/run/$wbs-verdict.json" &&
-          test "$(jq -r '.verdict // empty' .spur/run/$wbs-verdict.json 2>/dev/null)" = PASS
-  - from: verify
-    to: approve
-    description: "Verification completed — require explicit review approval."
-    guard:
-      kind: always
-  - from: approve
-    to: record
-    description: "Operator approved the research resolution."
-    guard:
-      kind: shell
-      options:
-        command: 'test "$__hitlAnswer" = yes'
-  - from: approve
-    to: cancelled
-    terminalReason: cancelled
-    description: "Operator cancelled the research resolution."
-    guard:
-      kind: shell
-      options:
-        command: 'test "$__hitlAnswer" = cancel'
-  - from: approve
-    to: failed
-    terminalReason: cancelled
-    description: "Operator rejected the research resolution."
-    guard:
-      kind: shell
-      options:
-        command: 'test "$__hitlAnswer" = no'
-  - from: record
-    to: done
-    description: "Captured record result PASS and the persisted status readback is actually done."
-    guard:
-      kind: shell
-      options:
-        command: 'test "$(cat .spur/run/$__runId-wayfinder-final.status 2>/dev/null)" = PASS && test "$(cat .spur/run/$__runId-wayfinder-status.txt 2>/dev/null)" = done'
-  - from: record
-    to: failed
-    terminalReason: failed-check
-    description: "Recording failed, was denied, or the task never reached done — stop without claiming completion."
-    guard:
-      kind: always

package/plugins/sp/skills/wayfinder/references/pipeline-resolution.md

@@ -1,30 +0,0 @@
-# Wayfinder resolution-pipeline authoring contract
-
-Reference for the `wayfinder-resolution` workflow's `investigate` hop. The pipeline passes a
-bounded pointer prompt; this page carries the full authoring contract the hop must follow.
-Context variables (`${vars.wbs}`, `${vars.resolutionMode}`, `${vars.evidencePolicy}`) are
-resolved by the engine before the hop runs.
-
-## Research boundary (preserve the research boundary)
-
-- Work only from the prepared local bundle `.spur/run/<runId>-wayfinder-input.json`, local
-  shell/file reads, and the `spur` CLI. Do not use network search or MCP tools.
-- Do not invoke `task-pipeline.yaml`, `/sp:dev-run`, `/sp:dev-runall`, or any code
-  implementation pipeline. This hop authors research/specification sections — it never
-  implements.
-
-## Procedure
-
-1. Read the task file for `<wbs>` and map its existing Requirements and Acceptance Criteria
-   onto the existing Design/Plan/References sections.
-2. Author concise Solution, Testing, and Review sections through
-   `spur task update --section --from-file` (write each section to a file, then pass it).
-3. Finish with a short summary and stop.
-
-## Evidence-anchor contract (mandatory — 0299 R1 line-anchor rule)
-
-When the task's evidence lives in a shared evidence file, anchor every Solution/Testing
-`file:line` citation truthfully — resolve the section's real start line with
-`grep -n "^## <wbs> " <evidence-file>` and cite that exact line. NEVER copy a line number
-from another ticket's example; each WBS anchors to its own section. Before finishing, re-read
-each cited line and confirm it names the requirement's subject.

package/web/_astro/channel.qgOLXjI_.js

@@ -1 +0,0 @@
-import{ah as o,ai as n}from"./mermaid.core.BDQ2FoPd.js";const t=(a,r)=>o.lang.round(n.parse(a)[r]);export{t as c};