continuous-improvement 3.20.4 → 3.22.0

package/.claude-plugin/marketplace.json

@@ -7,8 +7,8 @@
   "plugins": [
     {
       "name": "continuous-improvement",
-      "description": "The persistent-memory and runtime-discipline layer for Claude Code. It remembers the corrections you already gave, grounds every edit in real facts before it lands, and — through the Mulahazah engine — turns each fix into a reusable instinct, so a lesson learned once is applied automatically next time with no re-teaching. Built on the 7 Laws of AI Agent Discipline (research, plan, verify, reflect, learn) and shipped as 27 bundled skills, instinct-aware hooks, an MCP toolset for recall and reflection, and a GitHub Action transcript linter that feeds real work history back into sharper instincts.",
-      "version": "3.20.4",
+      "description": "The persistent-memory and runtime-discipline layer for Claude Code. It remembers the corrections you already gave, grounds every edit in real facts before it lands, and — through the Mulahazah engine — turns each fix into a reusable instinct, so a lesson learned once is applied automatically next time with no re-teaching. Built on the 7 Laws of AI Agent Discipline (research, plan, verify, reflect, learn) and shipped as 28 bundled skills, instinct-aware hooks, an MCP toolset for recall and reflection, and a GitHub Action transcript linter that feeds real work history back into sharper instincts.",
+      "version": "3.22.0",
       "source": "./plugins/continuous-improvement",
       "author": {
         "name": "naimkatiman"

package/CHANGELOG.md

@@ -4,6 +4,29 @@ All notable changes to this skill are documented here.
 
 ---
 
+## [3.22.0] — 2026-08-02
+
+### Added
+
+- **`ci-reconcile`**: the `reconcile` ground-truth pass is now a command, not just prose. It spawns `git` argv with no shell — no bash, no coreutils, no `.git/`-relative path — so it behaves the same in PowerShell, cmd, Git Bash and WSL, and stays correct inside a linked worktree. `--json`, `--explain`, `--verify-push <branch>`, and `--snapshot` (field-compatible with `scripts/git-state-snapshot.sh`, plus `contentDrift` and `inProgress`). Exits `0` clear / `1` blocked / `2` not a git repository. (#289)
+- **`verify:reconcile-parity`**, the 16th `verify:all` invariant: a fenced code block in each of `skills/reconcile.md` and `commands/reconcile.md` must prescribe every probe in `GROUND_TRUTH_PROBES` verbatim, and no fenced block may reintroduce a retired form. Fenced-only, so prose stays free to explain *why* a command was retired. (#289)
+
+### Fixed
+
+- **`reconcile` no longer reports a false clean state at four boundaries.** Reproduced against real git: asking `git rev-list` for counts against `@{u}` exits **128** with `fatal: no upstream configured` rather than returning zeros; `git branch --show-current` prints an empty string and exits **0** on a detached HEAD, indistinguishable from a successful read; inside a linked worktree `.git` is a **file**, so listing a `.git/`-relative `MERGE_HEAD` exits **2** exactly as it does on a clean tree, meaning a real conflicted merge read as clean; and `git status` overstates drift on an `autocrlf` tree. The skill and command now document a portable probe for each, plus a compatibility matrix. (#289)
+- **Every `git-state` classifier fails closed.** Unparseable ahead/behind counts read as `unknown` (a blocker), never `even`. A failed `git ls-remote` reads as `unverified` — never `not-landed` and never `landed` — so a network failure can no longer be reported as either outcome. An unprobed in-progress marker reads as `unprobed`, never `absent`. An unparseable branch name never matches an expected one. (#289)
+- Verify-lint count prose corrected across `CLAUDE.md` (claimed 14 and omitted `landing-version`), `CONTRIBUTING.md` (13) and `docs/RELEASING.md` (12); the actual count was 15, now 16. (#289)
+
+## [3.21.0] — 2026-07-11
+
+### Added
+
+- **`/simplicity-review`**: a diff-scoped over-engineering reviewer. It reads the current diff and walks a reuse ladder (does it need to exist? already in the codebase? stdlib? native feature? one line?), reporting `GO` or `TRIM` trim findings without editing, with a safety carve-out that never flags input validation, data-loss handling, security, or accessibility. Review-only (Law 4), tier 2, routed into `proceed-with-the-recommendation`. Brings the bundle to 28 skills. (#285)
+
+### Changed
+
+- **`/production-readiness-review` gains a fifth blind reviewer**: a simplicity and over-engineering dimension that delegates to the `simplicity-review` skill, so the readiness gate now spans performance, security, UI/UX, test coverage, and simplicity. (#286)
+
 ## [3.17.0] — 2026-06-28
 
 ### Added

package/QUICKSTART.md

@@ -139,7 +139,7 @@ npx continuous-improvement install --mode expert
 npx continuous-improvement install --pack react   # optional: react | python | go | meta
 ```
 
-Preconditions: Node 18 / 20 / 22, plus Git Bash on Windows (`hooks/observe.sh` is a Bash script). WSL Bash launched from native Windows cannot resolve the `C:/...` hook paths written by the installer. See [README.md § Expert](README.md#expert--adds-mcp-server-observation-hooks-and-instinct-packs) for the full preconditions and troubleshooting matrix.
+Precondition: Node 18 / 20 / 22. Runtime hooks execute Node directly, so Git Bash and `jq` are not required. Re-run the installer once after upgrading to migrate legacy Bash hook rows. See [README.md § Expert](README.md#expert--adds-mcp-server-observation-hooks-and-instinct-packs) for the troubleshooting matrix.
 
 Verify with `/dashboard` — you should see instinct health and observation count.
 

package/README.md

@@ -137,7 +137,7 @@ V1 honest limitations: the runtime gate is honor-system once the agent flips `_g
 
 Pick this if you want the MCP tools (19 of them, including `ci_plan_init` / `ci_plan_status` for `task_plan.md`-style planning), the session hooks that feed Mulahazah, and starter packs.
 
-Preconditions: Node 18 / 20 / 22, plus Git Bash on Windows (`hooks/observe.sh` is a Bash script). WSL Bash launched from native Windows cannot resolve the `C:/...` hook paths written by the installer. **`jq` is no longer required**: as of v3.6.0, `observe.sh` prefers the Node observer (`bin/observe.mjs`) which writes the rich event schema natively without external dependencies. The bash thin-schema path is kept as a two-phase shim, so legacy installs that have not re-run `npx continuous-improvement install` since v3.5.x will still degrade silently without `jq` (`winget install jqlang.jq` on Windows, `brew install jq` on macOS, `apt install jq` on Debian/Ubuntu) — re-running the installer is the cleaner fix and removes the dependency entirely. See [CHANGELOG.md](CHANGELOG.md) `[3.6.0]` for the migration details.
+Precondition: Node 18 / 20 / 22. Observation and session hooks execute Node directly, so Git Bash and `jq` are not required. Re-run the installer once after upgrading to migrate installer-owned `observe.sh` and `session.sh` rows to the Node entrypoints.
 
 ```bash
 npx continuous-improvement install --mode expert
@@ -158,7 +158,7 @@ Three failures account for nearly every install support thread. Try them in orde
 | Symptom | Real cause | Fix |
 |---|---|---|
 | `/discipline` says "command not recognized" right after `/plugin install` | Slash commands load on session start; the marketplace did pick the plugin up | Quit and reopen Claude Code, then run `/discipline` again |
-| Expert mode hooks never fire on Windows | WSL Bash cannot resolve the native `C:/...` hook paths | Install Git Bash, ensure its `bin` directory precedes `C:\Windows\System32` on PATH, then re-run `npx continuous-improvement install --mode expert` |
+| Hooks report Bash path errors after upgrading | Stale installer-owned `observe.sh` or `session.sh` rows remain in `settings.json` | Re-run `npx continuous-improvement install --mode expert`; the installer migrates those rows to Node and preserves foreign hooks |
 | `/plugin marketplace add ...` returned nothing visible | Marketplace add was silent; the plugin is not yet selected | Run `/plugin install continuous-improvement@continuous-improvement` to select and activate it |
 
 If none of those apply, paste the output of `npx continuous-improvement install` into a GitHub issue — that surface logs every step.
@@ -270,7 +270,7 @@ Hooks capture every tool call. After ~20 observations Claude analyzes patterns a
 ## Slash commands
 
 <details>
-<summary><b>All 28 commands (Beginner gets every one)</b></summary>
+<summary><b>All 29 commands (Beginner gets every one)</b></summary>
 
 `/seven-laws` is the canonical reflect-and-learn command. `/continuous-improvement` is kept as an alias for backward compatibility — both run the same workflow.
 
@@ -290,6 +290,7 @@ Hooks capture every tool call. After ~20 observations Claude analyzes patterns a
 /audit                            Audit recent commits for real defects, confirm each before fixing
 /ship                             Single-defect fast path — reconcile, TDD fix, verify, one PR
 /production-readiness-review      Parallel readiness gate — severity-ranked punch-list (reports only)
+/simplicity-review                Judge the current diff for over-engineering (GO / TRIM, reports only)
 /handoff                          End-of-session compaction into mktemp brief for the next agent
 /recall                           BM25 search over past observations — "have I hit this before?"
 /discipline                       Quick reference card of the 7 Laws
@@ -305,7 +306,7 @@ Hooks capture every tool call. After ~20 observations Claude analyzes patterns a
 /swarm                            Fan-out coordination across parallel sub-agents
 ```
 
-All 28 ship in the marketplace bundle. The Beginner install gets all of them — with one caveat: `/learn-eval`, `/harvest`, and `/distill` only produce useful output once Mulahazah has accumulated observation history (~20 observations), so running them on day 1 returns an empty result, not a broken command. `/swarm` and `/release-train` are orchestration commands aimed at larger multi-agent or multi-PR work. In Expert (`npx`) mode, the installer mirrors the full set into `~/.claude/commands/` and additionally exposes the planning workflow through the MCP tools `ci_plan_init` (initialize `task_plan.md`, `findings.md`, `progress.md` in the project root) and `ci_plan_status` (summarize their current contents).
+All 29 ship in the marketplace bundle. The Beginner install gets all of them — with one caveat: `/learn-eval`, `/harvest`, and `/distill` only produce useful output once Mulahazah has accumulated observation history (~20 observations), so running them on day 1 returns an empty result, not a broken command. `/swarm` and `/release-train` are orchestration commands aimed at larger multi-agent or multi-PR work. In Expert (`npx`) mode, the installer mirrors the full set into `~/.claude/commands/` and additionally exposes the planning workflow through the MCP tools `ci_plan_init` (initialize `task_plan.md`, `findings.md`, `progress.md` in the project root) and `ci_plan_status` (summarize their current contents).
 
 </details>
 
@@ -313,7 +314,7 @@ All 28 ship in the marketplace bundle. The Beginner install gets all of them —
 
 ## Skills
 
-The plugin ships **27 skills** — 1 core + 1 featured + 6 tier-1 + 16 tier-2 + 3 always-bundled. Beginner install gets tier-1, featured, and the always-bundled companion; Expert adds tier-2, the MCP server, and observation hooks. Full catalog with per-skill descriptions, Law tagging, and drop-in single-file install: [docs/skills.md](docs/skills.md). Adding a 28th skill: [CONTRIBUTING.md § Evolution — adding a new skill](CONTRIBUTING.md#evolution--adding-a-new-skill).
+The plugin ships **28 skills** — 1 core + 1 featured + 6 tier-1 + 17 tier-2 + 3 always-bundled. Beginner install gets tier-1, featured, and the always-bundled companion; Expert adds tier-2, the MCP server, and observation hooks. Full catalog with per-skill descriptions, Law tagging, and drop-in single-file install: [docs/skills.md](docs/skills.md). Adding a 29th skill: [CONTRIBUTING.md § Evolution — adding a new skill](CONTRIBUTING.md#evolution--adding-a-new-skill).
 
 ---
 
@@ -356,7 +357,7 @@ Proof-format templates ship in [templates/](templates/): `release_receipt_templa
 
 - [QUICKSTART.md](QUICKSTART.md) — 2-minute setup
 - [SKILL.md](SKILL.md) — full 7 Laws spec
-- [docs/skills.md](docs/skills.md) — full 27-skill catalog
+- [docs/skills.md](docs/skills.md) — full 28-skill catalog
 - [examples/](examples/) — bug fix, feature build, refactor walkthroughs
 - [templates/insights-claude-md.md](templates/insights-claude-md.md) — paste-in CLAUDE.md blocks for verification discipline, environment notes, think-before-acting, and git/deploy workflow (sourced from the 28-day usage report)
 - [CONTRIBUTING.md](CONTRIBUTING.md) — architecture, repo internals, adding a new skill

package/bin/check-reconcile-parity.mjs

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+/**
+ * Reconcile-Parity Invariant Check
+ *
+ * The ground-truth git command set exists in three places at once: the runner
+ * (`bin/reconcile.mjs`), the skill (`skills/reconcile.md`) and the slash command
+ * (`commands/reconcile.md`). Prose copies drift — the `'@{u}'` Bash-quoting fix
+ * had to be applied by hand to both docs, and a portability fix applied to one
+ * copy leaves the other telling agents to run the broken form.
+ *
+ * `GROUND_TRUTH_PROBES` in src/lib/git-state.mts is the single source of truth.
+ * This lint asserts the docs still document exactly that set, and that neither
+ * doc has regressed to a command proven non-portable on 2026-08-02:
+ *
+ *   Side A — a fenced code block in each doc prescribes every probe in
+ *            GROUND_TRUTH_PROBES verbatim. Fenced blocks only: a probe named in
+ *            prose but dropped from the copyable block would otherwise pass
+ *            while the command an agent actually runs had lost it.
+ *   Side B — no fenced code block in either doc *prescribes* a retired form:
+ *              `ls .git/...`            (`.git` is a FILE in a linked worktree,
+ *                                        so the probe silently reports nothing)
+ *              `branch --show-current`  (empty stdout + exit 0 on a detached
+ *                                        HEAD is indistinguishable from success)
+ *            Only fenced blocks are scanned, so the prose stays free to explain
+ *            why each form was retired without tripping its own lint.
+ *   Side C — both docs document `rev-parse --git-path`, the worktree-correct way
+ *            to locate an in-progress-operation marker.
+ *
+ * Fail-closed: a missing file or an empty doc is a violation, not a silent pass.
+ *
+ * Usage:
+ *   node bin/check-reconcile-parity.mjs              # Check the current repo
+ *   node bin/check-reconcile-parity.mjs <repo-root>  # Check a specific repo root
+ *
+ * Exit codes:
+ *   0 — both docs match the shipped probe set and carry no retired form
+ *   1 — at least one drift
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { argv, cwd, exit } from "node:process";
+import { GROUND_TRUTH_PROBES } from "../lib/git-state.mjs";
+const DOCS = ["skills/reconcile.md", "commands/reconcile.md"];
+const RETIRED_FORMS = [
+    {
+        pattern: /\bls\s+[^\n`]*\.git\//,
+        label: "ls .git/<marker>",
+        why: "`.git` is a FILE inside a linked worktree, so this probe exits 2 exactly as it does on a clean tree — a real merge reads as no operation in progress",
+    },
+    {
+        pattern: /\bbranch\s+--show-current\b/,
+        label: "git branch --show-current",
+        why: "returns an empty string with exit 0 on a detached HEAD, which cannot be told apart from a successful read; use `symbolic-ref --quiet --short HEAD`",
+    },
+];
+const REQUIRED_SUBSTRINGS = [
+    {
+        needle: "rev-parse --git-path",
+        why: "the only worktree-correct way to locate MERGE_HEAD / rebase-merge / rebase-apply",
+    },
+];
+/**
+ * Normalize a doc or a command for comparison: collapse whitespace and drop the
+ * shell quoting docs add around `@{u}` refspecs. Returns "" for absent input.
+ */
+export function normalizeForMatch(text) {
+    if (typeof text !== "string")
+        return "";
+    return text.replace(/[`'"]/g, "").replace(/\s+/g, " ");
+}
+/** The literal command line a doc must contain for a probe, before normalization. */
+export function probeCommand(args) {
+    return `git ${args.join(" ")}`;
+}
+/**
+ * Concatenate the bodies of every fenced code block in `body`.
+ *
+ * Retired forms are only a defect when a doc *prescribes* them, so Side B scans
+ * fenced blocks alone — prose may name a retired command to explain it. Returns
+ * "" when the doc has no fenced block.
+ */
+export function fencedBlocks(body) {
+    const lines = body.split(/\r?\n/);
+    const collected = [];
+    let inside = false;
+    for (const line of lines) {
+        if (/^\s*```/.test(line)) {
+            inside = !inside;
+            continue;
+        }
+        if (inside)
+            collected.push(line);
+    }
+    return collected.join("\n");
+}
+/** Check one doc body against the shipped probe set. Returns [] when reconciled. */
+export function checkDoc(doc, body) {
+    if (body === null)
+        return [{ doc, kind: "missing-file", detail: "file does not exist" }];
+    if (body.trim().length === 0)
+        return [{ doc, kind: "empty", detail: "file is empty" }];
+    const violations = [];
+    const prescribed = fencedBlocks(body);
+    const prescribedHaystack = normalizeForMatch(prescribed);
+    // Side A scans fenced blocks only. A probe named in prose but absent from the
+    // copyable block would otherwise satisfy the check while the command an agent
+    // actually runs had silently dropped it.
+    for (const probe of GROUND_TRUTH_PROBES) {
+        const command = probeCommand(probe.args);
+        if (!prescribedHaystack.includes(normalizeForMatch(command))) {
+            violations.push({
+                doc,
+                kind: "missing-probe",
+                detail: `no fenced block prescribes probe "${probe.id}": ${command}`,
+            });
+        }
+    }
+    for (const retired of RETIRED_FORMS) {
+        if (retired.pattern.test(prescribed)) {
+            violations.push({
+                doc,
+                kind: "retired-form",
+                detail: `a fenced block still prescribes \`${retired.label}\` — ${retired.why}`,
+            });
+        }
+    }
+    const haystack = normalizeForMatch(body);
+    for (const required of REQUIRED_SUBSTRINGS) {
+        if (!haystack.includes(normalizeForMatch(required.needle))) {
+            violations.push({
+                doc,
+                kind: "missing-substring",
+                detail: `does not mention \`${required.needle}\` — ${required.why}`,
+            });
+        }
+    }
+    return violations;
+}
+/** Read every doc under `repoRoot` and collect violations across all of them. */
+export function checkRepo(repoRoot) {
+    return DOCS.flatMap((doc) => {
+        const path = join(repoRoot, doc);
+        const body = existsSync(path) ? readFileSync(path, "utf8") : null;
+        return checkDoc(doc, body);
+    });
+}
+function main() {
+    const repoRoot = argv[2] ?? cwd();
+    const violations = checkRepo(repoRoot);
+    if (violations.length === 0) {
+        console.log(`OK reconcile-parity: ${DOCS.length} doc(s) document all ${GROUND_TRUTH_PROBES.length} ground-truth probe(s), no retired forms.`);
+        return;
+    }
+    console.error(`FAIL reconcile-parity: ${violations.length} drift(s).`);
+    console.error("");
+    for (const violation of violations) {
+        console.error(`  ${violation.doc} — ${violation.detail}`);
+    }
+    console.error("");
+    console.error("Fix: GROUND_TRUTH_PROBES in src/lib/git-state.mts is the source of truth. Update the");
+    console.error("doc prose to match it (or change the probe set there first), then `npm run build` so the");
+    console.error("plugin mirrors regenerate.");
+    exit(1);
+}
+const invokedDirectly = argv[1] !== undefined && import.meta.url.endsWith(argv[1].replace(/\\/g, "/"));
+if (invokedDirectly || argv[1]?.endsWith("check-reconcile-parity.mjs")) {
+    main();
+}

package/bin/generate-plugin-manifests.mjs

@@ -147,6 +147,8 @@ async function writePluginBundle() {
         copyFileTo(join(REPO_ROOT, "bin", "mcp-server.mjs"), join(PLUGIN_BUNDLE_DIR, "bin", "mcp-server.mjs")),
         copyFileTo(join(REPO_ROOT, "bin", "observe.mjs"), join(PLUGIN_BUNDLE_DIR, "bin", "observe.mjs")),
         copyFileTo(join(REPO_ROOT, "bin", "backfill.mjs"), join(PLUGIN_BUNDLE_DIR, "bin", "backfill.mjs")),
+        copyFileTo(join(REPO_ROOT, "bin", "reconcile.mjs"), join(PLUGIN_BUNDLE_DIR, "bin", "reconcile.mjs")),
+        copyFileTo(join(REPO_ROOT, "lib", "git-state.mjs"), join(PLUGIN_BUNDLE_DIR, "lib", "git-state.mjs")),
         copyFileTo(join(REPO_ROOT, "bin", "gateguard-clear.mjs"), join(PLUGIN_BUNDLE_DIR, "bin", "gateguard-clear.mjs")),
         copyFileTo(join(REPO_ROOT, "lib", "gateguard-state.mjs"), join(PLUGIN_BUNDLE_DIR, "lib", "gateguard-state.mjs")),
         copyFileTo(join(REPO_ROOT, "lib", "plugin-metadata.mjs"), join(PLUGIN_BUNDLE_DIR, "lib", "plugin-metadata.mjs")),

package/bin/install.mjs

@@ -10,7 +10,7 @@
  *   npx continuous-improvement install --uninstall    # remove everything
  */
 import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from "node:fs";
-import { execFileSync as runFileSync, execSync } from "node:child_process";
+import { execSync } from "node:child_process";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -45,29 +45,25 @@ const SESSION_HOOK_TYPES = ["SessionStart", "SessionEnd"];
 // accidental overlap between HOOK_TYPES and SESSION_HOOK_TYPES never causes
 // a hook bucket to be processed twice.
 const ALL_HOOK_TYPES = Array.from(new Set([...HOOK_TYPES, ...SESSION_HOOK_TYPES]));
-// Our installer writes `bash ".../.claude/instincts/(observe|session).sh"`.
-// Older Windows installs sometimes stored the same command with backslashes in
-// the quoted path; those no-op because bash can't resolve them. We strip only
-// that installer-owned command shape so foreign hooks that merely mention
-// observe.sh/session.sh survive.
-const INSTALLER_OBSERVE_SESSION_COMMAND_RE = /^bash ".*[\\/]\.claude[\\/]instincts[\\/](?:observe|session)\.sh"$/;
-function isBrokenObserveOrSessionCommand(command) {
+// Match only installer-owned lifecycle commands. Bash rows are legacy and get
+// migrated on install; both legacy and current Node rows are removed on uninstall.
+const LEGACY_OBSERVE_SESSION_COMMAND_RE = /^bash ".*[\\/]\.claude[\\/]instincts[\\/](?:observe|session)\.sh"$/;
+const NODE_OBSERVE_SESSION_COMMAND_RE = /^node ".*[\\/]\.claude[\\/]instincts[\\/](?:bin[\\/]observe|session)\.mjs"$/;
+function isLegacyObserveOrSessionCommand(command) {
     if (typeof command !== "string")
         return false;
-    return command.includes("\\") && INSTALLER_OBSERVE_SESSION_COMMAND_RE.test(command);
+    return LEGACY_OBSERVE_SESSION_COMMAND_RE.test(command);
 }
-// Any installer-owned observe.sh / session.sh hook command, broken or clean.
-// Used by uninstall to drop both freshly-installed forward-slash hooks and any
-// stale legacy entries. Pairs with isBrokenObserveOrSessionCommand above.
 function isOurObserveOrSessionCommand(command) {
     if (typeof command !== "string")
         return false;
-    return INSTALLER_OBSERVE_SESSION_COMMAND_RE.test(command);
+    return LEGACY_OBSERVE_SESSION_COMMAND_RE.test(command) ||
+        NODE_OBSERVE_SESSION_COMMAND_RE.test(command);
 }
 function getHomeDir() {
     return process.env.HOME || process.env.USERPROFILE || homedir();
 }
-function toBashPath(filePath) {
+function toCommandPath(filePath) {
     return filePath.replace(/\\/g, "/");
 }
 function isInstallMode(value) {
@@ -84,28 +80,6 @@ function readJsonFile(filePath) {
         return null;
     }
 }
-// The observation hooks are Bash scripts, and the native Windows settings use
-// forward-slash drive paths such as C:/Users/... . Git Bash resolves that form;
-// WSL's C:\Windows\System32\bash.exe does not. Probe the real packaged hook path
-// instead of accepting any executable that happens to answer `bash --version`.
-function assertBashCanReadHookOnWindows() {
-    if (process.platform !== "win32")
-        return;
-    const hookSource = toBashPath(join(REPO_ROOT, "hooks", "observe.sh"));
-    try {
-        runFileSync("bash", ["-c", 'test -r "$CONTINUOUS_IMPROVEMENT_HOOK_SOURCE"'], {
-            env: { ...process.env, CONTINUOUS_IMPROVEMENT_HOOK_SOURCE: hookSource },
-            stdio: "ignore",
-        });
-    }
-    catch {
-        console.error(`  ✗ Install refused: Bash on PATH cannot read the Windows hook path ${hookSource}. ` +
-            "Install Git Bash and ensure its bin directory comes before " +
-            "C:\\Windows\\System32 on PATH, then reopen your shell and re-run. " +
-            "See README > Troubleshooting install.");
-        process.exit(1);
-    }
-}
 // The marketplace `/plugin install` path and this npx installer both write into
 // ~/.claude/. Running both duplicates hooks, commands, and skills. We cannot
 // fully resolve Claude Code's marketplace layout from here, so this is a loud
@@ -169,39 +143,26 @@ function setupMulahazah() {
     const globalDir = join(instinctsDir, "global");
     mkdirSync(globalDir, { recursive: true });
     console.log(`  ✓ Instincts dir → ${instinctsDir}/`);
-    const observeSrc = join(REPO_ROOT, "hooks", "observe.sh");
-    const observeDest = join(instinctsDir, "observe.sh");
-    if (existsSync(observeSrc)) {
-        copyFileSync(observeSrc, observeDest);
-        chmodSync(observeDest, 0o755);
-        console.log(`  ✓ observe.sh → ${observeDest}`);
-    }
-    // Node observer (Phase 1 of the two-phase hook). The bash shim above
-    // exec's this when `node` and the file are both present; otherwise it
-    // falls back to the in-bash thin-schema path. Layout under instinctsDir
-    // mirrors the repo's bin/ + lib/ structure so the relative import in
-    // observe.mjs (`../lib/observe-event.mjs`) resolves correctly.
+    // Layout mirrors bin/ + lib/ so observe.mjs's relative import resolves.
     const observerJsSrc = join(REPO_ROOT, "bin", "observe.mjs");
     const observeEventSrc = join(REPO_ROOT, "lib", "observe-event.mjs");
+    const observerJsDest = join(instinctsDir, "bin", "observe.mjs");
     if (existsSync(observerJsSrc) && existsSync(observeEventSrc)) {
         const binDir = join(instinctsDir, "bin");
         const libDir = join(instinctsDir, "lib");
         mkdirSync(binDir, { recursive: true });
         mkdirSync(libDir, { recursive: true });
-        const observerJsDest = join(binDir, "observe.mjs");
         const observeEventDest = join(libDir, "observe-event.mjs");
         copyFileSync(observerJsSrc, observerJsDest);
         copyFileSync(observeEventSrc, observeEventDest);
         console.log(`  ✓ Node observer → ${observerJsDest}`);
     }
-    if (INSTALL_MODE === "expert") {
-        const sessionSrc = join(REPO_ROOT, "hooks", "session.sh");
-        const sessionDest = join(instinctsDir, "session.sh");
-        if (existsSync(sessionSrc)) {
-            copyFileSync(sessionSrc, sessionDest);
-            chmodSync(sessionDest, 0o755);
-            console.log(`  ✓ session.sh → ${sessionDest}`);
-        }
+    const sessionSrc = join(REPO_ROOT, "hooks", "session.mjs");
+    const sessionDest = join(instinctsDir, "session.mjs");
+    if (existsSync(sessionSrc)) {
+        copyFileSync(sessionSrc, sessionDest);
+        chmodSync(sessionDest, 0o755);
+        console.log(`  ✓ Node session hook → ${sessionDest}`);
     }
     const commandsDir = join(home, ".claude", "commands");
     mkdirSync(commandsDir, { recursive: true });
@@ -213,7 +174,7 @@ function setupMulahazah() {
             console.log(`  ✓ /${commandFile.replace(".md", "")} command → ${commandDest}`);
         }
     }
-    patchClaudeSettings(observeDest);
+    patchClaudeSettings(observerJsDest);
     if (INSTALL_MODE === "expert") {
         setupMcpServer();
     }
@@ -276,6 +237,10 @@ function patchClaudeSettings(observePath) {
     if (!settings.hooks) {
         settings.hooks = {};
     }
+    const preserveSessionHooks = INSTALL_MODE === "expert" || SESSION_HOOK_TYPES.some((hookType) => {
+        const entries = settings.hooks?.[hookType];
+        return Array.isArray(entries) && entries.some((entry) => Array.isArray(entry?.hooks) && entry.hooks.some((hook) => isOurObserveOrSessionCommand(hook?.command)));
+    });
     // Strip broken legacy observe/session hooks at the hook level, not the entry
     // level. A single entry may carry a foreign command alongside a broken hook;
     // dropping the whole entry to remove the broken hook would also wipe the
@@ -294,7 +259,7 @@ function patchClaudeSettings(observePath) {
                 cleanedEntries.push(entry);
                 continue;
             }
-            const filteredHooks = entryHooks.filter((hook) => !isBrokenObserveOrSessionCommand(hook?.command));
+            const filteredHooks = entryHooks.filter((hook) => !isLegacyObserveOrSessionCommand(hook?.command));
             if (filteredHooks.length === entryHooks.length) {
                 cleanedEntries.push(entry);
                 continue;
@@ -313,7 +278,7 @@ function patchClaudeSettings(observePath) {
             changed = true;
         }
     }
-    const observeCommand = `bash "${toBashPath(observePath)}"`;
+    const observeCommand = `node "${toCommandPath(observePath)}"`;
     for (const hookType of HOOK_TYPES) {
         if (!Array.isArray(settings.hooks[hookType])) {
             settings.hooks[hookType] = [];
@@ -332,9 +297,9 @@ function patchClaudeSettings(observePath) {
             changed = true;
         }
     }
-    if (INSTALL_MODE === "expert") {
-        const sessionPath = join(getHomeDir(), ".claude", "instincts", "session.sh");
-        const sessionCommand = `bash "${toBashPath(sessionPath)}"`;
+    if (preserveSessionHooks) {
+        const sessionPath = join(getHomeDir(), ".claude", "instincts", "session.mjs");
+        const sessionCommand = `node "${toCommandPath(sessionPath)}"`;
         for (const hookType of SESSION_HOOK_TYPES) {
             if (!Array.isArray(settings.hooks[hookType])) {
                 settings.hooks[hookType] = [];
@@ -351,7 +316,7 @@ function patchClaudeSettings(observePath) {
     }
     if (changed) {
         writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
-        const hookTypes = INSTALL_MODE === "expert"
+        const hookTypes = preserveSessionHooks
             ? "PreToolUse/PostToolUse/SessionStart/SessionEnd"
             : "PreToolUse/PostToolUse";
         console.log(`  ✓ Patched ~/.claude/settings.json with ${hookTypes} hooks`);
@@ -387,7 +352,7 @@ function uninstallAll() {
             console.error(`  ✗ ${commandName}: ${getErrorMessage(error)}`);
         }
     }
-    for (const hookFile of ["observe.sh", "session.sh"]) {
+    for (const hookFile of ["observe.sh", "session.sh", "session.mjs"]) {
         const filePath = join(home, ".claude", "instincts", hookFile);
         if (!existsSync(filePath)) {
             continue;
@@ -617,10 +582,6 @@ function installNonClaudeTargets(targetIds) {
     for (const note of notes)
         console.log(`  ℹ ${note}`);
 }
-// A mixed target install can write non-Claude rule files below. Validate the
-// Claude hook runtime first so an incompatible Bash cannot leave a partial install.
-if (requestedTargets.includes("claude"))
-    assertBashCanReadHookOnWindows();
 const nonClaudeTargets = requestedTargets.filter((targetId) => targetId !== "claude");
 if (nonClaudeTargets.length > 0) {
     console.log("\ncontinuous-improvement multi-platform install\n");