@pieerry/harness-kit 3.0.0 → 3.1.1

package/.claude/commands/pipeline/continue.md

@@ -0,0 +1,15 @@
+---
+description: Resume the active pipeline at the next pending stage.
+---
+
+Resume the active pipeline.
+
+1. Read state: `python3 .claude/scripts/pipeline.py read`. If no `feature_id` or `current`, tell the user the pipeline is idle and suggest `/product-manager:run` or `/sse:run`.
+2. Read the next command: `python3 .claude/scripts/pipeline.py next`. This prints the slash command to invoke.
+3. Show the current status line: `python3 .claude/scripts/pipeline.py render`.
+4. Invoke the next-stage command. Use the recorded `feature_id` so artifacts land under the same name.
+5. After the stage completes (file written, approval marker applied), the post-write/post-edit hooks update state automatically. Run `/pipeline:continue` again to chain into the next stage, or stop here.
+
+If state has `pipeline` but no `feature_id` yet (intent recorded, first stage not started), invoke the first stage in `pipeline`.
+
+If the user wants to abandon the run instead, suggest `/pipeline:reset`.

package/.claude/commands/pipeline/reset.md

@@ -0,0 +1,11 @@
+---
+description: Clear the pipeline state file. Abandons the active feature run.
+---
+
+Reset the pipeline.
+
+1. Confirm with the user that they want to abandon the active pipeline. Show `python3 .claude/scripts/pipeline.py render` so they see what they are dropping.
+2. On confirmation: `python3 .claude/scripts/pipeline.py clear`.
+3. Output files under `.claude/plugins/*/outputs/` are not deleted. Only the in-memory state is cleared.
+
+The status bar will return to idle after reset.

package/.claude/commands/product-manager/prd.md

@@ -4,6 +4,8 @@ description: Generate a Product Requirements Document for an team squad. Busines
 
 Generate a PRD. Follow .claude/plugins/product-manager/guides/pipeline.md for retry, approval, and publish.
 
+Print a header card before drafting and a footer card after gates run. Format: .claude/scripts/stage-card.md.
+
 Ask once if missing: squad, problem in 1-2 sentences, customers, hypothesis, bet link, stage.
 
 Compute feature_id = {YYYY-MM-DD}-{squad}-{slug}. Before generating, write the phase start marker:
@@ -28,4 +30,13 @@ Sensors: .claude/plugins/product-manager/sensors/prd-structure.md, .claude/plugi
 
 Evals: .claude/plugins/product-manager/evals/prd-quality.md, .claude/plugins/product-manager/evals/prd-readiness.md.
 
-After save reply: PRD saved at {path}. Score: {N}/10.
+After save, reply with this exact shape (name the actual sensors/evals/guides that ran, do not abbreviate):
+
+```
+PRD saved at {path}.
+  sensors: prd-structure ok, prd-acceptance-criteria ok
+  eval:    prd-quality {N}/10, prd-readiness {N}/10
+  guides:  product-guidelines.md, prd-guidelines.md, writing-style.md, templates/prd.md
+  refs:    business-info.md, squads/{squad}/context.md
+  next:    /product-manager:prp
+```

package/.claude/commands/product-manager/prp.md

@@ -4,6 +4,8 @@ description: Generate a Product Requirements Prompt for engineering handoff. Nee
 
 Generate a PRP. Follow .claude/plugins/product-manager/guides/pipeline.md for retry, approval, and publish.
 
+Print a header card before drafting and a footer card after gates run. Format: .claude/scripts/stage-card.md.
+
 Source PRD: if user passes a path, use it. Else pick the most recent in .claude/plugins/product-manager/outputs/prd/. None found, abort. Tell user to run /product-manager:prd first. .claude/plugins/product-manager/hooks/pre-prp-check.sh blocks if the PRD lacks the approved marker.
 
 Compute feature_id from the source PRD filename (basename without .md). Save the PRP to .claude/plugins/product-manager/outputs/prp/{feature_id}.md so it matches.
@@ -32,4 +34,13 @@ Sensors: .claude/plugins/product-manager/sensors/prp-structure.md, .claude/plugi
 
 Evals: .claude/plugins/product-manager/evals/prp-quality.md, .claude/plugins/product-manager/evals/prp-context-readiness.md.
 
-After save reply: PRP saved at {path}. Score: {N}/10. Ready for handoff.
+After save, reply with this exact shape (name the actual sensors/evals/guides that ran):
+
+```
+PRP saved at {path}.
+  sensors: prp-structure ok, prp-context-quality ok, prp-links ok
+  eval:    prp-quality {N}/10, prp-context-readiness {N}/10
+  guides:  prp-guidelines.md, writing-style.md, templates/prp.md
+  refs:    prd/{feature_id}.md, {target repo paths probed}
+  next:    /sse:plan (ready for handoff)
+```

package/.claude/commands/product-manager/run.md

@@ -11,21 +11,27 @@ Run end to end.
 
 Follow .claude/plugins/product-manager/guides/pipeline.md. Read .claude/agents/product-manager.md for inputs and rules.
 
-Return format:
+Return format. Name every sensor, eval, and guide that ran. Generic summaries are not acceptable — list specifics so the user sees what was checked and what was loaded.
 
 ```
 Pipeline complete.
 
 PRD: .claude/plugins/product-manager/outputs/prd/{path}
-  sensors: passed (attempts: N)
-  eval: {score}/10
+  sensors: prd-structure ok, prd-acceptance-criteria ok ({sub-checks})
+  eval:    prd-quality {score}/10, prd-readiness {score}/10 (attempts: N)
+  guides:  product-guidelines.md, prd-guidelines.md, writing-style.md, templates/prd.md
+  refs:    business-info.md, squads/{squad}/context.md
 
 PRP: .claude/plugins/product-manager/outputs/prp/{path}
-  sensors: passed (attempts: N)
-  eval: {score}/10
+  sensors: prp-structure ok, prp-context-quality ok, prp-links ok
+  eval:    prp-quality {score}/10, prp-context-readiness {score}/10 (attempts: N)
+  guides:  prp-guidelines.md, writing-style.md, templates/prp.md
+  refs:    prd/{feature_id}.md, target repo paths probed
 
-Confluence: {published | skipped, reason}
+Confluence: {published to {space-key}: {url} | skipped, reason}
 
 Blockers:
 - {file:line, issue, fix}
 ```
+
+If a phase has no sensors/eval/guides/refs, omit that line rather than printing an empty one.

package/.claude/commands/sse/dev.md

@@ -4,6 +4,8 @@ description: Implement the approved plan in code. Writes commits, runs gates, re
 
 Implement the plan. Follow .claude/plugins/staff-software-engineer/guides/pipeline.md.
 
+Print a header card before coding and a footer card after gates run. Format: .claude/scripts/stage-card.md.
+
 Source plan: latest in .claude/plugins/staff-software-engineer/outputs/plan/ with approved marker. If none, abort and ask user to run /sse:plan first.
 
 Before coding, write the phase start marker:
@@ -44,4 +46,14 @@ Append approval marker when all gates pass:
 <!-- approved: {YYYY-MM-DD} -->
 ```
 
-Reply: Dev complete. {N} files changed, {M} commits. Next /sse:test.
+After approval, reply with this exact shape (name the actual sensors/guides that ran):
+
+```
+Dev complete. branch {branch}.
+  files changed: {N}
+  commits: {M} ({short-sha}, {short-sha}, ...)
+  sensors: code-conventions ok, test-coverage ok
+  guides:  coding-style.md, commit-style.md, skills/{area}/SKILL.md
+  refs:    plan/{feature_id}.md, conventions/{area}.md
+  next:    /sse:test
+```

package/.claude/commands/sse/plan.md

@@ -4,6 +4,8 @@ description: Generate an implementation plan from an approved PRP. Sensors and e
 
 Generate a technical plan. Follow .claude/plugins/staff-software-engineer/guides/pipeline.md for retry, approval, and publish.
 
+Print a header card before drafting and a footer card after gates run. Format: .claude/scripts/stage-card.md.
+
 Source PRP: if user passes a path, use it. Else pick the most recent in .claude/plugins/product-manager/outputs/prp/. None found, abort. Tell user to run /product-manager:prp first.
 
 Compute feature_id from the source PRP filename (basename without .md). Save the plan to .claude/plugins/staff-software-engineer/outputs/plan/{feature_id}.md so it matches.
@@ -30,4 +32,13 @@ Sensors: .claude/plugins/staff-software-engineer/sensors/plan-structure.md.
 
 Evals: .claude/plugins/staff-software-engineer/evals/plan-quality.md.
 
-After save reply: Plan saved at {path}. Score: {N}/10.
+After save, reply with this exact shape (name the actual sensors/evals/guides that ran):
+
+```
+Plan saved at {path}.
+  sensors: plan-structure ok ({sub-checks: problem, files, gates, scope})
+  eval:    plan-quality {N}/10
+  guides:  pipeline.md, coding-style.md, skills/{area}/SKILL.md
+  refs:    prp/{feature_id}.md, conventions/{area}.md
+  next:    /sse:dev
+```

package/.claude/commands/sse/pr.md

@@ -4,6 +4,8 @@ description: Open a Pull Request on GitHub following team conventions. Draft by
 
 Open a Pull Request.
 
+Print a header card before opening and a footer card after gh returns. Format: .claude/scripts/stage-card.md.
+
 Prerequisites:
 - All previous gates passed (plan approved, dev approved, test approved).
 - Branch pushed to origin with current changes.
@@ -40,4 +42,13 @@ Append approval marker:
 <!-- approved: {YYYY-MM-DD} ready-for-handoff: true -->
 ```
 
-Reply: PR opened: {url}.
+Reply with this exact shape:
+
+```
+PR opened: {url}
+  title:  {title}
+  draft:  {yes|no}
+  guides: pr-template.md, commit-style.md
+  refs:   plan/{feature_id}.md, dev/{feature_id}.md
+  next:   request review (if draft, mark ready when checks pass)
+```

package/.claude/commands/sse/run.md

@@ -12,28 +12,39 @@ Run end to end.
 
 Follow .claude/plugins/staff-software-engineer/guides/pipeline.md for retry, approval markers, token accounting, and publish behavior.
 
-Return format:
+Return format. Name every sensor, eval, and guide that ran. Generic summaries are not acceptable — list specifics so the user sees what was checked and what was loaded.
 
 ```
 Engineering pipeline complete.
 
 Plan: .claude/plugins/staff-software-engineer/outputs/plan/{path}
-  sensors: passed (attempts: N)
-  eval: {score}/10
+  sensors: {sensor-name} ok ({sub-check, sub-check, ...}), {sensor-name} ok
+  eval:    {eval-name} {score}/10 (attempts: N)
+  guides:  {guide-1.md}, {guide-2.md}, skills/{area}/SKILL.md
+  refs:    prp/{feature_id}.md, conventions/{area}.md
 
 Dev: branch {branch}
   files changed: N
-  commits: N
-  gates: code-style ok, conventions ok
+  commits: N ({short-sha}, {short-sha}, ...)
+  sensors: code-conventions ok, test-coverage ok
+  guides:  coding-style.md, commit-style.md, skills/{area}/SKILL.md
+  refs:    plan/{feature_id}.md, conventions/{area}.md
 
 Test: .claude/plugins/staff-software-engineer/outputs/test/{path}
-  passed: N, failed: M
+  command: {detected-test-command}
+  passed:  N, failed: M
+  duration: {seconds}s
 
 PR: {url}
+  title: {title}
   draft: yes|no
+  guides: pr-template.md, commit-style.md
+  refs:   plan/{feature_id}.md, dev/{feature_id}.md
 
-Confluence: {published | skipped, reason}
+Confluence: {published to {space-key}: {url} | skipped, reason}
 
 Blockers:
 - {file:line, issue, fix}
 ```
+
+If a phase has no sensors/eval/guides/refs, omit that line for that phase rather than printing an empty one.

package/.claude/commands/sse/test.md

@@ -4,6 +4,8 @@ description: Run the project test suite. Reports results to .claude/plugins/staf
 
 Run the test suite for the current repo.
 
+Print a header card before running and a footer card after the suite finishes. Format: .claude/scripts/stage-card.md.
+
 Detect the project test command (in order):
 1. Check README.md or CONTRIBUTING.md for explicit test instructions.
 2. Maven (pom.xml present): `./mvnw test` or `mvn test`
@@ -35,4 +37,16 @@ Append approval marker when exit code is 0:
 
 If tests fail, return a blocker with the failing test names and a snippet of the failure output. Do not retry automatically; let the user decide.
 
-Reply: Tests {passed/failed}. {summary}.
+Reply with this exact shape:
+
+```
+Tests {passed|failed}.
+  command:  {detected-test-command}
+  passed:   {N}
+  failed:   {M}
+  duration: {seconds}s
+  output:   {path/to/test/output.md}
+  next:     /sse:pr (if passed) | fix failing tests (if failed)
+```
+
+If failed, append a `failures:` block listing each failing test name with a one-line snippet from the failure output.

package/.claude/hooks/pipeline-postedit.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+# PostToolUse hook for Edit. Re-detects state of tracked artifact (Edit may
+# have added the approval marker).
+
+set -e
+
+FILE_PATH="${CLAUDE_TOOL_FILE_PATH:-}"
+[ -z "$FILE_PATH" ] && exit 0
+
+PIPELINE_PY=".claude/scripts/pipeline.py"
+[ -x "$PIPELINE_PY" ] || exit 0
+
+python3 "$PIPELINE_PY" detect-from-file "$FILE_PATH" >/dev/null 2>&1 || true
+exit 0

package/.claude/hooks/pipeline-postwrite.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+# PostToolUse hook for Write. If the written file is a tracked pipeline
+# artifact, update state via pipeline.py detect-from-file.
+
+set -e
+
+FILE_PATH="${CLAUDE_TOOL_FILE_PATH:-}"
+[ -z "$FILE_PATH" ] && exit 0
+
+PIPELINE_PY=".claude/scripts/pipeline.py"
+[ -x "$PIPELINE_PY" ] || exit 0
+
+python3 "$PIPELINE_PY" detect-from-file "$FILE_PATH" >/dev/null 2>&1 || true
+exit 0

package/.claude/hooks/pipeline-prompt.sh

@@ -0,0 +1,31 @@
+#!/bin/sh
+# UserPromptSubmit hook. Detects pipeline slash commands in the user's input
+# and records intent in the pipeline state file.
+#
+# Reads JSON from stdin (Claude Code hook payload). Looks at the prompt text
+# and matches known commands. Does not block submission.
+
+set -e
+
+PROMPT="$(python3 -c 'import json,sys; d=json.load(sys.stdin); print(d.get("prompt","") or d.get("user_prompt",""))' 2>/dev/null || echo "")"
+
+[ -z "$PROMPT" ] && exit 0
+
+PIPELINE_PY=".claude/scripts/pipeline.py"
+[ -x "$PIPELINE_PY" ] || exit 0
+
+# Match leading slash commands. Order matters: more specific first.
+case "$PROMPT" in
+  /product-manager:run*) python3 "$PIPELINE_PY" intent pm-run >/dev/null 2>&1 ;;
+  /product-manager:prd*) python3 "$PIPELINE_PY" intent pm-prd >/dev/null 2>&1 ;;
+  /product-manager:prp*) python3 "$PIPELINE_PY" intent pm-prp >/dev/null 2>&1 ;;
+  /sse:run*)             python3 "$PIPELINE_PY" intent sse-run >/dev/null 2>&1 ;;
+  /sse:plan*)            python3 "$PIPELINE_PY" intent sse-plan >/dev/null 2>&1 ;;
+  /sse:dev*)             python3 "$PIPELINE_PY" intent sse-dev >/dev/null 2>&1 ;;
+  /sse:test*)            python3 "$PIPELINE_PY" intent sse-test >/dev/null 2>&1 ;;
+  /sse:pr*)              python3 "$PIPELINE_PY" intent sse-pr >/dev/null 2>&1 ;;
+  /pipeline:continue*)   python3 "$PIPELINE_PY" intent pipeline-continue >/dev/null 2>&1 ;;
+  /pipeline:reset*)      python3 "$PIPELINE_PY" clear >/dev/null 2>&1 ;;
+esac
+
+exit 0

package/.claude/hooks/pipeline-session-start.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+# SessionStart hook. If a pipeline state exists with an incomplete pipeline,
+# print a resume hint that the user can act on.
+
+set -e
+
+PIPELINE_PY=".claude/scripts/pipeline.py"
+STATE_FILE=".claude/.pipeline-state.json"
+[ -x "$PIPELINE_PY" ] || exit 0
+[ -f "$STATE_FILE" ] || exit 0
+
+CURRENT="$(python3 "$PIPELINE_PY" next 2>/dev/null || true)"
+[ -z "$CURRENT" ] && exit 0
+
+LINE="$(python3 "$PIPELINE_PY" render 2>/dev/null || true)"
+printf 'pipeline resume available: %s\nrun /pipeline:continue or /pipeline:reset to abandon\n' "$LINE"
+exit 0

package/.claude/hooks/status-line.sh

@@ -1,20 +1,19 @@
 #!/bin/sh
-# Status line for the PM and SSE plugin pipelines.
-#
-# Shows the current stage of the active feature. Stages, in order:
-#   prd   (product-manager plugin)
-#   prp   (product-manager plugin)
-#   plan  (staff-software-engineer plugin)
-#   dev   (staff-software-engineer plugin)
-#   test  (staff-software-engineer plugin)
-#   pr    (staff-software-engineer plugin)
-#
-# State per stage is "pending" (no file), "drafting" (file exists, no approval
-# marker), or "approved" (approval marker present). The bar shows the previous
-# approved stage plus the current stage, with the next command to run.
-#
-# A feature is "active" when any of its artifact files was modified in the last
-# hour. With no active feature, the bar shows an idle prompt.
+# Status line for the harness-kit pipeline. Reads .claude/.pipeline-state.json
+# (managed by .claude/scripts/pipeline.py) for live state. Falls back to a
+# file-scan if state is absent.
+
+PIPELINE_PY=".claude/scripts/pipeline.py"
+
+if [ -x "$PIPELINE_PY" ] && [ -f ".claude/.pipeline-state.json" ]; then
+  OUT="$(python3 "$PIPELINE_PY" render 2>/dev/null)"
+  if [ -n "$OUT" ]; then
+    printf '%s' "$OUT"
+    exit 0
+  fi
+fi
+
+# --- Fallback: original file-scan logic ---
 
 PM_DIR=".claude/plugins/product-manager"
 SSE_DIR=".claude/plugins/staff-software-engineer"
@@ -31,7 +30,7 @@ render() {
   done
 
   if [ -z "$LATEST" ]; then
-    printf "idle · start /product-manager:run or /sse:run"
+    printf "idle · /product-manager:run · /sse:run · /pipeline:continue"
     return 0
   fi
 
@@ -39,12 +38,11 @@ render() {
   MTIME=$(stat -f %m "$LATEST" 2>/dev/null || stat -c %Y "$LATEST" 2>/dev/null || echo 0)
   AGE=$((NOW - MTIME))
   if [ "$AGE" -ge 3600 ]; then
-    printf "idle · start /product-manager:run or /sse:run"
+    printf "idle · /product-manager:run · /sse:run · /pipeline:continue"
     return 0
   fi
 
   FID=$(basename "$LATEST" .md)
-  # Strip leading YYYY-MM-DD-. Optional team prefix accepted (any kebab-case slug).
   SLUG=$(echo "$FID" | sed -E 's/^[0-9]{4}-[0-9]{2}-[0-9]{2}-//')
 
   check_state() {

package/.claude/scripts/pipeline.py

@@ -0,0 +1,352 @@
+#!/usr/bin/env python3
+"""Pipeline state manager for harness-kit.
+
+Tracks the active feature, its pipeline shape (which stages will run), and
+each stage's state (pending|drafting|approved). Stored at
+.claude/.pipeline-state.json relative to repo root.
+
+Subcommands:
+  init <feature_id> <stage,stage,...>   create state, set pipeline shape
+  intent <kind>                         record last slash invocation intent
+                                        (sse-run, pm-run, full-run, sse-plan,
+                                         sse-dev, sse-test, sse-pr, pm-prd,
+                                         pm-prp, pipeline-continue)
+  set-feature <feature_id>              attach feature_id (if not yet known)
+  set-stage <stage> <state>             pending|drafting|approved
+  detect-from-file <abs_path>           infer stage+state from output file
+                                        path; auto-init pipeline if needed
+  read                                  print state JSON
+  render                                print one-line status bar
+  next                                  print next pending stage command
+  clear                                 remove state file
+"""
+
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+STATE_FILE = Path(".claude/.pipeline-state.json")
+
+PM_STAGES = ("prd", "prp")
+SSE_STAGES = ("plan", "dev", "test", "pr")
+ALL_STAGES = PM_STAGES + SSE_STAGES
+
+INTENT_TO_PIPELINE = {
+    "pm-run": list(PM_STAGES),
+    "sse-run": list(SSE_STAGES),
+    "full-run": list(ALL_STAGES),
+    "pm-prd": ["prd"],
+    "pm-prp": ["prp"],
+    "sse-plan": ["plan"],
+    "sse-dev": ["dev"],
+    "sse-test": ["test"],
+    "sse-pr": ["pr"],
+}
+
+STAGE_TO_COMMAND = {
+    "prd": "/product-manager:prd",
+    "prp": "/product-manager:prp",
+    "plan": "/sse:plan",
+    "dev": "/sse:dev",
+    "test": "/sse:test",
+    "pr": "/sse:pr",
+}
+
+STAGE_TO_OUTPUT_DIR = {
+    "prd": ".claude/plugins/product-manager/outputs/prd",
+    "prp": ".claude/plugins/product-manager/outputs/prp",
+    "plan": ".claude/plugins/staff-software-engineer/outputs/plan",
+    "dev": ".claude/plugins/staff-software-engineer/outputs/dev",
+    "test": ".claude/plugins/staff-software-engineer/outputs/test",
+    "pr": ".claude/plugins/staff-software-engineer/outputs/pr",
+}
+
+
+def now_iso():
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def load_state():
+    if not STATE_FILE.exists():
+        return None
+    try:
+        return json.loads(STATE_FILE.read_text())
+    except (json.JSONDecodeError, OSError):
+        return None
+
+
+def save_state(state):
+    state["updated_at"] = now_iso()
+    STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+    STATE_FILE.write_text(json.dumps(state, indent=2) + "\n")
+
+
+def init_state(feature_id, pipeline):
+    state = {
+        "feature_id": feature_id,
+        "pipeline": pipeline,
+        "stages": {s: "pending" for s in pipeline},
+        "current": pipeline[0] if pipeline else None,
+        "intent": None,
+        "started_at": now_iso(),
+        "updated_at": now_iso(),
+    }
+    save_state(state)
+    return state
+
+
+def merge_pipeline(state, new_stages):
+    """Extend pipeline with stages not already present, preserving order."""
+    pipeline = state.get("pipeline", [])
+    stages = state.get("stages", {})
+    changed = False
+    for s in new_stages:
+        if s not in pipeline:
+            pipeline.append(s)
+            stages[s] = "pending"
+            changed = True
+    if changed:
+        # Reorder by canonical sequence
+        pipeline.sort(key=lambda s: ALL_STAGES.index(s))
+        state["pipeline"] = pipeline
+        state["stages"] = stages
+    return state
+
+
+def recompute_current(state):
+    pipeline = state.get("pipeline", [])
+    stages = state.get("stages", {})
+    for s in pipeline:
+        if stages.get(s) != "approved":
+            state["current"] = s
+            return state
+    state["current"] = None
+    return state
+
+
+def slug(feature_id):
+    if not feature_id:
+        return ""
+    parts = feature_id.split("-")
+    if len(parts) > 3 and parts[0].isdigit() and len(parts[0]) == 4:
+        return "-".join(parts[3:])
+    return feature_id
+
+
+def render_line():
+    state = load_state()
+    if not state or not state.get("pipeline"):
+        return "idle · /product-manager:run · /sse:run · /pipeline:continue"
+
+    fid = state.get("feature_id")
+    name = slug(fid) if fid else f"starting {state.get('intent') or '?'}"
+
+    current = state.get("current")
+    pipeline = state["pipeline"]
+    stages = state.get("stages", {})
+
+    if current is None:
+        return f"{name} · complete ({'/'.join(pipeline)})"
+
+    # Find prev approved
+    prev = None
+    for s in pipeline:
+        if s == current:
+            break
+        if stages.get(s) == "approved":
+            prev = s
+
+    cur_state = stages.get(current, "pending")
+    next_cmd = STAGE_TO_COMMAND.get(current, "?")
+
+    shape = "+".join(pipeline)
+    if prev:
+        return f"{name} [{shape}] · {prev} approved · {current} {cur_state} · next {next_cmd}"
+    return f"{name} [{shape}] · {current} {cur_state} · next {next_cmd}"
+
+
+def cmd_init(args):
+    if len(args) < 2:
+        print("usage: pipeline.py init <feature_id> <stage,stage,...>", file=sys.stderr)
+        return 1
+    fid = args[0]
+    pipeline = [s for s in args[1].split(",") if s in ALL_STAGES]
+    if not pipeline:
+        print("no valid stages", file=sys.stderr)
+        return 1
+    init_state(fid, pipeline)
+    return 0
+
+
+def cmd_intent(args):
+    if not args:
+        print("usage: pipeline.py intent <kind>", file=sys.stderr)
+        return 1
+    kind = args[0]
+
+    if kind == "pipeline-continue":
+        # Don't mutate pipeline; just record intent
+        state = load_state() or {}
+        state["intent"] = kind
+        if state.get("pipeline"):
+            save_state(state)
+        return 0
+
+    new_stages = INTENT_TO_PIPELINE.get(kind)
+    if not new_stages:
+        print(f"unknown intent: {kind}", file=sys.stderr)
+        return 1
+
+    state = load_state()
+    if not state:
+        state = {
+            "feature_id": None,
+            "pipeline": list(new_stages),
+            "stages": {s: "pending" for s in new_stages},
+            "current": new_stages[0],
+            "intent": kind,
+            "started_at": now_iso(),
+            "updated_at": now_iso(),
+        }
+        save_state(state)
+        return 0
+
+    # Existing state: extend pipeline with new stages
+    state["intent"] = kind
+    merge_pipeline(state, new_stages)
+    recompute_current(state)
+    save_state(state)
+    return 0
+
+
+def cmd_set_feature(args):
+    if not args:
+        print("usage: pipeline.py set-feature <feature_id>", file=sys.stderr)
+        return 1
+    state = load_state()
+    if not state:
+        print("no state file", file=sys.stderr)
+        return 1
+    state["feature_id"] = args[0]
+    save_state(state)
+    return 0
+
+
+def cmd_set_stage(args):
+    if len(args) < 2:
+        print("usage: pipeline.py set-stage <stage> <pending|drafting|approved>", file=sys.stderr)
+        return 1
+    stage, st = args[0], args[1]
+    if stage not in ALL_STAGES:
+        print(f"unknown stage: {stage}", file=sys.stderr)
+        return 1
+    if st not in ("pending", "drafting", "approved"):
+        print(f"unknown state: {st}", file=sys.stderr)
+        return 1
+    state = load_state()
+    if not state:
+        # Lazy init with this single stage
+        state = {
+            "feature_id": None,
+            "pipeline": [stage],
+            "stages": {stage: st},
+            "current": stage,
+            "intent": None,
+            "started_at": now_iso(),
+            "updated_at": now_iso(),
+        }
+    else:
+        if stage not in state["pipeline"]:
+            merge_pipeline(state, [stage])
+        state["stages"][stage] = st
+    recompute_current(state)
+    save_state(state)
+    return 0
+
+
+def cmd_detect_from_file(args):
+    if not args:
+        print("usage: pipeline.py detect-from-file <abs_path>", file=sys.stderr)
+        return 1
+    path = args[0]
+    stage = None
+    for s, d in STAGE_TO_OUTPUT_DIR.items():
+        if d in path and path.endswith(".md"):
+            stage = s
+            break
+    if not stage:
+        return 0  # not a tracked path, no-op
+
+    fid = os.path.basename(path)[:-3]  # strip .md
+
+    # Determine state by file contents
+    file_state = "drafting"
+    try:
+        with open(path) as f:
+            if "<!-- approved:" in f.read():
+                file_state = "approved"
+    except OSError:
+        pass
+
+    state = load_state()
+    if not state:
+        state = init_state(fid, [stage])
+    else:
+        if not state.get("feature_id"):
+            state["feature_id"] = fid
+        merge_pipeline(state, [stage])
+        state["stages"][stage] = file_state
+        recompute_current(state)
+    save_state(state)
+    return 0
+
+
+def cmd_read(_args):
+    state = load_state()
+    print(json.dumps(state or {}, indent=2))
+    return 0
+
+
+def cmd_render(_args):
+    print(render_line())
+    return 0
+
+
+def cmd_next(_args):
+    state = load_state()
+    if not state or not state.get("current"):
+        return 1
+    print(STAGE_TO_COMMAND.get(state["current"], ""))
+    return 0
+
+
+def cmd_clear(_args):
+    if STATE_FILE.exists():
+        STATE_FILE.unlink()
+    return 0
+
+
+COMMANDS = {
+    "init": cmd_init,
+    "intent": cmd_intent,
+    "set-feature": cmd_set_feature,
+    "set-stage": cmd_set_stage,
+    "detect-from-file": cmd_detect_from_file,
+    "read": cmd_read,
+    "render": cmd_render,
+    "next": cmd_next,
+    "clear": cmd_clear,
+}
+
+
+def main():
+    if len(sys.argv) < 2 or sys.argv[1] not in COMMANDS:
+        print(__doc__, file=sys.stderr)
+        return 2
+    return COMMANDS[sys.argv[1]](sys.argv[2:])
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/.claude/scripts/stage-card.md

@@ -0,0 +1,74 @@
+# Stage card output convention
+
+Every pipeline stage command (PRD, PRP, plan, dev, test, pr) prints two blocks
+in its chat response. The card mirrors what the Remotion demo shows in its
+"active artifacts" panel — guides, refs, sensors, eval, next step — but renders
+inline in the Claude session so it works without any UI.
+
+The card is part of the LLM's output, not a hook. Hooks update the status bar;
+this card explains what the stage is about to do (or just did) in human-readable
+form.
+
+## Header card
+
+Printed before drafting begins. Lists what will be loaded and what comes next.
+
+```
+━━━ {command} · {feature_id}{area_suffix} ━━━
+guides:   {guide-1.md}, {guide-2.md}, ...
+refs:     {ref-1.md}, {ref-2.md}, ...
+sensors:  {sensor-name}, {sensor-name}, ...
+eval:     {eval-name}
+next:     {/next:command}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+`{area_suffix}` is ` · {area}` for SSE stages (backend, web, mobile, devops),
+empty otherwise.
+
+## Footer card
+
+Printed after the artifact is saved and gates ran. Shows pass/fail and score.
+
+```
+━━━ done · {command} ━━━
+artifact: {relative/output/path.md}
+sensors:  {pass | failed: name1, name2}
+eval:     {N}/10
+next:     {/next:command | (pipeline complete)}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+## Examples
+
+```
+━━━ /product-manager:prd · 2026-05-13-billing-multi-currency ━━━
+guides:   prd-guidelines.md, writing-style.md
+refs:     business-info.md, squads/billing/context.md
+sensors:  prd-structure, prd-acceptance-criteria
+eval:     prd-quality
+next:     /product-manager:prp
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+```
+━━━ done · /product-manager:prd ━━━
+artifact: outputs/prd/2026-05-13-billing-multi-currency.md
+sensors:  pass
+eval:     8.6/10
+next:     /product-manager:prp
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+```
+━━━ /sse:plan · 2026-05-13-billing-multi-currency · backend ━━━
+guides:   pipeline.md, coding-style.md, skills/backend/SKILL.md
+refs:     prp/2026-05-13-billing-multi-currency.md, conventions/backend.md
+sensors:  plan-structure
+eval:     plan-quality
+next:     /sse:dev
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+Keep the card terse. List filenames only (no full paths). Skip a line that has
+no entries.

package/.claude/settings.local.json

@@ -55,7 +55,23 @@
       "Bash(git -C /Users/pierryborges/Development/eng-delivery-playbook status -sb)",
       "Bash(git -C /Users/pierryborges/Development/eng-delivery-playbook push origin main)",
       "Bash(git remote *)",
-      "Bash(git fetch *)"
+      "Bash(git fetch *)",
+      "Bash(npx remotion *)",
+      "Bash(ffmpeg -version)",
+      "Bash(ffmpeg -y -i out/demo.mp4 -vf \"fps=12,scale=960:-1:flags=lanczos,split[s0][s1];[s0]palettegen=max_colors=128[p];[s1][p]paletteuse=dither=bayer:bayer_scale=4\" -loop 0 preview.gif)",
+      "Bash(ffmpeg -y -i out/demo.mp4 -vf \"fps=10,scale=720:-1:flags=lanczos,split[s0][s1];[s0]palettegen=max_colors=96[p];[s1][p]paletteuse=dither=bayer:bayer_scale=5\" -loop 0 preview.gif)",
+      "Bash(mkdir -p /tmp/hk-test)",
+      "Read(//tmp/**)",
+      "Bash(cd /)",
+      "Bash(rm -rf /tmp/hk-test)",
+      "Bash(npx tsc *)",
+      "Bash(git -C /Users/pierryborges/Development/harness-kit log --oneline demo/preview.gif)",
+      "Bash(git -C /Users/pierryborges/Development/harness-kit log -1 --stat demo/preview.gif)",
+      "Bash(git -C /Users/pierryborges/Development/harness-kit check-ignore demo/out/demo.mp4)",
+      "Bash(git -C /Users/pierryborges/Development/harness-kit diff --stat)",
+      "Bash(rm -rf /tmp/hk-fresh /tmp/hk-existing)",
+      "Bash(npm whoami *)",
+      "Bash(npm publish *)"
     ]
   }
 }

package/README.md

@@ -5,12 +5,18 @@
 Claude Code harness for product + engineering delivery.
 From idea to merged PR, one pipeline.
 
-[![Version](https://img.shields.io/badge/version-3.0.0-blue.svg)](VERSION)
+[![Version](https://img.shields.io/badge/version-3.1.1-blue.svg)](VERSION)
 [![Claude Code](https://img.shields.io/badge/Claude%20Code-plugin-8b5cf6.svg)](https://claude.ai/code)
 [![Plugins](https://img.shields.io/badge/plugins-2-success.svg)](#layout)
 [![Pipeline](https://img.shields.io/badge/stages-6-informational.svg)](#usage)
 [![License](https://img.shields.io/badge/license-MIT-lightgrey.svg)](LICENSE)
 
+<br/>
+
+![harness-kit demo](demo/preview.gif)
+
+<sub>100s walkthrough · install → 6 commands → PR → resume. Each command scene shows the active **guide · ref · sensor · eval**. Dedicated scenes for the dynamic status bar and `/pipeline:continue` resume flow.</sub>
+
 </div>
 
 ---
@@ -25,6 +31,7 @@ From idea to merged PR, one pipeline.
   - [Samples](#samples)
 - [Layout](#layout)
 - [Project conventions](#project-conventions)
+- [Anatomy of a stage](#anatomy-of-a-stage)
 - [Status bar](#status-bar)
 - [Tooling](#tooling)
 
@@ -54,7 +61,7 @@ CLI subcommands:
 No-npm path (if you don't want a Node dep):
 
 ```bash
-git clone https://github.com/space-metrics-ai/harness-kit ~/.harness-kit
+git clone https://github.com/Pierry/harness-kit ~/.harness-kit
 bash ~/.harness-kit/setup/install.sh
 ```
 
@@ -78,8 +85,18 @@ Pulls latest source and reinstalls. Idempotent. Version is read from the package
 | `/sse:test` | Run the project test suite |
 | `/sse:pr` | Open the draft PR |
 | `/sse:run` | Full SSE pipeline (plan, dev, test, pr) |
+| `/pipeline:continue` | Resume the active pipeline at its next pending stage |
+| `/pipeline:reset` | Abandon the active pipeline run (clears state, keeps artifacts) |
+
+Pipeline order: `prd → prp → plan → dev → test → pr`. Each stage gets an approval marker.
 
-Pipeline order: `prd → prp → plan → dev → test → pr`. Each stage gets an approval marker. The status bar tracks the current one.
+You can enter the pipeline at any stage. Three common shapes:
+
+- `prd → prp → plan → dev → test → pr` (full PM + SSE)
+- `prd → prp` (PM only, hand off to a separate engineering process)
+- `plan → dev → test → pr` (SSE only, when discovery already happened elsewhere)
+
+Status bar tracks the shape you started with. Close the session and reopen later — `/pipeline:continue` picks up at the next pending stage. `/pipeline:reset` clears the run if you decide to abandon it.
 
 ### Workflow
 
@@ -128,7 +145,14 @@ Reference artifacts ship inside the plugins:
 │   ├── commands/                     slash commands per plugin namespace
 │   ├── agents/                       Task-tool-invokable orchestrators
 │   ├── hooks/
-│   │   └── status-line.sh            pipeline status indicator
+│   │   ├── status-line.sh            pipeline status indicator
+│   │   ├── pipeline-prompt.sh        slash-command intent tracking
+│   │   ├── pipeline-postwrite.sh     stage-state from artifact writes
+│   │   ├── pipeline-postedit.sh      stage-state from approval marker
+│   │   └── pipeline-session-start.sh resume hint on startup
+│   ├── scripts/
+│   │   └── pipeline.py               state manager (state file CRUD)
+│   ├── .pipeline-state.json          active feature + per-stage state
 │   └── settings.json                 hooks wiring + permissions
 ├── context-library/                  reusable org/squad context
 ├── setup/
@@ -160,20 +184,39 @@ The installer scaffolds `.claude/conventions/README.md` to remind you of the con
 
 ---
 
+## Anatomy of a stage
+
+Every stage in the pipeline runs the same loop. Same four ingredients, every time:
+
+| Ingredient | What it is | Example |
+|-----------|------------|---------|
+| **guide** | How to write the artifact. Style + structure rules the LLM follows. | `prd-guidelines.md`, `coding-style.md` |
+| **ref** | Context pulled in before drafting. Org/squad data + prior artifacts. | `business-info.md`, `outputs/prp/...md`, `.claude/conventions/backend.md` |
+| **sensor** | Must-pass structural check. Blocks the stage from being approved. | `prd-structure`, `prp-links`, `code-conventions`, `test-coverage` |
+| **eval** | Scored quality rubric. Returns a 0–10 score with diff suggestions. | `prd-quality`, `prp-context-readiness`, `plan-quality` |
+
+Sensors are pass/fail (deterministic, fast). Evals are scored (LLM-judged, retried until ≥ threshold or max attempts). Approval markers (`<!-- approved: -->`) gate the next stage.
+
+The 85s demo above shows every command running with these artifacts loading live on the right panel.
+
+---
+
 ## Status bar
 
-The status line follows the active feature through the 6-stage pipeline. Examples:
+The status line follows the active feature through whatever pipeline shape you started. It is dynamic: a `UserPromptSubmit` hook records intent the moment you type a slash command, and `PostToolUse` hooks update state as artifact files land on disk.
 
 ```
-idle · start /product-manager:run or /sse:run
-multi-currency · prd drafting · next /product-manager:prd
-multi-currency · prd approved · prp pending · next /product-manager:prp
-multi-currency · prp approved · plan pending · next /sse:plan
-multi-currency · plan approved · dev pending · next /sse:dev
-multi-currency · complete
+idle · /product-manager:run · /sse:run · /pipeline:continue
+starting sse-run [plan+dev+test+pr] · plan pending · next /sse:plan
+multi-currency [plan+dev+test+pr] · plan drafting · next /sse:plan
+multi-currency [plan+dev+test+pr] · plan approved · dev pending · next /sse:dev
+multi-currency [prd+prp+plan+dev+test+pr] · prp approved · plan drafting · next /sse:plan
+multi-currency · complete (prd+prp+plan+dev+test+pr)
 ```
 
-State derives from artifact files plus the `<!-- approved: -->` marker. A feature is "active" when any of its artifacts was modified in the last hour. With no recent activity, the bar shows the idle prompt.
+The bracketed list is the pipeline shape — the stages this run will execute. The shape is inferred from the slash command you invoked and extended when you chain commands (e.g. running `/sse:run` after `/product-manager:run` appends `plan+dev+test+pr` to the existing `prd+prp`).
+
+State lives at `.claude/.pipeline-state.json`. Close the session and reopen — the SessionStart hook prints a one-line resume hint, and `/pipeline:continue` invokes the next pending stage. `/pipeline:reset` clears the file. Output artifacts under `.claude/plugins/*/outputs/` are never deleted by reset.
 
 ---
 

package/VERSION

@@ -1 +1 @@
-3.0.0
+3.1.1

package/bin/hk.js

@@ -62,9 +62,17 @@ function cmdUninstall(target) {
     '.claude/plugins/staff-software-engineer',
     '.claude/commands/product-manager',
     '.claude/commands/sse',
+    '.claude/commands/pipeline',
     '.claude/agents/product-manager.md',
     '.claude/agents/staff-software-engineer.md',
     '.claude/hooks/status-line.sh',
+    '.claude/hooks/pipeline-prompt.sh',
+    '.claude/hooks/pipeline-postwrite.sh',
+    '.claude/hooks/pipeline-postedit.sh',
+    '.claude/hooks/pipeline-session-start.sh',
+    '.claude/scripts/pipeline.py',
+    '.claude/scripts/stage-card.md',
+    '.claude/.pipeline-state.json',
     '.claude/settings.json',
     '.claude/.hk-version',
   ];
@@ -113,7 +121,8 @@ usage:
 
 after install, restart Claude Code and use:
   /product-manager:prd | :prp | :run
-  /sse:plan | :dev | :test | :pr | :run`);
+  /sse:plan | :dev | :test | :pr | :run
+  /pipeline:continue | :reset`);
 }
 
 function main() {

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@pieerry/harness-kit",
-  "version": "3.0.0",
+  "version": "3.1.1",
   "description": "Claude Code harness for product + engineering delivery. From idea to merged PR, one pipeline.",
   "author": "Space Metrics AI",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/space-metrics-ai/harness-kit.git"
+    "url": "git+https://github.com/Pierry/harness-kit.git"
   },
-  "homepage": "https://github.com/space-metrics-ai/harness-kit",
+  "homepage": "https://github.com/Pierry/harness-kit",
   "keywords": [
     "claude-code",
     "claude",

package/setup/install.sh

@@ -16,7 +16,7 @@ VERSION="$(cat "$SOURCE_ROOT/VERSION" 2>/dev/null || echo "0.0.0")"
 
 if [ ! -d "$SOURCE_ROOT/.claude/plugins/product-manager" ]; then
   echo "missing plugins at $SOURCE_ROOT/.claude/plugins/"
-  echo "clone the repo first, then re-run: git clone https://github.com/space-metrics-ai/harness-kit ~/.harness-kit"
+  echo "clone the repo first, then re-run: git clone https://github.com/Pierry/harness-kit ~/.harness-kit"
   exit 1
 fi
 
@@ -51,7 +51,7 @@ done
 
 # Copy slash commands and Task-invokable agents
 mkdir -p "$TARGET/.claude/commands" "$TARGET/.claude/agents"
-for ns in product-manager sse; do
+for ns in product-manager sse pipeline; do
   rm -rf "$TARGET/.claude/commands/$ns"
   cp -R "$SOURCE_ROOT/.claude/commands/$ns" "$TARGET/.claude/commands/$ns"
 done
@@ -66,12 +66,27 @@ for plugin in product-manager staff-software-engineer; do
          "$TARGET/.claude/plugins/$plugin/.claude-plugin"
 done
 
-# Copy status-line hook
+# Copy harness-kit hooks (status-line + pipeline tracking)
 mkdir -p "$TARGET/.claude/hooks"
-cp "$SOURCE_ROOT/.claude/hooks/status-line.sh" "$TARGET/.claude/hooks/status-line.sh"
-chmod +x "$TARGET/.claude/hooks/status-line.sh"
+for h in status-line.sh pipeline-prompt.sh pipeline-postwrite.sh pipeline-postedit.sh pipeline-session-start.sh; do
+  cp "$SOURCE_ROOT/.claude/hooks/$h" "$TARGET/.claude/hooks/$h"
+  chmod +x "$TARGET/.claude/hooks/$h"
+done
 
-# Settings.json
+# Copy harness-kit scripts (pipeline state manager + stage-card convention)
+mkdir -p "$TARGET/.claude/scripts"
+cp "$SOURCE_ROOT/.claude/scripts/pipeline.py" "$TARGET/.claude/scripts/pipeline.py"
+cp "$SOURCE_ROOT/.claude/scripts/stage-card.md" "$TARGET/.claude/scripts/stage-card.md"
+chmod +x "$TARGET/.claude/scripts/pipeline.py"
+
+# Settings.json (back up existing if content differs)
+if [ -f "$TARGET/.claude/settings.json" ]; then
+  STAMP="$(date +%Y%m%d-%H%M%S)"
+  BACKUP="$TARGET/.claude/settings.json.bak.$STAMP"
+  cp "$TARGET/.claude/settings.json" "$BACKUP"
+  echo "backed up existing settings.json -> .claude/settings.json.bak.$STAMP"
+  echo "  if you customized permissions or hooks, merge them back from the backup."
+fi
 cat > "$TARGET/.claude/settings.json" <<'EOF'
 {
   "permissions": {
@@ -93,6 +108,20 @@ cat > "$TARGET/.claude/settings.json" <<'EOF'
     ]
   },
   "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          { "type": "command", "command": "[ -x .claude/hooks/pipeline-session-start.sh ] && bash .claude/hooks/pipeline-session-start.sh; exit 0" }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          { "type": "command", "command": "[ -x .claude/hooks/pipeline-prompt.sh ] && bash .claude/hooks/pipeline-prompt.sh; exit 0" }
+        ]
+      }
+    ],
     "PreToolUse": [
       {
         "matcher": "Write",
@@ -107,7 +136,8 @@ cat > "$TARGET/.claude/settings.json" <<'EOF'
         "hooks": [
           { "type": "command", "command": "[ -x .claude/plugins/product-manager/hooks/post-write-prd.sh ] && bash .claude/plugins/product-manager/hooks/post-write-prd.sh; exit 0" },
           { "type": "command", "command": "[ -x .claude/plugins/product-manager/hooks/post-write-prp.sh ] && bash .claude/plugins/product-manager/hooks/post-write-prp.sh; exit 0" },
-          { "type": "command", "command": "[ -x .claude/plugins/staff-software-engineer/hooks/post-write-plan.sh ] && bash .claude/plugins/staff-software-engineer/hooks/post-write-plan.sh; exit 0" }
+          { "type": "command", "command": "[ -x .claude/plugins/staff-software-engineer/hooks/post-write-plan.sh ] && bash .claude/plugins/staff-software-engineer/hooks/post-write-plan.sh; exit 0" },
+          { "type": "command", "command": "[ -x .claude/hooks/pipeline-postwrite.sh ] && bash .claude/hooks/pipeline-postwrite.sh; exit 0" }
         ]
       },
       {
@@ -115,7 +145,8 @@ cat > "$TARGET/.claude/settings.json" <<'EOF'
         "hooks": [
           { "type": "command", "command": "[ -x .claude/plugins/product-manager/hooks/post-eval-prd.sh ] && bash .claude/plugins/product-manager/hooks/post-eval-prd.sh; exit 0" },
           { "type": "command", "command": "[ -x .claude/plugins/product-manager/hooks/post-eval-prp.sh ] && bash .claude/plugins/product-manager/hooks/post-eval-prp.sh; exit 0" },
-          { "type": "command", "command": "[ -x .claude/plugins/staff-software-engineer/hooks/post-eval-plan.sh ] && bash .claude/plugins/staff-software-engineer/hooks/post-eval-plan.sh; exit 0" }
+          { "type": "command", "command": "[ -x .claude/plugins/staff-software-engineer/hooks/post-eval-plan.sh ] && bash .claude/plugins/staff-software-engineer/hooks/post-eval-plan.sh; exit 0" },
+          { "type": "command", "command": "[ -x .claude/hooks/pipeline-postedit.sh ] && bash .claude/hooks/pipeline-postedit.sh; exit 0" }
         ]
       }
     ]
@@ -152,3 +183,4 @@ echo "$VERSION" > "$TARGET/.claude/.hk-version"
 echo "done. restart Claude Code to load."
 echo "  /product-manager:prd | :prp | :run"
 echo "  /sse:plan | :dev | :test | :pr | :run"
+echo "  /pipeline:continue | :reset"

package/setup/update.sh

@@ -1,5 +1,7 @@
 #!/usr/bin/env bash
-# harness-kit updater. Pulls latest source, then re-runs the installer.
+# harness-kit updater. Pulls latest source (git installs only), then re-runs
+# the installer. For npm installs, you must upgrade the package first:
+#   npm i -g @pieerry/harness-kit@latest
 #
 # Usage:
 #   bash /path/to/harness-kit/setup/update.sh [target-dir]
@@ -8,10 +10,25 @@ set -e
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 SOURCE_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+SOURCE_VERSION="$(cat "$SOURCE_ROOT/VERSION" 2>/dev/null || echo "0.0.0")"
 
 if [ -d "$SOURCE_ROOT/.git" ]; then
+  echo "git install detected at $SOURCE_ROOT"
   echo "fetching latest source..."
   git -C "$SOURCE_ROOT" pull --ff-only
+  NEW_VERSION="$(cat "$SOURCE_ROOT/VERSION" 2>/dev/null || echo "0.0.0")"
+  if [ "$SOURCE_VERSION" != "$NEW_VERSION" ]; then
+    echo "source: v$SOURCE_VERSION → v$NEW_VERSION"
+  fi
+else
+  echo "npm install detected at $SOURCE_ROOT (no .git)"
+  echo "source version bundled in this package: v$SOURCE_VERSION"
+  echo ""
+  echo "to fetch a newer version, upgrade the npm package first:"
+  echo "  npm i -g @pieerry/harness-kit@latest"
+  echo "then rerun: hk update"
+  echo ""
+  echo "continuing with reinstall of v$SOURCE_VERSION..."
 fi
 
 exec bash "$SCRIPT_DIR/install.sh" "$@"