continuous-improvement 3.23.0 → 3.25.0

package/bin/check-routing-targets.mjs

@@ -8,6 +8,13 @@
  *   (a) ships bundled at plugins/continuous-improvement/skills/<name>/SKILL.md, or
  *   (b) is declared in the root-level optional-companions.json file.
  *
+ * And, for the prefixes we vendor (oh-my-claudecode, superpowers, agent-skills,
+ * ruflo-swarm), that every declared target actually EXISTS in its snapshot under
+ * third-party/<snapshot>/skills/<name>/. Declaring a target only asserted intent;
+ * nothing checked the destination. oh-my-claudecode:ultrawork was declared after
+ * upstream deleted it, and oh-my-claudecode:retrospective was declared for months
+ * having never existed upstream at all — both with this check green.
+ *
  * Catches: a routing-table row that names a skill the bundle does not ship and
  * the maintainer has not declared as an optional companion. Without this gate,
  * such drift only surfaces at runtime when the orchestrator routes to a target
@@ -20,15 +27,60 @@
  *
  * Exit codes:
  *   0 — every routing target is accounted for (bundled or optional-declared)
- *   1 — at least one routing target is unaccounted for
+ *   1 — at least one routing target is unaccounted for, or a declared vendored
+ *       target has no directory in its snapshot
  */
-import { readdirSync, readFileSync, statSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { argv, cwd, exit } from "node:process";
 const ORCHESTRATOR_SKILL_PATH = "skills/proceed-with-the-recommendation.md";
 const OPTIONAL_COMPANIONS_PATH = "optional-companions.json";
 const PLUGIN_SKILLS_DIR = "plugins/continuous-improvement/skills";
 const SECTION_HEADER = "### Routing Table (with Inline Fallbacks)";
+/**
+ * Routing-target prefix -> vendored snapshot directory under third-party/.
+ *
+ * Declaring a target in optional-companions.json only asserted that we MEANT to
+ * route somewhere; nothing checked the destination existed. So when
+ * oh-my-claudecode 5.x deleted `ultrawork`, this check stayed green while the
+ * routing table named a skill upstream no longer ships (#308, fixed in #309) —
+ * and `oh-my-claudecode:retrospective` had been declared for months without ever
+ * existing upstream at all. For prefixes we vendor, the snapshot is ground truth.
+ *
+ * Prefixes NOT listed here (host built-ins, `frontend-design:`, `commit-commands:`)
+ * are deliberately unchecked: we have no local copy to check them against, and
+ * guessing would make this fail closed on things it cannot see.
+ */
+export const VENDORED_PREFIXES = {
+    "oh-my-claudecode": "oh-my-claudecode",
+    superpowers: "superpowers",
+    "agent-skills": "addy-agent-skills",
+    "ruflo-swarm": "ruflo-swarm",
+};
+/** Repo-relative skill path a vendored target must resolve to, or null if unvendored. */
+export function resolveVendoredSkillPath(target) {
+    const idx = target.indexOf(":");
+    if (idx < 0)
+        return null;
+    const dir = VENDORED_PREFIXES[target.slice(0, idx)];
+    if (!dir)
+        return null;
+    // Everything after the FIRST colon is the skill name, colons included.
+    return `third-party/${dir}/skills/${target.slice(idx + 1)}`;
+}
+/** Vendored targets with no directory in their snapshot. */
+export function findMissingVendoredTargets(repoRoot, targets) {
+    const missing = [];
+    for (const target of targets) {
+        const rel = resolveVendoredSkillPath(target);
+        if (rel === null)
+            continue;
+        const abs = join(repoRoot, rel);
+        if (!existsSync(abs))
+            missing.push({ target, expectedPath: abs });
+    }
+    return missing;
+}
 export function discoverBundledSkills(repoRoot) {
     const dir = join(repoRoot, PLUGIN_SKILLS_DIR);
     let entries;
@@ -119,19 +171,37 @@ export function checkRoutingTargets(repoRoot) {
             continue;
         drifts.push(t);
     }
+    // Declared is not the same as existing: for prefixes we vendor, the snapshot
+    // is ground truth. Checks the declared companion set, so a target that is
+    // declared but never referenced is still caught.
+    const missingVendored = findMissingVendoredTargets(repoRoot, optional);
     return {
         targets,
         drifts,
         bundledCount: bundled.size,
         optionalCount: optional.size,
+        missingVendored,
     };
 }
 function main() {
     const repoRoot = argv[2] ?? cwd();
-    const { targets, drifts, bundledCount, optionalCount } = checkRoutingTargets(repoRoot);
+    const { targets, drifts, bundledCount, optionalCount, missingVendored } = checkRoutingTargets(repoRoot);
+    if (missingVendored.length > 0) {
+        console.error(`FAIL routing-targets: ${missingVendored.length} declared target(s) do not exist in the vendored snapshot.\n`);
+        for (const m of missingVendored) {
+            console.error(`  - "${m.target}"`);
+            console.error(`      Declared in ${OPTIONAL_COMPANIONS_PATH}, but no directory at:`);
+            console.error(`      ${m.expectedPath}`);
+        }
+        console.error(`\nEither upstream removed or renamed the skill (retarget the routing rows and this ` +
+            `declaration), or the snapshot is stale (refresh it with ` +
+            `'node bin/refresh-third-party.mjs <name>'). Declaring a target does not make it exist.`);
+        exit(1);
+    }
     if (drifts.length === 0) {
         console.log(`OK routing-targets: all ${targets.length} routing target(s) accounted for ` +
-            `(${bundledCount} bundled skill(s), ${optionalCount} optional companion(s) declared).`);
+            `(${bundledCount} bundled skill(s), ${optionalCount} optional companion(s) declared, ` +
+            `every vendored target present in its snapshot).`);
         exit(0);
     }
     console.error(`FAIL routing-targets: ${drifts.length} unaccounted target(s) in ${ORCHESTRATOR_SKILL_PATH}.\n`);

package/bin/check-test-count.mjs

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+/**
+ * Test Count Check
+ *
+ * The landing page states the size of the test suite in two places: the spec
+ * strip ("1,271 / Tests in the suite") and the verification-loop panel
+ * ("tests      PASS  1271/1271"). Both are hand-maintained and both drifted
+ * twice in a single day on 2026-09-06 — 1,137 to 1,249 to 1,271 — because every
+ * PR that adds a test moves the real number and nothing guarded the claim. The
+ * skill and command counts are guarded (check-skill-count, check-command-count);
+ * this closes the same hole for tests.
+ *
+ * Unlike skills and commands, the real number cannot be derived from the
+ * filesystem: 45 test files generate cases in loops, so counting `it(` / `test(`
+ * declarations reports 1,066 against an actual 1,271. Node's runner has no
+ * collect-without-running mode either — filtering by name pattern reports the
+ * file count, not the test count. The only honest source is an actual run.
+ *
+ * So the check runs in two layers, and the docs are the source of truth:
+ *
+ *   1. Locally, inside `verify:all`, it asserts that every surface states the
+ *      SAME number. Fast, no suite run, and it catches the two-surfaces-disagree
+ *      case that a single-number edit produces.
+ *   2. In CI, after `npm test` has already run, `--actual-from <file>` parses
+ *      the runner's "tests N" summary out of the captured output and asserts the
+ *      claimed number equals reality. No second suite run.
+ *
+ * A claim that drifts from reality fails CI; two claims that drift apart fail
+ * locally. Fail-closed: a missing surface is a violation, not a silent pass.
+ *
+ * Usage:
+ *   node bin/check-test-count.mjs                        # Claims agree with each other
+ *   node bin/check-test-count.mjs --actual-from out.txt  # ...and with an actual run
+ *   node bin/check-test-count.mjs <repo-root> [--actual-from out.txt]
+ *
+ * Exit codes:
+ *   0 — every stated test count agrees (and matches the run, when supplied)
+ *   1 — a surface is missing, surfaces disagree, or a claim is stale
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { argv, cwd, exit } from "node:process";
+const LANDING = join("docs", "landing", "index.html");
+/** The spec strip cell: <span class="v">1,271</span><span class="k">Tests in the suite</span> */
+const STRIP_RE = /<span\b[^>]*class=["'][^"']*\bv\b[^"']*["'][^>]*>\s*([\d,]+)\s*<\/span>\s*<span\b[^>]*class=["'][^"']*\bk\b[^"']*["'][^>]*>\s*Tests in the suite\s*<\/span>/gi;
+/** The verification-loop panel line: tests      PASS  1271/1271 */
+const LADDER_RE = /^tests\s+PASS\s+([\d,]+)\/([\d,]+)\s*$/gim;
+/** The node test runner summary: "ℹ tests 1271" */
+const ACTUAL_RE = /^\W*tests\s+(\d+)\s*$/im;
+const toNumber = (raw) => Number(raw.replace(/,/g, ""));
+export function extractClaims(html) {
+    const strip = [...html.matchAll(STRIP_RE)].map((m) => toNumber(m[1]));
+    const ladder = [...html.matchAll(LADDER_RE)].flatMap((m) => [toNumber(m[1]), toNumber(m[2])]);
+    return { strip, ladder };
+}
+export function parseActualCount(runOutput) {
+    const m = ACTUAL_RE.exec(runOutput);
+    return m ? Number(m[1]) : null;
+}
+export function findViolations(claims, actual) {
+    const violations = [];
+    if (claims.strip.length === 0) {
+        violations.push(`the spec strip states no test count (expected a <span class="v">N</span> cell labelled "Tests in the suite").`);
+    }
+    if (claims.ladder.length === 0) {
+        violations.push(`the verification-loop ladder states no test count (expected a "tests      PASS  N/N" line).`);
+    }
+    if (violations.length > 0)
+        return violations;
+    const stated = [...claims.strip, ...claims.ladder];
+    const distinct = [...new Set(stated)].sort((a, b) => a - b);
+    if (distinct.length > 1) {
+        // Surfaces disagree with each other. Comparing a contested number to the run
+        // would emit a second, derivative violation; fix the disagreement first.
+        return [`the stated test counts disagree with each other: ${distinct.join(" vs ")}.`];
+    }
+    const claimed = distinct[0];
+    if (actual !== null && actual !== claimed) {
+        violations.push(`every surface states ${claimed} tests but the suite actually ran ${actual}.`);
+    }
+    return violations;
+}
+function main() {
+    const args = argv.slice(2);
+    const actualIdx = args.indexOf("--actual-from");
+    const actualPath = actualIdx === -1 ? null : args[actualIdx + 1];
+    if (actualIdx !== -1 && !actualPath) {
+        console.error("FAIL test-count: --actual-from needs a path to a captured test run.");
+        exit(1);
+    }
+    const repoRoot = args.find((a) => !a.startsWith("--") && a !== actualPath) ?? cwd();
+    let html;
+    try {
+        html = readFileSync(join(repoRoot, LANDING), "utf8");
+    }
+    catch {
+        console.error(`FAIL test-count: cannot read ${LANDING} at ${repoRoot}.`);
+        exit(1);
+    }
+    let actual = null;
+    if (actualPath) {
+        let runOutput;
+        try {
+            runOutput = readFileSync(actualPath, "utf8");
+        }
+        catch {
+            console.error(`FAIL test-count: cannot read the captured test run at ${actualPath}.`);
+            exit(1);
+        }
+        actual = parseActualCount(runOutput);
+        if (actual === null) {
+            console.error(`FAIL test-count: ${actualPath} has no "tests N" summary line, so the claim cannot be checked against a real run.`);
+            exit(1);
+        }
+    }
+    const claims = extractClaims(html);
+    const violations = findViolations(claims, actual);
+    if (violations.length === 0) {
+        const claimed = [...claims.strip, ...claims.ladder][0];
+        const against = actual === null ? "each other" : `each other and the actual run`;
+        console.log(`OK test-count: all ${claims.strip.length + claims.ladder.length} claim(s) state ${claimed} tests, matching ${against}.`);
+        exit(0);
+    }
+    console.error(`FAIL test-count: ${violations.length} issue(s) with the stated test count.`);
+    console.error("");
+    for (const v of violations)
+        console.error(`  ${v}`);
+    console.error("");
+    console.error(`Fix: run the suite, take the "tests N" total, and update both surfaces in ${LANDING} (the spec strip and the verification-loop panel).`);
+    exit(1);
+}
+const invokedDirectly = argv[1] !== undefined && import.meta.url.endsWith(argv[1].replace(/\\/g, "/"));
+if (invokedDirectly || argv[1]?.endsWith("check-test-count.mjs")) {
+    main();
+}

package/bin/companion-preference-status.mjs

@@ -19,9 +19,9 @@
  *   1 — argument parse error or unexpected runtime failure
  */
 import { execFileSync } from "node:child_process";
-import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
+import { hashProjectRoot } from "../lib/gateguard-state.mjs";
 import { join } from "node:path";
 import { argv, exit, stdout } from "node:process";
 const ACTIONS = [
@@ -99,10 +99,7 @@ function resolveProjectRoot() {
 }
 function defaultJsonlPath() {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? homedir();
-    const hash = createHash("sha256")
-        .update(resolveProjectRoot())
-        .digest("hex")
-        .slice(0, 12);
+    const hash = hashProjectRoot(resolveProjectRoot());
     return join(home, ".claude", "instincts", hash, "companion-preference.jsonl");
 }
 function parseJsonl(raw) {

package/bin/generate-plugin-manifests.mjs

@@ -4,6 +4,7 @@ import { basename, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { PACKAGE_NAME, PLUGIN_MODES, getPluginHooksConfig, getClaudePluginManifest, getClaudePluginMarketplaceManifest, getClaudeRepoMarketplaceManifest, getPluginManifest, } from "../lib/plugin-metadata.mjs";
 import { normalizeTier, parseSkillFrontmatter, renderBundledSkillsReadme, } from "../lib/skill-tiers.mjs";
+import { enforcementOf, lawOf, renderSkillCatalogHtml, } from "../lib/skill-catalog.mjs";
 const REPO_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
 const PLUGINS_DIR = join(REPO_ROOT, "plugins");
 const PLUGIN_BUNDLE_DIR = join(PLUGINS_DIR, PACKAGE_NAME);
@@ -67,6 +68,23 @@ async function writeBundledSkills() {
         });
     }
     await writeFile(join(targetSkillsDir, "README.md"), renderBundledSkillsReadme(skillsForReadme));
+    await writeSkillCatalogHtml(skillsForReadme);
+}
+/**
+ * Generate `docs/skill-catalog.html` from the same frontmatter that feeds the
+ * bundled README, so the catalog's Enforcement badges can never drift from the
+ * shipped file set. Guarded by `verify:generated`.
+ */
+async function writeSkillCatalogHtml(skills) {
+    const commandNames = new Set((await readdir(join(REPO_ROOT, "commands")))
+        .filter((f) => f.endsWith(".md") && f !== "README.md")
+        .map((f) => basename(f, ".md")));
+    const catalog = skills.map((skill) => ({
+        ...skill,
+        ...enforcementOf(skill.name, commandNames),
+        law: lawOf(skill.description),
+    }));
+    await writeFile(join(REPO_ROOT, "docs", "skill-catalog.html"), renderSkillCatalogHtml(catalog));
 }
 async function writePluginBundleReadme() {
     const readme = [
@@ -108,8 +126,7 @@ async function writePluginBundleReadme() {
         "- `tdd-workflow` — RED/GREEN/REFACTOR + 80% coverage gate",
         "- `workspace-surface-audit` — environment + capability audit",
         "- Tier-1/Tier-2 enforcement skills (`gateguard`, `verification-loop`,",
-        "  `safety-guard`, `token-budget-advisor`,",
-        "  `strategic-compact`, `wild-risa-balance`)",
+        "  `token-budget-advisor`, `strategic-compact`, `wild-risa-balance`)",
         "",
         "**Optional companions the orchestrator routes to (install separately if",
         "you want the dedicated skill instead of the inline fallback):**",
@@ -151,12 +168,14 @@ async function writePluginBundle() {
         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", "destructive-bash.mjs"), join(PLUGIN_BUNDLE_DIR, "lib", "destructive-bash.mjs")),
         copyFileTo(join(REPO_ROOT, "lib", "plugin-metadata.mjs"), join(PLUGIN_BUNDLE_DIR, "lib", "plugin-metadata.mjs")),
         copyFileTo(join(REPO_ROOT, "lib", "resolve-home-dir.mjs"), join(PLUGIN_BUNDLE_DIR, "lib", "resolve-home-dir.mjs")),
         copyFileTo(join(REPO_ROOT, "lib", "observe-event.mjs"), join(PLUGIN_BUNDLE_DIR, "lib", "observe-event.mjs")),
         copyFileTo(join(REPO_ROOT, "lib", "goal-state.mjs"), join(PLUGIN_BUNDLE_DIR, "lib", "goal-state.mjs")),
         copyFileTo(join(REPO_ROOT, "lib", "goal-drift-gate.mjs"), join(PLUGIN_BUNDLE_DIR, "lib", "goal-drift-gate.mjs")),
         copyFileTo(join(REPO_ROOT, "lib", "hook-pack-gate.mjs"), join(PLUGIN_BUNDLE_DIR, "lib", "hook-pack-gate.mjs")),
+        copyFileTo(join(REPO_ROOT, "lib", "config-guard-gate.mjs"), join(PLUGIN_BUNDLE_DIR, "lib", "config-guard-gate.mjs")),
         copyFileTo(join(REPO_ROOT, "lib", "recall-index.mjs"), join(PLUGIN_BUNDLE_DIR, "lib", "recall-index.mjs")),
         copyFileTo(join(REPO_ROOT, "lib", "recall-briefing.mjs"), join(PLUGIN_BUNDLE_DIR, "lib", "recall-briefing.mjs")),
         copyFileTo(join(REPO_ROOT, "lib", "skill-distill.mjs"), join(PLUGIN_BUNDLE_DIR, "lib", "skill-distill.mjs")),

package/bin/harvest-friction.mjs

@@ -33,7 +33,8 @@ import { createHash } from "node:crypto";
 import { appendFileSync, existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { argv, cwd, exit } from "node:process";
+import { argv, exit } from "node:process";
+import { hashProjectRoot, resolveProjectRoot } from "../lib/gateguard-state.mjs";
 const SUMMARY_TRUNCATE = 120;
 const DEDUP_KEY_INPUT_TRUNCATE = 120;
 /**
@@ -74,10 +75,13 @@ export function classifyObservation(row) {
         return build("env_issue", tool, summary, row.ts);
     }
     // permission_block — harness, sandbox, or OS denied the action.
+    // Do not match the substring "sandbox" alone: a plan file named
+    // slow-regime-gate-sandbox.md is not a denial (2026-08-22 false positive).
     if (/permission denied/i.test(out) ||
         /harness[- ]blocked/i.test(out) ||
-        /sandbox/i.test(out) ||
-        /operation not permitted/i.test(out)) {
+        /operation not permitted/i.test(out) ||
+        /\bblocked by (?:the )?sandbox\b/i.test(out) ||
+        /\bsandbox(?:ed)?[- ](?:denied|blocked|restrict(?:ed|ion)|violation)\b/i.test(out)) {
         return build("permission_block", tool, summary, row.ts);
     }
     // wrong_approach — agent acted on stale state. The "file changed since last
@@ -219,11 +223,9 @@ export function harvest(observationsPath, instinctsPath) {
     };
 }
 function defaultProjectHash() {
-    // Mirror the bash hook's hashing rule: sha256(project_root) → first 12 hex chars.
-    // Keeps the CLI compatible with whatever directory the bash hook was already
-    // populating, without re-implementing project-root detection here.
-    const root = cwd();
-    return createHash("sha256").update(root).digest("hex").slice(0, 12);
+    // Same root + canonical hash as observe/gateguard so `harvest-friction` from
+    // this repo reads the bucket the hook writes (C:/ vs c:/ vs cwd backslashes).
+    return hashProjectRoot(resolveProjectRoot());
 }
 function main() {
     const args = argv.slice(2);

package/bin/install.mjs

@@ -10,12 +10,11 @@
  *   npx continuous-improvement install --uninstall    # remove everything
  */
 import { chmodSync, copyFileSync, existsSync, lstatSync, mkdtempSync, mkdirSync, readFileSync, realpathSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
-import { execSync } from "node:child_process";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join, relative, sep } from "node:path";
 import { fileURLToPath } from "node:url";
-import { createHash } from "node:crypto";
 import { PACKAGE_NAME, VERSION, getToolNames } from "../lib/plugin-metadata.mjs";
+import { hashProjectRoot, resolveProjectRoot } from "../lib/gateguard-state.mjs";
 import { TARGET_IDS, planTargetWrites, resolveTargets } from "../lib/install-targets.mjs";
 import { evaluateUpdateCheck, fetchLatestNpmVersion, isThrottled, pendingNotice, } from "../lib/version-check.mjs";
 const __filename = fileURLToPath(import.meta.url);
@@ -674,19 +673,10 @@ Examples:
 `);
 }
 function getProjectHashSync() {
-    try {
-        // No shell redirect — `2>/dev/null` breaks under cmd.exe (tries to open a
-        // file literally named /dev/null); ignore stderr via stdio instead.
-        const root = execSync("git rev-parse --show-toplevel", {
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "ignore"],
-        }).trim();
-        const hash = createHash("sha256").update(root).digest("hex").slice(0, 12);
-        return { root, hash };
-    }
-    catch {
+    const root = resolveProjectRoot();
+    if (root === "global")
         return { root: "global", hash: "global" };
-    }
+    return { root, hash: hashProjectRoot(root) };
 }
 const args = process.argv.slice(2);
 const command = args[0];

package/bin/mcp-server.mjs

@@ -16,12 +16,11 @@ import { homedir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
-import { createHash } from "node:crypto";
 import { PACKAGE_NAME, VERSION, getToolDefinitions, isPluginMode, } from "../lib/plugin-metadata.mjs";
 import { formatDriftReport, parseGoalFromPlan, scoreObservations, } from "../lib/goal-state.mjs";
 import { buildIndex, formatRecallHits, parseSince, query as queryRecall, } from "../lib/recall-index.mjs";
 import { draftFromCandidate, draftFromWorkflowRun, extractTrajectories, findCandidates, formatCandidates, serializeDraft, workflowRunFromObservations, } from "../lib/skill-distill.mjs";
-import { MAX_CLEARED_FILES, canonicalizeFileKey, clearFiles, resolveInstinctsRoot, resolveSessionDir, } from "../lib/gateguard-state.mjs";
+import { MAX_CLEARED_FILES, canonicalizeFileKey, clearFiles, hashProjectRoot, resolveInstinctsRoot, resolveProjectRoot, resolveSessionDir, } from "../lib/gateguard-state.mjs";
 function getHomeDir() {
     return process.env.HOME || process.env.USERPROFILE || homedir();
 }
@@ -93,14 +92,10 @@ const modeIndex = args.indexOf("--mode");
 const requestedMode = args[modeIndex + 1];
 const MODE = isPluginMode(requestedMode) ? requestedMode : "beginner";
 function getProjectHash() {
-    try {
-        const root = execSync("git rev-parse --show-toplevel 2>/dev/null", { encoding: "utf8" }).trim();
-        const hash = createHash("sha256").update(root).digest("hex").slice(0, 12);
-        return { root, hash, name: basename(root) };
-    }
-    catch {
+    const root = resolveProjectRoot();
+    if (root === "global")
         return { root: "global", hash: "global", name: "global" };
-    }
+    return { root, hash: hashProjectRoot(root), name: basename(root) };
 }
 function readInstincts(projectHash) {
     const instincts = [];

package/bin/observe.mjs

@@ -16,10 +16,10 @@
 //
 // See docs/plans/2026-05-05-node-observer-rich-schema.md for the full design.
 import { execFileSync } from "node:child_process";
-import { createHash } from "node:crypto";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, join } from "node:path";
+import { canonicalizeProjectRoot, hashProjectRoot } from "../lib/gateguard-state.mjs";
 import { parseHookPayload, summariseInput, summariseOutput } from "../lib/observe-event.mjs";
 const ROTATION_LINE_THRESHOLD = 10_000;
 const ARCHIVE_RETENTION = 10;
@@ -40,8 +40,8 @@ function runObserver() {
     const payload = parseHookPayload(raw);
     if (!payload)
         return;
-    const projectRoot = resolveProjectRoot();
-    const projectHash = createHash("sha256").update(projectRoot).digest("hex").slice(0, 12);
+    const projectRoot = canonicalizeProjectRoot(resolveProjectRoot());
+    const projectHash = hashProjectRoot(projectRoot);
     const projectName = basename(projectRoot.replace(/\.git$/, ""));
     const instinctsDir = join(getHomeDir(), ".claude", "instincts");
     const projectDir = join(instinctsDir, projectHash);