claude-sprint-gate 1.2.0 → 1.4.0

package/bin/ccsg.js

@@ -90,18 +90,38 @@ if (uninstall) {
   process.exit(0);
 }
 
+// ── Plugin files to download ───────────────────────────────────────
+const PLUGIN_FILES = [
+  { remote: "plugin/hooks/ccsg.sh", local: "hooks/ccsg.sh" },
+  { remote: "plugin/hooks/hooks.json", local: "hooks/hooks.json" },
+  { remote: "plugin/.claude-plugin/plugin.json", local: ".claude-plugin/plugin.json" },
+  { remote: "plugin/commands/sprint.md", local: "commands/sprint.md" },
+  { remote: "plugin/commands/sprint-status.md", local: "commands/sprint-status.md" },
+  { remote: "plugin/commands/sprint-cancel.md", local: "commands/sprint-cancel.md" },
+  { remote: "plugin/commands/help.md", local: "commands/help.md" },
+];
+
 // ── Install ────────────────────────────────────────────────────────
 async function install() {
   console.log("\n\x1b[1mCCSG — Claude Code Sprint Gate\x1b[0m\n");
 
-  // 1. Download and install hook
-  info("Downloading hook script...");
+  // 1. Install as plugin
+  const pluginDir = path.join(claudeDir, "plugins", "ccsg");
+  info("Installing plugin...");
+
+  for (const file of PLUGIN_FILES) {
+    const dest = path.join(pluginDir, file.local);
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    const content = await download(file.remote);
+    fs.writeFileSync(dest, content, { mode: 0o755 });
+  }
+  info(`Plugin installed to ${pluginDir}`);
+
+  // 2. Also install standalone hook as backup (settings.json)
   fs.mkdirSync(hooksDir, { recursive: true });
   const hookContent = await download("ccsg.sh");
   fs.writeFileSync(hookScript, hookContent, { mode: 0o755 });
-  info(`Installed ${hookScript}`);
 
-  // 2. Settings
   const hookCommand = isGlobal
     ? `bash ${hookScript}`
     : "bash .claude/hooks/ccsg.sh";
@@ -137,7 +157,7 @@ async function install() {
     }
   }
 
-  // 3. Goal directories (project mode)
+  // 3. Goal directories + mission (project mode)
   if (!isGlobal) {
     fs.mkdirSync(goalsOpen, { recursive: true });
     fs.mkdirSync(goalsCompleted, { recursive: true });
@@ -159,7 +179,6 @@ First sprint. Define what needs to be built and verify it works.
       info("Created starter goal: goals-open/goal-sprint-v1.md");
     }
 
-    // Mission template (always included)
     const missionDest = path.join(root, "mission.md");
     if (!fs.existsSync(missionDest)) {
       const missionContent = await download("mission-template.md");
@@ -173,16 +192,19 @@ First sprint. Define what needs to be built and verify it works.
   // 4. Summary
   console.log(`\n\x1b[1m\x1b[32m[CCSG]\x1b[0m Installed.\n`);
   if (isGlobal) {
+    console.log(`  Plugin:   ${pluginDir}`);
     console.log(`  Hook:     ${hookScript}`);
     console.log(`  Settings: ${settingsFile}`);
   } else {
+    console.log("  Plugin:   .claude/plugins/ccsg/");
     console.log("  Hook:     .claude/hooks/ccsg.sh");
     console.log("  Settings: .claude/settings.json");
-    console.log("  Goals:    goals-open/ → goals-completed/");
+    console.log("  Goals:    goals-open/ \u2192 goals-completed/");
     console.log("  Mission:  mission.md (edit to set your product vision)");
   }
+  console.log("\n  Commands: /sprint, /sprint-status, /sprint-cancel");
   console.log(
-    "\n  Edit goals-open/goal-sprint-v1.md, then start Claude Code.\n"
+    "\n  Edit goals-open/goal-sprint-v1.md, then: claude\n  Type /sprint to begin.\n"
   );
 }
 

package/ccsg.sh

@@ -41,6 +41,20 @@ GOALS_COMPLETED="$ROOT/goals-completed"
 # Ensure directories exist
 mkdir -p "$GOALS_OPEN" "$GOALS_COMPLETED"
 
+# ── Helper: safe JSON encoding ──────────────────────────────────────
+json_encode() {
+  local input="$1"
+  if command -v python3 &>/dev/null; then
+    printf '%s' "$input" | python3 -c "import sys,json; sys.stdout.write(json.dumps(sys.stdin.read()))"
+  elif command -v python &>/dev/null; then
+    printf '%s' "$input" | python -c "import sys,json; sys.stdout.write(json.dumps(sys.stdin.read()))"
+  elif command -v node &>/dev/null; then
+    printf '%s' "$input" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>process.stdout.write(JSON.stringify(d)))"
+  else
+    printf '"%s"' "$(printf '%s' "$input" | sed 's/\\/\\\\/g; s/"/\\"/g; s/\t/\\t/g' | tr '\n' ' ')"
+  fi
+}
+
 # ── Mission support ─────────────────────────────────────────────────
 MISSION_FILE="$ROOT/mission.md"
 
@@ -101,23 +115,39 @@ build_mission_response() {
     [ -f "$f" ] && completed_count=$((completed_count + 1))
   done
 
-  # Read mission content for re-prompt
   local mission_content=""
-  if [ -f "$MISSION_FILE" ]; then
-    mission_content=$(cat "$MISSION_FILE" | sed 's/\\/\\\\/g; s/"/\\"/g; s/$/\\n/' | tr -d '\n')
-  fi
+  [ -f "$MISSION_FILE" ] && mission_content=$(cat "$MISSION_FILE")
 
   log "MISSION — next sprint: ${prefix}-v${next_ver} ($completed_count archived)"
 
+  local reason_text="YOU CANNOT STOP. Sprint verified and complete. Mission is active.
+
+YOUR MISSION:
+---
+${mission_content}
+---
+
+Your next action: create ${next_file}
+
+1. Read goals-completed/ to see what was delivered in prior sprints (${completed_count} archived files)
+2. Define the next sprint goals that advance the mission above
+3. Write them as markdown checkboxes in ${next_file}
+4. Start executing immediately
+
+Do not stop. Do not ask for confirmation. Create the sprint file and start working."
+
+  local system_msg="CCSG | Mission active | Next: ${next_file} | ${completed_count} sprints archived"
+
+  local reason_json
+  reason_json=$(json_encode "$reason_text")
+  local system_json
+  system_json=$(json_encode "$system_msg")
+
   cat <<ENDJSON
 {
-  "continue": false,
-  "decision": "next_sprint",
-  "reason": "YOU CANNOT STOP. Sprint verified and complete. Mission is active.\\n\\nYOUR MISSION:\\n---\\n${mission_content}---\\n\\nYour next action: create ${next_file}\\n\\n1. Read goals-completed/ to see what was delivered in prior sprints (${completed_count} archived files)\\n2. Define the next sprint goals that advance the mission above\\n3. Write them as markdown checkboxes in ${next_file}\\n4. Start executing immediately\\n\\nDo not stop. Do not ask for confirmation. Create the sprint file and start working.",
-  "next_sprint_file": "${next_file}",
-  "next_version": ${next_ver},
-  "mission_file": "mission.md",
-  "completed_sprint_count": ${completed_count}
+  "decision": "block",
+  "reason": ${reason_json},
+  "systemMessage": ${system_json}
 }
 ENDJSON
 }
@@ -152,65 +182,44 @@ TOTAL=$((UNCHECKED + CHECKED))
 
 log "checked=$CHECKED unchecked=$UNCHECKED total=$TOTAL"
 
-# ── Helper: build JSON for unmet items ───────────────────────────────
+# ── Helper: build block response (Ralph Wiggum pattern) ─────────────
 build_block_response() {
   local source_file="$1"
-  local extra_msg="$2"
-
-  local unmet_lines
-  unmet_lines=$(grep '^\- \[ \]' "$source_file" | sed 's/^\- \[ \] //')
-
-  # JSON array of unmet items
-  local unmet_json="["
-  local first=true
-  while IFS= read -r line; do
-    local escaped
-    escaped=$(printf '%s' "$line" | sed 's/\\/\\\\/g; s/"/\\"/g')
-    if [ "$first" = true ]; then
-      unmet_json="${unmet_json}\"${escaped}\""
-      first=false
-    else
-      unmet_json="${unmet_json},\"${escaped}\""
-    fi
-  done <<< "$unmet_lines"
-  unmet_json="${unmet_json}]"
-
-  # Human-readable reason
-  local summary="${UNCHECKED} of ${TOTAL} criteria in $(basename "$source_file") are not met:"
-  while IFS= read -r line; do
-    local escaped_line
-    escaped_line=$(printf '%s' "$line" | sed 's/\\/\\\\/g; s/"/\\"/g')
-    summary="${summary}\\n  - ${escaped_line}"
-  done <<< "$unmet_lines"
-
-  if [ -n "$extra_msg" ]; then
-    local escaped_extra
-    escaped_extra=$(printf '%s' "$extra_msg" | sed 's/\\/\\\\/g; s/"/\\"/g')
-    summary="${summary}\\n\\n${escaped_extra}"
-  fi
-
-  summary="${summary}\\nKeep working."
+  local reason_text="$2"
+  local system_msg="CCSG | ${CHECKED} of ${TOTAL} done | Goal: $(basename "$source_file")"
 
   log "BLOCKING — ${UNCHECKED} of ${TOTAL} not met in $(basename "$source_file")"
 
+  local reason_json
+  reason_json=$(json_encode "$reason_text")
+
+  local system_json
+  system_json=$(json_encode "$system_msg")
+
   cat <<ENDJSON
 {
-  "continue": false,
   "decision": "block",
-  "reason": "${summary}",
-  "unmet_criteria": ${unmet_json},
-  "progress": "${CHECKED} of ${TOTAL} done",
-  "goal_file": "$(basename "$source_file")"
+  "reason": ${reason_json},
+  "systemMessage": ${system_json}
 }
 ENDJSON
 }
 
 # ── BLOCK: unchecked items remain ────────────────────────────────────
 if [ "$UNCHECKED" -gt 0 ]; then
-  # Re-prompt: inject the full goal file so the agent gets the complete task back
-  GOAL_CONTENT=$(cat "$GOAL_FILE" | sed 's/\\/\\\\/g; s/"/\\"/g; s/$/\\n/' | tr -d '\n')
+  GOAL_CONTENT=$(cat "$GOAL_FILE")
+
+  REPROMPT="YOU CANNOT STOP. ${UNCHECKED} of ${TOTAL} items in $(basename "$GOAL_FILE") are not done.
 
-  REPROMPT="YOU CANNOT STOP. ${UNCHECKED} of ${TOTAL} items in $(basename "$GOAL_FILE") are not done.\\n\\nRe-read the goal file and continue executing. Here is your active task:\\n\\n---\\n${GOAL_CONTENT}---\\n\\nWork through each unchecked item (- [ ]) in order. Check each one off (- [x]) as you complete it. Do not stop until every box is checked.\\n\\nWORK ETHIC: Compilation is not verification. Test each thing the way its end user would use it. A UI — open it in a browser, click every button, fill every form. An API — call it with real requests, check the actual responses. A CLI — run the commands, read the output. A pipeline — feed it real data, verify what comes out. Whatever it is, use it the way a customer would, not the way the developer who wrote it imagines it works. If you cannot show real output proving it works end-to-end, it is not done. Never trade correctness for speed."
+Re-read the goal file and continue executing. Here is your active task:
+
+---
+${GOAL_CONTENT}
+---
+
+Work through each unchecked item (- [ ]) in order. Check each one off (- [x]) as you complete it. Do not stop until every box is checked.
+
+WORK ETHIC: Compilation is not verification. Test each thing the way its end user would use it. A UI — open it in a browser, click every button, fill every form. An API — call it with real requests, check the actual responses. A CLI — run the commands, read the output. A pipeline — feed it real data, verify what comes out. Whatever it is, use it the way a customer would, not the way the developer who wrote it imagines it works. If you cannot show real output proving it works end-to-end, it is not done. Never trade correctness for speed."
 
   build_block_response "$GOAL_FILE" "$REPROMPT"
   exit 0
@@ -346,7 +355,13 @@ TOTAL=$UNCHECKED
 # Block with the new verification sprint
 GOAL_FILE="$VERIFY_FILE"
 # Re-prompt with full verification sprint content
-VERIFY_CONTENT=$(cat "$VERIFY_FILE" | sed 's/\\/\\\\/g; s/"/\\"/g; s/$/\\n/' | tr -d '\n')
-VERIFY_REPROMPT="You just finished a sprint. But finishing code is not finishing the product. A verification sprint has been created. YOUR TASK NOW:\\n\\n---\\n${VERIFY_CONTENT}---\\n\\nWork through each unchecked item. Do not stop until every box is checked."
+VERIFY_CONTENT=$(cat "$VERIFY_FILE")
+VERIFY_REPROMPT="You just finished a sprint. But finishing code is not finishing the product. A verification sprint has been created. YOUR TASK NOW:
+
+---
+${VERIFY_CONTENT}
+---
+
+Work through each unchecked item. Do not stop until every box is checked."
 build_block_response "$VERIFY_FILE" "$VERIFY_REPROMPT"
 exit 0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-sprint-gate",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Claude Code Sprint Gate — sprint lifecycle manager with verification gates",
   "bin": {
     "ccsg": "bin/ccsg.js"

package/plugin/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "ccsg",
+  "version": "1.3.0",
+  "description": "Claude Code Sprint Gate — sprint lifecycle manager. Prevents stop until goals are met, auto-generates verification sprints, supports multi-sprint missions.",
+  "author": {
+    "name": "panbergco",
+    "url": "https://github.com/panbergco/claude-code-sprint-gate"
+  }
+}

package/plugin/commands/help.md

@@ -0,0 +1,46 @@
+---
+description: "Explain CCSG and available commands"
+---
+
+# CCSG — Claude Code Sprint Gate
+
+Please explain the following to the user:
+
+## What is CCSG?
+
+CCSG is a sprint lifecycle manager for Claude Code. It prevents the agent from stopping until all acceptance criteria in a goal file are met. When a sprint is complete, it auto-generates a verification sprint that forces end-to-end testing before the work is considered done.
+
+## How it works
+
+1. Goal files in `goals-open/` define sprint items as checkboxes (`- [ ]`)
+2. The stop hook fires every time the agent tries to stop
+3. If unchecked items remain, the hook blocks the stop and re-prompts with the full goal
+4. When all items are checked, a verification sprint is auto-generated
+5. The agent must pass verification before the sprint is archived
+6. If `mission.md` exists, a new sprint is prompted after verification
+
+## Available Commands
+
+### /sprint
+Start working on the current goal file. The agent reads the goal, executes each item, and cannot stop until all are checked off.
+
+### /sprint-status
+Show current progress — active goal, items done, mission state, archive count.
+
+### /sprint-cancel
+Emergency stop — archives the current goal so the agent can exit. Work is preserved, not deleted.
+
+## Key Files
+
+- `goals-open/goal-*.md` — Active sprint with checkbox items
+- `goals-completed/` — Archive of finished sprints
+- `mission.md` — Optional. Drives multi-sprint campaigns with a product vision.
+- `stop-condition.md` — Simple mode fallback (single file, no verification)
+
+## Mission Mode
+
+When `mission.md` exists, completing a verification sprint does not allow stop. Instead, CCSG prompts the agent to create the next sprint based on the mission objectives. Add `Sprints: N` to cap the campaign.
+
+## Learn More
+
+Repository: https://github.com/panbergco/claude-code-sprint-gate

package/plugin/commands/sprint-cancel.md

@@ -0,0 +1,15 @@
+---
+description: "Emergency stop — remove all goal files to allow exit"
+allowed-tools: ["Bash", "Read", "Glob"]
+---
+
+# Sprint Cancel
+
+Emergency break — allows the agent to stop by clearing the active sprint.
+
+1. Check if there's an active goal in `goals-open/`
+2. If yes, show the file name and current progress (checked/unchecked count)
+3. Move it to `goals-completed/` (archive, don't delete)
+4. Report: "Sprint cancelled. Goal archived to goals-completed/. You can now stop."
+
+Do NOT delete goal files — always move to goals-completed/ so work is preserved.

package/plugin/commands/sprint-status.md

@@ -0,0 +1,21 @@
+---
+description: "Show current sprint progress"
+allowed-tools: ["Bash", "Read", "Glob"]
+---
+
+# Sprint Status
+
+Check the current sprint state and report:
+
+1. Run: `ls goals-open/goal-*.md 2>/dev/null` to find the active goal
+2. If a goal file exists, read it and count:
+   - Checked items: `grep -c '^\- \[x\]' <file>`
+   - Unchecked items: `grep -c '^\- \[ \]' <file>`
+3. Check if `mission.md` exists
+4. Count files in `goals-completed/`
+
+Report a concise summary:
+- Active sprint file name and title
+- Progress: N of M items done
+- Mission: active (with sprint cap if set) or inactive
+- Completed sprints in archive

package/plugin/commands/sprint.md

@@ -0,0 +1,34 @@
+---
+description: "Start working on the current sprint"
+allowed-tools: ["Read", "Edit", "Write", "Bash", "Glob", "Grep"]
+hide-from-slash-command-tool: "true"
+---
+
+# Sprint — Start Working
+
+You are now in sprint mode. The stop hook will prevent you from stopping until all items are done.
+
+## Your task
+
+1. Check `goals-open/` for the active goal file (the most recent `goal-*.md`)
+2. If a `mission.md` exists, read it — that is your persona and objective
+3. Read the goal file completely
+4. Work through every unchecked item (`- [ ]`) in order
+5. As you complete each item, check it off (`- [x]`) in the goal file
+6. When all items are checked, the stop hook will handle what comes next:
+   - If it's a regular sprint: a verification sprint is auto-generated
+   - If it's a verification sprint: the sprint is archived
+   - If a mission is active: the next sprint is prompted
+
+## Rules
+
+- Do NOT stop or pause to ask for confirmation. Execute continuously.
+- Do NOT skip items. Work through them in order.
+- Test each deliverable the way its end user would use it — compilation is not verification.
+- If you get stuck on an item, try a different approach. Do not abandon it.
+- Check items off (`- [x]`) only AFTER you have completed and verified them.
+- When you try to stop, the hook will re-prompt you if work remains. This is by design.
+
+## Begin
+
+Read the active goal file now and start executing.

package/plugin/hooks/ccsg.sh

@@ -0,0 +1,367 @@
+#!/usr/bin/env bash
+#
+# CCSG — Claude Code Sprint Gate
+#
+# Sprint lifecycle manager for Claude Code. Prevents the agent from
+# stopping until all acceptance criteria are met. When a sprint is
+# complete, auto-generates a verification sprint that forces end-to-end
+# testing of the full deployment before allowing stop.
+#
+# Directory structure:
+#   goals-open/       — Active sprint (one goal file at a time)
+#   goals-completed/  — Archive of finished sprints
+#
+# Flow:
+#   1. Agent works through items in the active goal file
+#   2. Tries to stop → CCSG checks for unchecked items → blocks if any remain
+#   3. All items checked on a regular sprint →
+#      CCSG creates a verification sprint, moves original to completed, blocks
+#   4. All items checked on a verification sprint →
+#      CCSG moves it to completed, allows stop
+#
+# Mission mode (mission.md):
+#   When mission.md exists, completing a verification sprint does NOT allow
+#   stop. Instead, CCSG blocks and instructs the agent to create the next
+#   sprint — reading mission.md for persona/objectives and goals-completed/
+#   for history. The cycle repeats until the sprint cap is reached or
+#   mission.md is removed.
+#
+# Fallback: if no goal files exist, checks stop-condition.md (backward compat)
+#
+
+LOG_FILE="/tmp/ccsg.log"
+log() { echo "$(date): $1" >> "$LOG_FILE"; }
+log "stop hook fired"
+
+# Find project root
+ROOT="$(git rev-parse --show-toplevel 2>/dev/null || echo ".")"
+GOALS_OPEN="$ROOT/goals-open"
+GOALS_COMPLETED="$ROOT/goals-completed"
+
+# Ensure directories exist
+mkdir -p "$GOALS_OPEN" "$GOALS_COMPLETED"
+
+# ── Helper: safe JSON encoding ──────────────────────────────────────
+json_encode() {
+  local input="$1"
+  if command -v python3 &>/dev/null; then
+    printf '%s' "$input" | python3 -c "import sys,json; sys.stdout.write(json.dumps(sys.stdin.read()))"
+  elif command -v python &>/dev/null; then
+    printf '%s' "$input" | python -c "import sys,json; sys.stdout.write(json.dumps(sys.stdin.read()))"
+  elif command -v node &>/dev/null; then
+    printf '%s' "$input" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>process.stdout.write(JSON.stringify(d)))"
+  else
+    printf '"%s"' "$(printf '%s' "$input" | sed 's/\\/\\\\/g; s/"/\\"/g; s/\t/\\t/g' | tr '\n' ' ')"
+  fi
+}
+
+# ── Mission support ─────────────────────────────────────────────────
+MISSION_FILE="$ROOT/mission.md"
+
+mission_active() {
+  [ ! -f "$MISSION_FILE" ] && return 1
+
+  # Check sprint cap if specified (line like "Sprints: 20")
+  local max_sprints
+  max_sprints=$(grep -iE '^Sprints:\s*[0-9]+' "$MISSION_FILE" 2>/dev/null | head -1 | grep -o '[0-9]*')
+  if [ -n "$max_sprints" ]; then
+    local completed=0
+    for f in "$GOALS_COMPLETED"/goal-*.md; do
+      [ -f "$f" ] || continue
+      [[ "$(basename "$f")" == *"-verify"* ]] && continue
+      completed=$((completed + 1))
+    done
+    if [ "$completed" -ge "$max_sprints" ]; then
+      log "MISSION — sprint cap reached ($completed/$max_sprints)"
+      return 1
+    fi
+  fi
+
+  return 0
+}
+
+next_sprint_info() {
+  # Returns "prefix|next_version" — inferred from completed sprints
+  local highest=0
+  local prefix=""
+
+  for f in "$GOALS_COMPLETED"/goal-*.md; do
+    [ -f "$f" ] || continue
+    local bn
+    bn=$(basename "$f" .md)
+    [[ "$bn" == *"-verify" ]] && continue
+
+    local ver
+    ver=$(echo "$bn" | grep -oE 'v[0-9]+' | tail -1 | tr -d 'v')
+    if [ -n "$ver" ] && [ "$ver" -gt "$highest" ]; then
+      highest=$ver
+      prefix=$(echo "$bn" | sed "s/-v${ver}$//")
+    fi
+  done
+
+  [ -z "$prefix" ] && prefix="goal-sprint"
+  echo "${prefix}|$((highest + 1))"
+}
+
+build_mission_response() {
+  local info
+  info=$(next_sprint_info)
+  local prefix="${info%%|*}"
+  local next_ver="${info##*|}"
+  local next_file="goals-open/${prefix}-v${next_ver}.md"
+
+  local completed_count=0
+  for f in "$GOALS_COMPLETED"/goal-*.md; do
+    [ -f "$f" ] && completed_count=$((completed_count + 1))
+  done
+
+  local mission_content=""
+  [ -f "$MISSION_FILE" ] && mission_content=$(cat "$MISSION_FILE")
+
+  log "MISSION — next sprint: ${prefix}-v${next_ver} ($completed_count archived)"
+
+  local reason_text="YOU CANNOT STOP. Sprint verified and complete. Mission is active.
+
+YOUR MISSION:
+---
+${mission_content}
+---
+
+Your next action: create ${next_file}
+
+1. Read goals-completed/ to see what was delivered in prior sprints (${completed_count} archived files)
+2. Define the next sprint goals that advance the mission above
+3. Write them as markdown checkboxes in ${next_file}
+4. Start executing immediately
+
+Do not stop. Do not ask for confirmation. Create the sprint file and start working."
+
+  local system_msg="CCSG | Mission active | Next: ${next_file} | ${completed_count} sprints archived"
+
+  local reason_json
+  reason_json=$(json_encode "$reason_text")
+  local system_json
+  system_json=$(json_encode "$system_msg")
+
+  cat <<ENDJSON
+{
+  "decision": "block",
+  "reason": ${reason_json},
+  "systemMessage": ${system_json}
+}
+ENDJSON
+}
+
+# ── Locate the active goal file ──────────────────────────────────────
+GOAL_FILE=$(ls -t "$GOALS_OPEN"/goal-*.md 2>/dev/null | head -1)
+IS_GOALS_SYSTEM=false
+
+if [ -n "$GOAL_FILE" ]; then
+  IS_GOALS_SYSTEM=true
+  log "active goal: $(basename "$GOAL_FILE")"
+else
+  # Fallback to stop-condition.md
+  GOAL_FILE="$ROOT/stop-condition.md"
+  if [ ! -f "$GOAL_FILE" ]; then
+    # Mission mode: if mission.md exists, prompt next sprint even with empty goals-open/
+    if mission_active; then
+      build_mission_response
+      exit 0
+    fi
+    log "no active goal or stop-condition.md found, allowing stop"
+    echo '{"continue": true}'
+    exit 0
+  fi
+  log "fallback to stop-condition.md"
+fi
+
+# ── Count checked / unchecked ────────────────────────────────────────
+UNCHECKED=$(grep -c '^\- \[ \]' "$GOAL_FILE" 2>/dev/null) || UNCHECKED=0
+CHECKED=$(grep -c '^\- \[x\]' "$GOAL_FILE" 2>/dev/null) || CHECKED=0
+TOTAL=$((UNCHECKED + CHECKED))
+
+log "checked=$CHECKED unchecked=$UNCHECKED total=$TOTAL"
+
+# ── Helper: build block response (Ralph Wiggum pattern) ─────────────
+build_block_response() {
+  local source_file="$1"
+  local reason_text="$2"
+  local system_msg="CCSG | ${CHECKED} of ${TOTAL} done | Goal: $(basename "$source_file")"
+
+  log "BLOCKING — ${UNCHECKED} of ${TOTAL} not met in $(basename "$source_file")"
+
+  local reason_json
+  reason_json=$(json_encode "$reason_text")
+
+  local system_json
+  system_json=$(json_encode "$system_msg")
+
+  cat <<ENDJSON
+{
+  "decision": "block",
+  "reason": ${reason_json},
+  "systemMessage": ${system_json}
+}
+ENDJSON
+}
+
+# ── BLOCK: unchecked items remain ────────────────────────────────────
+if [ "$UNCHECKED" -gt 0 ]; then
+  GOAL_CONTENT=$(cat "$GOAL_FILE")
+
+  REPROMPT="YOU CANNOT STOP. ${UNCHECKED} of ${TOTAL} items in $(basename "$GOAL_FILE") are not done.
+
+Re-read the goal file and continue executing. Here is your active task:
+
+---
+${GOAL_CONTENT}
+---
+
+Work through each unchecked item (- [ ]) in order. Check each one off (- [x]) as you complete it. Do not stop until every box is checked.
+
+WORK ETHIC: Compilation is not verification. Test each thing the way its end user would use it. A UI — open it in a browser, click every button, fill every form. An API — call it with real requests, check the actual responses. A CLI — run the commands, read the output. A pipeline — feed it real data, verify what comes out. Whatever it is, use it the way a customer would, not the way the developer who wrote it imagines it works. If you cannot show real output proving it works end-to-end, it is not done. Never trade correctness for speed."
+
+  build_block_response "$GOAL_FILE" "$REPROMPT"
+  exit 0
+fi
+
+# ── ALL ITEMS CHECKED (or no checkboxes at all) ─────────────────────
+
+# If no checkboxes exist, there's nothing to enforce
+if [ "$TOTAL" -eq 0 ]; then
+  log "no checkboxes found in $(basename "$GOAL_FILE"), allowing stop"
+  echo '{"continue": true}'
+  exit 0
+fi
+
+# If using standalone stop-condition.md (no goals system), allow stop
+if [ "$IS_GOALS_SYSTEM" = false ]; then
+  log "all criteria in stop-condition.md met, allowing stop"
+  echo '{"continue": true}'
+  exit 0
+fi
+
+GOAL_BASENAME=$(basename "$GOAL_FILE")
+
+# ── Verification sprint complete → finish ────────────────────────────
+if [[ "$GOAL_BASENAME" == *"-verify"* ]]; then
+  mv "$GOAL_FILE" "$GOALS_COMPLETED/"
+  log "DONE — verification sprint $GOAL_BASENAME complete, moved to goals-completed/"
+
+  # Mission mode: don't stop — prompt the next sprint
+  if mission_active; then
+    build_mission_response
+    exit 0
+  fi
+
+  echo '{"continue": true}'
+  exit 0
+fi
+
+# ── Regular sprint complete → generate verification sprint ───────────
+log "sprint $GOAL_BASENAME complete — generating verification sprint"
+
+# Extract sprint info
+SPRINT_TITLE=$(grep -m1 '^# ' "$GOAL_FILE" | sed 's/^# //')
+SPRINT_NAME="${GOAL_BASENAME%.md}"
+VERIFY_FILE="$GOALS_OPEN/${SPRINT_NAME}-verify.md"
+
+# Collect what was delivered (checked items)
+DELIVERED=$(grep '^\- \[x\]' "$GOAL_FILE" | sed 's/^\- \[x\] //')
+
+# Build per-item verification lines
+VERIFY_ITEMS=""
+while IFS= read -r item; do
+  [ -n "$item" ] && VERIFY_ITEMS="${VERIFY_ITEMS}
+- [ ] VERIFY: ${item}"
+done <<< "$DELIVERED"
+
+# Write the verification sprint
+cat > "$VERIFY_FILE" <<SPRINT
+# Verification — ${SPRINT_TITLE}
+
+Sprint \`${SPRINT_NAME}\` is complete. Every checkbox was checked.
+But checked boxes are claims, not proof. This verification sprint
+exists because "it should work" is not the same as "it works."
+
+Your job now is to prove — through actual testing — that everything
+delivered in the previous sprint is real, working, and ready for a
+real user to depend on.
+
+## Work Ethic
+
+Compilation is not verification. Test each thing the way its end user would use it:
+
+- **A UI** — open it in a browser, click every button, fill every form, walk every path
+- **An API** — call every endpoint with real requests, check the actual responses
+- **A CLI** — run the commands with real arguments, read the real output
+- **A pipeline** — feed it real data, verify what comes out the other end
+
+Whatever it is, use it the way a customer would — not the way the developer who
+wrote it imagines it works. If you cannot show real output proving it works
+end-to-end, it is not done. Never trade correctness for speed. One properly
+verified feature is worth more than ten that "should work."
+
+## Build Verification
+
+- [ ] Delete all cached/compiled artifacts and rebuild from a clean state
+- [ ] All dependencies resolve cleanly — no warnings, no version conflicts
+- [ ] Build completes without warnings that could indicate runtime issues
+
+## Full Test Suite
+
+- [ ] Run the COMPLETE test suite — every test file, not just the new ones
+- [ ] Zero failures, zero skipped tests without documented justification
+- [ ] If there are integration tests, run those too — they catch what unit tests miss
+
+## End-to-End Feature Verification
+
+Walk through every feature delivered in the sprint as a real user would.
+Do not just call functions — use the actual UI/CLI/API entry points.
+${VERIFY_ITEMS}
+
+## Regression Testing
+
+- [ ] Features from prior sprints still work — spot check at least 3
+- [ ] No existing functionality broken by the new changes
+- [ ] Trigger error cases intentionally and verify they are handled gracefully
+- [ ] Check edge cases: empty inputs, missing data, concurrent access, large payloads
+
+## Deployment Readiness
+
+- [ ] No hardcoded development/debug values in production code
+- [ ] No temporary code, TODO hacks, or commented-out blocks left behind
+- [ ] No debug logging (console.log, print, debugger) left in source
+- [ ] Environment configuration is correct and complete
+- [ ] Dependencies are locked — no floating versions that could break tomorrow
+- [ ] No new security vulnerabilities introduced (review dependency changes)
+
+## Final Verdict
+
+- [ ] The product works. Not "should work." Works. You tested it yourself and saw it work.
+SPRINT
+
+log "created verification sprint: $(basename "$VERIFY_FILE")"
+
+# Move the completed sprint to archive
+mv "$GOAL_FILE" "$GOALS_COMPLETED/"
+log "moved $GOAL_BASENAME to goals-completed/"
+
+# Re-count for the new verification sprint
+UNCHECKED=$(grep -c '^\- \[ \]' "$VERIFY_FILE" 2>/dev/null) || UNCHECKED=0
+CHECKED=0
+TOTAL=$UNCHECKED
+
+# Block with the new verification sprint
+GOAL_FILE="$VERIFY_FILE"
+# Re-prompt with full verification sprint content
+VERIFY_CONTENT=$(cat "$VERIFY_FILE")
+VERIFY_REPROMPT="You just finished a sprint. But finishing code is not finishing the product. A verification sprint has been created. YOUR TASK NOW:
+
+---
+${VERIFY_CONTENT}
+---
+
+Work through each unchecked item. Do not stop until every box is checked."
+build_block_response "$VERIFY_FILE" "$VERIFY_REPROMPT"
+exit 0

package/plugin/hooks/hooks.json

@@ -0,0 +1,15 @@
+{
+  "description": "CCSG stop hook — sprint gate with re-prompting",
+  "hooks": {
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/ccsg.sh"
+          }
+        ]
+      }
+    ]
+  }
+}

package/test-ccsg.sh

@@ -177,9 +177,9 @@ EOF
 
 OUTPUT=$(bash "$HOOK" 2>/dev/null)
 
-assert_contains "blocks stop" '"continue": false' "$OUTPUT"
-assert_contains "lists unmet items" '"First task"' "$OUTPUT"
-assert_contains "has progress" '"progress"' "$OUTPUT"
+assert_contains "blocks stop" '"decision": "block"' "$OUTPUT"
+assert_contains "lists unmet items" 'First task' "$OUTPUT"
+assert_contains "has systemMessage" '"systemMessage"' "$OUTPUT"
 assert_contains "includes work ethic" 'way its end user would use it' "$OUTPUT"
 assert_json_valid "valid JSON" "$OUTPUT"
 
@@ -220,12 +220,12 @@ EOF
 
 OUTPUT=$(bash "$HOOK" 2>/dev/null)
 
-assert_contains "blocks stop" '"continue": false' "$OUTPUT"
+assert_contains "blocks stop" '"decision": "block"' "$OUTPUT"
 assert_contains "reports count" '2 of 3' "$OUTPUT"
-assert_contains "lists unmet item" '"Not done yet"' "$OUTPUT"
-assert_contains "lists other unmet item" '"Also not done"' "$OUTPUT"
-assert_contains "shows progress" '1 of 3 done' "$OUTPUT"
-assert_contains "shows goal file name" '"goal_file"' "$OUTPUT"
+assert_contains "lists unmet item" 'Not done yet' "$OUTPUT"
+assert_contains "lists other unmet item" 'Also not done' "$OUTPUT"
+assert_contains "shows progress in systemMessage" '1 of 3 done' "$OUTPUT"
+assert_contains "has systemMessage with goal name" 'goal-test-v1' "$OUTPUT"
 assert_contains "work ethic reminder" 'WORK ETHIC' "$OUTPUT"
 assert_json_valid "valid JSON" "$OUTPUT"
 
@@ -242,7 +242,7 @@ EOF
 
 OUTPUT=$(bash "$HOOK" 2>/dev/null)
 
-assert_contains "blocks stop" '"continue": false' "$OUTPUT"
+assert_contains "blocks stop" '"decision": "block"' "$OUTPUT"
 assert_json_valid "valid JSON despite special chars" "$OUTPUT"
 
 # ═══════════════════════════════════════════════════════════════════════
@@ -268,7 +268,7 @@ EOF
 
 OUTPUT=$(bash "$HOOK" 2>/dev/null)
 
-assert_contains "blocks stop (verification needed)" '"continue": false' "$OUTPUT"
+assert_contains "blocks stop (verification needed)" '"decision": "block"' "$OUTPUT"
 assert_file_exists "verification sprint created" "$GOALS_OPEN/goal-feature-v5-verify.md"
 assert_file_not_exists "original moved out of goals-open" "$GOALS_OPEN/goal-feature-v5.md"
 assert_file_exists "original moved to goals-completed" "$GOALS_COMPLETED/goal-feature-v5.md"
@@ -325,7 +325,7 @@ echo "=== Test 9: Verification sprint blocks when incomplete ==="
 # The verification sprint from test 6 should still be in goals-open
 OUTPUT=$(bash "$HOOK" 2>/dev/null)
 
-assert_contains "blocks on incomplete verification" '"continue": false' "$OUTPUT"
+assert_contains "blocks on incomplete verification" '"decision": "block"' "$OUTPUT"
 assert_contains "references verification file" 'verify' "$OUTPUT"
 assert_contains "includes work ethic" 'way its end user would use it' "$OUTPUT"
 
@@ -373,14 +373,14 @@ EOF
 
 # Step 2: Agent tries to stop → should block
 OUTPUT=$(bash "$HOOK" 2>/dev/null)
-assert_contains "step 1: blocks on incomplete sprint" '"continue": false' "$OUTPUT"
+assert_contains "step 1: blocks on incomplete sprint" '"decision": "block"' "$OUTPUT"
 
 # Step 3: Agent completes the work
 sed -i 's/^\- \[ \]/- [x]/' "$GOALS_OPEN/goal-widget-v10.md"
 
 # Step 4: Agent tries to stop → should block (creates verification)
 OUTPUT=$(bash "$HOOK" 2>/dev/null)
-assert_contains "step 2: blocks for verification" '"continue": false' "$OUTPUT"
+assert_contains "step 2: blocks for verification" '"decision": "block"' "$OUTPUT"
 assert_file_exists "step 2: verification sprint exists" "$GOALS_OPEN/goal-widget-v10-verify.md"
 assert_file_exists "step 2: original archived" "$GOALS_COMPLETED/goal-widget-v10.md"
 
@@ -443,7 +443,7 @@ EOF
 
 OUTPUT=$(bash "$HOOK" 2>/dev/null)
 
-assert_contains "blocks on goal file, ignoring stop-condition.md" '"continue": false' "$OUTPUT"
+assert_contains "blocks on goal file, ignoring stop-condition.md" '"decision": "block"' "$OUTPUT"
 assert_contains "references goal file" 'goal-priority-v1' "$OUTPUT"
 
 # ---------- Test 15: Log file records lifecycle events ----------
@@ -496,10 +496,10 @@ EOF
 
 OUTPUT=$(bash "$HOOK" 2>/dev/null)
 
-assert_contains "blocks stop (mission active)" '"continue": false' "$OUTPUT"
-assert_contains "decision is next_sprint" '"next_sprint"' "$OUTPUT"
+assert_contains "blocks stop (mission active)" '"decision": "block"' "$OUTPUT"
+assert_contains "blocks for next sprint" '"decision": "block"' "$OUTPUT"
 assert_contains "suggests v2" 'v2' "$OUTPUT"
-assert_contains "references mission.md" 'mission.md' "$OUTPUT"
+assert_contains "references mission" 'Mission active' "$OUTPUT"
 assert_contains "tells agent to keep working" 'Do not stop' "$OUTPUT"
 assert_file_exists "verify moved to completed" "$GOALS_COMPLETED/goal-product-v1-verify.md"
 assert_file_not_exists "verify removed from open" "$GOALS_OPEN/goal-product-v1-verify.md"
@@ -520,8 +520,8 @@ cp /dev/null "$GOALS_COMPLETED/goal-widget-v3.md"
 
 OUTPUT=$(bash "$HOOK" 2>/dev/null)
 
-assert_contains "blocks stop" '"continue": false' "$OUTPUT"
-assert_contains "decision is next_sprint" '"next_sprint"' "$OUTPUT"
+assert_contains "blocks stop" '"decision": "block"' "$OUTPUT"
+assert_contains "blocks for next sprint" '"decision": "block"' "$OUTPUT"
 assert_contains "increments to v4" 'v4' "$OUTPUT"
 assert_json_valid "valid JSON" "$OUTPUT"
 
@@ -589,13 +589,13 @@ EOF
 
 # Complete sprint → creates verification
 OUTPUT=$(bash "$HOOK" 2>/dev/null)
-assert_contains "lc step 1: blocks for verification" '"continue": false' "$OUTPUT"
+assert_contains "lc step 1: blocks for verification" '"decision": "block"' "$OUTPUT"
 assert_file_exists "lc step 1: verification created" "$GOALS_OPEN/goal-lifecycle-v1-verify.md"
 
 # Complete verification → mission prompts sprint 2
 sed -i 's/^\- \[ \]/- [x]/' "$GOALS_OPEN/goal-lifecycle-v1-verify.md"
 OUTPUT=$(bash "$HOOK" 2>/dev/null)
-assert_contains "lc step 2: mission prompts next sprint" '"next_sprint"' "$OUTPUT"
+assert_contains "lc step 2: mission blocks for next sprint" 'Mission active' "$OUTPUT"
 assert_contains "lc step 2: suggests v2" 'v2' "$OUTPUT"
 
 # Sprint 2: create and complete
@@ -605,7 +605,7 @@ cat > "$GOALS_OPEN/goal-lifecycle-v2.md" <<'EOF'
 EOF
 
 OUTPUT=$(bash "$HOOK" 2>/dev/null)
-assert_contains "lc step 3: blocks for verification" '"continue": false' "$OUTPUT"
+assert_contains "lc step 3: blocks for verification" '"decision": "block"' "$OUTPUT"
 assert_file_exists "lc step 3: verification created" "$GOALS_OPEN/goal-lifecycle-v2-verify.md"
 
 # Complete verification → cap reached, allows stop
@@ -631,7 +631,7 @@ done
 
 OUTPUT=$(bash "$HOOK" 2>/dev/null)
 
-assert_contains "still blocks at sprint 51" '"continue": false' "$OUTPUT"
+assert_contains "still blocks at sprint 51" '"decision": "block"' "$OUTPUT"
 assert_contains "suggests v51" 'v51' "$OUTPUT"
 assert_json_valid "valid JSON" "$OUTPUT"