@specship/specship-win32-arm64 0.23.0 → 0.25.0

package/lib/dist/workflows/defaults/spec-implement.yaml

@@ -100,9 +100,137 @@ nodes:
 
       When done, output a short diff summary (which files changed and why).
 
-  - id: verify
+  - id: quality_gate
     kind: bash
     depends_on: [implement]
+    output_type: quality_report
+    timeout: 600000
+    bash: |
+      # REQ-AUTHG-005.A1 — the project's own lint/typecheck, run in the
+      # worktree right after implement. The QUALITY_GATE marker is the
+      # contract the remediation node routes on: a project with neither a lint
+      # script nor a typecheck config says so explicitly, so "nothing ran" can
+      # never be mistaken for "clean" (same doctrine as VERIFY_RESULT=skipped).
+      QUALITY_CMD=""
+      if [ -f package.json ]; then
+        # The worktree may not have dependencies yet (verify installs them
+        # later) and lint needs them — bootstrap quietly, and treat a failed
+        # install as "no gate" rather than as a lint failure.
+        if [ ! -d node_modules ]; then
+          npm ci --no-audit --no-fund >/dev/null 2>&1 || npm install --no-audit --no-fund >/dev/null 2>&1 || true
+        fi
+        if node -e 'const s=(require("./package.json").scripts)||{};process.exit(s.lint?0:1)' 2>/dev/null; then
+          QUALITY_CMD="npm run lint --if-present"
+        elif [ -f tsconfig.json ]; then
+          QUALITY_CMD="npx --no-install tsc --noEmit"
+        fi
+      elif [ -f Cargo.toml ]; then
+        if command -v cargo >/dev/null 2>&1; then QUALITY_CMD="cargo clippy --no-deps"; fi
+      elif [ -f pyproject.toml ] || [ -f requirements.txt ]; then
+        if command -v ruff >/dev/null 2>&1; then QUALITY_CMD="ruff check ."; fi
+      fi
+      if [ -z "$QUALITY_CMD" ]; then
+        echo "QUALITY_GATE=skipped"
+        echo "QUALITY_REASON=no lint script and no typecheck configuration in this project"
+        exit 0
+      fi
+      echo "QUALITY_CMD=$QUALITY_CMD"
+      if OUT=$($QUALITY_CMD 2>&1); then
+        echo "QUALITY_GATE=passed"
+      else
+        echo "QUALITY_GATE=failed"
+        printf '%s\n' "$OUT" | tail -n 80
+      fi
+      # Exiting 0 on a lint failure is deliberate: the marker — not this node's
+      # exit code — drives the revise loop. quality_recheck is what halts.
+
+  - id: fix_quality
+    kind: prompt
+    depends_on: [quality_gate]
+    output_type: quality_fix
+    allowed_tools:
+      - Read
+      - Edit
+      - Write
+      - Bash
+      - mcp__specship__specship_explore
+      - mcp__specship__specship_node
+    prompt: |
+      Lint / typecheck result for the code you just wrote:
+
+      $quality_gate.output
+
+      Route on the QUALITY_GATE marker — do not re-judge the raw output:
+
+      - QUALITY_GATE=passed or QUALITY_GATE=skipped → change NOTHING. Output
+        exactly `FIX_QUALITY=not-needed` and stop.
+      - QUALITY_GATE=failed → fix every reported error, then re-run the
+        QUALITY_CMD shown above to confirm. Fix the code, never the lint
+        configuration; never silence or disable a rule to make it pass.
+
+      Output `FIX_QUALITY=fixed` (clean re-run) or `FIX_QUALITY=still-failing`
+      followed by the errors that remain.
+
+  - id: quality_recheck
+    kind: bash
+    depends_on: [fix_quality]
+    output_type: quality_result
+    timeout: 600000
+    bash: |
+      # REQ-AUTHG-005.A1 — the authoritative half of the gate. The fix node is
+      # a prompt, so its "FIX_QUALITY=fixed" claim is a claim, not evidence:
+      # this node re-runs the same command and halts the run while it still
+      # fails, so failing lint/typecheck never reaches verify, the link node,
+      # or the human gate.
+      GATE_OUT=$quality_gate.output
+      MARKER=$(printf '%s' "$GATE_OUT" | grep -oE 'QUALITY_GATE=[a-z-]+' | tail -n 1 | cut -d= -f2)
+      CMD=$(printf '%s' "$GATE_OUT" | grep -E '^QUALITY_CMD=' | tail -n 1 | cut -d= -f2-)
+      if [ "$MARKER" = "skipped" ] || [ -z "$CMD" ]; then
+        echo "QUALITY_RESULT=skipped"
+        echo "This project has no lint or typecheck gate — nothing was checked."
+        exit 0
+      fi
+      if OUT=$($CMD 2>&1); then
+        echo "QUALITY_RESULT=clean"
+        exit 0
+      fi
+      echo "QUALITY_RESULT=failed"
+      printf '%s\n' "$OUT" | tail -n 80
+      echo "HALT_CAUSE=lint/typecheck still fails after the fix attempt — the change is not reviewable yet"
+      exit 1
+
+  - id: diff
+    kind: bash
+    depends_on: [quality_recheck]
+    output_type: diff
+    bash: |
+      # REQ-AUTHG-004.A1 — the full diff, from git, into a run artifact. The
+      # human gate and the adversarial reviewer read THIS; the implement node's
+      # prose about what it believes it changed is not the change.
+      # `git add -A -N` registers new files as intent-to-add so untracked work
+      # appears in `git diff HEAD` without staging any content.
+      git add -A -N >/dev/null 2>&1 || true
+      echo "DIFF_BEGIN"
+      git --no-pager diff HEAD | head -c 400000
+      echo
+      echo "DIFF_END"
+
+  - id: diff_stat
+    kind: bash
+    depends_on: [diff]
+    output_type: diff_stat
+    bash: |
+      # REQ-AUTHG-004.A2 — the stat block the final gate shows: file names and
+      # insertions/deletions counted by git. Its own small node so the approval
+      # message carries the summary while the full diff stays in the `diff`
+      # artifact.
+      echo "DIFF_STAT_BEGIN"
+      git --no-pager diff HEAD --stat
+      echo "DIFF_STAT_END"
+
+  - id: verify
+    kind: bash
+    depends_on: [diff_stat]
     output_type: test_results
     timeout: 600000
     bash: |
@@ -111,25 +239,67 @@ nodes:
       # The VERIFY_RESULT marker is the machine-readable contract the link
       # node routes on (REQ-IMPLINT-001.A1): a skipped run must never be
       # mistaken for a passing one.
+      # Install and build failures fail fast with their own markers
+      # (REQ-REVINT-006.A1) — a broken environment or a build break is NOT a
+      # test failure, and must never be attributed to one.
       if [ -f package.json ]; then
         # A fresh worktree has no node_modules/ or build output — a verify
         # failure must mean the tests failed, not that the environment was
         # missing (WF-REJECT-DOC, REQ-WFREJ-005).
-        if [ ! -d node_modules ]; then npm ci --no-audit --no-fund || npm install --no-audit --no-fund; fi
-        npm run build --if-present
+        if [ ! -d node_modules ]; then
+          if ! { npm ci --no-audit --no-fund || npm install --no-audit --no-fund; }; then
+            echo "VERIFY_RESULT=env-failed"; exit 1
+          fi
+        fi
+        if ! npm run build --if-present; then echo "VERIFY_RESULT=build-failed"; exit 1; fi
         if npm test; then echo "VERIFY_RESULT=ran-and-passed"; else echo "VERIFY_RESULT=ran-and-failed"; exit 1; fi
       elif [ -f Cargo.toml ]; then
+        if ! cargo build; then echo "VERIFY_RESULT=build-failed"; exit 1; fi
         if cargo test; then echo "VERIFY_RESULT=ran-and-passed"; else echo "VERIFY_RESULT=ran-and-failed"; exit 1; fi
       elif [ -f pyproject.toml ] || [ -f requirements.txt ]; then
+        if ! python -c 'import pytest' 2>/dev/null; then echo "VERIFY_RESULT=env-failed"; exit 1; fi
         if python -m pytest; then echo "VERIFY_RESULT=ran-and-passed"; else echo "VERIFY_RESULT=ran-and-failed"; exit 1; fi
       else
         echo "no recognised test framework; tests did NOT run"
         echo "VERIFY_RESULT=skipped"
       fi
 
+  - id: route_verify
+    kind: bash
+    depends_on: [verify]
+    output_type: verify_route
+    bash: |
+      # Deterministic verify routing (REQ-VSTATE-005.A1): the VERIFY_RESULT
+      # marker is parsed HERE, in code, and turned into a LINK_ACTION the link
+      # node obeys. It used to be a prompt reading a test log — the one decision
+      # that governs whether links may be promoted was hallucinable.
+      VERIFY_OUT=$verify.output
+      MARKER=$(printf '%s' "$VERIFY_OUT" | grep -oE 'VERIFY_RESULT=[a-z-]+' | tail -n 1 | cut -d= -f2)
+      [ -n "$MARKER" ] || MARKER=missing
+      echo "VERIFY_RESULT=$MARKER"
+      # env-failed / build-failed halt BEFORE any link mutation, naming the
+      # environment cause (REQ-VSTATE-005.A3) — neither is a test failure.
+      case "$MARKER" in
+        ran-and-passed)
+          echo "LINK_ACTION=assert-and-verify-pass" ;;
+        ran-and-failed)
+          echo "LINK_ACTION=assert-and-verify-fail" ;;
+        skipped)
+          echo "LINK_ACTION=assert-only" ;;
+        env-failed)
+          echo "HALT_CAUSE=environment setup failed (dependency install) — nothing is known about the tests"
+          exit 1 ;;
+        build-failed)
+          echo "HALT_CAUSE=build failed — nothing is known about the tests"
+          exit 1 ;;
+        *)
+          echo "HALT_CAUSE=no VERIFY_RESULT marker found in the verify output — an unknown result is never a pass"
+          exit 1 ;;
+      esac
+
   - id: link
     kind: prompt
-    depends_on: [verify]
+    depends_on: [route_verify]
     output_type: link_summary
     allowed_tools:
       - mcp__specship__specship_link_assert
@@ -141,14 +311,31 @@ nodes:
       requirements), call specship_link_assert with the spec_id, the
       file path, and the qualified symbol name.
 
-      Then route on the VERIFY_RESULT marker in the test results below
-      (REQ-IMPLINT-001):
-      - VERIFY_RESULT=ran-and-passed → after each assert, call
+      You MUST NOT assert a `tests`-kind link (REQ-REVINT-005.A1). Every
+      specship_link_assert call here is an implementation link — leave `kind`
+      at its default and never pass kind: 'tests'. Test evidence is
+      file-derived only: it comes from the spec's `verifies:` block or an
+      `@verifies` comment on the test symbol, never from this node. A workflow
+      that minted its own test evidence would be promoting itself past the
+      gate that exists to check it.
+
+      Then act on LINK_ACTION, which a bash node already computed from the
+      VERIFY_RESULT marker (REQ-VSTATE-005.A1). Do NOT re-derive it from the
+      test log — read it:
+
+      $route_verify.output
+
+      - LINK_ACTION=assert-and-verify-pass → after each assert, call
         specship_link_verify with result="pass".
-      - VERIFY_RESULT=skipped → do NOT call specship_link_verify at all;
+      - LINK_ACTION=assert-and-verify-fail → call specship_link_verify with
+        result="fail" and the failing test name as the reason.
+      - LINK_ACTION=assert-only → do NOT call specship_link_verify at all;
         the links stay in the `implemented` state. Tests that did not run
         are never reported as passing.
 
+      A run whose environment or build broke never reaches this node — the
+      routing step halts it first (REQ-VSTATE-005.A3).
+
       Implementation diff summary:
       $implement.output
 
@@ -160,34 +347,88 @@ nodes:
       skipped.
 
   - id: coverage
-    kind: prompt
+    kind: bash
     depends_on: [link]
     output_type: coverage_summary
+    bash: |
+      # The acceptance-criteria coverage line is computed FROM THE DB
+      # (REQ-VSTATE-005.A2) — `specship coverage --line` renders the same
+      # `getSpecCoverage` report the MCP tool and the dashboard read, so the
+      # number on the approval gate cannot disagree with them. It used to be
+      # counted by a prompt.
+      if command -v specship >/dev/null 2>&1; then SS=specship
+      elif [ -x node_modules/.bin/specship ]; then SS=node_modules/.bin/specship
+      elif [ -x dist/bin/specship.js ]; then SS="node dist/bin/specship.js"
+      else SS=""; fi
+      if [ -z "$SS" ]; then
+        echo "COVERAGE_UNAVAILABLE=specship CLI not found — acceptance-criteria coverage was NOT computed"
+        exit 0
+      fi
+      LINE=$($SS coverage $INPUT.SPEC_ID --line) || {
+        echo "COVERAGE_UNAVAILABLE=specship coverage failed — coverage was NOT computed"
+        exit 0
+      }
+      echo "$LINE"
+      N=$(printf '%s' "$LINE" | awk '{print $1}')
+      M=$(printf '%s' "$LINE" | awk '{print $3}')
+      if [ "$N" != "$M" ]; then
+        echo "Close the gap with /specship:spec behaviour $INPUT.SPEC_ID."
+      fi
+
+  - id: adversarial_review
+    kind: prompt
+    depends_on: [coverage]
+    output_type: adversarial_review
     allowed_tools:
+      - Read
+      - Grep
       - mcp__specship__specship_spec
+      - mcp__specship__specship_explore
+      - mcp__specship__specship_node
+      - mcp__specship__specship_search
     prompt: |
-      Report acceptance-criteria test coverage for $INPUT.SPEC_ID
-      (REQ-IMPLINT-002). Call specship_spec with the spec_id, count its
-      acceptance criteria (the .A<N> children; if the spec has none,
-      treat the requirement itself as one criterion), and count how many
-      of them carry a `tests`-kind link.
+      Adversarial review (REQ-AUTHG-005.A3). You are NOT the implementer — your
+      job is to find what the implementation missed. This node is read-only:
+      you have no Edit, Write or Bash tool and must not try to fix anything.
 
-      Output exactly one or two lines:
-      - "N of M acceptance criteria for $INPUT.SPEC_ID have linked tests."
-      - If N < M, add: "Close the gap with /specship:spec behaviour
-        $INPUT.SPEC_ID."
+      Call specship_spec($INPUT.SPEC_ID) and read the spec body, including
+      every acceptance criterion.
+
+      The change under review (from git, not from the implementer's summary):
+
+      $diff.output
+
+      Report this and nothing else:
+
+      1. One line per acceptance criterion:
+         `<AC id>: satisfied | partial | unaddressed — <one sentence, grounded
+         in the diff>`. Judge from the diff and the code you read; "the
+         implementer said so" is not evidence.
+      2. `Untested new code paths:` the branches/functions this diff adds that
+         no test in the diff exercises (`none` if there are none).
+      3. `Verdict:` one line — the most serious gap a reviewer should look at
+         first, or `no gaps found`.
 
   - id: final_review
     kind: approval
-    depends_on: [coverage]
+    depends_on: [adversarial_review]
     message: |
       Implementation complete for $INPUT.SPEC_ID.
 
+      Changes (git diff --stat — measured, not summarized):
+      $diff_stat.output
+
+      Lint / typecheck:
+      $quality_recheck.output
+
       Links asserted:
       $link.output
 
       Acceptance-criteria test coverage:
       $coverage.output
 
+      Adversarial review:
+      $adversarial_review.output
+
       Approve to finalize the run (worktree is left for you to inspect
       and merge), or reject to abandon.

package/lib/dist/workflows/defaults/spec-verify.yaml

@@ -13,23 +13,58 @@ nodes:
     output_type: test_results
     timeout: 600000
     bash: |
+      # Same VERIFY_RESULT contract as spec-implement / spec-fix
+      # (REQ-REVINT-006, REQ-VSTATE-005): the marker is what the routing node
+      # reads. This node used to emit no marker at all and `exit 0` when it
+      # found no runner — a no-runner repo read as a clean verification pass.
       if [ -f package.json ]; then
         # Run against a built tree so a missing dist/ can't false-fail the
         # verify leg (WF-REJECT-DOC, REQ-WFREJ-005).
-        npm run build --if-present
-        npm test
+        if ! npm run build --if-present; then echo "VERIFY_RESULT=build-failed"; exit 1; fi
+        if npm test; then echo "VERIFY_RESULT=ran-and-passed"; else echo "VERIFY_RESULT=ran-and-failed"; exit 1; fi
       elif [ -f Cargo.toml ]; then
-        cargo test
+        if ! cargo build; then echo "VERIFY_RESULT=build-failed"; exit 1; fi
+        if cargo test; then echo "VERIFY_RESULT=ran-and-passed"; else echo "VERIFY_RESULT=ran-and-failed"; exit 1; fi
       elif [ -f pyproject.toml ] || [ -f requirements.txt ]; then
-        python -m pytest
+        if ! python -c 'import pytest' 2>/dev/null; then echo "VERIFY_RESULT=env-failed"; exit 1; fi
+        if python -m pytest; then echo "VERIFY_RESULT=ran-and-passed"; else echo "VERIFY_RESULT=ran-and-failed"; exit 1; fi
       else
-        echo "no recognised test framework; skipping" >&2
-        exit 0
+        echo "no recognised test framework; tests did NOT run" >&2
+        echo "VERIFY_RESULT=skipped"
       fi
 
+  - id: route_verify
+    kind: bash
+    depends_on: [run_tests]
+    output_type: verify_route
+    bash: |
+      # Deterministic routing (REQ-VSTATE-005.A1): code decides what the
+      # summarize node may do with link state.
+      VERIFY_OUT=$run_tests.output
+      MARKER=$(printf '%s' "$VERIFY_OUT" | grep -oE 'VERIFY_RESULT=[a-z-]+' | tail -n 1 | cut -d= -f2)
+      [ -n "$MARKER" ] || MARKER=missing
+      echo "VERIFY_RESULT=$MARKER"
+      case "$MARKER" in
+        ran-and-passed)
+          echo "LINK_ACTION=verify-evidenced" ;;
+        ran-and-failed)
+          echo "LINK_ACTION=verify-fail" ;;
+        skipped)
+          echo "LINK_ACTION=no-verify" ;;
+        env-failed)
+          echo "HALT_CAUSE=environment setup failed — nothing is known about the tests"
+          exit 1 ;;
+        build-failed)
+          echo "HALT_CAUSE=build failed — nothing is known about the tests"
+          exit 1 ;;
+        *)
+          echo "HALT_CAUSE=no VERIFY_RESULT marker found in the test output — an unknown result is never a pass"
+          exit 1 ;;
+      esac
+
   - id: summarize
     kind: prompt
-    depends_on: [run_tests]
+    depends_on: [route_verify]
     output_type: link_summary
     trigger_rule: all_done
     allowed_tools:
@@ -41,12 +76,23 @@ nodes:
 
       $run_tests.output
 
+      Routing decision (computed in code — act on it, do not re-derive it
+      from the log above):
+
+      $route_verify.output
+
       Promotion is EVIDENCE-BASED (VERIFY-EVID-DOC): a spec may only become
       "verified" when a test linked to it as evidence passed. Evidence links
-      have kind='tests' and come from a `verifies:` block in the spec or an
-      `@verifies REQ-X` comment on the test. A green suite alone proves
+      have kind='tests' and come from a `verifies:` block in the spec, an
+      `@verifies REQ-X` comment on the test, or a spec id inside an `it()`
+      title in a test file (REQ-VSTATE-002). A green suite alone proves
       nothing about a spec with no linked tests — never blanket-promote.
 
+      - LINK_ACTION=verify-evidenced → proceed with steps 1–4 below.
+      - LINK_ACTION=verify-fail → only demote (step 3). Promote nothing.
+      - LINK_ACTION=no-verify → no test ran. Mutate no link state at all;
+        report that verification was skipped and stop.
+
       1. Call specship_drifted to see any drifted/broken/orphaned links.
       2. For each 'implemented' link whose spec HAS test-evidence links:
          if all of that spec's evidence tests passed in the output above,
@@ -61,5 +107,10 @@ nodes:
          "unevidenced" in your summary so the author can add `verifies:`
          blocks (REQ-VEVID-003).
 
+      For a fully deterministic alternative to steps 2–3, run
+      `specship verify --report <vitest-json>` (REQ-VSTATE-004): it maps
+      reported test cases to `tests` links by file + title and moves the
+      state itself, with the run recorded as evidence.
+
       Output: a short summary — how many links moved to verified, how many
       to broken, which specs are unevidenced, and which are still drifted.

package/lib/node_modules/.package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@specship/specship",
-  "version": "0.23.0",
+  "version": "0.25.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/lib/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specship/specship",
-  "version": "0.23.0",
+  "version": "0.25.0",
   "description": "Supercharge Claude Code with semantic code intelligence. 94% fewer tool calls • 77% faster exploration • 100% local.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,12 +9,13 @@
   },
   "files": [
     "dist",
-    "scripts",
+    "!dist/**/*.map",
     "README.md",
     ".claude-plugin",
     "commands",
     "agents",
     "hooks",
+    "skills",
     "selectors.json"
   ],
   "scripts": {
@@ -22,8 +23,9 @@
     "build:core": "tsc && tsc -p src/designer/tsconfig.json && npm run copy-assets && node -e \"require('fs').chmodSync('dist/bin/specship.js', 0o755)\"",
     "build:server": "node scripts/build-server-bundle.mjs",
     "preuninstall": "node dist/bin/uninstall.js",
-    "copy-assets": "node -e \"const fs=require('fs');fs.mkdirSync('dist/db',{recursive:true});fs.copyFileSync('src/db/schema.sql','dist/db/schema.sql');fs.mkdirSync('dist/extraction/wasm',{recursive:true});fs.readdirSync('src/extraction/wasm').filter(f=>f.endsWith('.wasm')).forEach(f=>fs.copyFileSync('src/extraction/wasm/'+f,'dist/extraction/wasm/'+f));try{fs.mkdirSync('dist/workflows/defaults',{recursive:true});fs.readdirSync('src/workflows/defaults').filter(f=>/\\.ya?ml$/i.test(f)).forEach(f=>fs.copyFileSync('src/workflows/defaults/'+f,'dist/workflows/defaults/'+f))}catch(e){};['commands','agents','hooks','.claude-plugin'].forEach(d=>{try{fs.cpSync(d,'dist/'+d,{recursive:true})}catch(e){}})\"",
+    "copy-assets": "node scripts/copy-assets.mjs",
     "dev": "tsc --watch",
+    "lint": "tsc --noEmit && tsc --noEmit -p server/tsconfig.json",
     "cli": "npm run build && node dist/bin/specship.js",
     "test": "vitest run",
     "test:watch": "vitest",
@@ -63,6 +65,8 @@
     "@types/cross-spawn": "^6.0.6",
     "@types/node": "^20.19.30",
     "@types/picomatch": "^4.0.2",
+    "@vitest/coverage-v8": "^2.1.9",
+    "fast-check": "^4.10.2",
     "typescript": "^5.0.0",
     "vitest": "^2.1.9"
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specship/specship-win32-arm64",
-  "version": "0.23.0",
+  "version": "0.25.0",
   "description": "SpecShip self-contained bundle for win32-arm64",
   "os": [
     "win32"