@gobing-ai/spur 0.3.73 → 0.3.75

package/config/workflow-composition-baseline.json

@@ -1,615 +0,0 @@
-{
-    "schemaVersion": 1,
-    "workflows": {
-        "docs-pipeline": {
-            "definition": "config/workflows/docs-pipeline.yaml",
-            "terminalStates": ["done", "failed", "cancelled"],
-            "modelQueries": ["draft", "verify"],
-            "actions": {
-                "precheck:onEnter:0": {
-                    "kind": "command.gate"
-                },
-                "precheck:onEnter:1": {
-                    "kind": "command.gate"
-                },
-                "precheck:onEnter:2": {
-                    "kind": "shell",
-                    "invocation": "if test \"$(cat .spur/run/$wbs-docs-precheck-task.status 2>/dev/null)\" = PASS &&\n   test \"$(cat .spur/run/$wbs-docs-precheck-agent.status 2>/dev/null)\" = PASS;\nthen printf 'PASS\\n' > \".spur/run/$wbs-docs-precheck.status\"; else printf 'FAIL\\n' > \".spur/run/$wbs-docs-precheck.status\"; fi"
-                },
-                "precheck:onEnter:3": {
-                    "kind": "note"
-                },
-                "draft:onEnter:0": {
-                    "kind": "agent.run",
-                    "invocation": "/sp:dev-run --mode implement ${vars.wbs} --auto"
-                },
-                "draft:onEnter:1": {
-                    "kind": "shell",
-                    "invocation": "$spurBin task update $wbs wip --no-lifecycle"
-                },
-                "docs-review:onEnter:0": {
-                    "kind": "hitl.confirm"
-                },
-                "record:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "$spurBin task record $wbs --solution-from-diff --transition testing"
-                },
-                "done:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "$spurBin task update $wbs done --no-lifecycle"
-                },
-                "done:onEnter:1": {
-                    "kind": "note"
-                },
-                "verify:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "set -e; task_path=\"$($spurBin task path $wbs --json | jq -r '.path // .filePath // empty')\"; if [ -z \"$task_path\" ]; then echo \"docs-pipeline: task path did not resolve for wbs $wbs\" >&2; exit 1; fi; printf '%s' \"$task_path\" > \".spur/run/$wbs-docs-taskpath.txt\""
-                },
-                "verify:onEnter:1": {
-                    "kind": "file.read.into-var"
-                },
-                "verify:onEnter:2": {
-                    "kind": "proof.fingerprint",
-                    "invocation": "/sp:dev-verify ${vars.wbs} --auto --fix none --focus all"
-                },
-                "verify:onEnter:3": {
-                    "kind": "agent.run",
-                    "invocation": "/sp:dev-verify ${vars.wbs} --auto --fix none --focus all"
-                },
-                "verify:onEnter:4": {
-                    "kind": "shell",
-                    "invocation": "$spurBin task verdict $wbs --from-answer .spur/run/$wbs-verify-answer.txt"
-                },
-                "verify:onEnter:5": {
-                    "kind": "shell",
-                    "invocation": "V=\".spur/run/$wbs-verdict.json\"; if [ -f \"$V\" ] && [ -n \"$proofDigest\" ]; then\n  jq --arg d \"$proofDigest\" '. + {proof: {digest: $d, capturePoint: \"docs-verify-entry\"}}' \"$V\" > \"$V.tmp\" && mv \"$V.tmp\" \"$V\";\nfi; exit 0"
-                },
-                "verify:onEnter:6": {
-                    "kind": "run.artifact"
-                },
-                "verify:onEnter:7": {
-                    "kind": "proof.fingerprint",
-                    "invocation": "/sp:dev-verify ${vars.wbs} --auto --fix none --focus all"
-                }
-            }
-        },
-        "idea-pipeline": {
-            "definition": "config/workflows/idea-pipeline.yaml",
-            "terminalStates": ["handoff", "cancelled", "failed"],
-            "modelQueries": ["discovery", "feature-create", "ac-generate", "system-design", "decompose"],
-            "actions": {
-                "start:onEnter:0": {
-                    "kind": "note"
-                },
-                "start:onEnter:1": {
-                    "kind": "doctor.probe"
-                },
-                "start:onEnter:2": {
-                    "kind": "shell",
-                    "invocation": "test -n \"$idea\" || printf 'FAIL\\n' > \".spur/run/$__runId-idea-precheck-doctor.status\""
-                },
-                "discovery:onEnter:0": {
-                    "kind": "agent.run",
-                    "invocation": "Run sp:brainstorm for the idea: ${vars.idea}. The skill owns the approach-generation, design summary, and `needs_design` signal criteria; emit .spur/run/${vars.__runId}-idea-needs-design.json ({\"needs_design\": true|false}) and the design summary per the skill's `Design Approval Gate` and `The needs_design signal` sections. Also emit the idea-evaluation report to .spur/run/${vars.__runId}-idea-eval-report.md per the `sp:spur-dev` skill's `idea-evaluation` reference (urgency/necessity 0–5, premises, pros/cons, alternatives, enhanced idea, recommendation). At the END of the report, append a provenance footer block of the exact form: `---\\nrun_id: ${vars.__runId}\\ngenerated_at: <RFC3339 timestamp>\\n---` (omit the footer only if run_id is empty)."
-                },
-                "idea-eval:onEnter:0": {
-                    "kind": "hitl.confirm"
-                },
-                "feature-create:onEnter:0": {
-                    "kind": "agent.run",
-                    "invocation": "Create a feature for the idea: ${vars.idea}. Read .spur/run/${vars.__runId}-idea-eval-report.md if present for the enhanced idea and scores. Use 'spur feature create \"<name>\" --json' to create it. Write the feature id to .spur/run/${vars.__runId}-idea-feature-id.txt. If an existing feature is appropriate, use its id instead. Also write two body-only intent artifacts: .spur/run/${vars.__runId}-idea-goal.md with concise Goal intent only (a short statement of what the feature achieves; never task breakdowns, checklists, or how-to steps), and .spur/run/${vars.__runId}-idea-scope.md with explicit in-scope and out-of-scope boundary bullets."
-                },
-                "feature-create:onEnter:1": {
-                    "kind": "file.read.into-var"
-                },
-                "feature-create:onEnter:2": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run && test -s .spur/run/$__runId-idea-goal.md && $spurBin feature update \"$featureId\" --section Goal --from-file .spur/run/$__runId-idea-goal.md"
-                },
-                "feature-create:onEnter:3": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run && test -s .spur/run/$__runId-idea-scope.md && $spurBin feature update \"$featureId\" --section Scope --from-file .spur/run/$__runId-idea-scope.md"
-                },
-                "ac-generate:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run && count=$(cat .spur/run/$__runId-idea-ac-retry-count 2>/dev/null || echo 0); echo $((count + 1)) > .spur/run/$__runId-idea-ac-retry-count; rm -f .spur/run/$__runId-idea-ac-content.md .spur/run/$__runId-idea-ac-done.txt"
-                },
-                "ac-generate:onEnter:1": {
-                    "kind": "agent.run",
-                    "invocation": "Generate acceptance criteria for feature ${vars.featureId}. Read the feature file and author R-numbered BDD Gherkin scenarios per ac-style-guide.md. Output only the complete Acceptance Criteria section body, including the gherkin code fence, with no surrounding commentary and no section heading."
-                },
-                "ac-generate:onEnter:2": {
-                    "kind": "shell",
-                    "invocation": "if test -s .spur/run/$__runId-idea-ac-content.md; then\n  $spurBin feature update \"$featureId\" --section \"Acceptance Criteria\" --from-file .spur/run/$__runId-idea-ac-content.md && date -u +%Y-%m-%dT%H:%M:%SZ > .spur/run/$__runId-idea-ac-done.txt;\nelse\n  exit 0;\nfi"
-                },
-                "feature-check:onEnter:0": {
-                    "kind": "hitl.confirm"
-                },
-                "system-design:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run && REVIEW=\".spur/run/$__runId-idea-design-review.md\" && test -f \"$REVIEW\" || printf '## Proposed design\\n\\n## Operator feedback\\n\\n## Reconciliation\\n' > \"$REVIEW\""
-                },
-                "system-design:onEnter:1": {
-                    "kind": "agent.run",
-                    "invocation": "Run sp:sys-architecture for feature ${vars.featureId}. Read the brainstorm artifact, feature AC, and .spur/run/${vars.__runId}-idea-design-review.md. Produce ADR entries, architecture updates, and design satellites (docs/design/<slug>.md) following the constitution edit rules. Do not write task or feature corpus files directly. Design-review contract (.spur/run/${vars.__runId}-idea-design-review.md, fixed headings `## Proposed design`, `## Operator feedback`, `## Reconciliation`): on the first pass write the proposed design summary under `## Proposed design` and leave `## Operator feedback` empty; on retry with operator feedback present, revise the design/ADR artifacts, document the changes under `## Reconciliation`, and when the feedback invalidates an Acceptance Criteria scenario write the revised AC section body to a file and persist it via `$spurBin feature update \"$featureId\" --section \"Acceptance Criteria\" --from-file <file>` — never edit feature corpus files directly."
-                },
-                "system-design:onEnter:2": {
-                    "kind": "shell",
-                    "invocation": "REVIEW=\".spur/run/$__runId-idea-design-review.md\" && awk '/^## Proposed design/{f=1; next} /^## Operator feedback/{f=0} f' \"$REVIEW\" | grep -q '[^[:space:]]'"
-                },
-                "design-approval:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run && count=$(cat .spur/run/$__runId-idea-design-reject-count 2>/dev/null || echo 0); echo $((count + 1)) > .spur/run/$__runId-idea-design-reject-count"
-                },
-                "design-approval:onEnter:1": {
-                    "kind": "hitl.confirm"
-                },
-                "decompose:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run && count=$(cat .spur/run/$__runId-idea-decompose-retry-count 2>/dev/null || echo 0); echo $((count + 1)) > .spur/run/$__runId-idea-decompose-retry-count; rm -f .spur/run/$__runId-idea-task-batch.json .spur/run/$__runId-idea-task-order.json .spur/run/$__runId-idea-batch-create.done .spur/run/$__runId-idea-batch-create.failed .spur/run/$__runId-idea-batch-create-result.json .spur/run/$__runId-idea-handoff.md"
-                },
-                "decompose:onEnter:1": {
-                    "kind": "agent.run",
-                    "invocation": "Run sp:spec-decomposition for feature ${vars.featureId}. Read the brainstorm artifact, feature AC, and design doc. SIZING FIRST, before any JSON: apply the skill's `Default to NOT decomposing` rubric to the whole unit of work — if it scores 0-2 the correct output is a ONE-entry batch, not many. Scenario count is not task count: merge scenarios that one task delivers (same file surface, same subsystem, or unreadable apart in review), and list every scenario a task covers in its background. Merging never costs AC coverage — one task may carry several scenarios. Do not emit one entry per scenario or per requirement by reflex. Then produce a task-batch JSON array at .spur/run/${vars.__runId}-idea-task-batch.json, validated against task-batch.schema.json. Schema-permitted fields per entry: `name`, `background`, `requirements`, `feature_id`, `parent_wbs`, `priority`, `tags`, `template` — schema validation rejects anything else. Acceptance Criteria, Design, and Plan sections are filled in by the per-task refine step after batch-create, NOT at decompose time. Validate locally against the schema before emitting. Also emit the private task-order sidecar at .spur/run/${vars.__runId}-idea-task-order.json: a JSON array (one entry per batch item) of `{ name: <exact batch item name>, depends_on_names: [<batch item names>] }` declaring ordering/dependencies between the batch items; use `[]` when no ordering exists. Every `name` and every dependency must match exactly one batch item `name` — it is private workflow data, not part of task-batch.schema.json."
-                },
-                "decompose:onEnter:2": {
-                    "kind": "shell",
-                    "invocation": "BATCH=\".spur/run/$__runId-idea-task-batch.json\" && ORDER=\".spur/run/$__runId-idea-task-order.json\" && jq -e --slurpfile b \"$BATCH\" '\n  (type == \"array\") and\n  (($b[0] | map(.name) | length) == ($b[0] | map(.name) | unique | length)) and\n  ((map(.name) | length) == (map(.name) | unique | length)) and\n  ((map(.name) - ($b[0] | map(.name))) | length == 0) and\n  ((($b[0] | map(.name)) - map(.name)) | length == 0) and\n  (((map(.depends_on_names // []) | flatten | unique) - ($b[0] | map(.name))) | length == 0)\n' \"$ORDER\" >/dev/null"
-                },
-                "batch-create:onEnter:0": {
-                    "kind": "hitl.confirm"
-                },
-                "batch-create-run:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "if test -f .spur/run/$__runId-idea-batch-create.done; then exit 0; fi; rm -f .spur/run/$__runId-idea-batch-create.failed .spur/run/$__runId-idea-batch-create-result.json .spur/run/$__runId-idea-batch-create-result.json.tmp; if $spurBin task batch-create --file .spur/run/$__runId-idea-task-batch.json --json > .spur/run/$__runId-idea-batch-create-result.json.tmp && jq -e \".created == (.wbs | length)\" .spur/run/$__runId-idea-batch-create-result.json.tmp >/dev/null 2>&1; then\n  mv .spur/run/$__runId-idea-batch-create-result.json.tmp .spur/run/$__runId-idea-batch-create-result.json &&\n  date -u +%Y-%m-%dT%H:%M:%SZ > .spur/run/$__runId-idea-batch-create.done;\nelse\n  rm -f .spur/run/$__runId-idea-batch-create-result.json.tmp;\n  date -u +%Y-%m-%dT%H:%M:%SZ > .spur/run/$__runId-idea-batch-create.failed;\nfi"
-                },
-                "handoff-finalize:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "if [ -f packages/app/src/workflow/idea-handoff-cli.ts ]; then\n  bun packages/app/src/workflow/idea-handoff-cli.ts;\n  exit $?;\nfi; BATCH=\".spur/run/$__runId-idea-task-batch.json\" && RESULT=\".spur/run/$__runId-idea-batch-create-result.json\" && ORDER=\".spur/run/$__runId-idea-task-order.json\" && REPORT=\".spur/run/$__runId-idea-handoff.md\" && DEPMAP=\".spur/run/$__runId-idea-dep-map.tsv\" && CHECKS=\".spur/run/$__runId-idea-check-results.jsonl\" && rm -f \"$DEPMAP\" \"$CHECKS\" && jq -e --slurpfile b \"$BATCH\" '(.wbs | length) == ($b[0] | length) and (($b[0] | map(.name) | unique | length) == ($b[0] | length))' \"$RESULT\" >/dev/null && jq -r --slurpfile b \"$BATCH\" --slurpfile r \"$RESULT\" --slurpfile o \"$ORDER\" '\n  ($b[0] | map(.name)) as $names | ($r[0].wbs) as $wbs |\n  $o[0] | .[] |\n  (.name as $n | $names | index($n)) as $i |\n  (if $i == null or $wbs[$i] == null then \"MISSING\" else $wbs[$i] end) as $own |\n  ((.depends_on_names // []) | map(. as $dep | $names | index($dep) as $d | if $d == null then \"MISSING\" else $wbs[$d] end) | join(\" \")) as $deps |\n  [.name, $own, $deps] | @tsv\n' \"$ORDER\" > \"$DEPMAP\" && while IFS=\"$(printf '\\t')\" read -r name own deps; do\n  test \"$own\" != MISSING || exit 1;\n  if test -n \"$deps\"; then\n    for d in $deps; do test \"$d\" != MISSING || exit 1; done;\n    $spurBin task deps \"$own\" set $deps --json >/dev/null || exit 1;\n  fi;\ndone < \"$DEPMAP\" && $spurBin feature refresh --feature \"$featureId\" --json >/dev/null && WBS_LIST=$(jq -r '.wbs | join(\" \")' \"$RESULT\") && for wbs in $WBS_LIST; do\n  TMP=\".spur/run/$__runId-idea-check-$wbs.tmp\";\n  if $spurBin task check \"$wbs\" --json > \"$TMP\" 2>&1; then P=true; else P=false; fi;\n  jq -c --arg w \"$wbs\" --argjson p \"$P\" 'if (type == \"array\" and length > 0) then {wbs: $w, pass: $p, status: (.[0].status // \"unknown\")} else {wbs: $w, pass: $p, status: \"missing\"} end' \"$TMP\" >> \"$CHECKS\" || exit 1;\n  rm -f \"$TMP\";\ndone && CHECK_ROWS=$(wc -l < \"$CHECKS\" | tr -d ' ') && WBS_COUNT=$(printf '%s\\n' $WBS_LIST | wc -l | tr -d ' ') && test \"$CHECK_ROWS\" = \"$WBS_COUNT\" && NEXT=$(jq -r --arg feature \"$featureId\" --slurpfile c \"$CHECKS\" 'if ($c | any(.[]; .pass == false)) then \"/sp:dev-refineall --feature \\($feature) --auto --depth ready\" else \"/sp:dev-runall --feature \\($feature) --auto\" end' \"$RESULT\") && {\n  echo \"# Idea pipeline handoff report\";\n  echo;\n  echo \"Feature: $featureId\";\n  echo \"Run ID: $__runId\";\n  echo;\n  echo \"## Created tasks\";\n  printf '%s\\n' $WBS_LIST | sed 's/^/  - /';\n  echo;\n  echo \"## Per-task readiness (spur task check)\";\n  echo;\n  echo \"| WBS | Outcome |\";\n  echo \"|-----|---------|\";\n  while IFS= read -r line; do\n    w=$(printf '%s' \"$line\" | jq -r '.wbs');\n    o=$(printf '%s' \"$line\" | jq -r 'if .pass then \"PASS\" else \"FAIL\" end');\n    printf '| %s | %s |\\n' \"$w\" \"$o\";\n  done < \"$CHECKS\";\n  echo;\n  echo \"## Next command\";\n  echo;\n  echo \"$NEXT\";\n} > \"$REPORT\""
-                },
-                "handoff:onEnter:0": {
-                    "kind": "note"
-                },
-                "handoff:onEnter:1": {
-                    "kind": "run.artifact"
-                },
-                "handoff:onEnter:2": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/memory/sessions && echo \"checkpoint: idea-pipeline handoff feature=$featureId ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)\" > .spur/memory/sessions/idea-checkpoint.md"
-                }
-            }
-        },
-        "task-pipeline": {
-            "definition": "config/workflows/task-pipeline.yaml",
-            "terminalStates": ["done", "failed", "cancelled"],
-            "modelQueries": ["implement", "test-fix", "review", "verify"],
-            "actions": {
-                "precheck:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "DIRTY=$(git status --porcelain -- . ':(exclude)docs/tasks*' ':(exclude)docs/features' 2>/dev/null); if [ -n \"$DIRTY\" ]; then\n  echo \"precheck: WARNING - working tree has uncommitted non-corpus changes; commit or stash before starting a new task:\";\n  echo \"$DIRTY\";\nfi; CORPUS_DIRTY=$(git status --porcelain -- ':(glob)docs/tasks*/**' 2>/dev/null); if [ -n \"$CORPUS_DIRTY\" ]; then\n  echo \"precheck: NOTE - task corpus has uncommitted changes; review before staging with this task:\";\n  echo \"$CORPUS_DIRTY\";\nfi; exit 0"
-                },
-                "precheck:onEnter:1": {
-                    "kind": "note"
-                },
-                "precheck:onEnter:2": {
-                    "kind": "shell",
-                    "invocation": "if [ \"$profile\" = auto ]; then\n  FID=$($spurBin task show $wbs --json 2>/dev/null |\n  jq -r '.feature_id // .frontmatter.feature_id // empty' 2>/dev/null);\n  if [ -n \"$FID\" ]; then\n    if ! $spurBin feature sync \"$FID\" --force 2>/dev/null; then\n    if ! $spurBin feature update \"$FID\" active 2>/dev/null; then\n    echo \"precheck: FAIL - feature reactivation $FID failed;\" >&2;\n    echo \"precheck: feature sync + feature update both errored\" >&2;\n    exit 1;\n    fi;\n    fi;\n  fi;\nfi; exit 0"
-                },
-                "precheck:onEnter:3": {
-                    "kind": "shell",
-                    "invocation": "SIZE_FILE=\".spur/run/$wbs-precheck-size.status\" && mkdir -p .spur/run && SIZE_SCRIPT=\"plugins/sp/scripts/task-size-precheck.ts\"; [ -f \"$SIZE_SCRIPT\" ] || SIZE_SCRIPT=\"$(superskill script path sp task-size-precheck.ts 2>/dev/null)\"; if [ -n \"$SIZE_SCRIPT\" ] && [ -f \"$SIZE_SCRIPT\" ]; then bun \"$SIZE_SCRIPT\" \"$wbs\" --spur-bin \"$spurBin\" --max-reqs \"$maxImplementReqs\" --max-plan-items \"$maxImplementPlanItems\"; else\n  echo \"task-size-precheck failed closed — checker not found in\" >&2 &&\n  echo \"plugins/sp/scripts/ nor staged; run 'superskill install sp'.\" >&2 &&\n  echo \"FAIL\" > \"$SIZE_FILE\";\nfi && exit 0"
-                },
-                "precheck:onEnter:4": {
-                    "kind": "shell",
-                    "invocation": "EVID_FILE=\".spur/run/$wbs-precheck-evidence.status\" && mkdir -p .spur/run && EVID_SCRIPT=\"plugins/sp/scripts/task-evidence-precheck.ts\"; [ -f \"$EVID_SCRIPT\" ] || EVID_SCRIPT=\"$(superskill script path sp task-evidence-precheck.ts 2>/dev/null)\"; if [ -n \"$EVID_SCRIPT\" ] && [ -f \"$EVID_SCRIPT\" ]; then bun \"$EVID_SCRIPT\" \"$wbs\" --spur-bin \"$spurBin\"; else\n  echo \"task-evidence-precheck failed closed — checker not found\" >&2 &&\n  echo \"in plugins/sp/scripts/ nor staged; run 'superskill install sp'.\" >&2 &&\n  echo \"FAIL\" > \"$EVID_FILE\";\nfi && exit 0"
-                },
-                "precheck:onEnter:5": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run .spur/memory && RUN_ID=\"$__runId\" && if [ -z \"$RUN_ID\" ]; then RUN_ID=\"pipeline-$wbs\"; fi && REASON_FILE=\".spur/run/$RUN_ID-route-reason.txt\" && if [ \"$mode\" = \"fast\" ]; then\n  echo \"fast:evidence complete+consistent\" > \"$REASON_FILE\";\nelif [ -z \"$mode\" ]; then\n  echo \"safety:standard verification\" > \"$REASON_FILE\";\nelif [ \"$mode\" = \"unknown\" ]; then\n  echo \"safety:unknown evidence quality\" > \"$REASON_FILE\";\nelif [ \"$mode\" = \"conflict\" ]; then\n  echo \"safety:conflicting evidence\" > \"$REASON_FILE\";\nelse\n  echo \"safety:unrecognized evidence (mode=$mode)\" > \"$REASON_FILE\";\nfi && printf '%s %s %s\\n' \"$RUN_ID\" \"$wbs\" \"$(cat \"$REASON_FILE\")\" >> .spur/memory/task-pipeline-routes.log && exit 0"
-                },
-                "implement:onEnter:0": {
-                    "kind": "agent.run",
-                    "invocation": "/sp:dev-run --mode implement ${vars.wbs} --auto"
-                },
-                "implement:onEnter:1": {
-                    "kind": "shell",
-                    "invocation": "retry_transient() {\n  RETRY_OUTPUT=$(\"$@\" 2>&1); RETRY_RC=$?;\n  printf '%s\\n' \"$RETRY_OUTPUT\";\n  if [ \"$RETRY_RC\" -eq 0 ]; then return 0; fi;\n  if ! printf '%s' \"$RETRY_OUTPUT\" | grep -Eq 'ENOENT|EBUSY|ENOTEMPTY|database is locked'; then return \"$RETRY_RC\"; fi;\n  sleep 2;\n  RETRY_SECOND_OUTPUT=$(\"$@\" 2>&1); RETRY_RC=$?;\n  printf '%s\\n' \"$RETRY_SECOND_OUTPUT\";\n  if [ \"$RETRY_RC\" -ne 0 ] && printf '%s\\n%s' \"$RETRY_OUTPUT\" \"$RETRY_SECOND_OUTPUT\" | grep -Eq 'ENOENT|EBUSY|ENOTEMPTY'; then\n    echo \"node_modules link/dependency broken — run bun install and retry\";\n  fi;\n  return \"$RETRY_RC\";\n}; retry_transient $spurBin task update \"$wbs\" wip --no-lifecycle"
-                },
-                "implement:onEnter:2": {
-                    "kind": "shell",
-                    "invocation": "$formatCmd ; exit 0"
-                },
-                "test:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run; $spurBin task path $wbs --json | jq -r \".path // .filePath // empty\" > \".spur/run/$wbs-taskpath.txt\"; task_path=\"$(cat \".spur/run/$wbs-taskpath.txt\")\"; if [ -z \"$task_path\" ]; then echo \"fail-closed proof chain (0751 R2): task path for $wbs did not resolve - the task spec cannot be folded into the proof digest\" >&2; exit 1; fi; sed -n \"s/^priority:[[:space:]]*//p\" \"$task_path\" | head -1 | tr -d \"[:space:]\" | tr \"[:lower:]\" \"[:upper:]\" > \".spur/run/$wbs-priority.txt\""
-                },
-                "test:onEnter:1": {
-                    "kind": "file.read.into-var"
-                },
-                "test:onEnter:2": {
-                    "kind": "file.read.into-var"
-                },
-                "test:onEnter:3": {
-                    "kind": "proof.fingerprint"
-                },
-                "test:onEnter:4": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run && STATUS_FILE=\".spur/run/$wbs-test-gate.status\" && LOG_FILE=\".spur/run/$wbs-test-gate.log\" && ATTEMPT_FILE=\".spur/run/$wbs-test-fix-attempt\" && echo 0 > \"$ATTEMPT_FILE\" && : > \"$LOG_FILE\" && gate_attempt=1; while [ \"$gate_attempt\" -le 5 ]; do\n  ATTEMPT_LOG=\"$LOG_FILE.attempt-$gate_attempt\";\n  sh -c \"$qualityGateCmd\" > \"$ATTEMPT_LOG\" 2>&1; gate_rc=$?;\n  gate_locked=0;\n  grep -q 'SQLiteError: database is locked' \"$ATTEMPT_LOG\" && gate_locked=1;\n  cat \"$ATTEMPT_LOG\" >> \"$LOG_FILE\";\n  rm -f \"$ATTEMPT_LOG\";\n  if [ \"$gate_rc\" -eq 0 ] || [ \"$gate_locked\" -ne 1 ] || [ \"$gate_attempt\" -ge 5 ]; then break; fi;\n  printf 'quality gate: database is locked; retrying (%s/5) in 10s\\n' \"$gate_attempt\" | tee -a \"$LOG_FILE\";\n  sleep 10;\n  gate_attempt=$((gate_attempt + 1));\ndone && cat \"$LOG_FILE\" && FINDINGS_FILE=\".spur/run/$wbs-test-gate.findings\" && set +e; grep -oE '[A-Za-z0-9_./-]+\\.[A-Za-z]+:[0-9]+' \"$LOG_FILE\" | sort -u | head -20 | tr '\\n' ' ' > \"$FINDINGS_FILE\"; set -e && if [ \"$gate_rc\" -eq 0 ]; then\n  printf 'PASS\\n' > \"$STATUS_FILE\";\nelse\n  printf 'FAIL\\n' > \"$STATUS_FILE\";\nfi && printf 'proof-digest: %s\\n' \"$proofDigest\" >> \"$LOG_FILE\" && exit 0"
-                },
-                "test-fix:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run && ATTEMPT_FILE=\".spur/run/$wbs-test-fix-attempt\" && n=$(cat \"$ATTEMPT_FILE\" 2>/dev/null || echo 0) && printf '%s\\n' \"$((n + 1))\" > \"$ATTEMPT_FILE\" && if [ -f \".spur/run/$wbs-verdict.json\" ]; then\n  { echo '--- verify verdict (remediation input, task 0703 R4) ---';\n    cat \".spur/run/$wbs-verdict.json\";\n  } >> \".spur/run/$wbs-test-gate.log\";\nfi; exit 0"
-                },
-                "test-fix:onEnter:1": {
-                    "kind": "file.read.into-var"
-                },
-                "test-fix:onEnter:2": {
-                    "kind": "agent.run",
-                    "invocation": "/sp:dev-fixall \"${vars.qualityGateCmd}\" --gate-log .spur/run/${vars.wbs}-test-gate.log --findings \"${vars.gateFindings}\""
-                },
-                "test-recheck:onEnter:0": {
-                    "kind": "proof.fingerprint"
-                },
-                "test-recheck:onEnter:1": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run && STATUS_FILE=\".spur/run/$wbs-test-gate.status\" && LOG_FILE=\".spur/run/$wbs-test-gate.log\" && FINDINGS_FILE=\".spur/run/$wbs-test-gate.findings\" && : > \"$LOG_FILE\" && probe_rc=0; if [ -n \"$gateProbeCmd\" ]; then\n  sh -c \"$gateProbeCmd\" > \"$LOG_FILE.probe\" 2>&1; probe_rc=$?;\n  cat \"$LOG_FILE.probe\" >> \"$LOG_FILE\";\n  rm -f \"$LOG_FILE.probe\";\nfi; if [ \"$probe_rc\" -ne 0 ]; then\n  gate_rc=$probe_rc;\nelse\n  gate_attempt=1;\n  while [ \"$gate_attempt\" -le 5 ]; do\n    ATTEMPT_LOG=\"$LOG_FILE.attempt-$gate_attempt\";\n    sh -c \"$qualityGateCmd\" > \"$ATTEMPT_LOG\" 2>&1; gate_rc=$?;\n    gate_locked=0;\n    grep -q 'SQLiteError: database is locked' \"$ATTEMPT_LOG\" && gate_locked=1;\n    cat \"$ATTEMPT_LOG\" >> \"$LOG_FILE\";\n    rm -f \"$ATTEMPT_LOG\";\n    if [ \"$gate_rc\" -eq 0 ] || [ \"$gate_locked\" -ne 1 ] || [ \"$gate_attempt\" -ge 5 ]; then break; fi;\n    printf 'quality gate: database is locked; retrying (%s/5) in 10s\\n' \"$gate_attempt\" | tee -a \"$LOG_FILE\";\n    sleep 10;\n    gate_attempt=$((gate_attempt + 1));\n  done;\nfi && cat \"$LOG_FILE\" && set +e; grep -oE '[A-Za-z0-9_./-]+\\.[A-Za-z]+:[0-9]+' \"$LOG_FILE\" | sort -u | head -20 | tr '\\n' ' ' > \"$FINDINGS_FILE\"; set -e && if [ \"$gate_rc\" -eq 0 ]; then\n  printf 'PASS\\n' > \"$STATUS_FILE\";\nelse\n  printf 'FAIL\\n' > \"$STATUS_FILE\";\nfi && printf 'proof-digest: %s\\n' \"$proofDigest\" >> \"$LOG_FILE\" && exit 0"
-                },
-                "review:onEnter:0": {
-                    "kind": "agent.run",
-                    "invocation": "/sp:dev-review ${vars.wbs} --auto"
-                },
-                "approve:onEnter:0": {
-                    "kind": "hitl.confirm"
-                },
-                "verify:onEnter:0": {
-                    "kind": "proof.fingerprint"
-                },
-                "verify:onEnter:1": {
-                    "kind": "agent.run",
-                    "invocation": "/sp:dev-verify ${vars.wbs} --auto --fix none --focus all"
-                },
-                "verify:onEnter:2": {
-                    "kind": "shell",
-                    "invocation": "LINT_SCRIPT=\"plugins/sp/scripts/verify-answer-lint.ts\"; [ -f \"$LINT_SCRIPT\" ] || LINT_SCRIPT=\"$(superskill script path sp verify-answer-lint.ts 2>/dev/null)\"; if [ -z \"$LINT_SCRIPT\" ] || [ ! -f \"$LINT_SCRIPT\" ]; then\n  echo \"verify-answer-lint: checker not found in plugins/sp/scripts/ nor staged — run 'superskill install sp'\" >&2;\n  exit 1;\nfi; bun \"$LINT_SCRIPT\" \"$wbs\" --answer \".spur/run/$wbs-verify-answer.txt\" --spur-bin \"$spurBin\""
-                },
-                "verify:onEnter:3": {
-                    "kind": "shell",
-                    "invocation": "$spurBin task verdict $wbs --from-answer .spur/run/$wbs-verify-answer.txt"
-                },
-                "verify:onEnter:4": {
-                    "kind": "shell",
-                    "invocation": "V=\".spur/run/$wbs-verdict.json\"; if [ -f \"$V\" ] && [ -n \"$proofDigest\" ]; then\n  jq --arg d \"$proofDigest\" --arg r \"$__runId\" --arg dd \"$__definitionDigest\" --arg g \"$(cat .spur/run/$wbs-test-gate.status 2>/dev/null || echo UNKNOWN)\"\n  '. + {proof: {digest: $d, runId: $r, definitionDigest: $dd, capturePoint: \"quality-gate-entry\", stages: {\n    qualityGate: {status: $g, digest: $d},\n    review: {status: \"completed\", digest: $d},\n    verification: {status: .verdict, digest: $d}}}}\n    | .checks += [{name: \"proof-input-digest\", status: \"pass\", evidence: $d}]'\n  \"$V\" > \"$V.tmp\" && mv \"$V.tmp\" \"$V\";\nfi; exit 0"
-                },
-                "record:onEnter:0": {
-                    "kind": "proof.fingerprint"
-                },
-                "record:onEnter:1": {
-                    "kind": "shell",
-                    "invocation": "retry_transient() {\n  RETRY_OUTPUT=$(\"$@\" 2>&1); RETRY_RC=$?;\n  printf '%s\\n' \"$RETRY_OUTPUT\";\n  if [ \"$RETRY_RC\" -eq 0 ]; then return 0; fi;\n  if ! printf '%s' \"$RETRY_OUTPUT\" | grep -Eq 'ENOENT|EBUSY|ENOTEMPTY|database is locked'; then return \"$RETRY_RC\"; fi;\n  sleep 2;\n  RETRY_SECOND_OUTPUT=$(\"$@\" 2>&1); RETRY_RC=$?;\n  printf '%s\\n' \"$RETRY_SECOND_OUTPUT\";\n  if [ \"$RETRY_RC\" -ne 0 ] && printf '%s\\n%s' \"$RETRY_OUTPUT\" \"$RETRY_SECOND_OUTPUT\" | grep -Eq 'ENOENT|EBUSY|ENOTEMPTY'; then\n    echo \"node_modules link/dependency broken — run bun install and retry\";\n  fi;\n  return \"$RETRY_RC\";\n}; retry_transient $spurBin task record \"$wbs\" --solution-from-diff --transition testing"
-                },
-                "record:onEnter:2": {
-                    "kind": "shell",
-                    "invocation": "FID=$($spurBin task show $wbs --json 2>/dev/null | jq -r \".feature_id // .frontmatter.feature_id // empty\" 2>/dev/null); if [ -n \"$FID\" ]; then\n  if [ -f plugins/sp/scripts/feature-sync-bounded.ts ]; then\n    bun plugins/sp/scripts/feature-sync-bounded.ts \"$FID\" --spur-bin \"$spurBin\" --json;\n  elif SYNC_MJS=\"$(superskill script path sp feature-sync-bounded.mjs 2>/dev/null)\" && [ -f \"$SYNC_MJS\" ]; then\n    node \"$SYNC_MJS\" \"$FID\" --spur-bin \"$spurBin\" --json;\n  else\n    $spurBin feature sync \"$FID\" --json;\n  fi;\nelse\n  echo \"Orphan task $wbs — no feature_id linked; proposal: consider linking to a parent feature.\" >> \".spur/run/$wbs-report.txt\";\nfi; exit 0"
-                },
-                "done:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "retry_transient() {\n  RETRY_OUTPUT=$(\"$@\" 2>&1); RETRY_RC=$?;\n  printf '%s\\n' \"$RETRY_OUTPUT\";\n  if [ \"$RETRY_RC\" -eq 0 ]; then return 0; fi;\n  if ! printf '%s' \"$RETRY_OUTPUT\" | grep -Eq 'ENOENT|EBUSY|ENOTEMPTY|database is locked'; then return \"$RETRY_RC\"; fi;\n  sleep 2;\n  RETRY_SECOND_OUTPUT=$(\"$@\" 2>&1); RETRY_RC=$?;\n  printf '%s\\n' \"$RETRY_SECOND_OUTPUT\";\n  if [ \"$RETRY_RC\" -ne 0 ] && printf '%s\\n%s' \"$RETRY_OUTPUT\" \"$RETRY_SECOND_OUTPUT\" | grep -Eq 'ENOENT|EBUSY|ENOTEMPTY'; then\n    echo \"node_modules link/dependency broken — run bun install and retry\";\n  fi;\n  return \"$RETRY_RC\";\n}; retry_transient $spurBin task update \"$wbs\" done --no-lifecycle"
-                },
-                "done:onEnter:1": {
-                    "kind": "run.artifact"
-                },
-                "done:onEnter:2": {
-                    "kind": "note"
-                },
-                "done:onEnter:3": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/memory/sessions; CP_TS=\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"; CP_COMMIT=\"$(git rev-parse HEAD 2>/dev/null || echo unknown)\"; CP_DIGEST=\"$(cut -d= -f2 .spur/run/$wbs-proofdigest.txt 2>/dev/null || echo '')\"; CP_RUN=\"$SPUR_RUN_ID\"; [ -z \"$CP_RUN\" ] && CP_RUN=\"$RUN_ID\"; printf '%s\\n' '---' 'schema_version: 1' \"session_id: $(date -u +%Y-%m-%d)-$wbs\" 'workflow: task-pipeline' \"run_id: $CP_RUN\" \"task_wbs: $wbs\" 'feature_id: \"\"' 'phase: done' 'status: done' 'last_gate: record' \"source_commit: $CP_COMMIT\" \"digest: $CP_DIGEST\" \"generated_at: $CP_TS\" \"updated_at: $CP_TS\" \"next_action: none - task $wbs complete (terminal; advisory only)\" 'artifacts:' '  - .spur/run/$wbs-verdict.json' '  - .spur/run/$wbs-test-gate.log' '---' '' '## Session Notes' '' \"Terminal checkpoint for task $wbs (task-pipeline done).\" 'Advisory only; the task file is authoritative.' > .spur/memory/sessions/$wbs-checkpoint.md; exit 0"
-                }
-            }
-        },
-        "wrapup-pipeline": {
-            "definition": "config/workflows/wrapup-pipeline.yaml",
-            "terminalStates": ["done", "skipped"],
-            "modelQueries": ["doc-sync"],
-            "actions": {
-                "start:onEnter:0": {
-                    "kind": "note"
-                },
-                "task-resolve:onEnter:0": {
-                    "kind": "note"
-                },
-                "task-resolve:onEnter:1": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run .spur/memory && RUN_ID=\"$__runId\" && if [ -z \"$RUN_ID\" ]; then RUN_ID=\"wrapup\"; fi && REASON_FILE=\".spur/run/$RUN_ID-route-reason.txt\" && if [ \"$(echo \"$tasks\" | jq length 2>/dev/null || echo 0)\" -eq 0 ]; then\n  echo \"skipped:empty task list\" > \"$REASON_FILE\";\nelif [ \"$mode\" = \"fast\" ]; then\n  echo \"fast:evidence complete+consistent\" > \"$REASON_FILE\";\nelif [ -z \"$mode\" ]; then\n  echo \"safety:missing evidence (mode empty)\" > \"$REASON_FILE\";\nelif [ \"$mode\" = \"unknown\" ]; then\n  echo \"safety:unknown evidence quality\" > \"$REASON_FILE\";\nelif [ \"$mode\" = \"conflict\" ]; then\n  echo \"safety:conflicting evidence\" > \"$REASON_FILE\";\nelse\n  echo \"safety:unrecognized evidence (mode=$mode)\" > \"$REASON_FILE\";\nfi && printf '%s %s\\n' \"$RUN_ID\" \"$(cat \"$REASON_FILE\")\" >> .spur/memory/wrapup-routes.log && exit 0"
-                },
-                "doc-sync:onEnter:0": {
-                    "kind": "agent.run",
-                    "invocation": "First run Skill(skill=\"sp:doc-evolve\", args=\"wrapup tasks=${vars.tasks}\") to repair drift in docs/00_ADR.md, docs/03_ARCHITECTURE.md, docs/04_DESIGN.md, docs/design/* per constitution edit rules; do not write task/feature corpus. THEN extract working learnings from tasks ${vars.tasks} — conventions, errors fixed, patterns, gotchas, grouped by date and task WBS — as raw markdown (no fences) and END your final message with that markdown (it is captured to .spur/run/wrapup-learnings.md)."
-                },
-                "doc-sync:onEnter:1": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/memory && if test -s .spur/run/wrapup-learnings.md; then\n  cat .spur/run/wrapup-learnings.md >> .spur/memory/learnings.md &&\n  printf '\\n' >> .spur/memory/learnings.md;\nelse\n  echo \"wrapup: learning capture missing or empty at $PWD/.spur/run/wrapup-learnings.md - append skipped\" >&2;\nfi && exit 0"
-                },
-                "metrics-record:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/memory && printf '%s' \"$tasks\" | jq -r '(if type == \"string\" then (try fromjson catch .) else . end) | if type == \"array\" then .[] else empty end' | while IFS= read -r wbs; do\n  if [ -n \"$wbs\" ]; then\n    task_json=$($spurBin task show \"$wbs\" --json 2>/dev/null || true);\n    if [ -n \"$task_json\" ]; then\n      feat=$(printf '%s' \"$task_json\" | jq -r '.frontmatter.feature_id // .feature_id // empty' 2>/dev/null || true);\n      stat=$(printf '%s' \"$task_json\" | jq -r '.frontmatter.status // .status // \"unknown\"' 2>/dev/null || true);\n      verdict=\"UNKNOWN\";\n      if [ -f \".spur/run/$wbs-verdict.json\" ]; then\n        v=$(jq -r '.verdict // \"UNKNOWN\"' \".spur/run/$wbs-verdict.json\" 2>/dev/null || true);\n        if [ -n \"$v\" ]; then verdict=\"$v\"; fi;\n      fi;\n      ts=$(date -u +\"%Y-%m-%dT%H:%M:%SZ\");\n      printf '{\"wbs\":\"%s\",\"feature_id\":\"%s\",\"status\":\"%s\",\"verdict\":\"%s\",\"timestamp\":\"%s\"}\\n' \"$wbs\" \"$feat\" \"$stat\" \"$verdict\" \"$ts\" >> .spur/memory/wrapup-metrics.jsonl;\n    fi;\n  fi;\ndone && exit 0"
-                },
-                "feature-transition:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "if [ -z \"$feature\" ]; then\n  echo \"feature-transition: vars.feature is empty — refusing no-op feature sync (mis-invocation, not a blocked sync)\" >&2;\n  exit 1;\nfi; SYNC_OUTPUT=$(if [ -f plugins/sp/scripts/feature-sync-bounded.ts ]; then\n  bun plugins/sp/scripts/feature-sync-bounded.ts \"$feature\" --spur-bin \"$spurBin\" --json;\nelif SYNC_MJS=\"$(superskill script path sp feature-sync-bounded.mjs 2>/dev/null)\" && [ -f \"$SYNC_MJS\" ]; then\n  node \"$SYNC_MJS\" \"$feature\" --spur-bin \"$spurBin\" --json;\nelse\n  $spurBin feature sync \"$feature\" --json;\nfi); SYNC_RC=$?; printf '%s\\n' \"$SYNC_OUTPUT\"; APPLIED=$(printf '%s' \"$SYNC_OUTPUT\" | jq -r '.applied // false' 2>/dev/null || echo false); if [ \"$APPLIED\" = \"true\" ] || [ \"$SYNC_RC\" -ne 0 ]; then\n  echo \"feature-transition: sync applied or failed after a possible partial transition for $feature — running corpus-aware gate: $featureGateCmd\";\n  if sh -c \"$featureGateCmd\"; then\n    echo \"feature-transition: corpus-aware gate PASS for feature $feature\";\n  else\n    echo \"feature-transition: corpus-aware gate FAIL for feature $feature — inspect findings before reporting the transition complete\" >&2;\n  fi;\nelse\n  echo \"feature-transition: sync did not apply a transition (rc=$SYNC_RC, applied=$APPLIED) — corpus-aware gate skipped\";\nfi; exit 0"
-                },
-                "branch-cleanup:onEnter:0": {
-                    "kind": "hitl.confirm"
-                },
-                "done:onEnter:0": {
-                    "kind": "note"
-                },
-                "done:onEnter:1": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/memory/sessions && echo \"checkpoint: wrapup-pipeline done tasks=$tasks ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)\" > .spur/memory/sessions/wrapup-checkpoint.md"
-                }
-            }
-        },
-        "pr-review": {
-            "definition": "config/workflows/pr-review.yaml",
-            "terminalStates": ["done", "pending", "failed"],
-            "modelQueries": [],
-            "actions": {
-                "preflight:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run && STATUS_FILE=\".spur/run/$__runId-pr-preflight.status\" && set +e && bun \"$(superskill script path sp pr-reviewing.ts)\" preflight --base \"$baseBranch\" --json > \".spur/run/$__runId-pr-context.json\"; rc=$?; set -e && if [ \"$rc\" -eq 0 ]; then printf 'PASS\\n' > \"$STATUS_FILE\"; else printf 'FAIL\\n' > \"$STATUS_FILE\"; fi && exit 0"
-                },
-                "hygiene:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run && STATUS_FILE=\".spur/run/$__runId-pr-hygiene.status\" && set +e && bun \"$(superskill script path sp pr-reviewing.ts)\" hygiene --base \"$baseBranch\" --json --status-file \"$STATUS_FILE\" > \".spur/run/$__runId-pr-hygiene.json\"; rc=$?; set -e && if [ ! -f \"$STATUS_FILE\" ]; then printf 'FAIL\\n' > \"$STATUS_FILE\"; fi && exit 0"
-                },
-                "precheck:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run && STATUS_FILE=\".spur/run/$__runId-pr-precheck.status\" && if [ -z \"$preReviewCmd\" ]; then\n  printf 'SKIP\\n' > \"$STATUS_FILE\";\nelse\n  set +e; sh -c \"$preReviewCmd\"; rc=$?; set -e;\n  if [ \"$rc\" -eq 0 ]; then printf 'PASS\\n' > \"$STATUS_FILE\"; else printf 'FAIL\\n' > \"$STATUS_FILE\"; fi;\nfi && exit 0"
-                },
-                "push:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run && STATUS_FILE=\".spur/run/$__runId-pr-push.status\" && set +e && bun \"$(superskill script path sp pr-reviewing.ts)\" push --json --status-file \"$STATUS_FILE\" > \".spur/run/$__runId-pr-push.json\"; rc=$?; set -e && if [ ! -f \"$STATUS_FILE\" ]; then printf 'FAIL\\n' > \"$STATUS_FILE\"; fi && exit 0"
-                },
-                "ensure-pr:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run && STATUS_FILE=\".spur/run/$__runId-pr-ensure.status\" && set +e && bun \"$(superskill script path sp pr-reviewing.ts)\" ensure-pr --base \"$baseBranch\" --json --status-file \"$STATUS_FILE\" > \".spur/run/$__runId-pr.json\"; rc=$?; set -e && if [ ! -f \"$STATUS_FILE\" ]; then printf 'FAIL\\n' > \"$STATUS_FILE\"; fi && exit 0"
-                },
-                "request:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run && STATUS_FILE=\".spur/run/$__runId-pr-request.status\" && FORCE_FLAG=\"\" && if [ \"$mode\" = \"rerun\" ]; then FORCE_FLAG=\"--force\"; fi && set +e && bun \"$(superskill script path sp pr-reviewing.ts)\" request --focus \"$focus\" $FORCE_FLAG --json --status-file \"$STATUS_FILE\" > \".spur/run/$__runId-pr-request.json\"; rc=$?; set -e && if [ ! -f \"$STATUS_FILE\" ]; then printf 'FAIL\\n' > \"$STATUS_FILE\"; fi && exit 0"
-                },
-                "wait:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run && STATUS_FILE=\".spur/run/$__runId-pr-wait.status\" && set +e && SINCE=\"$(bun -e 'const fs=require(\"node:fs\");const value=JSON.parse(fs.readFileSync(process.argv[1],\"utf8\")).requestedAt;process.stdout.write(value ?? \"\")' \".spur/run/$__runId-pr-request.json\")\" && REQUEST_HEAD=\"$(bun -e 'const fs=require(\"node:fs\");const value=JSON.parse(fs.readFileSync(process.argv[1],\"utf8\")).head;process.stdout.write(value ?? \"\")' \".spur/run/$__runId-pr-request.json\")\" && bun \"$(superskill script path sp pr-reviewing.ts)\" wait --since \"$SINCE\" --head \"$REQUEST_HEAD\" --timeout \"$waitTimeoutSec\" --interval \"$waitIntervalSec\" --json --status-file \"$STATUS_FILE\" > \".spur/run/$__runId-pr-wait.json\"; rc=$?; set -e && if [ ! -f \"$STATUS_FILE\" ]; then printf 'FAIL\\n' > \"$STATUS_FILE\"; fi && exit 0"
-                },
-                "collect:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run && STATUS_FILE=\".spur/run/$__runId-pr-collect.status\" && set +e && SINCE=\"$(bun -e 'const fs=require(\"node:fs\");const value=JSON.parse(fs.readFileSync(process.argv[1],\"utf8\")).requestedAt;process.stdout.write(value ?? \"\")' \".spur/run/$__runId-pr-request.json\")\" && REQUEST_HEAD=\"$(bun -e 'const fs=require(\"node:fs\");const value=JSON.parse(fs.readFileSync(process.argv[1],\"utf8\")).head;process.stdout.write(value ?? \"\")' \".spur/run/$__runId-pr-request.json\")\" && bun \"$(superskill script path sp pr-reviewing.ts)\" collect --since \"$SINCE\" --head \"$REQUEST_HEAD\" --json --status-file \"$STATUS_FILE\" > \".spur/run/$__runId-pr-findings.json\"; collect_rc=$?; bun \"$(superskill script path sp pr-reviewing.ts)\" status --since \"$SINCE\" --head \"$REQUEST_HEAD\" --json > \".spur/run/$__runId-pr-status.json\"; status_rc=$?; set -e && if [ \"$collect_rc\" -ne 0 ] || [ \"$status_rc\" -ne 0 ]; then printf 'FAIL\\n' > \"$STATUS_FILE\"; fi && if [ ! -f \"$STATUS_FILE\" ]; then printf 'FAIL\\n' > \"$STATUS_FILE\"; fi && { cat \".spur/run/$__runId-pr-findings.json\" 2>/dev/null || true; } && exit 0"
-                }
-            }
-        },
-        "basic": {
-            "definition": "config/workflows/basic.yaml",
-            "terminalStates": ["done", "failed"],
-            "modelQueries": ["fix"],
-            "actions": {
-                "implement:onEnter:0": {
-                    "kind": "note"
-                },
-                "implement:onEnter:1": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run && printf '0\\n' > .spur/run/$__runId-basic-fix-attempt"
-                },
-                "check:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run && STATUS_FILE=\".spur/run/$__runId-basic-gate.status\" && set +e && ( $qualityGateCmd ); gate_rc=$?; set -e && if [ \"$gate_rc\" -eq 0 ]; then\n  printf 'PASS\\n' > \"$STATUS_FILE\";\nelse\n  printf 'FAIL\\n' > \"$STATUS_FILE\";\nfi && exit 0"
-                },
-                "fix:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run && ATTEMPT_FILE=\".spur/run/$__runId-basic-fix-attempt\" && n=$(cat \"$ATTEMPT_FILE\" 2>/dev/null || echo 0) && printf '%s\\n' \"$((n + 1))\" > \"$ATTEMPT_FILE\""
-                },
-                "fix:onEnter:1": {
-                    "kind": "agent.run",
-                    "invocation": "/sp:dev-fixall \"${vars.qualityGateCmd}\""
-                }
-            }
-        },
-        "feature-dev": {
-            "definition": "config/workflows/feature-dev.yaml",
-            "terminalStates": ["done", "failed"],
-            "modelQueries": ["brainstorm", "plan", "execute-tasks-auto", "execute-tasks"],
-            "actions": {
-                "precheck:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run && set +e && test -n \"$featureId\"; id_rc=$?; $spurBin agent doctor $agent; doctor_rc=$?; set -e && if [ \"$id_rc\" -eq 0 ] && [ \"$doctor_rc\" -eq 0 ]; then\n  printf 'PASS\\n' > \".spur/run/$__runId-feature-dev-precheck.status\";\nelse\n  printf 'FAIL\\n' > \".spur/run/$__runId-feature-dev-precheck.status\";\nfi && exit 0"
-                },
-                "precheck:onEnter:1": {
-                    "kind": "note"
-                },
-                "brainstorm:onEnter:0": {
-                    "kind": "agent.run",
-                    "invocation": "/sp:dev-brainstorm --feature ${vars.featureId}"
-                },
-                "plan:onEnter:0": {
-                    "kind": "agent.run",
-                    "invocation": "/sp:dev-plan --feature ${vars.featureId}"
-                },
-                "execute-tasks-auto:onEnter:0": {
-                    "kind": "agent.run",
-                    "invocation": "/sp:dev-runall --feature ${vars.featureId} --auto"
-                },
-                "execute-tasks:onEnter:0": {
-                    "kind": "agent.run",
-                    "invocation": "/sp:dev-runall --feature ${vars.featureId}"
-                },
-                "integration-review:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run && STATUS_FILE=\".spur/run/$__runId-integration-review.status\" && REQUEST_JSON=\".spur/run/$__runId-integration-review.json\" && PR_REQUEST_STATUS=\".spur/run/$__runId-integration-review-pr-request.status\" && set +e && bun \"$(superskill script path sp pr-reviewing.ts)\" request --base \"$baseBranch\" --json --status-file \"$PR_REQUEST_STATUS\" > \"$REQUEST_JSON\" 2>&1; rc=$?; set -e && if [ \"$rc\" -eq 0 ]; then\n  printf 'PASS\\n' > \"$STATUS_FILE\";\nelse\n  printf 'FAIL\\n' > \"$STATUS_FILE\";\nfi && exit 0"
-                },
-                "integration-review:onEnter:1": {
-                    "kind": "note"
-                },
-                "done:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/memory/sessions && echo \"checkpoint: feature-dev done featureId=$featureId ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)\" > .spur/memory/sessions/$featureId-checkpoint.md"
-                }
-            }
-        },
-        "wayfinder-resolution": {
-            "definition": "config/workflows/wayfinder-resolution.yaml",
-            "terminalStates": ["done", "failed", "cancelled"],
-            "modelQueries": ["investigate", "verify"],
-            "actions": {
-                "precheck:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run/wayfinder && set +e && $spurBin task check $wbs; check_rc=$?; $spurBin task show $wbs --json > .spur/run/wayfinder/$wbs-show.json; show_rc=$?; set -e && if [ \"$check_rc\" -eq 0 ] && [ \"$show_rc\" -eq 0 ]; then\n  printf 'PASS\\n' > .spur/run/wayfinder/$wbs-precheck.status;\nelse\n  printf 'FAIL\\n' > .spur/run/wayfinder/$wbs-precheck.status;\nfi && exit 0"
-                },
-                "precheck:onEnter:1": {
-                    "kind": "note"
-                },
-                "collect:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run/wayfinder && $spurBin task show $wbs --json > .spur/run/wayfinder/$wbs-input.json"
-                },
-                "collect:onEnter:1": {
-                    "kind": "shell",
-                    "invocation": "$spurBin workflow validate wayfinder-resolution.yaml > .spur/run/wayfinder/$wbs-workflow-check.txt"
-                },
-                "collect:onEnter:2": {
-                    "kind": "shell",
-                    "invocation": "$spurBin task check $wbs > .spur/run/wayfinder/$wbs-precheck.txt"
-                },
-                "investigate:onEnter:0": {
-                    "kind": "agent.run",
-                    "invocation": "Resolve task ${vars.wbs} in resolution mode ${vars.resolutionMode} using the prepared local bundle `.spur/run/wayfinder/${vars.wbs}-input.json` and only local shell/file reads plus the `spur` CLI; do not use network search or MCP tools. Do not invoke task-pipeline.yaml, /sp:dev-run, /sp:dev-runall, or code implementation. Read the task file, map its existing Requirements and Acceptance Criteria to the existing Design/Plan/References, then author concise Solution, Testing, and Review sections through `spur task update --section --from-file`. Preserve the research boundary. Finish with a short summary and stop. Evidence policy: ${vars.evidencePolicy}.\nEvidence-anchor and content contract (mandatory — 0300 R1/R2): when the task's evidence lives in a shared evidence file (e.g. `.spur/run/wayfinder-O/implementation-evidence.md`), the `## <wbs>` section you author MUST (a) be substantive — more than 5 lines AND more than 60 words, covering the task's own requirements, not a generic 2–3 sentence placeholder; and (b) be anchored truthfully — after writing the section, resolve its real start line with `grep -n \"^## <wbs> \" <evidence-file>` and use that exact line number in every Solution/Testing `file:line` citation. NEVER copy a line number from another ticket's example (e.g. `:5` from an earlier WBS); each WBS anchors to its own section. Before finishing, re-read each cited line and confirm it names the requirement's subject (0299 R1 line-anchor rule)."
-                },
-                "verify:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "rm -f .spur/run/wayfinder/$wbs-resolution-verdict.txt"
-                },
-                "verify:onEnter:1": {
-                    "kind": "agent.run",
-                    "invocation": "Verify resolved task ${vars.wbs} using only local reads and `spur` CLI. Check its requirements, acceptance scenarios, Solution, Testing, and Review. Confirm workflow orchestration uses `spur workflow` and execution uses `spur` CLI by default. Run `spur task check ${vars.wbs}` and update Testing/Review via the CLI only if needed. Do not implement plugin code. Write the final verdict word (exactly PASS, PARTIAL, or FAIL, nothing else) to `.spur/run/wayfinder/${vars.wbs}-resolution-verdict.txt`, then finish with the same verdict and stop."
-                },
-                "approve:onEnter:0": {
-                    "kind": "hitl.confirm"
-                },
-                "record:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "$spurBin task check $wbs ; exit 0"
-                },
-                "record:onEnter:1": {
-                    "kind": "shell",
-                    "invocation": "$spurBin task update $wbs done ; exit 0"
-                },
-                "done:onEnter:0": {
-                    "kind": "note"
-                }
-            }
-        },
-        "feature-lifecycle": {
-            "definition": "config/workflows/feature-lifecycle.yaml",
-            "terminalStates": ["cancelled"],
-            "modelQueries": [],
-            "actions": {}
-        },
-        "history-anatomy": {
-            "definition": "config/workflows/history-anatomy.yaml",
-            "terminalStates": ["published", "failed"],
-            "modelQueries": ["resolve-scope", "enrich", "validate", "correct"],
-            "actions": {
-                "start:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "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"
-                },
-                "resolve-scope:onEnter:0": {
-                    "kind": "agent.run",
-                    "invocation": "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."
-                },
-                "resolve-paths:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "h=$(superskill script path sp history-anatomy-cache.mjs); node \"$h\" paths --helper \"$h\" --report-dir \"$reportDir\" --date \"$date\" --output \"$output\" --mode \"$mode\" --since \"$since\" --until \"$until\" --out .spur/run/$__runId-paths.txt"
-                },
-                "analyze:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "mkdir -p .spur/run; . .spur/run/$__runId-paths.txt; $spurBin history analyze --out .spur/run/$__runId-history-anatomy-current.json --since \"$HA_SINCE\" --until \"$HA_UNTIL\" --json"
-                },
-                "analyze:onEnter:1": {
-                    "kind": "shell",
-                    "invocation": ". .spur/run/$__runId-paths.txt; $spurBin history analyze --out .spur/run/$__runId-history-anatomy-baseline.json --since \"$HA_BASELINE_SINCE\" --until \"$HA_BASELINE_UNTIL\" --json 2>/dev/null || true"
-                },
-                "cache-probe:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": ". .spur/run/$__runId-paths.txt; 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"
-                },
-                "render:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "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"
-                },
-                "enrich:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "git status --porcelain > .spur/run/$__runId-baseline-enrich.txt || true"
-                },
-                "enrich:onEnter:1": {
-                    "kind": "agent.run",
-                    "invocation": "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."
-                },
-                "enrich:onEnter:2": {
-                    "kind": "shell",
-                    "invocation": "node \"$(superskill script path sp history-anatomy-cache.mjs)\" assert-clean --baseline .spur/run/$__runId-baseline-enrich.txt --expect .spur/run/$__runId-candidate.md"
-                },
-                "structure-gate:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "node \"$(superskill script path sp history-anatomy-cache.mjs)\" check \\\n  .spur/run/$__runId-candidate.md > .spur/run/$__runId-structure-gate.txt 2>&1 || true"
-                },
-                "validate:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "git status --porcelain > .spur/run/$__runId-baseline-validate.txt || true"
-                },
-                "validate:onEnter:1": {
-                    "kind": "agent.run",
-                    "invocation": "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."
-                },
-                "validate:onEnter:2": {
-                    "kind": "shell",
-                    "invocation": "node \"$(superskill script path sp history-anatomy-cache.mjs)\" assert-clean --baseline .spur/run/$__runId-baseline-validate.txt --expect .spur/run/$__runId-validation.txt"
-                },
-                "correct:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": "n=$(cat .spur/run/$__runId-correction-count 2>/dev/null || echo 0) && printf '%s\\n' \"$((n + 1))\" > .spur/run/$__runId-correction-count"
-                },
-                "correct:onEnter:1": {
-                    "kind": "shell",
-                    "invocation": "git status --porcelain > .spur/run/$__runId-baseline-correct.txt || true"
-                },
-                "correct:onEnter:2": {
-                    "kind": "agent.run",
-                    "invocation": "Repair .spur/run/${vars.__runId}-candidate.md in place. Read its structure-gate findings, optional validation notes, references/report-contract.md, and the references/operations.md validate rubric; fix every violation. Use a backticked `.md`/`.ts`/`.json` path or a `path:line` anchor, never `current #/...`; remove placeholders and empty rows; restore the twelve-section order; ensure every problem and positive finding carries the full field set; verify every quantitative claim (counts, durations, percentages, distributions) and every current/baseline full-digest match against .spur/run/${vars.__runId}-history-anatomy-current.json and -baseline.json. Overwrite only the candidate; never launch a workflow."
-                },
-                "correct:onEnter:3": {
-                    "kind": "shell",
-                    "invocation": "node \"$(superskill script path sp history-anatomy-cache.mjs)\" assert-clean --baseline .spur/run/$__runId-baseline-correct.txt --expect .spur/run/$__runId-candidate.md"
-                },
-                "refresh-provenance:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": ". .spur/run/$__runId-paths.txt; node \"$HA_HELPER\" refresh --report \"$HA_TARGET\" --out .spur/run/$__runId-publishable.md --disposition hit"
-                },
-                "stamp:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": ". .spur/run/$__runId-paths.txt; node \"$HA_HELPER\" stamp --candidate .spur/run/$__runId-candidate.md --provenance .spur/run/$__runId-provenance.json --out .spur/run/$__runId-publishable.md"
-                },
-                "publish:onEnter:0": {
-                    "kind": "shell",
-                    "invocation": ". .spur/run/$__runId-paths.txt; mkdir -p \"$(dirname \"$HA_TARGET\")\"; node \"$HA_HELPER\" publish .spur/run/$__runId-publishable.md \"$HA_TARGET\""
-                }
-            }
-        },
-        "task-lifecycle": {
-            "definition": "config/workflows/task-lifecycle.yaml",
-            "terminalStates": ["cancelled"],
-            "modelQueries": [],
-            "actions": {}
-        }
-    }
-}