fullcourtdefense-cli 1.26.3 → 1.26.5

package/dist/commands/daemon.js

@@ -59,6 +59,7 @@ const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 const config_1 = require("../config");
 const distress_1 = require("../distress");
+const pollLoop_1 = require("../pollLoop");
 const selfTest_1 = require("../selfTest");
 const daemonForensics_1 = require("../daemonForensics");
 const securityAgents_1 = require("../securityAgents");
@@ -107,6 +108,14 @@ const RESCAN_INTERVAL_MS = envMs('FCD_DAEMON_RESCAN_MS', 5 * 60_000);
 const HEARTBEAT_INTERVAL_MS = envMs('FCD_DAEMON_HEARTBEAT_MS', 5 * 60_000);
 /** Bundle (mode / suspension / policy version) poll cadence. */
 const BUNDLE_POLL_MS = envMs('FCD_DAEMON_BUNDLE_POLL_MS', 60_000);
+/**
+ * Hard ceilings for one poll attempt (see startPollLoop). Generous multiples of
+ * the work each poll actually does — a bundle poll is a 1.5s fetch plus an 8s
+ * snapshot refresh, a heartbeat is a spool flush plus a log upload — so these
+ * only ever fire on a genuinely hung socket, never on a merely slow network.
+ */
+const BUNDLE_POLL_DEADLINE_MS = envMs('FCD_DAEMON_BUNDLE_DEADLINE_MS', 45_000);
+const HEARTBEAT_DEADLINE_MS = envMs('FCD_DAEMON_HEARTBEAT_DEADLINE_MS', 120_000);
 /** Delay before the one-time initial discovery sweep on a fresh machine. */
 const INITIAL_DISCOVER_DELAY_MS = envMs('FCD_DAEMON_INITIAL_DISCOVER_MS', 2 * 60_000);
 /** A discovery upload older than this is stale — the daemon catches up itself. */
@@ -1287,33 +1296,35 @@ async function runDaemon(args, config) {
     // The bundle poll additionally honors the server's pollIntervalMs, and the
     // next tick is scheduled only AFTER the previous poll finishes — a slow
     // gate can never pile up overlapping polls.
-    const jittered = (baseMs) => Math.max(5_000, Math.round(baseMs * (0.8 + Math.random() * 0.4)));
-    let bundleTimer;
-    const scheduleBundlePoll = () => {
-        if (stopped)
-            return;
-        bundleTimer = setTimeout(async () => {
-            try {
-                await pollBundle();
-            }
-            catch { /* poll never throws, but never stop the loop */ }
-            scheduleBundlePoll();
-        }, jittered(bundlePollBaseMs));
-    };
-    scheduleBundlePoll();
-    let heartbeatTimer;
-    const scheduleHeartbeat = () => {
-        if (stopped)
-            return;
-        heartbeatTimer = setTimeout(async () => {
-            try {
-                await heartbeat();
-            }
-            catch { /* keep the loop alive */ }
-            scheduleHeartbeat();
-        }, jittered(HEARTBEAT_INTERVAL_MS));
-    };
-    scheduleHeartbeat();
+    //
+    // Both loops run through startPollLoop, which bounds every attempt with a
+    // hard deadline. A poll that never settles (socket dead without a FIN after
+    // sleep / VPN change / proxy drop — `AbortSignal.timeout` does not always
+    // rescue that) used to kill its loop for the life of the process. When that
+    // happened to the bundle poll, remote actions — whose ONLY delivery path is
+    // this poll — silently expired unacknowledged while heartbeats kept the
+    // machine looking healthy. Abandoning the hung attempt restores delivery on
+    // the next tick and leaves a `poll_stalled` signal in the fleet.
+    const bundleLoop = (0, pollLoop_1.startPollLoop)({
+        run: pollBundle,
+        intervalMs: () => bundlePollBaseMs,
+        deadlineMs: BUNDLE_POLL_DEADLINE_MS,
+        onStalled: deadlineMs => {
+            log(`Bundle poll did not finish within ${Math.round(deadlineMs / 1000)}s — abandoned; remote actions and policy updates were delayed. Next poll continues normally.`);
+            (0, distress_1.reportDistress)('bundle', distress_1.DISTRESS.POLL_STALLED, `bundle poll exceeded ${deadlineMs}ms`);
+        },
+        onError: error => log(`Bundle poll error: ${error instanceof Error ? error.message : String(error)}`),
+    });
+    const heartbeatLoop = (0, pollLoop_1.startPollLoop)({
+        run: heartbeat,
+        intervalMs: () => HEARTBEAT_INTERVAL_MS,
+        deadlineMs: HEARTBEAT_DEADLINE_MS,
+        onStalled: deadlineMs => {
+            log(`Heartbeat did not finish within ${Math.round(deadlineMs / 1000)}s — abandoned; spooled events stay on disk for the next tick.`);
+            (0, distress_1.reportDistress)('heartbeat', distress_1.DISTRESS.POLL_STALLED, `heartbeat exceeded ${deadlineMs}ms`);
+        },
+        onError: error => log(`Heartbeat error: ${error instanceof Error ? error.message : String(error)}`),
+    });
     // PowerShell transcript retention (Windows): the Transcription policy FCD
     // enables writes a file per session forever — prune anything older than the
     // retention window once a day (plus once shortly after boot, so laptops
@@ -1337,10 +1348,8 @@ async function runDaemon(args, config) {
         stopped = true;
         log(`Received ${signal} — shutting down.`);
         clearInterval(rescanTimer);
-        if (bundleTimer)
-            clearTimeout(bundleTimer);
-        if (heartbeatTimer)
-            clearTimeout(heartbeatTimer);
+        bundleLoop.stop();
+        heartbeatLoop.stop();
         clearTimeout(transcriptPruneBootTimer);
         clearInterval(transcriptPruneTimer);
         clearTimeout(discoverCatchUpBootTimer);

package/dist/commands/hook.js

@@ -36,9 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeClaudePayload = normalizeClaudePayload;
 exports.evaluateHookRequest = evaluateHookRequest;
 exports.hookCommand = hookCommand;
-const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
-const path = __importStar(require("path"));
 const config_1 = require("../config");
 const runtimeConfig_1 = require("../runtimeConfig");
 const telemetry_1 = require("../telemetry");
@@ -51,73 +49,9 @@ const policyGateHealth_1 = require("../policyGateHealth");
 const verdictIpc_1 = require("../verdictIpc");
 const machineIdentity_1 = require("../machineIdentity");
 const actionPolicyEngine_1 = require("../actionPolicyEngine");
-const DEBUG_LOG = path.join(os.homedir(), '.fullcourtdefense-hook.log');
-/**
- * Verbose diagnostics (FCD_HOOK_DEBUG=1) additionally log content previews
- * (raw payload + prompt text snippets). Default logging keeps operational
- * metadata only — user prompt content must never sit in a plaintext file on
- * a customer laptop unless support explicitly opts in.
- */
-const HOOK_DEBUG_VERBOSE = process.env.FCD_HOOK_DEBUG === '1';
-/** Rotate the hook log when it grows past this size (same scheme as daemon.log). */
-const DEBUG_LOG_MAX_BYTES = 1_000_000;
-// Checked once per (short-lived) hook process: unbounded hook.log growth was
-// real customer disk churn — and every append to a huge file re-triggers AV
-// scanning. One stat per process is enough for a hook run; the resident
-// daemon (verdict IPC evaluation) re-checks every 500 writes so a long
-// uptime can't outgrow the cap either.
-let debugLogRotationChecked = false;
-let debugLogWritesSinceCheck = 0;
-/** Append a diagnostic line so we can see exactly what Cursor invoked + the verdict. */
-function dbg(obj) {
-    try {
-        debugLogWritesSinceCheck += 1;
-        if (!debugLogRotationChecked || debugLogWritesSinceCheck >= 500) {
-            debugLogRotationChecked = true;
-            debugLogWritesSinceCheck = 0;
-            try {
-                if (fs.existsSync(DEBUG_LOG) && fs.statSync(DEBUG_LOG).size > DEBUG_LOG_MAX_BYTES) {
-                    fs.renameSync(DEBUG_LOG, `${DEBUG_LOG}.1`);
-                }
-            }
-            catch { /* rotation is best-effort */ }
-        }
-        fs.appendFileSync(DEBUG_LOG, JSON.stringify({ t: new Date().toISOString(), ...obj }) + '\n');
-    }
-    catch { /* ignore */ }
-}
-function readStdin() {
-    return new Promise((resolve) => {
-        const stdin = process.stdin;
-        if (stdin.isTTY) {
-            resolve('');
-            return;
-        }
-        // Read raw BYTES (no setEncoding) and decode the whole payload as UTF-8 once.
-        // Per-chunk string decoding + concat corrupts multibyte chars (e.g. Hebrew),
-        // turning them into Latin-1 mojibake before they ever reach the backend.
-        const chunks = [];
-        let settled = false;
-        const finish = () => {
-            if (settled)
-                return;
-            settled = true;
-            let buf = Buffer.concat(chunks);
-            // Strip UTF-8 BOM at the byte level (Cursor on Windows prepends EF BB BF).
-            if (buf.length >= 3 && buf[0] === 0xEF && buf[1] === 0xBB && buf[2] === 0xBF) {
-                buf = buf.subarray(3);
-            }
-            resolve(buf.toString('utf8'));
-        };
-        stdin.on('data', (chunk) => {
-            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-        });
-        stdin.on('end', finish);
-        stdin.on('error', finish);
-        // Safety: if nothing arrives, don't hang forever.
-        setTimeout(finish, 2000).unref?.();
-    });
-}
+// Shared with the slim hook entry (hookSlim.ts) so both entries log to the
+// same rotated hook.log and read stdin identically.
+const hookIo_1 = require("../hookIo");
 function inferEvent(explicit, payload) {
     const e = (explicit || '').toLowerCase();
     if (e) {
@@ -427,7 +361,7 @@ function respondDegraded(ctx, detail, toolName, authRejected = false, opts = {})
         // Grace window: transient failure on a fail-closed machine — allow this
         // action, but record distress so the episode is visible in the console.
         (0, distress_1.reportDistress)('hook', authRejected ? distress_1.DISTRESS.AUTH_BROKEN : distress_1.DISTRESS.NETWORK_DOWN, `Policy gate failure ${health.consecutiveFailures}/3 (grace window, still allowing): ${detail}`);
-        dbg({ phase: 'policy_grace_allow', event: ctx.event, consecutiveFailures: health.consecutiveFailures, detail });
+        (0, hookIo_1.dbg)({ phase: 'policy_grace_allow', event: ctx.event, consecutiveFailures: health.consecutiveFailures, detail });
         (0, telemetry_1.spoolEvent)({ decision: 'allow', toolName, reason: `degraded (grace ${health.consecutiveFailures}/3): ${detail}`, offlineEnforced: true });
         (0, telemetry_1.triggerFlush)(false);
         ctx.respond(false, undefined, degradedAllowMessage(ctx.event, detail));
@@ -469,7 +403,7 @@ function tryLocalPolicyEnforcement(ctx, call, detail, opts = {}) {
     context.machineName = os.hostname();
     const declaredOperations = (0, actionPolicyEngine_1.deriveToolOperations)(call.toolName);
     const local = (0, actionPolicyEngine_1.evaluateActionPolicies)(policies, call.toolName, operation, context, declaredOperations);
-    dbg({ phase: 'policy_local_verdict', event: ctx.event, tool: call.toolName, operation, verdict: local.verdict, policyName: local.policyName, detail });
+    (0, hookIo_1.dbg)({ phase: 'policy_local_verdict', event: ctx.event, tool: call.toolName, operation, verdict: local.verdict, policyName: local.policyName, detail });
     if (local.verdict === 'block' || local.verdict === 'require_approval') {
         const reason = local.reason || `${call.toolName}: local policy ${local.verdict}`;
         if (ctx.shadow) {
@@ -617,7 +551,7 @@ function spoolLocalFinding(input) {
  */
 function spoolLocalWarnings(warnings, toolName, operation) {
     for (const finding of warnings) {
-        dbg({ phase: 'local_deterministic_warn', tool: toolName, ruleId: finding.ruleId, itemId: finding.itemId });
+        (0, hookIo_1.dbg)({ phase: 'local_deterministic_warn', tool: toolName, ruleId: finding.ruleId, itemId: finding.itemId });
         spoolLocalFinding({ finding, toolName, operation, decision: 'warn' });
     }
 }
@@ -695,7 +629,7 @@ async function hookCommandOuter(args, config, startedAt) {
         let raw = '';
         let stdinErr = '';
         try {
-            raw = await readStdin();
+            raw = await (0, hookIo_1.readStdin)();
         }
         catch (e) {
             stdinErr = e instanceof Error ? e.message : String(e);
@@ -709,7 +643,7 @@ async function hookCommandOuter(args, config, startedAt) {
         if (process.env.FCD_VERDICT_IPC !== 'off') {
             const ipc = await (0, verdictIpc_1.requestDaemonVerdict)(args, raw, undefined, startedAt);
             if (ipc.outcome === 'verdict') {
-                dbg({ phase: 'ipc_verdict', event: args.event, exitCode: ipc.exitCode });
+                (0, hookIo_1.dbg)({ phase: 'ipc_verdict', event: args.event, exitCode: ipc.exitCode });
                 if (ipc.stderr) {
                     try {
                         process.stderr.write(ipc.stderr);
@@ -726,7 +660,7 @@ async function hookCommandOuter(args, config, startedAt) {
             }
             // Daemon down / busy / refused — evaluate locally as always. Logged so a
             // machine that silently stopped using the fast path is diagnosable.
-            dbg({ phase: 'ipc_unavailable', event: args.event, detail: ipc.detail });
+            (0, hookIo_1.dbg)({ phase: 'ipc_unavailable', event: args.event, detail: ipc.detail });
         }
         await hookCommandInner(args, config, processIo(raw, stdinErr));
     }
@@ -763,7 +697,7 @@ function failOpenOutcome(event, message) {
     }
     catch { /* never throw */ }
     try {
-        dbg({ phase: 'hook_fail_open', event, error: message, suspended });
+        (0, hookIo_1.dbg)({ phase: 'hook_fail_open', event, error: message, suspended });
     }
     catch { /* never throw */ }
     try {
@@ -855,7 +789,7 @@ async function hookCommandInner(args, config, io) {
                     machineSuspended = true;
                     shadow = false;
                 }
-                dbg({ phase: 'mode_resolved', mode: bundle.mode, source: bundle.source, shadow, failClosed, suspended: machineSuspended });
+                (0, hookIo_1.dbg)({ phase: 'mode_resolved', mode: bundle.mode, source: bundle.source, shadow, failClosed, suspended: machineSuspended });
             }
         }
         catch { /* keep the local default */ }
@@ -863,7 +797,7 @@ async function hookCommandInner(args, config, io) {
     // Monitor-first: no authoritative bundle (fresh/uncached/fetch failed) => report-only.
     if (!modeResolved && !forceEnforce) {
         shadow = true;
-        dbg({ phase: 'mode_default_monitor_first', shadow });
+        (0, hookIo_1.dbg)({ phase: 'mode_default_monitor_first', shadow });
     }
     if (forceEnforce)
         shadow = false;
@@ -908,8 +842,8 @@ async function hookCommandInner(args, config, io) {
     else {
         event = inferEvent(args.event, payload);
     }
-    dbg({ phase: 'invoke', event, argEvent: args.event, format: hookFormat, client, pid: process.pid,
-        isTTY, rawLen: raw.length, ...(HOOK_DEBUG_VERBOSE ? { rawPreview: raw.slice(0, 300) } : {}), stdinErr, parseErr,
+    (0, hookIo_1.dbg)({ phase: 'invoke', event, argEvent: args.event, format: hookFormat, client, pid: process.pid,
+        isTTY, rawLen: raw.length, ...(hookIo_1.HOOK_DEBUG_VERBOSE ? { rawPreview: raw.slice(0, 300) } : {}), stdinErr, parseErr,
         argv: process.argv.slice(2), payloadKeys: Object.keys(payload) });
     // Emit the verdict in the shape THIS client expects, then exit.
     //   Cursor: beforeSubmitPrompt blocks via { continue: false }; execution hooks
@@ -949,7 +883,7 @@ async function hookCommandInner(args, config, io) {
             if (agentMsg)
                 decision.agent_message = agentMsg;
         }
-        dbg({ phase: 'verdict', event, format: hookFormat, blocked, decision });
+        (0, hookIo_1.dbg)({ phase: 'verdict', event, format: hookFormat, blocked, decision });
         if (hookFormat === 'claude' && event === 'prompt' && blocked) {
             // Claude Desktop/Code variants do not all honor the structured
             // UserPromptSubmit decision consistently. Exit 2 is the documented hard
@@ -1001,7 +935,7 @@ async function hookCommandInner(args, config, io) {
     // --- Shield text analysis for prompts (developer chat) ---
     if (event === 'prompt') {
         const text = extractPromptText(payload).trim();
-        dbg({ phase: 'prompt_text', textLen: text.length, ...(HOOK_DEBUG_VERBOSE ? { textPreview: text.slice(0, 300) } : {}) });
+        (0, hookIo_1.dbg)({ phase: 'prompt_text', textLen: text.length, ...(hookIo_1.HOOK_DEBUG_VERBOSE ? { textPreview: text.slice(0, 300) } : {}) });
         if (!text)
             respond(false);
         // Record the developer's prompt so taint-tracking can later tell whether a
@@ -1020,7 +954,7 @@ async function hookCommandInner(args, config, io) {
         spoolLocalWarnings(promptOutcome.warnings, 'prompt', 'prompt');
         const localBlock = promptOutcome.blockingFinding;
         if (localBlock) {
-            dbg({ phase: 'local_deterministic_prompt_block', event, ruleId: localBlock.ruleId, category: localBlock.category });
+            (0, hookIo_1.dbg)({ phase: 'local_deterministic_prompt_block', event, ruleId: localBlock.ruleId, category: localBlock.category });
             if (shadow) {
                 // Truth-in-reporting: this prompt RAN (shadow/monitor) — 'warn', never 'block'.
                 spoolLocalFinding({ finding: localBlock, toolName: 'prompt', operation: 'prompt', decision: 'warn' });
@@ -1032,7 +966,7 @@ async function hookCommandInner(args, config, io) {
             return;
         }
         if (localOnly) {
-            dbg({ phase: 'local_deterministic_prompt_allow', event });
+            (0, hookIo_1.dbg)({ phase: 'local_deterministic_prompt_allow', event });
             respond(false);
             return;
         }
@@ -1094,9 +1028,9 @@ async function runTaintApproveOnce(ctx, event, call, sessId, taintFinding) {
             + `Deny:        fullcourtdefense approve ${approval.id} --deny\n`
             + `(run "fullcourtdefense approve" to list; expires in ${Math.round(timeoutMs / 60000)} min)`,
     });
-    dbg({ phase: 'taint_approve_once_wait', event, tool: call.toolName, approvalId: approval.id, timeoutMs });
+    (0, hookIo_1.dbg)({ phase: 'taint_approve_once_wait', event, tool: call.toolName, approvalId: approval.id, timeoutMs });
     const outcome = await (0, taintLedger_1.waitForTaintApproval)(approval.id, timeoutMs, Math.max(750, Math.min(ctx.approvalPollMs, 2000)));
-    dbg({ phase: 'taint_approve_once_outcome', approvalId: approval.id, outcome });
+    (0, hookIo_1.dbg)({ phase: 'taint_approve_once_outcome', approvalId: approval.id, outcome });
     if (outcome === 'approved') {
         (0, telemetry_1.spoolEvent)({
             decision: 'allow',
@@ -1146,7 +1080,7 @@ async function enforceActionPolicy(ctx) {
     spoolLocalWarnings(toolOutcome.warnings, call.toolName, event);
     const localBlock = toolOutcome.blockingFinding;
     if (localBlock) {
-        dbg({ phase: 'local_deterministic_block', event, tool: call.toolName, ruleId: localBlock.ruleId, category: localBlock.category });
+        (0, hookIo_1.dbg)({ phase: 'local_deterministic_block', event, tool: call.toolName, ruleId: localBlock.ruleId, category: localBlock.category });
         if (shadow) {
             // Truth-in-reporting: this action RAN (shadow/monitor) — 'warn', never 'block'.
             spoolLocalFinding({ finding: localBlock, toolName: call.toolName, operation: event, decision: 'warn' });
@@ -1162,7 +1096,7 @@ async function enforceActionPolicy(ctx) {
     // state directory; otherwise a compromised agent could approve itself.
     const selfApproval = (0, taintLedger_1.detectTaintSelfApproval)(event, call.toolName, call.toolArgs);
     if (selfApproval) {
-        dbg({ phase: 'taint_self_approval_block', event, tool: call.toolName });
+        (0, hookIo_1.dbg)({ phase: 'taint_self_approval_block', event, tool: call.toolName });
         if (shadow) {
             respond(false, undefined, `[FullCourtDefense shadow] would block ${call.toolName}: ${selfApproval.reason}`);
             return;
@@ -1180,7 +1114,7 @@ async function enforceActionPolicy(ctx) {
     const sessId = sessionId(payload);
     const taintFinding = (0, taintLedger_1.checkTaintedSink)(sessId, event, call.toolName, call.toolArgs);
     if (taintFinding) {
-        dbg({ phase: 'local_taint_block', event, tool: call.toolName, ruleId: taintFinding.ruleId, sink: taintFinding.sink.kind, targets: taintFinding.sink.targets });
+        (0, hookIo_1.dbg)({ phase: 'local_taint_block', event, tool: call.toolName, ruleId: taintFinding.ruleId, sink: taintFinding.sink.kind, targets: taintFinding.sink.targets });
         if (shadow) {
             respond(false, undefined, `[FullCourtDefense shadow] would block ${call.toolName}: ${taintFinding.reason}`);
             return;
@@ -1204,7 +1138,7 @@ async function enforceActionPolicy(ctx) {
     // (detached flush child). Enforce machines keep the full timeout + retry:
     // their verdict actually gates the action.
     if (shadow) {
-        dbg({ phase: 'policy_skip_monitor', event, tool: call.toolName });
+        (0, hookIo_1.dbg)({ phase: 'policy_skip_monitor', event, tool: call.toolName });
         const detail = 'monitor mode — synchronous policy check skipped by design.';
         if (!tryLocalPolicyEnforcement(ctx, call, detail, { countAsGateFailure: false })) {
             (0, telemetry_1.spoolEvent)({ decision: 'allow', toolName: call.toolName, reason: `monitor: ${detail}`, offlineEnforced: true });
@@ -1246,7 +1180,7 @@ async function enforceActionPolicy(ctx) {
         localCtx.developerName = developerId();
         localCtx.machineName = os.hostname();
         const localVerdict = (0, actionPolicyEngine_1.evaluateActionPolicies)(ctx.localPolicies, call.toolName, localOp, localCtx, (0, actionPolicyEngine_1.deriveToolOperations)(call.toolName));
-        dbg({ phase: 'policy_local_first', event, tool: call.toolName, operation: localOp, verdict: localVerdict.verdict, policyName: localVerdict.policyName });
+        (0, hookIo_1.dbg)({ phase: 'policy_local_first', event, tool: call.toolName, operation: localOp, verdict: localVerdict.verdict, policyName: localVerdict.policyName });
         if (localVerdict.verdict === 'allow') {
             // Audit rides async: server records the action + its own verdict; if it
             // is unreachable the spool keeps the trail (idempotent on eventId).
@@ -1275,7 +1209,7 @@ async function enforceActionPolicy(ctx) {
     // skip does NOT refresh the failure window, so the next call after 60s
     // probes the gate again (bounded), and a success resets the streak.
     if ((0, policyGateHealth_1.gateRecentlyDown)()) {
-        dbg({ phase: 'policy_skip_gate_down', event, tool: call.toolName });
+        (0, hookIo_1.dbg)({ phase: 'policy_skip_gate_down', event, tool: call.toolName });
         const detail = 'policy service recently unreachable — synchronous wait skipped (fast-probe window).';
         if (!tryLocalPolicyEnforcement(ctx, call, detail, { countAsGateFailure: false })) {
             respondDegraded(ctx, detail, call.toolName, false, { countAsGateFailure: false });
@@ -1293,9 +1227,9 @@ async function enforceActionPolicy(ctx) {
             method: 'POST',
             headers,
             body: gateBody,
-        }, gateTimeoutMs, (attempt, err) => dbg({ phase: 'policy_retry', event, attempt, error: err }), gateAttempts);
+        }, gateTimeoutMs, (attempt, err) => (0, hookIo_1.dbg)({ phase: 'policy_retry', event, attempt, error: err }), gateAttempts);
         if (!resp.ok) {
-            dbg({ phase: 'policy_http_error', event, status: resp.status, failClosed: ctx.failClosed });
+            (0, hookIo_1.dbg)({ phase: 'policy_http_error', event, status: resp.status, failClosed: ctx.failClosed });
             const authRejected = resp.status === 401 || resp.status === 403;
             const detail = authRejected
                 ? `The policy service rejected this machine's credentials (HTTP ${resp.status}) — the shield key saved here is broken or revoked, not a network problem.`
@@ -1314,7 +1248,7 @@ async function enforceActionPolicy(ctx) {
         }
         const body = await resp.json().catch(() => ({}));
         if (!body.success || !body.data) {
-            dbg({ phase: 'policy_no_data', event, error: body.error, failClosed: ctx.failClosed });
+            (0, hookIo_1.dbg)({ phase: 'policy_no_data', event, error: body.error, failClosed: ctx.failClosed });
             const detail = body.error ? `Backend error: ${body.error}` : 'Backend returned no policy data.';
             if (!tryLocalPolicyEnforcement(ctx, call, detail)) {
                 respondDegraded(ctx, detail, call.toolName);
@@ -1326,7 +1260,7 @@ async function enforceActionPolicy(ctx) {
         (0, policyGateHealth_1.recordGateSuccess)();
     }
     catch (err) {
-        dbg({ phase: 'policy_exception', event, error: err instanceof Error ? err.message : String(err), failClosed: ctx.failClosed });
+        (0, hookIo_1.dbg)({ phase: 'policy_exception', event, error: err instanceof Error ? err.message : String(err), failClosed: ctx.failClosed });
         const detail = `Hook error: ${err instanceof Error ? err.message : String(err)}.`;
         if (!tryLocalPolicyEnforcement(ctx, call, detail)) {
             respondDegraded(ctx, detail, call.toolName);
@@ -1337,7 +1271,7 @@ async function enforceActionPolicy(ctx) {
         || result.intentEvaluation?.reasons?.[0]
         || `${call.toolName} ${result.decision}ed by Action Policy.`;
     const policyName = result.actionPolicy?.policyName;
-    dbg({ phase: 'policy_verdict', event, tool: call.toolName, decision: result.decision, allowed: result.allowed, policyName });
+    (0, hookIo_1.dbg)({ phase: 'policy_verdict', event, tool: call.toolName, decision: result.decision, allowed: result.allowed, policyName });
     if (result.allowed && result.decision === 'allow') {
         respond(false);
         return;
@@ -1396,7 +1330,7 @@ async function waitForApproval(input) {
         headers['x-shield-key'] = input.shieldKey;
     const url = `${input.apiUrl}/api/agent-security/runtime/approvals/${encodeURIComponent(input.actionId)}?shieldId=${encodeURIComponent(input.shieldId)}`;
     const deadline = Date.now() + input.timeoutMs;
-    dbg({ phase: 'approval_wait_start', actionId: input.actionId, timeoutMs: input.timeoutMs });
+    (0, hookIo_1.dbg)({ phase: 'approval_wait_start', actionId: input.actionId, timeoutMs: input.timeoutMs });
     while (Date.now() <= deadline) {
         try {
             const resp = await fetch(url, { method: 'GET', headers, signal: AbortSignal.timeout(15000) });
@@ -1415,7 +1349,7 @@ async function waitForApproval(input) {
             }
         }
         catch (err) {
-            dbg({ phase: 'approval_poll_error', actionId: input.actionId, error: err instanceof Error ? err.message : String(err) });
+            (0, hookIo_1.dbg)({ phase: 'approval_poll_error', actionId: input.actionId, error: err instanceof Error ? err.message : String(err) });
         }
         await new Promise((resolve) => setTimeout(resolve, Math.min(input.pollMs, Math.max(0, deadline - Date.now()))));
     }
@@ -1431,7 +1365,7 @@ async function enforceShieldText(ctx) {
     // deterministic rules already ran before this point; the audit trail rides
     // the async spool. Enforce machines keep the full window: their verdict gates.
     if (shadow) {
-        dbg({ phase: 'shield_skip_monitor', event });
+        (0, hookIo_1.dbg)({ phase: 'shield_skip_monitor', event });
         (0, telemetry_1.spoolEvent)({ decision: 'allow', toolName: 'prompt', reason: 'monitor: synchronous Shield scan skipped by design.', offlineEnforced: true });
         (0, telemetry_1.triggerFlush)(false);
         respond(false);
@@ -1440,7 +1374,7 @@ async function enforceShieldText(ctx) {
     // recently-failed gate is not re-probed on every prompt; the degraded stance
     // resolves instantly instead of paying the full timeout per event.
     if ((0, policyGateHealth_1.gateRecentlyDown)()) {
-        dbg({ phase: 'shield_skip_gate_down', event });
+        (0, hookIo_1.dbg)({ phase: 'shield_skip_gate_down', event });
         respondDegraded(ctx, 'Shield service recently unreachable — synchronous wait skipped (fast-probe window).', 'prompt', false, { countAsGateFailure: false });
         return;
     }
@@ -1460,7 +1394,7 @@ async function enforceShieldText(ctx) {
             method: 'POST',
             headers,
             body: JSON.stringify({ message: text }),
-        }, gateTimeoutMs, (attempt, error) => dbg({ phase: 'shield_retry', event, attempt, error }), gateAttempts);
+        }, gateTimeoutMs, (attempt, error) => (0, hookIo_1.dbg)({ phase: 'shield_retry', event, attempt, error }), gateAttempts);
         if (!resp.ok) {
             respondDegraded(ctx, `Backend returned HTTP ${resp.status}.`, 'prompt');
             return;

package/dist/commands/installClaudeHook.js

@@ -41,6 +41,7 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const config_1 = require("../config");
+const hookIo_1 = require("../hookIo");
 const restartNotice_1 = require("./restartNotice");
 const COLOR = {
     reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
@@ -77,9 +78,23 @@ function isManagedCommand(cmd) {
     return typeof cmd?.command === 'string'
         && (cmd.command.includes(MANAGED_MARKER) || cmd.command.includes(MANAGED_TAG));
 }
+/**
+ * Prefer the SLIM hook entry (dist/hookSlim.js — Node-builtins-only module
+ * graph, near-spawn-floor cold start) and fall back to the full CLI entry on
+ * older dist layouts. Repair rewrites stale entries through this prefix too,
+ * which is how an enrolled fleet migrates to the slim hook on upgrade.
+ */
+function hookScriptPath() {
+    const cliScript = process.argv[1] || path.join(__dirname, '..', 'index.js');
+    // argv[1] first (normal CLI invocation), then this module's own dist
+    // location — argv[1] can be an npm shim or a daemon-driven repair helper.
+    return (0, hookIo_1.slimHookEntryPath)(cliScript)
+        || (0, hookIo_1.slimHookEntryPath)(path.join(__dirname, '..', 'index.js'))
+        || cliScript;
+}
 function hookInvocationPrefix() {
     const q = (s) => (/\s/.test(s) ? `"${s}"` : s);
-    return `${q(process.execPath)} ${q(process.argv[1] || path.join(__dirname, '..', 'index.js'))}`;
+    return `${q(process.execPath)} ${q(hookScriptPath())}`;
 }
 function repairManagedCommandPath(command) {
     const marker = command.indexOf(' hook ');
@@ -189,12 +204,11 @@ function stripManaged(hooks) {
 /** Build the absolute, shell-agnostic command that invokes this CLI's `hook`. */
 function buildHookCommand(opts) {
     const nodeExe = process.execPath;
-    const scriptPath = process.argv[1] || path.join(__dirname, '..', 'index.js');
     const q = (s) => (/\s/.test(s) ? `"${s}"` : s);
     // No --event flag: the bridge detects the Claude payload (hook_event_name) itself.
     // local-only affects prompt events only; tool events still use the complete
     // Action Policy/approval path. This keeps prompt text on the endpoint.
-    let cmd = `${q(nodeExe)} ${q(scriptPath)} hook --approval-mode wait --local-only true`;
+    let cmd = `${q(nodeExe)} ${q(hookScriptPath())} hook --approval-mode wait --local-only true`;
     if (opts.shadow)
         cmd += ' --shadow true';
     if (opts.failClosed)

package/dist/commands/installCursorHook.js

@@ -41,6 +41,7 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const config_1 = require("../config");
+const hookIo_1 = require("../hookIo");
 const restartNotice_1 = require("./restartNotice");
 const COLOR = {
     reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
@@ -70,12 +71,29 @@ const EVENT_MAP = {
     file: { hookKey: 'afterFileEdit', flag: 'file', timeoutSec: APPROVAL_CAPABLE_TIMEOUT_SEC },
     read: { hookKey: 'beforeReadFile', flag: 'read', timeoutSec: APPROVAL_CAPABLE_TIMEOUT_SEC },
 };
+/**
+ * The script a hook command invokes: the SLIM entry (dist/hookSlim.js) when it
+ * exists — a Node-builtins-only module graph, so per-event cold start is the
+ * node spawn plus three small files instead of the whole CLI (the difference
+ * an EDR-heavy corporate machine feels on every docker command). Falls back
+ * to the full CLI entry when the slim file is absent (older dist layouts).
+ * The literal ` hook ` subcommand is kept in the command either way — it is
+ * the marker managed-entry repair keys on, and the slim entry ignores it.
+ */
+function hookScriptPath() {
+    const cliScript = process.argv[1] || path.join(__dirname, '..', 'index.js');
+    // Resolve the slim entry against argv[1] first (normal CLI invocation), then
+    // against this module's own dist location — argv[1] can be an npm shim or a
+    // helper script (daemon-driven repair) rather than dist/index.js.
+    return (0, hookIo_1.slimHookEntryPath)(cliScript)
+        || (0, hookIo_1.slimHookEntryPath)(path.join(__dirname, '..', 'index.js'))
+        || cliScript;
+}
 /** Build the absolute, shell-agnostic command that invokes this CLI's `hook`. */
 function buildHookCommand(flag, opts) {
     const nodeExe = process.execPath; // real node binary (handles Windows/Linux/mac)
-    const scriptPath = process.argv[1] || path.join(__dirname, '..', 'index.js');
     const q = (s) => (/\s/.test(s) ? `"${s}"` : s);
-    let cmd = `${q(nodeExe)} ${q(scriptPath)} hook --event ${flag}`;
+    let cmd = `${q(nodeExe)} ${q(hookScriptPath())} hook --event ${flag}`;
     if (opts.shadow)
         cmd += ' --shadow true';
     if (opts.failClosed)
@@ -113,9 +131,11 @@ function isManaged(entry) {
 }
 function hookInvocationPrefix() {
     const nodeExe = process.execPath;
-    const scriptPath = process.argv[1] || path.join(__dirname, '..', 'index.js');
     const q = (s) => (/\s/.test(s) ? `"${s}"` : s);
-    return `${q(nodeExe)} ${q(scriptPath)}`;
+    // Repair rewrites stale managed entries to the slim entry too — this is how
+    // an already-enrolled fleet migrates to the slim hook on upgrade, without a
+    // reinstall (protection repair runs from the daemon after every update).
+    return `${q(nodeExe)} ${q(hookScriptPath())}`;
 }
 function repairManagedCommandPath(command) {
     const marker = command.indexOf(' hook ');

package/dist/distress.d.ts

@@ -48,6 +48,12 @@ export declare const DISTRESS: {
     readonly MACHINE_KEYFILE_ACL_FAILED: "machine_keyfile_acl_failed";
     /** Fail-closed engaged: hook is BLOCKING user actions because the policy gate is persistently unreachable. */
     readonly HOOK_FAIL_CLOSED: "hook_fail_closed";
+    /**
+     * A daemon poll never settled and was abandoned at its deadline. Usually a
+     * socket that died without a FIN (sleep / VPN / proxy). Self-heals on the
+     * next tick — but while it lasted, remote actions were undeliverable.
+     */
+    readonly POLL_STALLED: "poll_stalled";
     /** Anything nobody predicted — reported via reportUnexpected(). */
     readonly UNEXPECTED: "unexpected_error";
 };

package/dist/distress.js

@@ -93,6 +93,12 @@ exports.DISTRESS = {
     MACHINE_KEYFILE_ACL_FAILED: 'machine_keyfile_acl_failed',
     /** Fail-closed engaged: hook is BLOCKING user actions because the policy gate is persistently unreachable. */
     HOOK_FAIL_CLOSED: 'hook_fail_closed',
+    /**
+     * A daemon poll never settled and was abandoned at its deadline. Usually a
+     * socket that died without a FIN (sleep / VPN / proxy). Self-heals on the
+     * next tick — but while it lasted, remote actions were undeliverable.
+     */
+    POLL_STALLED: 'poll_stalled',
     /** Anything nobody predicted — reported via reportUnexpected(). */
     UNEXPECTED: 'unexpected_error',
 };

package/dist/hookIo.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Hook I/O leaf — the pieces of the hook runtime that BOTH entries share:
+ *
+ *   - `dist/hookSlim.js` (the slim hook entry installed into IDE hook configs)
+ *   - `dist/index.js hook` (the full CLI's hook command, and the daemon's
+ *     in-process evaluator)
+ *
+ * COLD-START CONTRACT: this module is on the slim entry's module graph, which
+ * is loaded on EVERY IDE hook event. It may import Node built-ins ONLY —
+ * every additional module here is bytes the customer's EDR re-scans per
+ * docker command. `scripts/test-slim-hook.js` enforces the graph budget.
+ */
+export declare const HOOK_DEBUG_LOG: string;
+/**
+ * Verbose diagnostics (FCD_HOOK_DEBUG=1) additionally log content previews
+ * (raw payload + prompt text snippets). Default logging keeps operational
+ * metadata only — user prompt content must never sit in a plaintext file on
+ * a customer laptop unless support explicitly opts in.
+ */
+export declare const HOOK_DEBUG_VERBOSE: boolean;
+/** Append a diagnostic line so we can see exactly what the IDE invoked + the verdict. */
+export declare function dbg(obj: Record<string, unknown>): void;
+export declare function readStdin(): Promise<string>;
+/**
+ * kebab-case CLI flags -> the camelCase HookArgs shape. ONE mapping shared by
+ * the full CLI entry (`index.ts` case 'hook') and the slim entry, so the
+ * daemon's IPC evaluator always receives identical argument shapes no matter
+ * which entry the IDE invoked.
+ */
+export declare function mapHookFlags(flags: Record<string, string>): Record<string, string | undefined>;
+/**
+ * Minimal `--flag value` / `--flag=value` parser with the same semantics as
+ * the full CLI's parseArgs, restricted to what a hook command line carries.
+ * Positionals (the literal `hook` subcommand kept in installed commands for
+ * the managed-entry repair marker) are ignored.
+ */
+export declare function parseHookFlags(argv: string[]): Record<string, string>;
+/**
+ * Absolute path of the slim hook entry that sits next to a given CLI script
+ * (`dist/index.js` -> `dist/hookSlim.js`). Installers prefer the slim entry
+ * when it exists; older installs (pre-slim dist) keep pointing at index.js.
+ */
+export declare function slimHookEntryPath(cliScriptPath: string): string | undefined;