claude-code-pilot 3.1.0 → 3.2.0

package/src/hooks/ccp-read-injection-scanner.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+// ccp-hook-version: {{CCP_VERSION}}
+// CCP Read Injection Scanner — PostToolUse hook (ported from GSD #2201)
+// Scans file content returned by the Read tool for prompt injection patterns.
+// Catches poisoned content at ingestion before it enters conversation context.
+//
+// Defense-in-depth: long sessions hit context compression, and the
+// summariser does not distinguish user instructions from content read from
+// external files. Poisoned instructions that survive compression become
+// indistinguishable from trusted context. This hook warns at ingestion time.
+//
+// Triggers on: Read tool PostToolUse events
+// Action: Advisory warning (does not block) — logs detection for awareness
+// Severity: LOW (1–2 patterns), HIGH (3+ patterns)
+//
+// False-positive exclusion: .planning/, REVIEW.md, CHECKPOINT, security docs,
+// hook source files — these legitimately contain injection-like strings.
+
+const path = require('path');
+
+// Summarisation-specific patterns (novel — not in ccp-prompt-guard.js).
+// These target instructions specifically designed to survive context compression.
+const SUMMARISATION_PATTERNS = [
+  /when\s+(?:summari[sz]ing|compressing|compacting),?\s+(?:retain|preserve|keep)\s+(?:this|these)/i,
+  /this\s+(?:instruction|directive|rule)\s+is\s+(?:permanent|persistent|immutable)/i,
+  /preserve\s+(?:these|this)\s+(?:rules?|instructions?|directives?)\s+(?:in|through|after|during)/i,
+  /(?:retain|keep)\s+(?:this|these)\s+(?:in|through|after)\s+(?:summar|compress|compact)/i,
+];
+
+// Standard injection patterns — mirrors ccp-prompt-guard.js, inlined for hook independence.
+const INJECTION_PATTERNS = [
+  /ignore\s+(all\s+)?previous\s+instructions/i,
+  /ignore\s+(all\s+)?above\s+instructions/i,
+  /disregard\s+(all\s+)?previous/i,
+  /forget\s+(all\s+)?(your\s+)?instructions/i,
+  /override\s+(system|previous)\s+(prompt|instructions)/i,
+  /you\s+are\s+now\s+(?:a|an|the)\s+/i,
+  /act\s+as\s+(?:a|an|the)\s+(?!plan|phase|wave)/i,
+  /pretend\s+(?:you(?:'re| are)\s+|to\s+be\s+)/i,
+  /from\s+now\s+on,?\s+you\s+(?:are|will|should|must)/i,
+  /(?:print|output|reveal|show|display|repeat)\s+(?:your\s+)?(?:system\s+)?(?:prompt|instructions)/i,
+  /<\/?(?:system|assistant|human)>/i,
+  /\[SYSTEM\]/i,
+  /\[INST\]/i,
+  /<<\s*SYS\s*>>/i,
+];
+
+const ALL_PATTERNS = [...INJECTION_PATTERNS, ...SUMMARISATION_PATTERNS];
+
+function isExcludedPath(filePath) {
+  const p = filePath.replace(/\\/g, '/');
+  return (
+    p.includes('/.planning/') ||
+    p.includes('.planning/') ||
+    /(?:^|\/)REVIEW\.md$/i.test(p) ||
+    /CHECKPOINT/i.test(path.basename(p)) ||
+    /[/\\](?:security|techsec|injection)[/\\.]/i.test(p) ||
+    /security\.cjs$/.test(p) ||
+    p.includes('/.claude/hooks/')
+  );
+}
+
+let inputBuf = '';
+const stdinTimeout = setTimeout(() => process.exit(0), 5000);
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { inputBuf += chunk; });
+process.stdin.on('end', () => {
+  clearTimeout(stdinTimeout);
+  try {
+    const data = JSON.parse(inputBuf);
+
+    if (data.tool_name !== 'Read') {
+      process.exit(0);
+    }
+
+    const filePath = data.tool_input?.file_path || '';
+    if (!filePath) {
+      process.exit(0);
+    }
+
+    if (isExcludedPath(filePath)) {
+      process.exit(0);
+    }
+
+    // Extract content from tool_response — string (cat -n output) or object form
+    let content = '';
+    const resp = data.tool_response;
+    if (typeof resp === 'string') {
+      content = resp;
+    } else if (resp && typeof resp === 'object') {
+      const c = resp.content;
+      if (Array.isArray(c)) {
+        content = c.map(b => (typeof b === 'string' ? b : b.text || '')).join('\n');
+      } else if (c != null) {
+        content = String(c);
+      }
+    }
+
+    if (!content || content.length < 20) {
+      process.exit(0);
+    }
+
+    const findings = [];
+
+    for (const pattern of ALL_PATTERNS) {
+      if (pattern.test(content)) {
+        // Trim pattern source for readable output
+        findings.push(pattern.source.replace(/\\s\+/g, '-').replace(/[()\\]/g, '').substring(0, 50));
+      }
+    }
+
+    // Invisible Unicode (zero-width, RTL override, soft hyphen, BOM)
+    if (/[\u200B-\u200F\u2028-\u202F\uFEFF\u00AD\u2060-\u2069]/.test(content)) {
+      findings.push('invisible-unicode');
+    }
+
+    // Unicode tag block U+E0000–E007F (invisible instruction injection vector)
+    try {
+      if (/[\u{E0000}-\u{E007F}]/u.test(content)) {
+        findings.push('unicode-tag-block');
+      }
+    } catch {
+      // Engine does not support Unicode property escapes — skip this check
+    }
+
+    if (findings.length === 0) {
+      process.exit(0);
+    }
+
+    const severity = findings.length >= 3 ? 'HIGH' : 'LOW';
+    const fileName = path.basename(filePath);
+    const detail = severity === 'HIGH'
+      ? 'Multiple patterns — strong injection signal. Review the file for embedded instructions before proceeding.'
+      : 'Single pattern match may be a false positive (e.g., documentation). Proceed with awareness.';
+
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: 'PostToolUse',
+        additionalContext:
+          `\u26a0\ufe0f READ INJECTION SCAN [${severity}]: File "${fileName}" triggered ` +
+          `${findings.length} pattern(s): ${findings.join(', ')}. ` +
+          `This content is now in your conversation context. ${detail} ` +
+          `Source: ${filePath}`,
+      },
+    };
+
+    process.stdout.write(JSON.stringify(output));
+  } catch {
+    // Silent fail — never block tool execution
+    process.exit(0);
+  }
+});

package/src/hooks/kit-check-update.js

@@ -41,17 +41,69 @@ const child = spawn(process.execPath, ['-e', `
 `], { stdio: 'ignore', windowsHide: true, detached: true });
 child.unref();
 
-// Show cached result if fresh
+// Stale-hook detector: scan installed .claude/hooks/*.{js,sh} for ccp-hook-version
+// headers, compare against the installed pilot VERSION. Advisory only; never blocks.
+//
+// Regex matches both bash ('# ') and JS ('// ') comment styles to avoid the
+// upstream bug where bash hooks landed in the "unknown" branch on every session.
+// The negative case (no comment prefix) is intentional to prevent false positives
+// on bare version strings inside file content.
+function findStaleHooks(hooksDir, installedVersion) {
+  if (!hooksDir || !fs.existsSync(hooksDir)) return [];
+  const VERSION_RE = /(?:\/\/|#) ccp-hook-version:\s*(.+)/;
+  const stale = [];
+  try {
+    for (const file of fs.readdirSync(hooksDir)) {
+      if (!file.endsWith('.js') && !file.endsWith('.sh')) continue;
+      const p = path.join(hooksDir, file);
+      let content;
+      try { content = fs.readFileSync(p, 'utf8'); } catch { continue; }
+      const m = content.match(VERSION_RE);
+      if (!m) continue; // unversioned hooks are not flagged
+      const hookVersion = m[1].trim();
+      if (hookVersion.includes('{{')) continue; // unsubstituted placeholder -- skip
+      if (hookVersion !== installedVersion) {
+        stale.push({ file, hookVersion, installedVersion });
+      }
+    }
+  } catch {
+    // detector failure is silent; never break SessionStart
+  }
+  return stale;
+}
+
+// Show cached result if fresh + stale-hook advisory (combined into one notice)
 try {
+  let installedVersion = '0.0.0';
+  try { installedVersion = fs.readFileSync(versionFile, 'utf8').trim(); } catch {}
+  const hooksDir = path.join(path.dirname(path.dirname(versionFile)), 'hooks');
+  let stale = [];
+  try { stale = findStaleHooks(hooksDir, installedVersion); } catch {}
+
+  let updateMsg = null;
   if (fs.existsSync(cacheFile)) {
     const cached = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
     if ((Math.floor(Date.now() / 1000) - (cached.checked || 0)) < 86400 && cached.update_available) {
-      process.stdout.write(JSON.stringify({
-        hookSpecificOutput: {
-          hookEventName: 'SessionStart',
-          additionalContext: `Pilot update available: ${cached.installed} -> ${cached.latest}. Run /ccp:update to upgrade.`
-        }
-      }));
+      updateMsg = `Pilot update available: ${cached.installed} -> ${cached.latest}. Run /ccp:update to upgrade.`;
     }
   }
+
+  let staleMsg = null;
+  if (stale.length > 0) {
+    staleMsg = `Stale hooks detected (run /ccp:update): ${stale.map(s => s.file).join(', ')}`;
+  }
+
+  if (updateMsg || staleMsg) {
+    const lines = [];
+    if (staleMsg) lines.push(staleMsg);
+    if (updateMsg) lines.push(updateMsg);
+    process.stdout.write(JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'SessionStart',
+        additionalContext: lines.join('\n')
+      }
+    }));
+  }
 } catch {}
+
+module.exports = { findStaleHooks };

package/src/hooks/run-with-flags-shell.sh

@@ -1,4 +1,5 @@
 #!/usr/bin/env bash
+# ccp-hook-version: {{CCP_VERSION}}
 set -euo pipefail
 
 HOOK_ID="${1:-}"

package/src/hooks/run-with-flags.js

@@ -9,9 +9,10 @@
 'use strict';
 
 const fs = require('fs');
+const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
-const { isHookEnabled } = require('../lib/hook-flags');
+const { isHookEnabled, isProfilingEnabled } = require('../lib/hook-flags');
 
 const MAX_STDIN = 1024 * 1024;
 
@@ -85,6 +86,45 @@ function getPluginRoot() {
   return path.resolve(__dirname, '..', '..');
 }
 
+/**
+ * Append a single JSONL row to the timings sidecar.
+ *
+ * Wrapped in try/catch so timing failures NEVER block the hook itself.
+ * File path: {CCP_HOOK_TIMINGS_DIR || os.tmpdir()}/ccp-hook-timings-{sessionId}.json
+ */
+function recordTiming(hookId, durationMs) {
+  try {
+    const timingsDir = (process.env.CCP_HOOK_TIMINGS_DIR && process.env.CCP_HOOK_TIMINGS_DIR.trim())
+      ? process.env.CCP_HOOK_TIMINGS_DIR
+      : os.tmpdir();
+    const sessionId = (process.env.CLAUDE_SESSION_ID && process.env.CLAUDE_SESSION_ID.trim())
+      ? process.env.CLAUDE_SESSION_ID
+      : 'unknown';
+    const sidecarPath = path.join(timingsDir, `ccp-hook-timings-${sessionId}.json`);
+    const row = JSON.stringify({
+      hookId: String(hookId || ''),
+      durationMs: Number(durationMs) || 0,
+      ts: Date.now()
+    });
+    try {
+      fs.appendFileSync(sidecarPath, row + '\n', { flag: 'a' });
+    } catch {
+      // sidecar write failed -- swallow silently; never block the hook
+    }
+  } catch {
+    // outer guard: even path resolution must not break the dispatcher
+  }
+}
+
+/**
+ * Measure wall-clock duration in milliseconds using the monotonic hrtime
+ * clock (resists wall-clock skew/NTP adjustments).
+ */
+function elapsedMs(startNs) {
+  const deltaNs = process.hrtime.bigint() - startNs;
+  return Number(deltaNs) / 1e6;
+}
+
 async function main() {
   const [, , hookId, relScriptPath, profilesCsv] = process.argv;
   const { raw, truncated } = await readStdinRaw();
@@ -135,11 +175,16 @@ async function main() {
     }
   }
 
+  const profileOn = isProfilingEnabled();
+
   if (hookModule && typeof hookModule.run === 'function') {
+    const startNs = profileOn ? process.hrtime.bigint() : null;
     try {
       const output = hookModule.run(raw, { truncated, maxStdin: MAX_STDIN });
+      if (profileOn) recordTiming(hookId, elapsedMs(startNs));
       process.exit(emitHookResult(raw, output));
     } catch (runErr) {
+      if (profileOn) recordTiming(hookId, elapsedMs(startNs));
       process.stderr.write(`[Hook] run() error for ${hookId}: ${runErr.message}\n`);
       process.stdout.write(raw);
     }
@@ -147,6 +192,7 @@ async function main() {
   }
 
   // Legacy path: spawn a child Node process for hooks without run() export
+  const legacyStartNs = profileOn ? process.hrtime.bigint() : null;
   const result = spawnSync(process.execPath, [scriptPath], {
     input: raw,
     encoding: 'utf8',
@@ -158,6 +204,7 @@ async function main() {
     cwd: process.cwd(),
     timeout: 30000
   });
+  if (profileOn) recordTiming(hookId, elapsedMs(legacyStartNs));
 
   writeLegacySpawnOutput(raw, result);
   if (result.stderr) process.stderr.write(result.stderr);

package/src/hooks/session-end.js

@@ -11,6 +11,7 @@
 
 const path = require('path');
 const fs = require('fs');
+const os = require('os');
 const {
   getSessionsDir,
   getDateString,
@@ -25,6 +26,52 @@ const {
   log
 } = require('../lib/utils');
 
+// Cap sidecar reads at 1 MB to prevent memory blow-up if the file grew
+// unexpectedly large. Mitigation for T-21-02 in the threat model.
+const MAX_TIMINGS_SIDECAR_BYTES = 1024 * 1024;
+
+/**
+ * Build a "## Hook Timings" markdown section by parsing a JSONL sidecar.
+ * Returns null if the sidecar is missing/empty/unreadable. Wrapped in
+ * try/catch by callers; this helper is best-effort and never throws.
+ */
+function buildHookTimingsSection(sidecarPath) {
+  try {
+    if (!sidecarPath || !fs.existsSync(sidecarPath)) return null;
+    const stat = fs.statSync(sidecarPath);
+    if (stat.size === 0 || stat.size > MAX_TIMINGS_SIDECAR_BYTES) return null;
+    const raw = fs.readFileSync(sidecarPath, 'utf8');
+    const grouped = new Map();
+    for (const line of raw.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      let row;
+      try { row = JSON.parse(trimmed); } catch { continue; }
+      if (!row || typeof row.hookId !== 'string') continue;
+      const id = row.hookId;
+      const dur = Number(row.durationMs) || 0;
+      const prev = grouped.get(id) || { calls: 0, totalMs: 0 };
+      prev.calls += 1;
+      prev.totalMs += dur;
+      grouped.set(id, prev);
+    }
+    if (grouped.size === 0) return null;
+    const rows = Array.from(grouped.entries())
+      .sort((a, b) => b[1].totalMs - a[1].totalMs)
+      .map(([id, s]) => `| ${id} | ${s.calls} | ${s.totalMs.toFixed(2)} | ${(s.totalMs / s.calls).toFixed(2)} |`);
+    return [
+      '## Hook Timings',
+      '',
+      '| Hook | Calls | Total (ms) | Avg (ms) |',
+      '|------|-------|------------|----------|',
+      ...rows,
+      ''
+    ].join('\n');
+  } catch {
+    return null;
+  }
+}
+
 const SUMMARY_START_MARKER = '<!-- ECC:SUMMARY:START -->';
 const SUMMARY_END_MARKER = '<!-- ECC:SUMMARY:END -->';
 const SESSION_SEPARATOR = '\n---\n';
@@ -178,11 +225,13 @@ function mergeSessionHeader(content, today, currentTime, metadata) {
 }
 
 async function main() {
-  // Parse stdin JSON to get transcript_path
+  // Parse stdin JSON to get transcript_path + session_id
   let transcriptPath = null;
+  let sessionIdFromStdin = null;
   try {
     const input = JSON.parse(stdinData);
     transcriptPath = input.transcript_path;
+    sessionIdFromStdin = input.session_id;
   } catch {
     // Fallback: try env var for backwards compatibility
     transcriptPath = process.env.CLAUDE_TRANSCRIPT_PATH;
@@ -260,6 +309,44 @@ async function main() {
     log(`[SessionEnd] Created session file: ${sessionFile}`);
   }
 
+  // Hook Timings summary -- best-effort. If a sidecar exists, summarise it
+  // into a "## Hook Timings" markdown section appended to the session file,
+  // then delete the sidecar. Failures are silent; never block session-end.
+  try {
+    const sessionId = (sessionIdFromStdin && String(sessionIdFromStdin).trim())
+      ? String(sessionIdFromStdin).trim()
+      : (process.env.CLAUDE_SESSION_ID && process.env.CLAUDE_SESSION_ID.trim()
+        ? process.env.CLAUDE_SESSION_ID.trim()
+        : null);
+    if (sessionId) {
+      const timingsDir = (process.env.CCP_HOOK_TIMINGS_DIR && process.env.CCP_HOOK_TIMINGS_DIR.trim())
+        ? process.env.CCP_HOOK_TIMINGS_DIR
+        : os.tmpdir();
+      const sidecarPath = path.join(timingsDir, `ccp-hook-timings-${sessionId}.json`);
+      const timingSection = buildHookTimingsSection(sidecarPath);
+      if (timingSection && fs.existsSync(sessionFile)) {
+        try {
+          const existing = readFile(sessionFile) || '';
+          // If a previous Hook Timings section exists, replace it; otherwise append.
+          let updated;
+          if (existing.includes('## Hook Timings')) {
+            updated = existing.replace(/## Hook Timings[\s\S]*?(?=\n## |\n# |$)/, timingSection + '\n');
+          } else {
+            updated = existing.endsWith('\n')
+              ? `${existing}\n${timingSection}\n`
+              : `${existing}\n\n${timingSection}\n`;
+          }
+          writeFile(sessionFile, updated);
+        } catch {
+          // ignore: never block on timing summary write failure
+        }
+        try { fs.unlinkSync(sidecarPath); } catch { /* ignore */ }
+      }
+    }
+  } catch {
+    // outer guard: timing summary must not affect session-end success
+  }
+
   process.exit(0);
 }
 

package/src/lib/hook-flags.js

@@ -24,6 +24,19 @@ function getHookProfile() {
   return VALID_PROFILES.has(raw) ? raw : 'standard';
 }
 
+/**
+ * Boolean toggle for per-hook timing instrumentation.
+ *
+ * Distinct from getHookProfile() (string profile selector). The timing toggle
+ * is read from CCP_HOOK_PROFILE === '1' (or ECC_HOOK_PROFILE === '1' for
+ * back-compat). Other values like 'standard' / 'minimal' / 'strict' do NOT
+ * enable timing — those are profile names handled by getHookProfile().
+ */
+function isProfilingEnabled() {
+  const raw = String(process.env.CCP_HOOK_PROFILE || process.env.ECC_HOOK_PROFILE || '').trim();
+  return raw === '1';
+}
+
 function getDisabledHookIds() {
   const raw = String(process.env.CCP_DISABLED_HOOKS || process.env.ECC_DISABLED_HOOKS || '');
   if (!raw.trim()) return new Set();
@@ -72,6 +85,7 @@ module.exports = {
   VALID_PROFILES,
   normalizeId,
   getHookProfile,
+  isProfilingEnabled,
   getDisabledHookIds,
   parseProfiles,
   isHookEnabled,

package/src/pilot/references/agent-contracts.md

@@ -0,0 +1,79 @@
+# Agent Contracts
+
+Completion markers and handoff schemas for all GSD agents. Workflows use these markers to detect agent completion and route accordingly.
+
+This doc describes what IS, not what should be. Casing inconsistencies are documented as they appear in agent source files.
+
+---
+
+## Agent Registry
+
+| Agent | Role | Completion Markers |
+|-------|------|--------------------|
+| gsd-planner | Plan creation | `## PLANNING COMPLETE` |
+| gsd-executor | Plan execution | `## PLAN COMPLETE`, `## CHECKPOINT REACHED` |
+| gsd-phase-researcher | Phase-scoped research | `## RESEARCH COMPLETE`, `## RESEARCH BLOCKED` |
+| gsd-project-researcher | Project-wide research | `## RESEARCH COMPLETE`, `## RESEARCH BLOCKED` |
+| gsd-plan-checker | Plan validation | `## VERIFICATION PASSED`, `## ISSUES FOUND` |
+| gsd-research-synthesizer | Multi-research synthesis | `## SYNTHESIS COMPLETE`, `## SYNTHESIS BLOCKED` |
+| gsd-debugger | Debug investigation | `## DEBUG COMPLETE`, `## ROOT CAUSE FOUND`, `## CHECKPOINT REACHED` |
+| gsd-roadmapper | Roadmap creation/revision | `## ROADMAP CREATED`, `## ROADMAP REVISED`, `## ROADMAP BLOCKED` |
+| gsd-ui-auditor | UI review | `## UI REVIEW COMPLETE` |
+| gsd-ui-checker | UI validation | `## ISSUES FOUND` |
+| gsd-ui-researcher | UI spec creation | `## UI-SPEC COMPLETE`, `## UI-SPEC BLOCKED` |
+| gsd-verifier | Post-execution verification | `## Verification Complete` (title case) |
+| gsd-integration-checker | Cross-phase integration check | `## Integration Check Complete` (title case) |
+| gsd-nyquist-auditor | Sampling audit | `## PARTIAL`, `## ESCALATE` (non-standard) |
+| gsd-security-auditor | Security audit | `## OPEN_THREATS`, `## ESCALATE` (non-standard) |
+| gsd-codebase-mapper | Codebase analysis | No marker (writes docs directly) |
+| gsd-assumptions-analyzer | Assumption extraction | No marker (returns `## Assumptions` sections) |
+| gsd-doc-verifier | Doc validation | No marker (writes JSON to `.planning/tmp/`) |
+| gsd-doc-writer | Doc generation | No marker (writes docs directly) |
+| gsd-advisor-researcher | Advisory research | No marker (utility agent) |
+| gsd-user-profiler | User profiling | No marker (returns JSON in analysis tags) |
+| gsd-intel-updater | Codebase intelligence analysis | `## INTEL UPDATE COMPLETE`, `## INTEL UPDATE FAILED` |
+
+## Marker Rules
+
+1. **ALL-CAPS markers** (e.g., `## PLANNING COMPLETE`) are the standard convention
+2. **Title-case markers** (e.g., `## Verification Complete`) exist in gsd-verifier and gsd-integration-checker -- these are intentional as-is, not bugs
+3. **Non-standard markers** (e.g., `## PARTIAL`, `## ESCALATE`) in audit agents indicate partial results requiring orchestrator judgment
+4. **Agents without markers** either write artifacts directly to disk or return structured data (JSON/sections) that the caller parses
+5. Markers must appear as H2 headings (`## `) at the start of a line in the agent's final output
+
+## Key Handoff Contracts
+
+### Planner -> Executor (via PLAN.md)
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| Frontmatter | Yes | phase, plan, type, wave, depends_on, files_modified, autonomous, requirements |
+| `<objective>` | Yes | What the plan achieves |
+| `<tasks>` | Yes | Ordered task list with type, files, action, verify, acceptance_criteria |
+| `<verification>` | Yes | Overall verification steps |
+| `<success_criteria>` | Yes | Measurable completion criteria |
+
+### Executor -> Verifier (via SUMMARY.md)
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| Frontmatter | Yes | phase, plan, subsystem, tags, key-files, metrics |
+| Commits table | Yes | Per-task commit hashes and descriptions |
+| Deviations section | Yes | Auto-fixed issues or "None" |
+| Self-Check | Yes | PASSED or FAILED with details |
+
+## Workflow Regex Patterns
+
+Workflows match these markers to detect agent completion:
+
+**plan-phase.md matches:**
+- `## RESEARCH COMPLETE` / `## RESEARCH BLOCKED` (researcher output)
+- `## PLANNING COMPLETE` (planner output)
+- `## CHECKPOINT REACHED` (planner/executor pause)
+- `## VERIFICATION PASSED` / `## ISSUES FOUND` (plan-checker output)
+
+**execute-phase.md matches:**
+- `## PHASE COMPLETE` (all plans in phase done)
+- `## Self-Check: FAILED` (summary self-check)
+
+> **NOTE:** `## PLAN COMPLETE` is the gsd-executor's completion marker but execute-phase.md does not regex-match it. Instead, it detects executor completion via spot-checks (SUMMARY.md existence, git commit state). This is intentional behavior, not a mismatch.