fullcourtdefense-cli 1.26.3 → 1.26.5

package/dist/verdictIpc.d.ts

@@ -1,82 +1,19 @@
 /**
- * Daemon verdict IPC — the resident-agent pattern real endpoint products use
- * (one resident process; per-event interceptors are thin clients that ask it
- * over local IPC), applied to the IDE hook path.
+ * Daemon verdict IPC — SERVER side (runs inside the resident daemon).
  *
- * Why: every IDE hook event spawns a fresh Node process. The spawn itself is
- * unavoidable (the IDE invokes a command), but everything AFTER it — config
- * parse, credential resolution, bundle read, snapshot load, policy evaluation,
- * possible network — used to repeat per event. The daemon is already resident
- * with all of that warm in memory, so the spawned hook becomes a THIN CLIENT:
- * it forwards `{args, stdin}` over a named pipe (Windows) / Unix domain socket
- * and prints the verdict the daemon computed in single-digit milliseconds.
+ * The resident-agent pattern real endpoint products use: one resident process;
+ * per-event interceptors are thin clients that ask it over local IPC. The
+ * daemon is already resident with config, credentials, bundle, and snapshot
+ * warm in memory, so a spawned hook becomes a THIN CLIENT that forwards
+ * `{args, stdin}` over a named pipe (Windows) / Unix domain socket and prints
+ * the verdict the daemon computed in single-digit milliseconds.
  *
- * Fallback contract: ANY failure — pipe missing, handshake error, slow or
- * busy daemon (response cap ~2.5s) — makes the hook silently fall back to its
- * full local evaluation, identical to before this feature existed. Local
- * re-evaluation after a partial daemon evaluation is safe: verdict
- * computation is read-mostly (worst case a duplicate telemetry event), and
- * enforcement is never weakened by evaluating twice. The cap guarantees a
- * busy daemon (blocking schtasks call, GC pause) can never make a hook
- * SLOWER than the pre-IPC status quo.
- *
- * Security: named pipes are reachable by other local users by default, so the
- * server requires a per-boot random token stored under ~/.fullcourtdefense
- * (user-profile ACL). A client that cannot read the token cannot get verdicts.
- * The protocol is line-delimited JSON — one request line, one response line.
- */
-export declare const VERDICT_IPC_PROTOCOL_VERSION = 1;
-export interface VerdictRequest {
-    v: number;
-    token: string;
-    /** HookArgs as parsed by the CLI entry (all-string values). */
-    args: Record<string, string | undefined>;
-    /** Raw stdin payload exactly as the IDE piped it (BOM already stripped). */
-    stdin: string;
-    /**
-     * Client's `Date.now()` at hook start, so the daemon-written telemetry event
-     * carries the wall time the DEVELOPER waited (process spawn + pipe + verdict),
-     * not just the daemon's own evaluation slice. Optional on purpose: during a
-     * staged rollout an old client omits it (daemon falls back to its own clock)
-     * and an old daemon ignores it — same-machine clock, so no skew.
-     */
-    t0?: number;
-}
-export interface VerdictResponse {
-    v: number;
-    /** Present on evaluation success. */
-    stdout?: string;
-    stderr?: string;
-    exitCode?: number;
-    /** Present when the daemon could not evaluate — client falls back locally. */
-    error?: string;
-}
-/** Result of a client attempt. Anything but 'verdict' → evaluate locally. */
-export interface VerdictClientResult {
-    outcome: 'verdict' | 'unavailable';
-    stdout?: string;
-    stderr?: string;
-    exitCode?: number;
-    detail?: string;
-}
-export declare function verdictTokenFile(): string;
-export declare function verdictPipePath(): string;
-/**
- * Ask the resident daemon for a verdict. Bounded hard: connect budget ~250ms
- * (a missing pipe fails in <1ms with ENOENT — the common daemon-down case
- * costs nothing), response capped at ~2.5s. A verdict that legitimately needs
- * longer than that (synchronous approval wait, no-cache gate call) is exactly
- * the case where the IPC saves nothing — the local evaluation path handles it
- * with its own bounded waits. Never throws.
- *
- * Burst behavior: an agent firing many commands at once (docker compose +
- * exec + build in flight together) means many hooks connecting to the ONE
- * pipe simultaneously — some connects lose the race (EBUSY / connect
- * timeout) while the daemon is demonstrably alive (token present). Those
- * get ONE short jittered retry; hard failures (ENOENT stale pipe, refused)
- * still fall back to local evaluation instantly.
+ * The client half lives in `verdictIpcClient.ts` — a Node-builtins-only leaf
+ * shared with the slim hook entry (`hookSlim.ts`), whose module graph must
+ * stay tiny because it loads on every IDE hook event. This file re-exports
+ * the client API so existing imports keep working.
  */
-export declare function requestDaemonVerdict(args: Record<string, string | undefined>, stdin: string, responseTimeoutMs?: number, clientStartedAt?: number): Promise<VerdictClientResult>;
+export { VERDICT_IPC_PROTOCOL_VERSION, VerdictRequest, VerdictResponse, VerdictClientResult, requestDaemonVerdict, verdictPipePath, verdictTokenFile, } from './verdictIpcClient';
 export interface VerdictServerHandle {
     close(): void;
 }

package/dist/verdictIpc.js

@@ -33,163 +33,33 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VERDICT_IPC_PROTOCOL_VERSION = void 0;
-exports.verdictTokenFile = verdictTokenFile;
-exports.verdictPipePath = verdictPipePath;
-exports.requestDaemonVerdict = requestDaemonVerdict;
+exports.verdictTokenFile = exports.verdictPipePath = exports.requestDaemonVerdict = exports.VERDICT_IPC_PROTOCOL_VERSION = void 0;
 exports.startVerdictServer = startVerdictServer;
 const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs"));
 const net = __importStar(require("net"));
-const os = __importStar(require("os"));
-const path = __importStar(require("path"));
 const telemetry_1 = require("./telemetry");
+const verdictIpcClient_1 = require("./verdictIpcClient");
 /**
- * Daemon verdict IPC — the resident-agent pattern real endpoint products use
- * (one resident process; per-event interceptors are thin clients that ask it
- * over local IPC), applied to the IDE hook path.
+ * Daemon verdict IPC — SERVER side (runs inside the resident daemon).
  *
- * Why: every IDE hook event spawns a fresh Node process. The spawn itself is
- * unavoidable (the IDE invokes a command), but everything AFTER it — config
- * parse, credential resolution, bundle read, snapshot load, policy evaluation,
- * possible network — used to repeat per event. The daemon is already resident
- * with all of that warm in memory, so the spawned hook becomes a THIN CLIENT:
- * it forwards `{args, stdin}` over a named pipe (Windows) / Unix domain socket
- * and prints the verdict the daemon computed in single-digit milliseconds.
+ * The resident-agent pattern real endpoint products use: one resident process;
+ * per-event interceptors are thin clients that ask it over local IPC. The
+ * daemon is already resident with config, credentials, bundle, and snapshot
+ * warm in memory, so a spawned hook becomes a THIN CLIENT that forwards
+ * `{args, stdin}` over a named pipe (Windows) / Unix domain socket and prints
+ * the verdict the daemon computed in single-digit milliseconds.
  *
- * Fallback contract: ANY failure — pipe missing, handshake error, slow or
- * busy daemon (response cap ~2.5s) — makes the hook silently fall back to its
- * full local evaluation, identical to before this feature existed. Local
- * re-evaluation after a partial daemon evaluation is safe: verdict
- * computation is read-mostly (worst case a duplicate telemetry event), and
- * enforcement is never weakened by evaluating twice. The cap guarantees a
- * busy daemon (blocking schtasks call, GC pause) can never make a hook
- * SLOWER than the pre-IPC status quo.
- *
- * Security: named pipes are reachable by other local users by default, so the
- * server requires a per-boot random token stored under ~/.fullcourtdefense
- * (user-profile ACL). A client that cannot read the token cannot get verdicts.
- * The protocol is line-delimited JSON — one request line, one response line.
+ * The client half lives in `verdictIpcClient.ts` — a Node-builtins-only leaf
+ * shared with the slim hook entry (`hookSlim.ts`), whose module graph must
+ * stay tiny because it loads on every IDE hook event. This file re-exports
+ * the client API so existing imports keep working.
  */
-exports.VERDICT_IPC_PROTOCOL_VERSION = 1;
-function stateDir() {
-    return path.join(os.homedir(), '.fullcourtdefense');
-}
-function verdictTokenFile() {
-    return path.join(stateDir(), 'verdict-ipc-token');
-}
-function verdictPipePath() {
-    // Test isolation / unusual environments: explicit endpoint override.
-    const override = process.env.FCD_VERDICT_PIPE;
-    if (override)
-        return override;
-    if (process.platform === 'win32') {
-        // Per-user pipe name: two users on one machine each get their own daemon.
-        const user = (os.userInfo().username || 'user').replace(/[^a-zA-Z0-9_-]/g, '_');
-        return `\\\\.\\pipe\\fullcourtdefense-verdict-${user}`;
-    }
-    return path.join(stateDir(), 'verdict.sock');
-}
-function readToken() {
-    try {
-        const token = fs.readFileSync(verdictTokenFile(), 'utf8').trim();
-        return token.length >= 16 ? token : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-// ---------------------------------------------------------------------------
-// Client (thin hook side)
-// ---------------------------------------------------------------------------
-const CONNECT_TIMEOUT_MS = 250;
-const RESPONSE_TIMEOUT_MS = 2_500;
-/**
- * Ask the resident daemon for a verdict. Bounded hard: connect budget ~250ms
- * (a missing pipe fails in <1ms with ENOENT — the common daemon-down case
- * costs nothing), response capped at ~2.5s. A verdict that legitimately needs
- * longer than that (synchronous approval wait, no-cache gate call) is exactly
- * the case where the IPC saves nothing — the local evaluation path handles it
- * with its own bounded waits. Never throws.
- *
- * Burst behavior: an agent firing many commands at once (docker compose +
- * exec + build in flight together) means many hooks connecting to the ONE
- * pipe simultaneously — some connects lose the race (EBUSY / connect
- * timeout) while the daemon is demonstrably alive (token present). Those
- * get ONE short jittered retry; hard failures (ENOENT stale pipe, refused)
- * still fall back to local evaluation instantly.
- */
-async function requestDaemonVerdict(args, stdin, responseTimeoutMs = RESPONSE_TIMEOUT_MS, clientStartedAt) {
-    const first = await attemptDaemonVerdict(args, stdin, responseTimeoutMs, clientStartedAt);
-    if (first.outcome === 'unavailable' && /EBUSY|busy|EAGAIN|connect timeout/i.test(first.detail || '')) {
-        await new Promise((r) => setTimeout(r, 20 + Math.floor(Math.random() * 30)));
-        return attemptDaemonVerdict(args, stdin, responseTimeoutMs, clientStartedAt);
-    }
-    return first;
-}
-function attemptDaemonVerdict(args, stdin, responseTimeoutMs, clientStartedAt) {
-    return new Promise((resolve) => {
-        const token = readToken();
-        if (!token) {
-            resolve({ outcome: 'unavailable', detail: 'no ipc token (daemon not running or old version)' });
-            return;
-        }
-        let settled = false;
-        const finish = (result) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(connectTimer);
-            clearTimeout(responseTimer);
-            try {
-                socket.destroy();
-            }
-            catch { /* already gone */ }
-            resolve(result);
-        };
-        const fail = (detail) => finish({ outcome: 'unavailable', detail });
-        const socket = net.connect({ path: verdictPipePath() });
-        const connectTimer = setTimeout(() => fail('connect timeout'), CONNECT_TIMEOUT_MS);
-        const responseTimer = setTimeout(() => fail('response timeout'), responseTimeoutMs);
-        socket.on('error', (err) => fail(err.message));
-        socket.on('connect', () => {
-            clearTimeout(connectTimer);
-            const request = { v: exports.VERDICT_IPC_PROTOCOL_VERSION, token, args, stdin, t0: clientStartedAt };
-            try {
-                socket.write(JSON.stringify(request) + '\n');
-            }
-            catch (err) {
-                fail(err instanceof Error ? err.message : String(err));
-            }
-        });
-        let buffer = '';
-        socket.on('data', (chunk) => {
-            buffer += chunk.toString('utf8');
-            const nl = buffer.indexOf('\n');
-            if (nl === -1)
-                return;
-            try {
-                const resp = JSON.parse(buffer.slice(0, nl));
-                if (resp.error || typeof resp.stdout !== 'string') {
-                    // The daemon declined (protocol mismatch, internal error). Nothing
-                    // was decided — treat as unavailable so the hook evaluates locally.
-                    finish({ outcome: 'unavailable', detail: resp.error || 'malformed response' });
-                    return;
-                }
-                finish({
-                    outcome: 'verdict',
-                    stdout: resp.stdout,
-                    stderr: resp.stderr || '',
-                    exitCode: typeof resp.exitCode === 'number' ? resp.exitCode : 0,
-                });
-            }
-            catch (err) {
-                fail(err instanceof Error ? err.message : String(err));
-            }
-        });
-        socket.on('close', () => fail('connection closed'));
-    });
-}
+var verdictIpcClient_2 = require("./verdictIpcClient");
+Object.defineProperty(exports, "VERDICT_IPC_PROTOCOL_VERSION", { enumerable: true, get: function () { return verdictIpcClient_2.VERDICT_IPC_PROTOCOL_VERSION; } });
+Object.defineProperty(exports, "requestDaemonVerdict", { enumerable: true, get: function () { return verdictIpcClient_2.requestDaemonVerdict; } });
+Object.defineProperty(exports, "verdictPipePath", { enumerable: true, get: function () { return verdictIpcClient_2.verdictPipePath; } });
+Object.defineProperty(exports, "verdictTokenFile", { enumerable: true, get: function () { return verdictIpcClient_2.verdictTokenFile; } });
 /**
  * Start the verdict server inside the daemon. Returns undefined when the
  * endpoint cannot be created (another daemon holds the pipe, filesystem
@@ -204,13 +74,13 @@ function startVerdictServer(evaluate, log) {
     // path until the next daemon restart.
     const removeTokenIfOurs = () => {
         try {
-            if (fs.readFileSync(verdictTokenFile(), 'utf8') === token) {
-                fs.unlinkSync(verdictTokenFile());
+            if (fs.readFileSync((0, verdictIpcClient_1.verdictTokenFile)(), 'utf8') === token) {
+                fs.unlinkSync((0, verdictIpcClient_1.verdictTokenFile)());
             }
         }
         catch { /* absent or unreadable — nothing of ours to clean */ }
     };
-    const pipePath = verdictPipePath();
+    const pipePath = (0, verdictIpcClient_1.verdictPipePath)();
     if (process.platform !== 'win32') {
         // A stale socket file from a crashed daemon blocks listen() with EADDRINUSE.
         try {
@@ -244,18 +114,18 @@ function startVerdictServer(evaluate, log) {
                     request = JSON.parse(line);
                 }
                 catch {
-                    reply({ v: exports.VERDICT_IPC_PROTOCOL_VERSION, error: 'malformed request' });
+                    reply({ v: verdictIpcClient_1.VERDICT_IPC_PROTOCOL_VERSION, error: 'malformed request' });
                     return;
                 }
-                if (request.v !== exports.VERDICT_IPC_PROTOCOL_VERSION) {
-                    reply({ v: exports.VERDICT_IPC_PROTOCOL_VERSION, error: `unsupported protocol version ${request.v}` });
+                if (request.v !== verdictIpcClient_1.VERDICT_IPC_PROTOCOL_VERSION) {
+                    reply({ v: verdictIpcClient_1.VERDICT_IPC_PROTOCOL_VERSION, error: `unsupported protocol version ${request.v}` });
                     return;
                 }
                 // Timing-safe token check — the pipe is reachable by other local users.
                 const expected = Buffer.from(token);
                 const got = Buffer.from(String(request.token || ''));
                 if (got.length !== expected.length || !crypto.timingSafeEqual(expected, got)) {
-                    reply({ v: exports.VERDICT_IPC_PROTOCOL_VERSION, error: 'unauthorized' });
+                    reply({ v: verdictIpcClient_1.VERDICT_IPC_PROTOCOL_VERSION, error: 'unauthorized' });
                     return;
                 }
                 try {
@@ -264,12 +134,12 @@ function startVerdictServer(evaluate, log) {
                     // developer waited. Per-request (AsyncLocalStorage), so concurrent
                     // hooks in this one daemon never borrow each other's timings.
                     const result = await (0, telemetry_1.markVerdictTiming)({ startedAt: typeof request.t0 === 'number' ? request.t0 : Date.now(), path: 'ipc' }, () => evaluate(request.args || {}, String(request.stdin ?? '')));
-                    reply({ v: exports.VERDICT_IPC_PROTOCOL_VERSION, ...result });
+                    reply({ v: verdictIpcClient_1.VERDICT_IPC_PROTOCOL_VERSION, ...result });
                 }
                 catch (err) {
                     // Evaluator bug — tell the client to fall back locally (which will
                     // itself fail open if the same bug reproduces there).
-                    reply({ v: exports.VERDICT_IPC_PROTOCOL_VERSION, error: err instanceof Error ? err.message : String(err) });
+                    reply({ v: verdictIpcClient_1.VERDICT_IPC_PROTOCOL_VERSION, error: err instanceof Error ? err.message : String(err) });
                 }
             })();
         });
@@ -291,8 +161,8 @@ function startVerdictServer(evaluate, log) {
             }
             // Publish the token only now that the pipe is actually owned by us.
             try {
-                fs.mkdirSync(stateDir(), { recursive: true });
-                fs.writeFileSync(verdictTokenFile(), token, { encoding: 'utf8', mode: 0o600 });
+                fs.mkdirSync((0, verdictIpcClient_1.verdictStateDir)(), { recursive: true });
+                fs.writeFileSync((0, verdictIpcClient_1.verdictTokenFile)(), token, { encoding: 'utf8', mode: 0o600 });
                 log(`Verdict IPC: serving hook verdicts on ${pipePath} (thin-client hooks, ms verdicts).`);
             }
             catch (err) {
@@ -319,7 +189,7 @@ function startVerdictServer(evaluate, log) {
             catch { /* best-effort */ }
             if (process.platform !== 'win32') {
                 try {
-                    fs.unlinkSync(verdictPipePath());
+                    fs.unlinkSync((0, verdictIpcClient_1.verdictPipePath)());
                 }
                 catch { /* best-effort */ }
             }

package/dist/verdictIpcClient.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Verdict IPC — CLIENT side (thin hook -> resident daemon).
+ *
+ * Split from the server half (`verdictIpc.ts`) on purpose: the client is on
+ * the slim hook entry's module graph, loaded on EVERY IDE hook event, so it
+ * may import Node built-ins ONLY. The server half runs inside the resident
+ * daemon where module weight is irrelevant. `scripts/test-slim-hook.js`
+ * enforces the graph budget.
+ *
+ * Fallback contract: ANY failure — pipe missing, handshake error, slow or
+ * busy daemon (response cap ~2.5s) — makes the hook silently fall back to its
+ * full local evaluation, identical to before this feature existed. Local
+ * re-evaluation after a partial daemon evaluation is safe: verdict
+ * computation is read-mostly (worst case a duplicate telemetry event), and
+ * enforcement is never weakened by evaluating twice. The cap guarantees a
+ * busy daemon (blocking schtasks call, GC pause) can never make a hook
+ * SLOWER than the pre-IPC status quo.
+ *
+ * Security: named pipes are reachable by other local users by default, so the
+ * server requires a per-boot random token stored under ~/.fullcourtdefense
+ * (user-profile ACL). A client that cannot read the token cannot get verdicts.
+ * The protocol is line-delimited JSON — one request line, one response line.
+ */
+export declare const VERDICT_IPC_PROTOCOL_VERSION = 1;
+export interface VerdictRequest {
+    v: number;
+    token: string;
+    /** HookArgs as parsed by the CLI entry (all-string values). */
+    args: Record<string, string | undefined>;
+    /** Raw stdin payload exactly as the IDE piped it (BOM already stripped). */
+    stdin: string;
+    /**
+     * Client's `Date.now()` at hook start, so the daemon-written telemetry event
+     * carries the wall time the DEVELOPER waited (process spawn + pipe + verdict),
+     * not just the daemon's own evaluation slice. Optional on purpose: during a
+     * staged rollout an old client omits it (daemon falls back to its own clock)
+     * and an old daemon ignores it — same-machine clock, so no skew.
+     */
+    t0?: number;
+}
+export interface VerdictResponse {
+    v: number;
+    /** Present on evaluation success. */
+    stdout?: string;
+    stderr?: string;
+    exitCode?: number;
+    /** Present when the daemon could not evaluate — client falls back locally. */
+    error?: string;
+}
+/** Result of a client attempt. Anything but 'verdict' → evaluate locally. */
+export interface VerdictClientResult {
+    outcome: 'verdict' | 'unavailable';
+    stdout?: string;
+    stderr?: string;
+    exitCode?: number;
+    detail?: string;
+}
+export declare function verdictStateDir(): string;
+export declare function verdictTokenFile(): string;
+export declare function verdictPipePath(): string;
+/**
+ * Ask the resident daemon for a verdict. Bounded hard: connect budget ~250ms
+ * (a missing pipe fails in <1ms with ENOENT — the common daemon-down case
+ * costs nothing), response capped at ~2.5s. A verdict that legitimately needs
+ * longer than that (synchronous approval wait, no-cache gate call) is exactly
+ * the case where the IPC saves nothing — the local evaluation path handles it
+ * with its own bounded waits. Never throws.
+ *
+ * Burst behavior: an agent firing many commands at once (docker compose +
+ * exec + build in flight together) means many hooks connecting to the ONE
+ * pipe simultaneously — some connects lose the race (EBUSY / connect
+ * timeout) while the daemon is demonstrably alive (token present). Those
+ * get ONE short jittered retry; hard failures (ENOENT stale pipe, refused)
+ * still fall back to local evaluation instantly.
+ */
+export declare function requestDaemonVerdict(args: Record<string, string | undefined>, stdin: string, responseTimeoutMs?: number, clientStartedAt?: number): Promise<VerdictClientResult>;

package/dist/verdictIpcClient.js

@@ -0,0 +1,183 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERDICT_IPC_PROTOCOL_VERSION = void 0;
+exports.verdictStateDir = verdictStateDir;
+exports.verdictTokenFile = verdictTokenFile;
+exports.verdictPipePath = verdictPipePath;
+exports.requestDaemonVerdict = requestDaemonVerdict;
+const fs = __importStar(require("fs"));
+const net = __importStar(require("net"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+/**
+ * Verdict IPC — CLIENT side (thin hook -> resident daemon).
+ *
+ * Split from the server half (`verdictIpc.ts`) on purpose: the client is on
+ * the slim hook entry's module graph, loaded on EVERY IDE hook event, so it
+ * may import Node built-ins ONLY. The server half runs inside the resident
+ * daemon where module weight is irrelevant. `scripts/test-slim-hook.js`
+ * enforces the graph budget.
+ *
+ * Fallback contract: ANY failure — pipe missing, handshake error, slow or
+ * busy daemon (response cap ~2.5s) — makes the hook silently fall back to its
+ * full local evaluation, identical to before this feature existed. Local
+ * re-evaluation after a partial daemon evaluation is safe: verdict
+ * computation is read-mostly (worst case a duplicate telemetry event), and
+ * enforcement is never weakened by evaluating twice. The cap guarantees a
+ * busy daemon (blocking schtasks call, GC pause) can never make a hook
+ * SLOWER than the pre-IPC status quo.
+ *
+ * Security: named pipes are reachable by other local users by default, so the
+ * server requires a per-boot random token stored under ~/.fullcourtdefense
+ * (user-profile ACL). A client that cannot read the token cannot get verdicts.
+ * The protocol is line-delimited JSON — one request line, one response line.
+ */
+exports.VERDICT_IPC_PROTOCOL_VERSION = 1;
+function verdictStateDir() {
+    return path.join(os.homedir(), '.fullcourtdefense');
+}
+function verdictTokenFile() {
+    return path.join(verdictStateDir(), 'verdict-ipc-token');
+}
+function verdictPipePath() {
+    // Test isolation / unusual environments: explicit endpoint override.
+    const override = process.env.FCD_VERDICT_PIPE;
+    if (override)
+        return override;
+    if (process.platform === 'win32') {
+        // Per-user pipe name: two users on one machine each get their own daemon.
+        const user = (os.userInfo().username || 'user').replace(/[^a-zA-Z0-9_-]/g, '_');
+        return `\\\\.\\pipe\\fullcourtdefense-verdict-${user}`;
+    }
+    return path.join(verdictStateDir(), 'verdict.sock');
+}
+function readToken() {
+    try {
+        const token = fs.readFileSync(verdictTokenFile(), 'utf8').trim();
+        return token.length >= 16 ? token : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const CONNECT_TIMEOUT_MS = 250;
+const RESPONSE_TIMEOUT_MS = 2_500;
+/**
+ * Ask the resident daemon for a verdict. Bounded hard: connect budget ~250ms
+ * (a missing pipe fails in <1ms with ENOENT — the common daemon-down case
+ * costs nothing), response capped at ~2.5s. A verdict that legitimately needs
+ * longer than that (synchronous approval wait, no-cache gate call) is exactly
+ * the case where the IPC saves nothing — the local evaluation path handles it
+ * with its own bounded waits. Never throws.
+ *
+ * Burst behavior: an agent firing many commands at once (docker compose +
+ * exec + build in flight together) means many hooks connecting to the ONE
+ * pipe simultaneously — some connects lose the race (EBUSY / connect
+ * timeout) while the daemon is demonstrably alive (token present). Those
+ * get ONE short jittered retry; hard failures (ENOENT stale pipe, refused)
+ * still fall back to local evaluation instantly.
+ */
+async function requestDaemonVerdict(args, stdin, responseTimeoutMs = RESPONSE_TIMEOUT_MS, clientStartedAt) {
+    const first = await attemptDaemonVerdict(args, stdin, responseTimeoutMs, clientStartedAt);
+    if (first.outcome === 'unavailable' && /EBUSY|busy|EAGAIN|connect timeout/i.test(first.detail || '')) {
+        await new Promise((r) => setTimeout(r, 20 + Math.floor(Math.random() * 30)));
+        return attemptDaemonVerdict(args, stdin, responseTimeoutMs, clientStartedAt);
+    }
+    return first;
+}
+function attemptDaemonVerdict(args, stdin, responseTimeoutMs, clientStartedAt) {
+    return new Promise((resolve) => {
+        const token = readToken();
+        if (!token) {
+            resolve({ outcome: 'unavailable', detail: 'no ipc token (daemon not running or old version)' });
+            return;
+        }
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(connectTimer);
+            clearTimeout(responseTimer);
+            try {
+                socket.destroy();
+            }
+            catch { /* already gone */ }
+            resolve(result);
+        };
+        const fail = (detail) => finish({ outcome: 'unavailable', detail });
+        const socket = net.connect({ path: verdictPipePath() });
+        const connectTimer = setTimeout(() => fail('connect timeout'), CONNECT_TIMEOUT_MS);
+        const responseTimer = setTimeout(() => fail('response timeout'), responseTimeoutMs);
+        socket.on('error', (err) => fail(err.message));
+        socket.on('connect', () => {
+            clearTimeout(connectTimer);
+            const request = { v: exports.VERDICT_IPC_PROTOCOL_VERSION, token, args, stdin, t0: clientStartedAt };
+            try {
+                socket.write(JSON.stringify(request) + '\n');
+            }
+            catch (err) {
+                fail(err instanceof Error ? err.message : String(err));
+            }
+        });
+        let buffer = '';
+        socket.on('data', (chunk) => {
+            buffer += chunk.toString('utf8');
+            const nl = buffer.indexOf('\n');
+            if (nl === -1)
+                return;
+            try {
+                const resp = JSON.parse(buffer.slice(0, nl));
+                if (resp.error || typeof resp.stdout !== 'string') {
+                    // The daemon declined (protocol mismatch, internal error). Nothing
+                    // was decided — treat as unavailable so the hook evaluates locally.
+                    finish({ outcome: 'unavailable', detail: resp.error || 'malformed response' });
+                    return;
+                }
+                finish({
+                    outcome: 'verdict',
+                    stdout: resp.stdout,
+                    stderr: resp.stderr || '',
+                    exitCode: typeof resp.exitCode === 'number' ? resp.exitCode : 0,
+                });
+            }
+            catch (err) {
+                fail(err instanceof Error ? err.message : String(err));
+            }
+        });
+        socket.on('close', () => fail('connection closed'));
+    });
+}

package/dist/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "1.26.3"
+  "version": "1.26.5"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fullcourtdefense-cli",
-  "version": "1.26.3",
+  "version": "1.26.5",
   "description": "Full Court Defense CLI — security scanning for AI agents from your terminal",
   "main": "dist/index.js",
   "bin": {
@@ -53,6 +53,8 @@
     "test:scan-root-compaction": "npm run build && node scripts/test-scan-root-compaction.js",
     "test:dpapi-config": "npm run build && node scripts/test-dpapi-config.js",
     "test:distress-ledger": "npm run build && node scripts/test-distress-ledger.js",
+    "test:poll-loop": "npm run build && node scripts/test-poll-loop-resilience.js",
+    "test:slim-hook": "npm run build && node scripts/test-slim-hook.js",
     "test:deep-selftest": "npm run build && node scripts/test-deep-selftest.js",
     "test:update-loop": "npm run build && node scripts/test-update-loop-detection.js",
     "test:bricked-rescue": "npm run build && node scripts/test-bricked-machine-rescue.js",