litcodex-ai 0.3.6 → 0.3.8

package/node_modules/@litcodex/lit-loop/dist/loop-cli.js

@@ -9,7 +9,7 @@
 // store PLAN_MISSING→3, PLAN_CORRUPT→4, WRITE_FAILED→5; unknown subcommand/usage→1; bad args→2;
 // not-found→3. The `doctor` route delegates to the canonical M11 6-check doctor (A3 C5) and ALWAYS
 // resolves exit 0 (a diagnostic, never a gate).
-import { renderDoctorJson, renderDoctorText, runLoopDoctor } from "./loop-doctor.js";
+import { hookRegisteredInstalled, renderDoctorJson, renderDoctorText, runLoopDoctor } from "./loop-doctor.js";
 import { exitCodeForLoop, LitLoopError } from "./loop-errors.js";
 import { handleCheckpoint, handleCreate, handleRecordEvidence, handleRun, handleStatus, hasFlag, } from "./loop-handlers.js";
 import { resolveLoopScope } from "./state-store.js";
@@ -59,7 +59,10 @@ export async function loopCommand(argv, io, clock) {
     const scope = resolveLoopScope({ argv: rest, env: process.env });
     if (head === "doctor") {
         // A3 C5: delegate to the canonical M11 6-check doctor; ALWAYS exit 0 (diagnostic, not gate).
-        const report = await runLoopDoctor({ repoRoot, scope });
+        // Use the INSTALL-AWARE hook probe: a real `litcodex loop doctor` runs from an arbitrary cwd
+        // (no dev-tree manifest), so the pure repoRoot-only probe falsely warns "hook not registered".
+        // hookRegisteredInstalled also checks where the installed plugin actually lives (Codex cache).
+        const report = await runLoopDoctor({ repoRoot, scope }, { hookRegistered: (r) => hookRegisteredInstalled(r) });
         stdout.write(json ? renderDoctorJson(report) : renderDoctorText(report));
         return 0;
     }

package/node_modules/@litcodex/lit-loop/dist/loop-doctor.d.ts

@@ -12,6 +12,19 @@ export declare const TERMINAL_LEDGER_KINDS: {
  * catch (→ warn). Never executes any command from the manifest.
  */
 export declare function hookRegistered(repoRoot: string): Promise<boolean>;
+/**
+ * Install-aware hook probe (production default the global CLI injects). The dev-tree manifest
+ * `<repoRoot>/plugins/litcodex/hooks/hooks.json` ONLY exists when run from the repo; a real install
+ * (`litcodex loop doctor` from any cwd) has no such file, so the pure `hookRegistered` falsely warns
+ * "not registered". This trusts the repoRoot manifest when present (dev/test), and otherwise looks
+ * where the INSTALLED plugin actually lives: the Codex plugin cache
+ * `<CODEX_HOME>/plugins/cache/.../hooks/hooks.json` (the global CLI runs the bundled lit-loop, so the
+ * plugin's aggregate manifest only exists in that cache). Pure-read, never executes a command;
+ * `opts.codexHome` is injectable so tests stay hermetic.
+ */
+export declare function hookRegisteredInstalled(repoRoot: string, opts?: {
+    codexHome?: string;
+}): Promise<boolean>;
 /** Scan the ledger tail backward for the last terminal entry; null when none usable. */
 export declare function latestCheckpointFromLedger(entries: ReadonlyArray<Record<string, unknown>>): LoopCheckpointRef | null;
 /**

package/node_modules/@litcodex/lit-loop/dist/loop-doctor.js

@@ -11,7 +11,8 @@
 //
 // Imports flat siblings `./state-store.js`/`./state-paths.js`/`./loop-model.js`/`./loop-types.js`
 // (A3 C9 — NEVER `../state/...`). No `node:fs` import: existence-probing is M08 `statExists` only.
-import { readFile } from "node:fs/promises";
+import { readdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
 import { join } from "node:path";
 import { sanitizeId } from "./loop-doctor-render.js";
 import { summarizePlan } from "./loop-model.js";
@@ -52,6 +53,58 @@ export async function hookRegistered(repoRoot) {
     const parsed = JSON.parse(raw);
     return scanForCommand(parsed);
 }
+/** Read + scan a manifest at an absolute path; ENOENT/parse-error ⇒ false (never throws). */
+async function scanManifestAt(manifestAbs) {
+    try {
+        if (!(await statExists(manifestAbs)))
+            return false;
+        return scanForCommand(JSON.parse(await readFile(manifestAbs, "utf8")));
+    }
+    catch {
+        return false;
+    }
+}
+/** Walk `<cacheRoot>/<marketplace>/<plugin>/<version>/hooks/hooks.json` (bounded; a few installs). */
+async function scanCodexPluginCache(cacheRoot) {
+    const listDirs = async (dir) => {
+        try {
+            return await readdir(dir);
+        }
+        catch {
+            return [];
+        }
+    };
+    for (const mp of await listDirs(cacheRoot)) {
+        for (const plugin of await listDirs(join(cacheRoot, mp))) {
+            for (const ver of await listDirs(join(cacheRoot, mp, plugin))) {
+                if (await scanManifestAt(join(cacheRoot, mp, plugin, ver, "hooks", "hooks.json")))
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Install-aware hook probe (production default the global CLI injects). The dev-tree manifest
+ * `<repoRoot>/plugins/litcodex/hooks/hooks.json` ONLY exists when run from the repo; a real install
+ * (`litcodex loop doctor` from any cwd) has no such file, so the pure `hookRegistered` falsely warns
+ * "not registered". This trusts the repoRoot manifest when present (dev/test), and otherwise looks
+ * where the INSTALLED plugin actually lives: the Codex plugin cache
+ * `<CODEX_HOME>/plugins/cache/.../hooks/hooks.json` (the global CLI runs the bundled lit-loop, so the
+ * plugin's aggregate manifest only exists in that cache). Pure-read, never executes a command;
+ * `opts.codexHome` is injectable so tests stay hermetic.
+ */
+export async function hookRegisteredInstalled(repoRoot, opts) {
+    // 1. Dev tree — authoritative when present (preserves dev/test behavior and keeps the real-fs cache
+    //    walk below from ever running inside the repo's own hermetic unit tests).
+    const devManifest = join(repoRoot, ...HOOK_MANIFEST_RELPATH.split("/"));
+    if (await statExists(devManifest)) {
+        return scanManifestAt(devManifest);
+    }
+    // 2. Codex plugin cache — the real install context for a global-CLI `litcodex loop doctor`.
+    const codexHome = opts?.codexHome ?? (process.env["CODEX_HOME"]?.trim() || join(homedir(), ".codex"));
+    return scanCodexPluginCache(join(codexHome, "plugins", "cache"));
+}
 /** Recursively scan every string value under a `command` key for ALL three fragments. */
 function scanForCommand(node) {
     if (Array.isArray(node)) {

package/node_modules/@litcodex/lit-loop/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@litcodex/lit-loop",
-	"version": "0.3.6",
+	"version": "0.3.8",
 	"description": "LitCodex Lit-Loop runtime: durable repo-native multi-goal orchestration with embedded success criteria and observable evidence audit.",
 	"type": "module",
 	"bin": {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "litcodex-ai",
-	"version": "0.3.6",
+	"version": "0.3.8",
 	"description": "Codex loop harness installer. Run `npx litcodex-ai install` to set up the LitCodex Codex platform: the bare `lit` hook and the durable lit-loop runtime.",
 	"keywords": ["codex", "litcodex", "lit-loop", "ai-agents", "orchestration"],
 	"author": "LitCodex Authors",
@@ -15,7 +15,7 @@
 	},
 	"files": ["bin", "dist", "model-catalog.json", "README.md", "LICENSE"],
 	"dependencies": {
-		"@litcodex/lit-loop": "0.3.6"
+		"@litcodex/lit-loop": "0.3.8"
 	},
 	"bundledDependencies": ["@litcodex/lit-loop"],
 	"scripts": {