fullcourtdefense-cli 1.36.4 → 1.37.0

package/dist/commands/desktopChatGuard.js

@@ -460,6 +460,8 @@ function startDesktopChatGuard(runtime) {
                 shieldKey: runtime.shieldKey,
                 developerName: snapshotIdentity.developerName,
                 machineName: snapshotIdentity.machineName,
+                // Read what the daemon poll keeps current — no re-download per tick.
+                hotPath: true,
             });
             scanOptions = (0, localSafetySnapshot_1.snapshotToScanOptions)(snapshot);
         }

package/dist/commands/discoverPaths.d.ts

@@ -38,6 +38,16 @@ export declare function claudeDesktopInstallTargets(configPath?: string): Claude
 export declare function candidateConfigPaths(cwd: string, extra?: string): ConfigPathCandidate[];
 /** Common places developers keep code, used by `--scan-root auto`. */
 export declare function defaultScanRoots(): string[];
+type ProjectConfigScan = {
+    candidates: ConfigPathCandidate[];
+    scannedDirs: number;
+    excludedDirs: number;
+    truncated: boolean;
+    truncatedReason?: ScanTruncationReason;
+    maxDepth: number;
+    maxDirs: number;
+};
+export declare function setProjectConfigScanPass(key: string | undefined): void;
 /**
  * Bounded walk of developer folders looking for project-scoped MCP configs
  * (`--scan-root`). Depth- and volume-capped so it stays fast and predictable —
@@ -48,15 +58,7 @@ export declare function scanRootsForProjectConfigs(roots: string[], options?: {
     maxDepth?: number;
     maxDirs?: number;
     excludedRoots?: string[];
-}): {
-    candidates: ConfigPathCandidate[];
-    scannedDirs: number;
-    excludedDirs: number;
-    truncated: boolean;
-    truncatedReason?: ScanTruncationReason;
-    maxDepth: number;
-    maxDirs: number;
-};
+}): ProjectConfigScan;
 export interface FolderCatalogEntry {
     path: string;
     /** Depth relative to its walk root (home or a dev root) — lets the UI indent. */
@@ -85,3 +87,4 @@ export declare function discoverScanTargets(cwd: string, extra?: string): Config
  * `~/.codex` / `~/.cursor` without Cursor.exe must not count as installed.
  */
 export declare function detectIdeAppInstalled(clientKey: string, env?: NodeJS.ProcessEnv, home?: string, platform?: NodeJS.Platform): boolean;
+export {};

package/dist/commands/discoverPaths.js

@@ -46,6 +46,7 @@ exports.claudeDesktopLikelyInstalled = claudeDesktopLikelyInstalled;
 exports.claudeDesktopInstallTargets = claudeDesktopInstallTargets;
 exports.candidateConfigPaths = candidateConfigPaths;
 exports.defaultScanRoots = defaultScanRoots;
+exports.setProjectConfigScanPass = setProjectConfigScanPass;
 exports.scanRootsForProjectConfigs = scanRootsForProjectConfigs;
 exports.buildFolderCatalog = buildFolderCatalog;
 exports.resolveScanRoots = resolveScanRoots;
@@ -297,6 +298,23 @@ function defaultScanRoots() {
         }
     });
 }
+/**
+ * Reuse of one walk across a single daemon protection pass. A pass inspects,
+ * repairs, rescans and verifies, and each step walked every scan root again
+ * (4-7 walks of up to 25,000 folders). Only the daemon's housekeeping sets a
+ * pass key; every other caller (and work between a pass's steps) walks fresh.
+ */
+let scanPassKey;
+const scanPassResults = new Map();
+const SCAN_PASSES_KEPT = 4;
+function setProjectConfigScanPass(key) {
+    scanPassKey = key;
+    if (key === undefined || scanPassResults.has(key))
+        return;
+    scanPassResults.set(key, new Map());
+    while (scanPassResults.size > SCAN_PASSES_KEPT)
+        scanPassResults.delete(scanPassResults.keys().next().value);
+}
 /**
  * Bounded walk of developer folders looking for project-scoped MCP configs
  * (`--scan-root`). Depth- and volume-capped so it stays fast and predictable —
@@ -304,6 +322,18 @@ function defaultScanRoots() {
  * are pruned; only the known project config filenames are checked.
  */
 function scanRootsForProjectConfigs(roots, options = {}) {
+    const pass = scanPassKey === undefined ? undefined : scanPassResults.get(scanPassKey);
+    if (!pass)
+        return walkProjectConfigs(roots, options);
+    const memoKey = JSON.stringify([roots, options.maxDepth, options.maxDirs, options.excludedRoots]);
+    const cached = pass.get(memoKey);
+    if (cached)
+        return { ...cached, candidates: cached.candidates.map(candidate => ({ ...candidate })) };
+    const result = walkProjectConfigs(roots, options);
+    pass.set(memoKey, result);
+    return { ...result, candidates: result.candidates.map(candidate => ({ ...candidate })) };
+}
+function walkProjectConfigs(roots, options) {
     const maxDepth = options.maxDepth ?? 4;
     const maxDirs = options.maxDirs ?? 25000;
     const candidates = [];

package/dist/commands/ephemeralStack.js

@@ -51,6 +51,7 @@ const config_1 = require("../config");
 const child_process_1 = require("child_process");
 const installClaudeHook_1 = require("./installClaudeHook");
 const mcpGateway_1 = require("./mcpGateway");
+const refreshPolicyCache_1 = require("./refreshPolicyCache");
 /**
  * Written by `ci-protect` / `workload-protect` next to the credentials they
  * save. Its presence says "the enrollment on this machine is EPHEMERAL", so a
@@ -214,6 +215,12 @@ async function startDetachedHttpGateway(input) {
  */
 async function installEphemeralProtectionStack(options, config) {
     const sendLog = options.sendLog || exports.silentLogSink;
+    // Seed both policy caches before the agent's first action, as login does:
+    // hooks and gateways never fetch policy while a cache exists, and a job or
+    // container has no daemon to poll. Callers export the ephemeral identity
+    // (FCD_MACHINE_ID) first, so the seed carries it. Best-effort and silent —
+    // on failure the hot path's single-flight no-cache attempt still applies.
+    await (0, refreshPolicyCache_1.refreshPolicyCachesInBackground)({ apiUrl: options.apiUrl, shieldId: options.shieldId, shieldKey: options.shieldKey });
     // The Claude-format hook covers Claude Code, VS Code agent mode, and
     // Copilot CLI — the common agents on runners and in containers.
     if (options.hooks !== 'false') {

package/dist/commands/flushSpool.d.ts

@@ -4,6 +4,8 @@ export interface FlushSpoolArgs {
     shieldId?: string;
     shieldKey?: string;
     heartbeat?: string;
+    /** `false`: leave the terminal guard rule files alone (the daemon keeps their 30 s cadence). */
+    guardRules?: string;
 }
 /**
  * `fullcourtdefense flush-spool` — drain the local telemetry spool to the backend

package/dist/commands/flushSpool.js

@@ -16,12 +16,19 @@ async function flushSpoolCommand(args, config) {
     });
     if (!creds.shieldId)
         return; // nothing to attribute to
-    const result = await (0, telemetry_1.flushSpool)({
+    // Drains in batches and records completion for the hooks that coalesced
+    // onto this flusher. `--heartbeat liveness` (hook-requested flushes):
+    // liveness only, no diagnostic payload, and a short linger for the rest of
+    // the burst that requested it.
+    const hookRequested = args.heartbeat === 'liveness';
+    const result = await (0, telemetry_1.drainSpool)({
         apiUrl: creds.apiUrl,
         shieldId: creds.shieldId,
         shieldKey: creds.shieldKey,
         heartbeat: args.heartbeat !== 'false',
-    });
+        livenessOnly: hookRequested,
+        refreshGuardRules: args.guardRules !== 'false',
+    }, { linger: hookRequested });
     if (result) {
         console.log(`Flushed ${result.accepted} event(s)${result.deduped ? `, ${result.deduped} deduped` : ''}.`);
     }

package/dist/commands/hook.d.ts

@@ -34,6 +34,7 @@ export interface HookArgs {
     approvalMode?: string;
     approvalTimeoutMs?: string;
     approvalPollMs?: string;
+    ideTimeout?: string;
 }
 /**
  * `post` = a post-execution hook (Cursor afterShellExecution / afterMCPExecution, Claude
@@ -209,6 +210,14 @@ export interface HookIo {
      * mode, where `exit` only unwinds the evaluation and the process lives on.
      */
     exitsProcess: boolean;
+    /**
+     * Native hooks (Codex, Gemini CLI, Windsurf, Kiro): a block-mode local-first
+     * allow queues its check-tool-call report (gateReports.ts) instead of
+     * spooling it. These processes used to send that report themselves and
+     * wait for it; its answer still ends a gate-failure streak and feeds the
+     * server's behavior baseline, only after the verdict and off this process.
+     */
+    deferGateReports?: boolean;
     /** Evaluated inside the resident daemon for a thin client (see DaemonDeclined). */
     viaDaemon?: boolean;
     /** Set when this evaluation's verdict is a stop still being settled (approval wait). */
@@ -245,9 +254,14 @@ export declare function crashVerdictForProcess(event: string | undefined, messag
  * snapshot, policy engine) is warm here — verdicts resolve in milliseconds.
  * Mirrors hookCommand's fail-open contract: any unexpected exception yields
  * an allow verdict, never an error the thin client would surface.
+ * `exitsProcess`: the caller is a one-shot hook process that ends with this
+ * verdict (the slim entry's fallback, native hooks) — see HookIo.exitsProcess.
+ * `deferGateReports`: native hooks — see HookIo.deferGateReports.
  */
 export declare function evaluateHookRequest(args: HookArgs, stdinRaw: string, config: BotGuardConfig, opts?: {
     viaDaemon?: boolean;
+    exitsProcess?: boolean;
+    deferGateReports?: boolean;
 }): Promise<{
     stdout: string;
     stderr: string;