continuous-improvement 3.9.2 → 3.12.3

package/plugins/continuous-improvement/commands/harvest.md

@@ -65,7 +65,7 @@ Appended 12 instinct(s) to /Users/.../instincts/0af156594b39/instincts.jsonl
 If `tool_complete rows: 0`, the bash-fallback hook is active (no jq AND the Node observer is not on PATH) and only emits `tool_start` events. Two remediation paths:
 
 - **Install jq** — `winget install jqlang.jq` (Windows), `brew install jq` (macOS), `apt install jq` (Linux).
-- **Wire the Node observer** — ensure `hooks/bin/observe.mjs` is reachable from the active hook script.
+- **Wire the Node observer** — ensure the installed observer shim `instincts/bin/observe.mjs` (copied from `bin/observe.mjs`) sits beside the active hook script.
 
 Both are documented in the WARNING the classifier prints on a thin-schema host.
 

package/plugins/continuous-improvement/commands/proceed-with-the-recommendation.md

@@ -18,6 +18,26 @@ Invoke immediately after the agent has offered a numbered list of recommendation
 - "execute the recommendations"
 - "yes do it" / "all of them"
 
+## Fast-path: `--once` mode
+
+For a single-item, `safe`-tagged confirmation, append `--once` to skip P-MAG, Plan, Reflect, and the three-section close. Runs Phase 1 + Phase 3 + Phase 4 only and ends with one line: `Done: <item>. Verified: <check + output>.`
+
+Trigger phrases:
+
+- `/proceed-with-the-recommendation --once`
+- `/proceed --once`
+- "proceed once with that" / "just do that one"
+- Any standard trigger phrase plus the literal `--once` suffix
+
+Hard preconditions (the skill refuses `--once` and falls back to the full flow if any fail):
+
+- Recommendation list has exactly one item
+- Item is tagged `safe` (not `caution`, not `needs-approval`)
+- Item touches ≤3 files, ≤150 LOC, and none of `.github/`, `bin/`, `lib/`, `src/`, `third-party/`
+- Item is not destructive (no deploy, force-push, DB drop, secret rotation)
+
+Full behavior is defined in [`skills/proceed-with-the-recommendation.md`](../skills/proceed-with-the-recommendation.md) under § "Fast-Path: `--once` Mode".
+
 ## What happens
 
 1. **Pre-flight (Law 1)** — restate the recommendation list in original order, tag each `safe` / `caution` / `needs-approval`

package/plugins/continuous-improvement/commands/recall.md

@@ -0,0 +1,49 @@
+---
+name: recall
+description: Search past tool-call observations with BM25 ranking to answer "have I seen this before?" before re-deriving a fix or repeating a mistake. Enforces Law 1 (Research Before Executing).
+---
+
+# /recall — Episodic Search Over Past Sessions
+
+Search this project's observation history for relevant prior activity and return the most relevant past tool calls, ranked.
+
+## What it does
+
+Builds an in-memory BM25 index over `~/.claude/instincts/<project-hash>/observations.jsonl` and returns the top matches with redacted snippets, relevance scores, and timestamps. Backed by the `ci_recall` MCP tool (expert mode) and the `recall` skill.
+
+## How to invoke
+
+```
+ci_recall query="permission denied push"     # top 5 matches
+ci_recall query="jq command not found" k=3    # cap results
+ci_recall query="auth login" since=7d          # only the last 7 days
+```
+
+`since` accepts an ISO timestamp or a relative window: `7d`, `24h`, `30m`.
+
+## Output shape
+
+```
+## Recall: "permission denied push"
+
+2 match(es), most relevant first:
+
+- [2026-05-20T10:00:00Z] **Bash** (score 3.41)
+  …git push origin main  Permission denied: harness blocked direct push to main…
+- ...
+```
+
+## Privacy
+
+Snippets are passed through a secret redactor (AWS keys, JWT-shaped triplets, bearer tokens, KEY/SECRET/TOKEN/PASSWORD assignments, long hex strings) before display.
+
+## Notes
+
+- **Lexical, not semantic** — search with the vocabulary that actually appeared in the tool calls; try several phrasings if the first returns nothing.
+- Searches the full captured history, not just the recent window.
+
+## Pairs with
+
+- **`recall`** skill — the discipline this command runs.
+- **`continuous-improvement`** (core SKILL.md, Law 1 — Research Before Executing).
+- **`gateguard`** — recall a past failure before clearing a high-risk action.

package/plugins/continuous-improvement/commands/reconcile.md

@@ -0,0 +1,47 @@
+---
+name: reconcile
+description: Establish git ground truth (branch, status, stashes, worktrees, ahead/behind) before any mutation, halt on protected or destructive operations, and verify a push actually landed. Enforces Law 1 (Research Before Executing).
+---
+
+# /reconcile — Ground-Truth Git State Before You Touch It
+
+Read the repo's real state before acting on it: a branch that shifted, a push that did not land, or another session mid-merge will burn a whole session if you assume instead of check.
+
+## What it does
+
+Snapshots the full git state in one pass, detects a concurrent writer, classifies the upstream relationship, then acts only on the known state — stopping at every operation that is hard to reverse. Backed by the `reconcile` skill.
+
+## Establish ground truth
+
+```
+git branch --show-current
+git status --porcelain=v1                     # but trust git diff --stat for real drift (autocrlf)
+git rev-list --left-right --count @{u}...HEAD  # behind / ahead
+git stash list
+git worktree list
+ls .git/MERGE_HEAD .git/rebase-merge .git/rebase-apply 2>/dev/null  # in-progress op = another actor; do not race
+```
+
+## Then act, with gates
+
+```
+even      -> safe to branch (confirm local base == origin/base first)
+ahead     -> push or PR, AFTER the protected-op gate
+behind    -> git pull --ff-only
+diverged  -> rebase/merge deliberately; never blind --force
+```
+
+STOP for authorization before: pushing to a protected branch (this repo = feature branch + PR, never direct push to main), `--force` / `--force-with-lease`, `reset --hard`, `clean -fd`, or removing a dirty worktree. Never stage with `git add -A` on a Windows autocrlf tree (it commits phantom line-ending-only changes) — stage by explicit filename.
+
+## Verify the push landed
+
+```
+git ls-remote origin refs/heads/<branch>   # remote tip must equal local HEAD, else it did not land
+```
+
+## Pairs with
+
+- **`reconcile`** skill — the discipline this command runs.
+- **`gateguard`** / **`safety-guard`** — runtime + destructive-op guardrails.
+- **`recall`** — recall whether the same git op failed here before.
+- **`audit`** — the loop that often produces the fix `reconcile` then ships.

package/plugins/continuous-improvement/commands/seven-laws.md

@@ -1,16 +1,16 @@
----
-name: seven-laws
-description: "Brand-aligned alias for /continuous-improvement. Reflect on the current session, analyze observations for patterns, and show instinct status under the 7 Laws of AI Agent Discipline."
----
-
-# /seven-laws
-
-Brand-aligned alias for [`/continuous-improvement`](continuous-improvement.md). Both commands run the exact same three-step workflow under the 7 Laws of AI Agent Discipline:
-
-1. **Reflect** (Law 5) — generate a reflection block for this session.
-2. **Analyze** (Law 7) — process pending observations into instincts.
-3. **Status** — show all instincts for the project + global with confidence and current level.
-
-Run the workflow defined in [`continuous-improvement.md`](continuous-improvement.md). Subcommands `weekly` and `always-on` work identically.
-
-`/continuous-improvement` remains supported indefinitely for backward compatibility. Prefer `/seven-laws` going forward — it matches the brand and the SKILL.md spec.
+---
+name: seven-laws
+description: "Brand-aligned alias for /continuous-improvement. Reflect on the current session, analyze observations for patterns, and show instinct status under the 7 Laws of AI Agent Discipline."
+---
+
+# /seven-laws
+
+Brand-aligned alias for [`/continuous-improvement`](continuous-improvement.md). Both commands run the exact same three-step workflow under the 7 Laws of AI Agent Discipline:
+
+1. **Reflect** (Law 5) — generate a reflection block for this session.
+2. **Analyze** (Law 7) — process pending observations into instincts.
+3. **Status** — show all instincts for the project + global with confidence and current level.
+
+Run the workflow defined in [`continuous-improvement.md`](continuous-improvement.md). Subcommands `weekly` and `always-on` work identically.
+
+`/continuous-improvement` remains supported indefinitely for backward compatibility. Prefer `/seven-laws` going forward — it matches the brand and the SKILL.md spec.

package/plugins/continuous-improvement/commands/superpowers.md

@@ -7,9 +7,9 @@ description: "Law activator and dispatcher — route the task to the right Law-a
 
 `/superpowers` is **the dispatcher**, not a peer skill. It does not do work itself; it routes each user task to the correct Law-aligned specialist so the right discipline fires automatically instead of the agent skipping a step.
 
-The 7 Laws define *what* discipline must be applied. `/superpowers` decides *which specialist* enforces it for this specific task, across five sources installed from this marketplace.
+The 7 Laws define *what* discipline must be applied. `/superpowers` decides *which specialist* enforces it for this specific task, across four sources installed from this marketplace.
 
-## Routing surface (five sources)
+## Routing surface (four sources)
 
 | Source | Where it lives | Examples of what it routes to |
 |---|---|---|
@@ -17,7 +17,7 @@ The 7 Laws define *what* discipline must be applied. `/superpowers` decides *whi
 | `obra/superpowers` (Jesse Vincent) | vendored at `third-party/superpowers/`, pinned SHA `f2cbfbe` (v5.1.0) | `superpowers:brainstorming`, `:writing-plans`, `:executing-plans`, `:test-driven-development`, `:systematic-debugging`, `:requesting-code-review`, `:receiving-code-review`, `:verification-before-completion`, `:dispatching-parallel-agents`, `:using-git-worktrees`, `:finishing-a-development-branch`, `:subagent-driven-development`, `:writing-skills`, `:using-superpowers` |
 | `addyosmani/agent-skills` | vendored at `third-party/addy-agent-skills/`, pinned SHA `742dca5` (v1.0.0) | `spec-driven-development`, `source-driven-development`, `context-engineering`, `idea-refine`, `incremental-implementation`, `code-review-and-quality`, `code-simplification`, `security-and-hardening`, `debugging-and-error-recovery`, `performance-optimization`, `api-and-interface-design`, `frontend-ui-engineering`, `browser-testing-with-devtools`, `ci-cd-and-automation`, `deprecation-and-migration`, `documentation-and-adrs`, `git-workflow-and-versioning`, `planning-and-task-breakdown`, `shipping-and-launch` |
 | `ruflo-swarm` (ruvnet) | vendored at `third-party/ruflo-swarm/`, pinned SHA `addb5cd` (v0.2.0) | `swarm-init`, `monitor-stream`; `swarm_*` and `agent_*` MCP tools; `/swarm`, `/watch` |
-| `oh-my-claudecode` (Yeachan-Heo) | vendored at `third-party/oh-my-claudecode/`, pinned SHA `aacde3e` (v4.13.6) | 39 skills + 19 agents — `release`, `ultrawork`, `ultraqa`, `team`, `trace`, `visual-verdict`, `debug`, `deep-dive`, `deep-interview`, `autopilot`, `autoresearch`, plus a separate `ralph` (overlaps with our `/ralph` — see "Distinct variants" below) |
+| `oh-my-claudecode` (Yeachan-Heo) | vendored at `third-party/oh-my-claudecode/`, pinned SHA `aacde3e` (v4.13.6) | 38 skills + 19 agents — `release`, `ultrawork`, `ultraqa`, `team`, `trace`, `visual-verdict`, `debug`, `deep-dive`, `deep-interview`, `autopilot`, `autoresearch`, plus a separate `ralph` (overlaps with our `/ralph` — see "Distinct variants" below) |
 
 PM coverage (product-management skills) lives **outside** this marketplace. If you need it, install [`phuryn/pm-skills`](https://github.com/phuryn/pm-skills) separately via Claude Code's host marketplace; the dispatcher names it as a routing target without pre-resolving the namespace. See [docs/THIRD_PARTY.md § Routing in /superpowers](../docs/THIRD_PARTY.md#routing-in-superpowers).
 

package/plugins/continuous-improvement/commands/verify-install.md

@@ -0,0 +1,55 @@
+---
+name: verify-install
+description: Walk the post-install verification in one shot — confirm slash commands loaded, the gateguard runtime hook fires, and observation capture is recording — then print a single ✓ wired / ✗ missing line.
+---
+
+# /verify-install
+
+Replaces the manual post-install dance (restart, run `/discipline`, hand-write a
+hostile prompt, eyeball `/dashboard`) with one command that runs all three
+checks and reports a single line.
+
+Run the three checks **in order**. Do not skip a check because an earlier one
+passed — each proves a different layer.
+
+## Check 1 — slash commands loaded
+
+If this command is executing, the marketplace did pick the plugin up and the
+command registry loaded it. Record `commands: ✓`.
+
+If you are reading this file directly rather than running it as `/verify-install`,
+stop — the command is not registered. The fix is a Claude Code session restart
+(slash commands load on session start). Record `commands: ✗ (restart the session)`.
+
+## Check 2 — gateguard runtime hook fires
+
+The runtime gate ships as a PreToolUse hook (`hooks/gateguard.mjs`). Probe it:
+attempt to `Write` a throwaway file at a sandbox path (`./.ci-verify-install-probe.txt`
+with the text `probe`) **without presenting any research first**.
+
+- If the hook **blocks** the write with a fact-list reason — the runtime layer is
+  wired. Record `gateguard: ✓`. Do not retry the write; the block is the pass.
+- If the write **goes through** with no pause — the hook did not load. Record
+  `gateguard: ✗ (hooks/gateguard.mjs not wired — see README → Troubleshooting install)`.
+  Delete the probe file if it was created.
+
+## Check 3 — observation capture recording
+
+The observation hook appends one row per tool call to
+`~/.claude/instincts/<project-hash>/observations.jsonl`. Read that file (resolve
+`<project-hash>` from the current repo, or check `~/.claude/instincts/global/`).
+
+- If it exists and has at least one row — capture is recording. Record `observe: ✓`.
+- If it is missing or empty — record `observe: ✗ (observation hook not recording —
+  on Windows confirm Git Bash / WSL is installed, then re-run the installer)`.
+
+## Report
+
+Emit exactly one summary line, nothing else after it:
+
+- All three passed: `✓ wired — commands, gateguard, observe all confirmed.`
+- Any failed: `✗ <comma-separated failing checks with their fix hints>.`
+
+Do not claim "should be fine" for a check you could not actually run. If a check
+is genuinely unrunnable (e.g. no repo context for the project hash), mark it
+`unverified` with the reason rather than `✓`.

package/plugins/continuous-improvement/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/plugins/continuous-improvement/hooks/companion-preference.mjs

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+/**
+ * Runtime PreToolUse companion-preference hook.
+ *
+ * Reads ~/.claude/settings.json → continuous_improvement.companion_preference
+ * and enforces the Companion-Preference Override contract documented in
+ * skills/superpowers.md for `Skill` tool calls.
+ *
+ *   ci-first       (default): no-op, allow.
+ *   companions-first        : advisory stderr on mapped CI→companion pair; allow.
+ *   strict-companions       : block mapped CI route. Reason names the companion
+ *                             (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.
+ *
+ * Stdin  : JSON { tool_name, tool_input }
+ * Stdout : JSON { decision: "allow" | "block", reason?: string }
+ * Exit   : 0 always — decision lives in stdout, never in the exit code.
+ *
+ * OVERRIDES map must stay row-aligned with skills/superpowers.md
+ * § "Which rows the override affects" — drift will surface when the test
+ * suite or a follow-up audit walks the table against this map.
+ */
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const OVERRIDES = {
+    "tdd-workflow": {
+        companion: "superpowers:test-driven-development",
+        plugin: "superpowers",
+    },
+    "verification-loop": {
+        companion: "superpowers:verification-before-completion",
+        plugin: "superpowers",
+    },
+    "context-budget": {
+        companion: "agent-skills:context-engineering",
+        plugin: "agent-skills",
+    },
+    ralph: {
+        companion: "oh-my-claudecode:ultrawork",
+        plugin: "oh-my-claudecode",
+    },
+    "learn-eval": {
+        companion: "oh-my-claudecode:retrospective",
+        plugin: "oh-my-claudecode",
+    },
+};
+function emitAndExit(d) {
+    process.stdout.write(`${JSON.stringify(d)}\n`);
+    process.exit(0);
+}
+function readStdin() {
+    try {
+        return readFileSync(0, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+function readMode(home) {
+    try {
+        const raw = readFileSync(join(home, ".claude", "settings.json"), "utf8");
+        const settings = JSON.parse(raw);
+        const mode = settings.continuous_improvement?.companion_preference;
+        if (mode === "companions-first" || mode === "strict-companions")
+            return mode;
+        return "ci-first";
+    }
+    catch {
+        return "ci-first";
+    }
+}
+function isCompanionInstalled(home, plugin) {
+    try {
+        return existsSync(join(home, ".claude", "plugins", plugin));
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeSkill(skill) {
+    return skill.startsWith("ci:") ? skill.slice(3) : skill;
+}
+function resolveHome() {
+    return process.env.HOME ?? process.env.USERPROFILE ?? homedir();
+}
+function resolveProjectRoot() {
+    const fromEnv = process.env.CLAUDE_PROJECT_DIR;
+    if (fromEnv)
+        return fromEnv;
+    try {
+        const root = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        if (root)
+            return root;
+    }
+    catch {
+        // not in a git repo
+    }
+    return "global";
+}
+function telemetryPath(home) {
+    const hash = createHash("sha256")
+        .update(resolveProjectRoot())
+        .digest("hex")
+        .slice(0, 12);
+    return join(home, ".claude", "instincts", hash, "companion-preference.jsonl");
+}
+/**
+ * Append one JSONL line per hook decision. Wrapped to fail open: any write
+ * error (read-only dir, disk full, race on mkdir) is swallowed and the hook
+ * decision proceeds. Telemetry must never block tool calls.
+ */
+function writeTelemetry(home, event) {
+    try {
+        const path = telemetryPath(home);
+        const dir = join(path, "..");
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        appendFileSync(path, `${JSON.stringify(event)}\n`);
+    }
+    catch {
+        // fail-open — telemetry failure never changes the decision
+    }
+}
+function main() {
+    const raw = readStdin();
+    let payload;
+    try {
+        payload = JSON.parse(raw);
+    }
+    catch {
+        emitAndExit({ decision: "allow" });
+    }
+    if (payload.tool_name !== "Skill") {
+        emitAndExit({ decision: "allow" });
+    }
+    const skill = payload.tool_input?.skill;
+    if (typeof skill !== "string" || skill.length === 0) {
+        emitAndExit({ decision: "allow" });
+    }
+    const normalized = normalizeSkill(skill);
+    const override = OVERRIDES[normalized];
+    if (!override) {
+        emitAndExit({ decision: "allow" });
+    }
+    const home = resolveHome();
+    const mode = readMode(home);
+    const installed = isCompanionInstalled(home, override.plugin);
+    const baseEvent = {
+        ts: new Date().toISOString(),
+        hook: "companion-preference",
+        ci_skill: normalized,
+        companion: override.companion,
+        plugin: override.plugin,
+        companion_installed: installed,
+    };
+    if (mode === "ci-first") {
+        // 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" });
+    }
+    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" });
+    }
+    // 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.`,
+        });
+    }
+    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.`,
+    });
+}
+main();