@gobing-ai/spur 0.3.30 → 0.3.32

package/config/workflows/wayfinder-resolution.yaml

@@ -1,3 +1,15 @@
+# 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)
+#   - collect fail-closed on non-empty input bundle
+#   - investigate→verify enforces Testing content floor (0300 R2) before independent verify
+#   - verify writes machine-readable PASS|PARTIAL|FAIL with expectFile
+#   - HITL approve routing is exhaustive (yes/no/cancel)
+#   - record → done is fail-closed on check + actual status=done
+#   - Free-form agent inputs are intentional: no pure-slash research surface yet
+
 "$schema": "@gobing-ai/spur/schemas/state-machine-workflow.schema.json"
 kind: state-machine
 name: wayfinder-resolution
@@ -8,12 +20,15 @@ terminalStates:
   - done
   - failed
   - cancelled
+failureStates:
+  - failed
+  - cancelled
 vars:
   wbs: "0000"
   profile: "standard"
   spurBin: "spur"
   agent: "omp"
-  stepTimeoutMs: "900000"
+  stepTimeoutMs: "1800000"
   approval: "required"
   resolutionMode: "research"
   evidencePolicy: "spur-cli-first"
@@ -21,14 +36,24 @@ vars:
 
 states:
   - id: precheck
-    description: "Validate the task and confirm the requested resolution mode before delegation."
+    description: >
+      Soft precheck: task check + show, status files, always exit 0 so failures
+      route to `failed` via transitions (not a raw lifecycle abort).
     onEnter:
       - kind: shell
         options:
-          command: "${vars.spurBin} task check ${vars.wbs}"
-      - kind: shell
-        options:
-          command: "${vars.spurBin} task show ${vars.wbs} --json"
+          command: >-
+            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
+              printf 'PASS\n' > .spur/run/wayfinder/$wbs-precheck.status;
+            else
+              printf 'FAIL\n' > .spur/run/wayfinder/$wbs-precheck.status;
+            fi &&
+            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."
@@ -38,13 +63,17 @@ states:
     onEnter:
       - kind: shell
         options:
-          command: "mkdir -p .spur/run/wayfinder && ${vars.spurBin} task show ${vars.wbs} --json > .spur/run/wayfinder/${vars.wbs}-input.json"
+          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.
       - kind: shell
         options:
-          command: "${vars.spurBin} workflow validate config/workflows/wayfinder-resolution.yaml > .spur/run/wayfinder/${vars.wbs}-workflow-check.txt"
+          command: "$spurBin workflow validate .spur/workflows/wayfinder-resolution.yaml > .spur/run/wayfinder/$wbs-workflow-check.txt"
       - kind: shell
         options:
-          command: "${vars.spurBin} task check ${vars.wbs} > .spur/run/wayfinder/${vars.wbs}-precheck.txt"
+          command: "$spurBin task check $wbs > .spur/run/wayfinder/$wbs-precheck.txt"
 
   - id: investigate
     description: "Resolve the task's research/specification requirements and author evidence-backed sections through Spur CLI."
@@ -79,6 +108,9 @@ states:
   - id: verify
     description: "Perform an independent evidence and traceability check for the resolved research task."
     onEnter:
+      - kind: shell
+        options:
+          command: 'rm -f .spur/run/wayfinder/$wbs-resolution-verdict.txt'
       - kind: agent.run
         options:
           agent: ${vars.agent}
@@ -92,6 +124,7 @@ states:
             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.
+          expectFile: .spur/run/wayfinder/${vars.wbs}-resolution-verdict.txt
           timeoutMs: ${vars.stepTimeoutMs}
 
   - id: approve
@@ -105,14 +138,20 @@ states:
   - id: record
     description: "Record the resolution through the canonical task CLI and transition only after checks pass."
     onEnter:
+      # Both steps are soft (`; exit 0`) BY DESIGN, not laxity: the real gate is the
+      # `record → done` guard below, which re-runs `spur task check` AND asserts the
+      # status actually reached done. Hard-failing here aborted the run inside the
+      # state, so the declared `record → failed` edge was unreachable and a blocked
+      # lifecycle transition surfaced as a bare "Command exited with 1" instead of
+      # the terminal `failed` this workflow documents.
       - kind: shell
         options:
-          command: "${vars.spurBin} task check ${vars.wbs}"
+          command: "$spurBin task check $wbs ; exit 0"
       - kind: shell
         options:
           # PASS-only completion (preserve-list P4): lifecycle guards stay on; a forced
           # done without verdict evidence is the 0280 regression this replaces (see 0292).
-          command: "${vars.spurBin} task update ${vars.wbs} done"
+          command: "$spurBin task update $wbs done ; exit 0"
 
   - id: done
     description: "Research task resolved and ready to feed the implementation backlog."
@@ -130,53 +169,51 @@ states:
 transitions:
   - from: precheck
     to: collect
-    description: "Precheck passed — collect deterministic local inputs."
+    description: "Precheck PASS — collect deterministic local inputs."
     guard:
       kind: shell
       options:
-        command: "${vars.spurBin} task check ${vars.wbs}"
+        command: 'test "$(cat .spur/run/wayfinder/$wbs-precheck.status 2>/dev/null)" = PASS'
   - from: precheck
     to: failed
-    description: "Precheck failed — stop before delegation."
+    description: "Precheck FAIL — stop before delegation."
     guard:
-      kind: shell
-      options:
-        command: "! ${vars.spurBin} task check ${vars.wbs}"
+      kind: always
   - from: collect
     to: investigate
     description: "Input bundle collected — resolve the research task."
     guard:
       kind: shell
       options:
-        command: "test -s .spur/run/wayfinder/${vars.wbs}-input.json && test -s .spur/run/wayfinder/${vars.wbs}-precheck.txt"
+        command: "test -s .spur/run/wayfinder/$wbs-input.json && test -s .spur/run/wayfinder/$wbs-precheck.txt"
   - from: collect
     to: failed
     description: "Input collection failed — stop before delegation."
     guard:
       kind: shell
       options:
-        command: "! test -s .spur/run/wayfinder/${vars.wbs}-input.json || ! test -s .spur/run/wayfinder/${vars.wbs}-precheck.txt"
+        command: "! test -s .spur/run/wayfinder/$wbs-input.json || ! test -s .spur/run/wayfinder/$wbs-precheck.txt"
   - from: investigate
     to: verify
     description: "Research resolution authored — verify evidence and traceability. Guard enforces the evidence content floor (0300 R2): the task's Testing section must be non-placeholder (>5 lines, >60 words) before independent verification may begin."
     guard:
       kind: shell
       options:
-        command: 'test "$(${vars.spurBin} task show ${vars.wbs} --json | jq -r ".content" | awk "/^### Testing/{f=1;next} /^### /{f=0} f" | wc -l)" -gt 5 && test "$(${vars.spurBin} task show ${vars.wbs} --json | jq -r ".content" | awk "/^### Testing/{f=1;next} /^### /{f=0} f" | wc -w)" -gt 60'
+        command: 'test "$($spurBin task show $wbs --json | jq -r ".content" | awk "/^### Testing/{f=1;next} /^### /{f=0} f" | wc -l)" -gt 5 && test "$($spurBin task show $wbs --json | jq -r ".content" | awk "/^### Testing/{f=1;next} /^### /{f=0} f" | wc -w)" -gt 60'
   - from: investigate
     to: failed
     description: "Evidence content floor not met (0300 R2) — investigate authored a placeholder Testing section; stop before verification rather than certify hollow evidence."
     guard:
       kind: shell
       options:
-        command: 'test "$(${vars.spurBin} task show ${vars.wbs} --json | jq -r ".content" | awk "/^### Testing/{f=1;next} /^### /{f=0} f" | wc -l)" -le 5 || test "$(${vars.spurBin} task show ${vars.wbs} --json | jq -r ".content" | awk "/^### Testing/{f=1;next} /^### /{f=0} f" | wc -w)" -le 60'
+        command: 'test "$($spurBin task show $wbs --json | jq -r ".content" | awk "/^### Testing/{f=1;next} /^### /{f=0} f" | wc -l)" -le 5 || test "$($spurBin task show $wbs --json | jq -r ".content" | awk "/^### Testing/{f=1;next} /^### /{f=0} f" | wc -w)" -le 60'
   - from: verify
     to: record
     description: "Auto profile — record only on a machine-readable PASS verdict (fail-closed to the approve gate otherwise)."
     guard:
       kind: shell
       options:
-        command: 'test "${vars.approval}" = auto && grep -qx PASS .spur/run/wayfinder/${vars.wbs}-resolution-verdict.txt'
+        command: 'test "$approval" = auto && grep -qx PASS .spur/run/wayfinder/$wbs-resolution-verdict.txt'
   - from: verify
     to: approve
     description: "Verification completed — require explicit review approval."
@@ -188,32 +225,32 @@ transitions:
     guard:
       kind: shell
       options:
-        command: 'test "${vars.__hitlAnswer}" = yes'
+        command: 'test "$__hitlAnswer" = yes'
   - from: approve
     to: cancelled
     description: "Operator cancelled the research resolution."
     guard:
       kind: shell
       options:
-        command: 'test "${vars.__hitlAnswer}" = cancel'
+        command: 'test "$__hitlAnswer" = cancel'
   - from: approve
     to: failed
     description: "Operator rejected the research resolution."
     guard:
       kind: shell
       options:
-        command: 'test "${vars.__hitlAnswer}" = no'
+        command: 'test "$__hitlAnswer" = no'
   - from: record
     to: done
     description: "Task check passed and the task status is actually done (the lifecycle transition succeeded)."
     guard:
       kind: shell
       options:
-        command: '${vars.spurBin} task check ${vars.wbs} && test "$(${vars.spurBin} task show ${vars.wbs} --json | jq -r .status)" = done'
+        command: '$spurBin task check $wbs && test "$($spurBin task show $wbs --json | jq -r .status)" = done'
   - from: record
     to: failed
     description: "Recording/check failed or the task never reached done — stop without claiming completion."
     guard:
       kind: shell
       options:
-        command: '! ${vars.spurBin} task check ${vars.wbs} || test "$(${vars.spurBin} task show ${vars.wbs} --json | jq -r .status)" != done'
+        command: '! $spurBin task check $wbs || test "$($spurBin task show $wbs --json | jq -r .status)" != done'

package/config/workflows/wrapup-pipeline.yaml

@@ -22,7 +22,15 @@
 #   spurBin  — PATH-independent spur invocation (overridden by CLI at run start)
 #   agent    — agent for agent.run steps (default: omp)
 #
-# Seeded by `spur init`; adapt the agent.run inputs to your project's command set.
+# Reliability (aligned with task-pipeline / ADR-043):
+#   - Prefer pure slash commands when a command exists; free-form inputs remain only
+#     where capture artifacts (answerFile) have no dedicated slash surface yet.
+#   - learning-capture / metrics-record use expectFile + soft append (empty capture
+#     does not abort wrap-up after prior steps already landed).
+#   - feature-transition is a soft shell (always exit 0) so a blocked feature sync
+#     does not abort wrap-up after learnings/metrics already landed.
+#   - branch-cleanup HITL is exhaustive (yes/no/cancel → done; missing answer defense).
+#   - Wrap-up never mutates task status (consumes completed work only).
 
 "$schema": "@gobing-ai/spur/schemas/state-machine-workflow.schema.json"
 kind: state-machine
@@ -40,7 +48,8 @@ vars:
   merge: "false"
   spurBin: "spur"
   agent: "omp"
-  stepTimeoutMs: "600000"
+  stepTimeoutMs: "1800000"
+  __hitlAnswer: ""
 
 states:
   - id: start
@@ -64,67 +73,81 @@ states:
 
   - id: doc-sync
     description: >
-      Dispatch sp:doc-evolve once for the entire batch. Project-level doc drift repair
-      runs once, not per-task. The agent reads the batch's completed tasks, identifies
-      doc drift (04_DESIGN, 03_ARCHITECTURE, 00_ADR, docs/design/*), and repairs it
-      following the constitution's edit rules. Does NOT write task or feature corpus.
+      Project-level doc drift repair for the batch (04_DESIGN, 03_ARCHITECTURE,
+      00_ADR, docs/design/*). No dedicated slash command yet — free-form skill
+      pointer until a /sp:doc-evolve command exists (ADR-043 residual).
     onEnter:
       - kind: agent.run
         options:
           agent: ${vars.agent}
-          input: "Run sp:doc-evolve for completed tasks ${vars.tasks}. Repair doc drift in 04_DESIGN, 03_ARCHITECTURE, 00_ADR, docs/design/* following the constitution edit rules. Do not write task or feature corpus files."
+          input: "Skill(skill=\"sp:doc-evolve\", args=\"wrapup tasks=${vars.tasks}\"). 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."
           timeoutMs: ${vars.stepTimeoutMs}
 
   - id: learning-capture
     description: >
-      Append working learnings to .spur/memory/learnings.md. The agent extracts
-      insights from the batch and writes them to a capture file; a downstream shell
-      step appends that file to the learnings scratchpad. This decouples content
-      generation from file persistence: the shell step's exit code is the real
-      success signal, and the capture file is verified before the append.
+      Append working learnings to .spur/memory/learnings.md. Capture+shell decoupling:
+      expectFile gates non-empty capture before append; append is best-effort soft
+      (empty capture skips without aborting wrap-up).
     onEnter:
       - kind: agent.run
         options:
           agent: ${vars.agent}
-          input: "Extract working learnings from tasks ${vars.tasks}. Output as markdown grouped by date and task WBS. Include: conventions discovered, errors hit and resolved, patterns that worked, gotchas. Output raw markdown (no code fences) — your answer will be captured to a file and appended to .spur/memory/learnings.md."
+          input: "Extract working learnings from tasks ${vars.tasks}. Output raw markdown (no fences) grouped by date and task WBS: conventions, errors fixed, patterns, gotchas. Captured to .spur/run/wrapup-learnings.md."
           answerFile: .spur/run/wrapup-learnings.md
           expectFile: .spur/run/wrapup-learnings.md
           timeoutMs: ${vars.stepTimeoutMs}
       - kind: shell
         options:
-          command: 'test -s .spur/run/wrapup-learnings.md && mkdir -p .spur/memory && cat .spur/run/wrapup-learnings.md >> .spur/memory/learnings.md && printf "\n" >> .spur/memory/learnings.md'
+          command: >-
+            mkdir -p .spur/memory &&
+            if test -s .spur/run/wrapup-learnings.md; then
+              cat .spur/run/wrapup-learnings.md >> .spur/memory/learnings.md &&
+              printf '\n' >> .spur/memory/learnings.md;
+            fi &&
+            exit 0
 
   - id: metrics-record
     description: >
-      Append one JSONL row per task to .spur/memory/wrapup-metrics.jsonl. The agent
-      produces the JSONL content to a capture file; a downstream shell step appends
-      it. Each row records: task WBS, feature id, status, verdict, timestamp.
-      Append-only and machine-readable. The capture+shell decoupling means a
-      non-empty capture file is verified before the append (the agent.run exit-0
-      is no longer the sole success signal — the shell step's exit code gates the
-      write).
+      Append one JSONL row per task to .spur/memory/wrapup-metrics.jsonl. Soft append
+      (empty capture does not abort wrap-up after learnings already landed).
     onEnter:
       - kind: agent.run
         options:
           agent: ${vars.agent}
-          input: "For each task in ${vars.tasks}, read the task file and output one JSONL line per task with fields: wbs, feature_id, status, verdict (from .spur/run/<wbs>-verdict.json if available), timestamp. Output raw JSONL (no code fences) — your answer will be captured to a file and appended to .spur/memory/wrapup-metrics.jsonl."
+          input: "For each task in ${vars.tasks}, output one JSONL line (no fences) with fields: wbs, feature_id, status, verdict, timestamp. Captured to .spur/run/wrapup-metrics.jsonl."
           answerFile: .spur/run/wrapup-metrics.jsonl
           expectFile: .spur/run/wrapup-metrics.jsonl
           timeoutMs: ${vars.stepTimeoutMs}
       - kind: shell
         options:
-          command: 'test -s .spur/run/wrapup-metrics.jsonl && mkdir -p .spur/memory && cat .spur/run/wrapup-metrics.jsonl >> .spur/memory/wrapup-metrics.jsonl'
+          command: >-
+            mkdir -p .spur/memory &&
+            if test -s .spur/run/wrapup-metrics.jsonl; then
+              cat .spur/run/wrapup-metrics.jsonl >> .spur/memory/wrapup-metrics.jsonl;
+            fi &&
+            exit 0
 
   - id: feature-transition
     description: >
-      If vars.feature is set, derive and sync feature status with linked task states via the
-      bounded `feature-sync-bounded` wrapper (task 0328 / ADR-0322, task 0411 retry-suppression).
-      Replaces prior unconditional `spur feature advance` with conservative status sync that
-      suppresses identical blocked retries until relevant inputs change.
+      If vars.feature is set, sync feature status via bounded feature-sync-bounded
+      (0411). Soft shell — blocked/failed sync must not abort wrap-up after metrics.
     onEnter:
+      # Genuinely soft: the terminating `exit 0` must be reached on BOTH branches, so
+      # the sync is chained with `;` — with `&&` a non-zero sync skipped `exit 0` and
+      # aborted the run at this state, discarding the learnings/metrics that already
+      # landed and never reaching branch-cleanup/done (the exact failure the state
+      # description promises against). `feature-sync-bounded.ts` is a Spur-monorepo
+      # path (`spur init` does not scaffold `plugins/sp/`), so seeded projects fall
+      # back to the plain `spur feature sync` verb.
       - kind: shell
         options:
-          command: 'bun plugins/sp/scripts/feature-sync-bounded.ts ${vars.feature} --spur-bin "${vars.spurBin}" --json'
+          command: >-
+            if [ -f plugins/sp/scripts/feature-sync-bounded.ts ]; then
+              bun plugins/sp/scripts/feature-sync-bounded.ts "$feature" --spur-bin "$spurBin" --json;
+            else
+              $spurBin feature sync "$feature" --json;
+            fi;
+            exit 0
 
   - id: branch-cleanup
     description: >
@@ -148,7 +171,7 @@ states:
       # Checkpoint write: record session state for resume (Phase 4, task 0171 R3)
       - kind: shell
         options:
-          command: 'mkdir -p .spur/memory/sessions && echo "checkpoint: wrapup-pipeline done tasks=${vars.tasks} ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)" > .spur/memory/sessions/wrapup-checkpoint.md'
+          command: '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'
 
   - id: skipped
     description: Terminal — wrap-up skipped (empty task list or operator abort).
@@ -161,21 +184,30 @@ transitions:
     guard:
       kind: always
 
-  # ── task-resolve: non-empty -> doc-sync, empty -> skipped ──
+  # ── task-resolve: non-empty -> doc-sync, empty/unparseable -> skipped ──
+  # `|| echo 0` is load-bearing: a malformed vars.tasks (or a box without `jq`) makes
+  # `jq length` emit nothing, and bare `test "" -gt 0` exits 2 — so BOTH edges failed
+  # and the run died with an opaque `no-passing-transition` instead of skipping. The
+  # trailing `always` edge is the belt-and-braces defense for any other guard fault.
   - from: task-resolve
     to: doc-sync
     description: Task list resolved and non-empty — begin doc-sync.
     guard:
       kind: shell
       options:
-        command: 'test "$(echo "${vars.tasks}" | jq length)" -gt 0'
+        command: 'test "$(echo "$tasks" | jq length 2>/dev/null || echo 0)" -gt 0'
   - from: task-resolve
     to: skipped
     description: Task list is empty — skip wrap-up.
     guard:
       kind: shell
       options:
-        command: 'test "$(echo "${vars.tasks}" | jq length)" -eq 0'
+        command: 'test "$(echo "$tasks" | jq length 2>/dev/null || echo 0)" -eq 0'
+  - from: task-resolve
+    to: skipped
+    description: Defense — task list unparseable; skip rather than fail with no-passing-transition.
+    guard:
+      kind: always
 
   # ── linear body: doc-sync -> learning-capture -> metrics-record ──
   - from: doc-sync
@@ -198,21 +230,21 @@ transitions:
     guard:
       kind: shell
       options:
-        command: 'test -n "${vars.feature}"'
+        command: 'test -n "$feature"'
   - from: metrics-record
     to: branch-cleanup
     description: No feature id, but merge is requested — go to branch cleanup.
     guard:
       kind: shell
       options:
-        command: 'test -z "${vars.feature}" && test "${vars.merge}" = true'
+        command: 'test -z "$feature" && test "$merge" = true'
   - from: metrics-record
     to: done
     description: No feature id and no merge — wrap-up is done.
     guard:
       kind: shell
       options:
-        command: 'test -z "${vars.feature}" && test "${vars.merge}" != true'
+        command: 'test -z "$feature" && test "$merge" != true'
 
   # ── feature-transition: -> branch-cleanup (if merge) or done ──
   - from: feature-transition
@@ -221,18 +253,26 @@ transitions:
     guard:
       kind: shell
       options:
-        command: 'test "${vars.merge}" = true'
+        command: 'test "$merge" = true'
   - from: feature-transition
     to: done
     description: Feature advanced — no merge requested.
     guard:
       kind: shell
       options:
-        command: 'test "${vars.merge}" != true'
+        command: 'test "$merge" != true'
 
-  # ── branch-cleanup: HITL confirmed -> done ──
+  # ── branch-cleanup: HITL exhaustive routing (yes / no / cancel → done) ──
+  # No irreversible git op is wired yet; confirmation is recorded, then wrap completes.
+  - from: branch-cleanup
+    to: done
+    description: Branch cleanup HITL answered — wrap-up complete.
+    guard:
+      kind: shell
+      options:
+        command: 'test "$__hitlAnswer" = yes || test "$__hitlAnswer" = no || test "$__hitlAnswer" = cancel'
   - from: branch-cleanup
     to: done
-    description: Branch cleanup confirmed — wrap-up complete.
+    description: Defense — missing HITL answer still completes wrap (cleanup is optional).
     guard:
       kind: always

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gobing-ai/spur",
-    "version": "0.3.30",
+    "version": "0.3.32",
     "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",
@@ -50,14 +50,14 @@
     },
     "devDependencies": {
         "@commander-js/extra-typings": "^14.0.0",
-        "@gobing-ai/ts-db": "^0.4.16",
-        "@gobing-ai/ts-ai-runner": "^0.4.16",
-        "@gobing-ai/ts-dual-workflow-engine": "^0.4.16",
-        "@gobing-ai/ts-infra": "^0.4.16",
-        "@gobing-ai/ts-llm-jsonl-importer": "^0.4.16",
-        "@gobing-ai/ts-rule-engine": "^0.4.16",
-        "@gobing-ai/ts-runtime": "^0.4.16",
-        "@gobing-ai/ts-utils": "^0.4.16",
+        "@gobing-ai/ts-db": "^0.4.18",
+        "@gobing-ai/ts-ai-runner": "^0.4.18",
+        "@gobing-ai/ts-dual-workflow-engine": "^0.4.18",
+        "@gobing-ai/ts-infra": "^0.4.18",
+        "@gobing-ai/ts-llm-jsonl-importer": "^0.4.18",
+        "@gobing-ai/ts-rule-engine": "^0.4.18",
+        "@gobing-ai/ts-runtime": "^0.4.18",
+        "@gobing-ai/ts-utils": "^0.4.18",
         "@types/bun": "1.3.14",
         "@types/figlet": "^1.7.0",
         "@types/node-notifier": "8.0.5",

package/schemas/state-machine-workflow.schema.json

@@ -13,6 +13,11 @@
         "description": { "type": "string" },
         "initialState": { "type": "string", "minLength": 1 },
         "terminalStates": { "type": "array", "items": { "type": "string", "minLength": 1 } },
+        "failureStates": {
+            "type": "array",
+            "items": { "type": "string", "minLength": 1 },
+            "description": "Subset of terminalStates whose reach finalizes the run as failed. Absent ⇒ every terminal is a success."
+        },
         "iterationBound": { "type": "integer", "exclusiveMinimum": 0 },
         "vars": {
             "type": "object",