continuous-improvement 3.12.3 → 3.15.0

package/commands/workspace-surface-audit.md

@@ -1,77 +1,77 @@
----
-name: workspace-surface-audit
-description: "Audit workspace capabilities and recommend continuous-improvement-native skills, hooks, and workflows"
----
-
-# /workspace-surface-audit
-
-Audit the active repo, MCP servers, plugins, connectors, env surfaces, and harness setup. Returns a 5-section report with specific next moves.
-
-## Usage
-
-```
-/workspace-surface-audit
-```
-
-## What It Checks
-
-1. **Repo surface** — `package.json`, lockfiles, framework config, `.mcp.json`, `.claude/settings*.json`, `AGENTS.md`
-2. **Environment surface** — `.env*` files (key names only, no secrets)
-3. **Connected tools** — installed plugins, MCP servers, LSPs, app integrations
-4. **continuous-improvement surface** — existing skills, commands, hooks, agents
-
-## Output Format
-
-```
-=== Workspace Surface Audit ===
-
-## Current Surface
-- [What is usable right now]
-
-## Parity
-- [Where continuous-improvement matches or exceeds benchmarks]
-
-## Primitive-Only Gaps
-- [Tools exist, but continuous-improvement lacks clean operator skills]
-
-## Missing Integrations
-- [Capabilities not available yet]
-
-## Top 3-5 Next Moves
-1. [Concrete continuous-improvement-native addition]
-2. [Ordered by impact]
-```
-
-## Rules
-
-- **Never print secrets** — only provider names, capability names, file paths
-- **Prefer continuous-improvement** over generic "install another plugin" advice
-- **Organize by workflows**, not API brands
-- **Specific recommendations** — concrete enough to implement without another discovery pass
-
-## Example Output
-
-```
-## Current Surface
-- MCP: filesystem, github, playwright
-- Plugins: beginner, expert (continuous-improvement)
-- Env: STRIPE_API_KEY, FAL_KEY configured
-- Framework: Next.js 15, React 19, TypeScript
-
-## Parity
-- Continuous improvement: covered (native)
-- Testing discipline: covered (TDD workflows)
-
-## Primitive-Only Gaps
-- Stripe connected but no billing-operator skill
-- GitHub MCP available but no issue-triage workflow
-
-## Missing Integrations
-- No Linear connector detected
-- No Slack webhook configured
-
-## Top 3-5 Next Moves
-1. Create billing-operator skill (Stripe integration)
-2. Create github-ops workflow for issue triage
-3. Add Linear connector skill for project management
-```
+---
+name: workspace-surface-audit
+description: "Audit workspace capabilities and recommend continuous-improvement-native skills, hooks, and workflows"
+---
+
+# /workspace-surface-audit
+
+Audit the active repo, MCP servers, plugins, connectors, env surfaces, and harness setup. Returns a 5-section report with specific next moves.
+
+## Usage
+
+```
+/workspace-surface-audit
+```
+
+## What It Checks
+
+1. **Repo surface** — `package.json`, lockfiles, framework config, `.mcp.json`, `.claude/settings*.json`, `AGENTS.md`
+2. **Environment surface** — `.env*` files (key names only, no secrets)
+3. **Connected tools** — installed plugins, MCP servers, LSPs, app integrations
+4. **continuous-improvement surface** — existing skills, commands, hooks, agents
+
+## Output Format
+
+```
+=== Workspace Surface Audit ===
+
+## Current Surface
+- [What is usable right now]
+
+## Parity
+- [Where continuous-improvement matches or exceeds benchmarks]
+
+## Primitive-Only Gaps
+- [Tools exist, but continuous-improvement lacks clean operator skills]
+
+## Missing Integrations
+- [Capabilities not available yet]
+
+## Top 3-5 Next Moves
+1. [Concrete continuous-improvement-native addition]
+2. [Ordered by impact]
+```
+
+## Rules
+
+- **Never print secrets** — only provider names, capability names, file paths
+- **Prefer continuous-improvement** over generic "install another plugin" advice
+- **Organize by workflows**, not API brands
+- **Specific recommendations** — concrete enough to implement without another discovery pass
+
+## Example Output
+
+```
+## Current Surface
+- MCP: filesystem, github, playwright
+- Plugins: beginner, expert (continuous-improvement)
+- Env: STRIPE_API_KEY, FAL_KEY configured
+- Framework: Next.js 15, React 19, TypeScript
+
+## Parity
+- Continuous improvement: covered (native)
+- Testing discipline: covered (TDD workflows)
+
+## Primitive-Only Gaps
+- Stripe connected but no billing-operator skill
+- GitHub MCP available but no issue-triage workflow
+
+## Missing Integrations
+- No Linear connector detected
+- No Slack webhook configured
+
+## Top 3-5 Next Moves
+1. Create billing-operator skill (Stripe integration)
+2. Create github-ops workflow for issue triage
+3. Add Linear connector skill for project management
+```

package/hooks/companion-preference.mjs

@@ -12,11 +12,17 @@
  *                             (when installed) or the install hint (when not).
  *
  * Fail-open: any unexpected error reading stdin / parsing settings / probing
- * the filesystem → emit { decision: "allow" } and exit 0. The hook never
- * blocks on its own bugs.
+ * the filesystem → exit 0 with empty stdout (allow). The hook never blocks
+ * on its own bugs.
  *
  * Stdin  : JSON { tool_name, tool_input }
- * Stdout : JSON { decision: "allow" | "block", reason?: string }
+ * Stdout : empty on allow (no output = no opinion, the call proceeds); on
+ *          deny, the documented PreToolUse shape:
+ *          { hookSpecificOutput: { hookEventName: "PreToolUse",
+ *            permissionDecision: "deny", permissionDecisionReason } }
+ *          A bare { decision: "allow" } is not schema-valid for PreToolUse
+ *          (the deprecated enum is "approve" | "block") and surfaces as a
+ *          "Hook JSON output validation failed" error on every tool call.
  * Exit   : 0 always — decision lives in stdout, never in the exit code.
  *
  * OVERRIDES map must stay row-aligned with skills/superpowers.md
@@ -50,8 +56,20 @@ const OVERRIDES = {
         plugin: "oh-my-claudecode",
     },
 };
-function emitAndExit(d) {
-    process.stdout.write(`${JSON.stringify(d)}\n`);
+// Allow = empty stdout + exit 0. Emitting JSON here is wrong: PreToolUse has
+// no { decision: "allow" } shape, and the invalid output surfaces as a
+// per-tool-call "Hook JSON output validation failed" error in the client.
+function emitAllowAndExit() {
+    process.exit(0);
+}
+function emitDenyAndExit(reason) {
+    process.stdout.write(`${JSON.stringify({
+        hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            permissionDecision: "deny",
+            permissionDecisionReason: reason,
+        },
+    })}\n`);
     process.exit(0);
 }
 function readStdin() {
@@ -137,19 +155,19 @@ function main() {
         payload = JSON.parse(raw);
     }
     catch {
-        emitAndExit({ decision: "allow" });
+        emitAllowAndExit();
     }
     if (payload.tool_name !== "Skill") {
-        emitAndExit({ decision: "allow" });
+        emitAllowAndExit();
     }
     const skill = payload.tool_input?.skill;
     if (typeof skill !== "string" || skill.length === 0) {
-        emitAndExit({ decision: "allow" });
+        emitAllowAndExit();
     }
     const normalized = normalizeSkill(skill);
     const override = OVERRIDES[normalized];
     if (!override) {
-        emitAndExit({ decision: "allow" });
+        emitAllowAndExit();
     }
     const home = resolveHome();
     const mode = readMode(home);
@@ -166,25 +184,19 @@ function main() {
         // Shadow row: what companions-first would have done. This is the data
         // set that earns a future default-flip decision.
         writeTelemetry(home, { ...baseEvent, mode, action: "observation" });
-        emitAndExit({ decision: "allow" });
+        emitAllowAndExit();
     }
     if (mode === "companions-first") {
         process.stderr.write(`[continuous-improvement] companion_preference=companions-first → prefer \`${override.companion}\` over \`ci:${normalized}\`.\n`);
         writeTelemetry(home, { ...baseEvent, mode, action: "advisory" });
-        emitAndExit({ decision: "allow" });
+        emitAllowAndExit();
     }
     // strict-companions: always block; reason depends on install state.
     if (installed) {
         writeTelemetry(home, { ...baseEvent, mode, action: "block" });
-        emitAndExit({
-            decision: "block",
-            reason: `companion_preference=strict-companions: route to \`${override.companion}\` instead of \`ci:${normalized}\`. The CI fallback is suppressed by your setting.`,
-        });
+        emitDenyAndExit(`companion_preference=strict-companions: route to \`${override.companion}\` instead of \`ci:${normalized}\`. The CI fallback is suppressed by your setting.`);
     }
     writeTelemetry(home, { ...baseEvent, mode, action: "block-not-installed" });
-    emitAndExit({
-        decision: "block",
-        reason: `companion_preference=strict-companions: companion plugin \`${override.plugin}\` is not installed. Install with \`/plugin install ${override.plugin}@continuous-improvement\` or relax the setting to \`companions-first\` or \`ci-first\` in ~/.claude/settings.json.`,
-    });
+    emitDenyAndExit(`companion_preference=strict-companions: companion plugin \`${override.plugin}\` is not installed. Install with \`/plugin install ${override.plugin}@continuous-improvement\` or relax the setting to \`companions-first\` or \`ci-first\` in ~/.claude/settings.json.`);
 }
 main();

package/hooks/gateguard.mjs

@@ -3,7 +3,13 @@
  * Runtime PreToolUse gateguard hook.
  *
  * Stdin  : JSON { tool_name, tool_input }
- * Stdout : JSON { decision: "allow" | "block", reason?: string }
+ * Stdout : empty on allow (no output = no opinion, the call proceeds); on
+ *          deny, the documented PreToolUse shape:
+ *          { hookSpecificOutput: { hookEventName: "PreToolUse",
+ *            permissionDecision: "deny", permissionDecisionReason } }
+ *          A bare { decision: "allow" } is not schema-valid for PreToolUse
+ *          (the deprecated enum is "approve" | "block") and surfaces as a
+ *          "Hook JSON output validation failed" error on every tool call.
  * Exit   : 0 always (decision is in stdout, fail-open on parse error).
  *
  * Three-stage gate per skills/gateguard.md:
@@ -132,7 +138,7 @@ function buildMutatingFileReason(toolName, filePaths, stateFilePath) {
         "",
         "Then clear the gate and retry the same call. Either route works:",
         `  A. Bash (always works — run verbatim): node ${quotePath(CLEAR_CLI_PATH)} --state ${quotePath(stateFilePath)} ${quoted.join(" ")}`,
-        `  B. MCP tool (when the continuous-improvement server is connected): ci_gateguard_clear  {file_paths: [${quoted.join(", ")}]}`,
+        `  B. MCP tool (when the continuous-improvement server is connected): ci_gateguard_clear  {file_paths: [${quoted.join(", ")}], state_path: ${quotePath(stateFilePath)}}`,
         "  Both canonicalize paths — drive-letter case and separators don't matter.",
         "  (Harnesses that forward unknown tool params may instead retry the call with",
         "  `_gateguard_facts_presented: true`; Claude Code's strict schema rejects that, so use A or B.)",
@@ -151,13 +157,26 @@ function buildDestructiveBashReason(command) {
 }
 function buildCapReachedReason() {
     return [
-        `Gateguard session clearance cap reached (${MAX_CLEARED_FILES} distinct files).`,
-        "Start a new Claude Code session to reset the gate. The cap exists to bound",
-        "stuck-loop or rogue-agent clearance from compounding within a single session.",
+        `Gateguard clearance cap reached (${MAX_CLEARED_FILES} distinct files this session).`,
+        "The cap is per-session: start a new Claude Code session to reset it, or wait",
+        "for the state file to self-heal. It bounds stuck-loop or rogue-agent clearance",
+        "from compounding within one session without affecting your other sessions.",
     ].join("\n");
 }
-function emit(decision) {
-    process.stdout.write(`${JSON.stringify(decision)}\n`);
+// Allow = empty stdout + exit 0. Emitting JSON here is wrong: PreToolUse has
+// no { decision: "allow" } shape, and the invalid output surfaces as a
+// per-tool-call "Hook JSON output validation failed" error in the client.
+function emitAllow() {
+    process.exit(0);
+}
+function emitDeny(reason) {
+    process.stdout.write(`${JSON.stringify({
+        hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            permissionDecision: "deny",
+            permissionDecisionReason: reason,
+        },
+    })}\n`);
     process.exit(0);
 }
 function main() {
@@ -166,7 +185,7 @@ function main() {
         raw = readFileSync(0, "utf8");
     }
     catch {
-        emit({ decision: "allow" });
+        emitAllow();
         return;
     }
     let payload;
@@ -174,23 +193,26 @@ function main() {
         payload = JSON.parse(raw);
     }
     catch {
-        emit({ decision: "allow" }); // fail-open
+        emitAllow(); // fail-open
         return;
     }
     const toolName = typeof payload.tool_name === "string" ? payload.tool_name : "";
     const toolInput = payload.tool_input ?? {};
     const gate = classifyTool(toolName, toolInput);
     if (gate === "allow") {
-        emit({ decision: "allow" });
+        emitAllow();
         return;
     }
     if (gate === "destructive-bash") {
         const cmd = typeof toolInput.command === "string" ? toolInput.command : "";
-        emit({ decision: "block", reason: buildDestructiveBashReason(cmd) });
+        emitDeny(buildDestructiveBashReason(cmd));
         return;
     }
-    // mutating-file
-    const sessionDir = resolveSessionDir();
+    // mutating-file — scope state to THIS session so the clearance cap never
+    // bleeds across concurrent same-day sessions. session_id is the standard hook
+    // stdin field (see recall-briefing / observe-event); absent → legacy dir.
+    const sessionId = typeof payload.session_id === "string" ? payload.session_id : undefined;
+    const sessionDir = resolveSessionDir(sessionId);
     const stateFilePath = join(sessionDir, "gateguard-session.json");
     const state = loadState(sessionDir);
     const filePaths = extractFilePaths(toolInput);
@@ -199,12 +221,12 @@ function main() {
     const alreadyCleared = filePaths.length > 0 && filePaths.every((path) => isFileCleared(state, path));
     const newFileCount = countDistinctNewFilePaths(filePaths, state);
     if (!factsFlagged && !alreadyCleared) {
-        emit({ decision: "block", reason: buildMutatingFileReason(toolName, filePaths.length > 0 ? filePaths : [filePath], stateFilePath) });
+        emitDeny(buildMutatingFileReason(toolName, filePaths.length > 0 ? filePaths : [filePath], stateFilePath));
         return;
     }
     if (factsFlagged && !alreadyCleared) {
         if (isCapReached(state) || Object.keys(state.cleared_files).length + newFileCount > MAX_CLEARED_FILES) {
-            emit({ decision: "block", reason: buildCapReachedReason() });
+            emitDeny(buildCapReachedReason());
             return;
         }
         let nextState = state;
@@ -214,6 +236,6 @@ function main() {
         if (filePaths.length > 0)
             saveState(sessionDir, nextState);
     }
-    emit({ decision: "allow" });
+    emitAllow();
 }
 main();

package/hooks/hook-pack.mjs

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+/**
+ * Runtime PreToolUse enforcing-hook pack (v1).
+ *
+ * Stdin  : JSON { tool_name, tool_input: { command } }
+ * Stdout : empty on allow / warn (warn prints to stderr); on block, the
+ *          documented PreToolUse shape:
+ *          { hookSpecificOutput: { hookEventName: "PreToolUse",
+ *            permissionDecision: "deny", permissionDecisionReason } }
+ *          A bare { decision: "allow" } is not schema-valid for PreToolUse.
+ * Exit   : 0 always (decision is in stdout; fail-open on any error).
+ *
+ * Two gates over Bash git commands (pure logic in ../lib/hook-pack-gate.mjs):
+ *   - push-to-main : a direct `git push` to main/master/release-*
+ *   - commit-size  : a `git commit` staging more than COMMIT_FILE_LIMIT files
+ *
+ * Mode via CLAUDE_CI_HOOKPACK_GATE: "warn" (default) | "block" | "off".
+ *   warn  : print a one-line notice to stderr; never blocks.
+ *   block : emit the PreToolUse deny shape.
+ *   off   : no-op.
+ *
+ * Only `git push` / `git commit` commands spawn a git subprocess; every other
+ * Bash command and non-Bash tool returns immediately. No network. Fail-open.
+ */
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { COMMIT_FILE_LIMIT, classifyCommand, decide, evaluateCommitSize, evaluatePush, parseMode, } from "../lib/hook-pack-gate.mjs";
+function readStdinSync() {
+    try {
+        return readFileSync(0, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+function safeJsonParse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+function gitCurrentBranch() {
+    try {
+        const branch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        return branch || null;
+    }
+    catch {
+        return null;
+    }
+}
+function gitStagedCount() {
+    try {
+        const out = execFileSync("git", ["diff", "--cached", "--name-only"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return out.split(/\r?\n/).filter(Boolean).length;
+    }
+    catch {
+        return 0;
+    }
+}
+const ALLOW = { action: "allow", reason: "" };
+function compute() {
+    const mode = parseMode(process.env.CLAUDE_CI_HOOKPACK_GATE);
+    if (mode === "off")
+        return ALLOW;
+    const payload = safeJsonParse(readStdinSync());
+    if (!payload || typeof payload !== "object")
+        return ALLOW;
+    const obj = payload;
+    if (obj.tool_name !== "Bash")
+        return ALLOW;
+    const input = (obj.tool_input && typeof obj.tool_input === "object"
+        ? obj.tool_input
+        : {});
+    const command = typeof input.command === "string" ? input.command : "";
+    const kind = classifyCommand(command);
+    if (kind === "push") {
+        const res = evaluatePush(command, gitCurrentBranch());
+        return decide(mode, res.gated, `Direct push to protected branch "${res.branch}" — open a feature branch + PR instead.`);
+    }
+    if (kind === "commit") {
+        const res = evaluateCommitSize(command, gitStagedCount());
+        return decide(mode, res.gated, `This commit stages more than ${COMMIT_FILE_LIMIT} files — exceeds the one-concern limit. Split by layer, or set CLAUDE_CI_HOOKPACK_GATE=off for genuinely generated bulk.`);
+    }
+    return ALLOW;
+}
+function main() {
+    const decision = compute();
+    if (decision.action === "block") {
+        process.stdout.write(JSON.stringify({
+            hookSpecificOutput: {
+                hookEventName: "PreToolUse",
+                permissionDecision: "deny",
+                permissionDecisionReason: decision.reason,
+            },
+        }));
+    }
+    else if (decision.action === "warn") {
+        process.stderr.write(`[hook-pack] ${decision.reason}\n`);
+    }
+    process.exit(0);
+}
+main();