fullcourtdefense-cli 1.15.12 → 1.17.0

package/dist/commands/daemon.js

@@ -50,6 +50,7 @@ const notify_1 = require("../notify");
 const integrity_1 = require("../integrity");
 const machineIdentity_1 = require("../machineIdentity");
 const discoveryMarker_1 = require("../discoveryMarker");
+const selfUpdate_1 = require("../selfUpdate");
 const COLOR = {
     reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
     red: '\x1b[31m', yellow: '\x1b[33m', green: '\x1b[32m', cyan: '\x1b[36m', gray: '\x1b[90m',
@@ -293,6 +294,8 @@ async function runDaemon(args, config) {
     let suspended = false;
     let stopped = false;
     const executingActionIds = new Set();
+    /** Latest org auto-update policy seen on a bundle poll. */
+    let autoUpdatePolicy;
     const reprotect = async (reasonPaths) => {
         if (reprotecting || stopped)
             return;
@@ -525,6 +528,24 @@ async function runDaemon(args, config) {
                 log(`Repair protection: verified (${verification.protectedMcpConfigs}/${verification.discoveredMcpConfigs} MCP configs wrapped).`);
                 resultSummary = 'AgentGuard hooks, gateways, and protection configuration were repaired and verified.';
             }
+            else if (action.type === 'upgrade_cli') {
+                // Explicit version in the action reason wins; otherwise the org
+                // auto-update target from the bundle (pinned or latest release).
+                const target = action.reason.match(/\d+\.\d+\.\d+/)?.[0] || autoUpdatePolicy?.targetVersion;
+                if (!target)
+                    throw new Error('No target version available — the control plane could not resolve the latest release.');
+                log(`Upgrade CLI: admin requested an upgrade to ${target}.`);
+                const outcome = (0, selfUpdate_1.maybeSelfUpdate)({ currentVersion: cliVersion(), targetVersion: target, enabled: true, log });
+                if (!outcome) {
+                    resultSummary = `CLI ${cliVersion() || 'unknown'} is already at ${target} (or an upgrade is in progress).`;
+                }
+                else if (outcome.started) {
+                    resultSummary = outcome.detail;
+                }
+                else {
+                    throw new Error(outcome.detail);
+                }
+            }
             else if (action.type === 'discovery_scan') {
                 log('Discovery scan: starting full surface sweep (MCP + secrets + agent files + posture)…');
                 await uploadLogTail();
@@ -585,6 +606,27 @@ async function runDaemon(args, config) {
             if (bundle.machineAction) {
                 void executeMachineAction(bundle.machineAction);
             }
+            // Silent auto-update: upgrade toward the org's target version. Skipped
+            // while a remote action runs, while suspended, and rate-limited so a
+            // pending upgrade isn't re-kicked every poll.
+            autoUpdatePolicy = bundle.autoUpdate;
+            // Mirror the org policy for the elevated MSI updater task (it runs as
+            // SYSTEM and cannot read the shield-key-authenticated bundle itself).
+            if (bundle.autoUpdate) {
+                try {
+                    fs.writeFileSync(path.join(daemonDir(), 'update-policy.json'), JSON.stringify({ ...bundle.autoUpdate, updatedAt: new Date().toISOString() }), 'utf8');
+                }
+                catch { /* mirror is best-effort; the updater defaults to enabled */ }
+            }
+            if (!suspended && bundle.autoUpdate?.enabled) {
+                (0, selfUpdate_1.maybeSelfUpdate)({
+                    currentVersion: cliVersion(),
+                    targetVersion: bundle.autoUpdate.targetVersion,
+                    enabled: true,
+                    busy: executingActionIds.size > 0,
+                    log,
+                });
+            }
         }
         catch { /* offline — cached stance applies */ }
     };

package/dist/commands/installAll.js

@@ -42,8 +42,9 @@ async function installAllCommand(args, config) {
             apiUrl: creds.apiUrl,
             project: args.cursorProject,
             // Scope is MCP/tool actions only — prompt text never leaves the machine.
+            // No failClosed flag: the offline stance is server-authoritative (from
+            // the runtime bundle), unified with the Claude/VS Code hook below.
             events: 'shell,mcp',
-            failClosed: 'true',
         };
         try {
             await (0, installCursorHook_1.installCursorHookCommand)(hookArgs, config);

package/dist/commands/installCursorHook.js

@@ -59,12 +59,16 @@ const MANAGED_TAG = 'fullcourtdefense';
 // developer would see a silent hook failure instead of a clean
 // approved/rejected/timeout verdict.
 const APPROVAL_CAPABLE_TIMEOUT_SEC = 960; // 16 min: 15 min approval window + poll slack
+// Offline stance is deliberately NOT baked into the hook command by default:
+// the runtime `hook` resolves it from the org's runtime bundle (enforcing
+// machines fail closed, monitor machines fail open), identical to the Claude
+// hook. Passing --fail-closed at install time writes an explicit override.
 const EVENT_MAP = {
-    prompt: { hookKey: 'beforeSubmitPrompt', flag: 'prompt', failClosedDefault: false, timeoutSec: 10 },
-    shell: { hookKey: 'beforeShellExecution', flag: 'shell', failClosedDefault: true, timeoutSec: APPROVAL_CAPABLE_TIMEOUT_SEC },
-    mcp: { hookKey: 'beforeMCPExecution', flag: 'mcp', failClosedDefault: true, timeoutSec: APPROVAL_CAPABLE_TIMEOUT_SEC },
-    file: { hookKey: 'afterFileEdit', flag: 'file', failClosedDefault: false, timeoutSec: APPROVAL_CAPABLE_TIMEOUT_SEC },
-    read: { hookKey: 'beforeReadFile', flag: 'read', failClosedDefault: false, timeoutSec: APPROVAL_CAPABLE_TIMEOUT_SEC },
+    prompt: { hookKey: 'beforeSubmitPrompt', flag: 'prompt', timeoutSec: 10 },
+    shell: { hookKey: 'beforeShellExecution', flag: 'shell', timeoutSec: APPROVAL_CAPABLE_TIMEOUT_SEC },
+    mcp: { hookKey: 'beforeMCPExecution', flag: 'mcp', timeoutSec: APPROVAL_CAPABLE_TIMEOUT_SEC },
+    file: { hookKey: 'afterFileEdit', flag: 'file', timeoutSec: APPROVAL_CAPABLE_TIMEOUT_SEC },
+    read: { hookKey: 'beforeReadFile', flag: 'read', timeoutSec: APPROVAL_CAPABLE_TIMEOUT_SEC },
 };
 /** Build the absolute, shell-agnostic command that invokes this CLI's `hook`. */
 function buildHookCommand(flag, opts) {
@@ -142,12 +146,12 @@ function repairCursorManagedHooks() {
     let changed = false;
     if (before.managedEntries === 0) {
         for (const event of ['shell', 'mcp']) {
-            const { hookKey, flag, failClosedDefault, timeoutSec } = EVENT_MAP[event];
+            const { hookKey, flag, timeoutSec } = EVENT_MAP[event];
             const list = Array.isArray(json.hooks[hookKey]) ? json.hooks[hookKey] : [];
             list.push({
-                command: buildHookCommand(flag, { shadow: false, failClosed: failClosedDefault, waitForApproval: true }),
+                // Offline stance comes from the runtime bundle at hook time.
+                command: buildHookCommand(flag, { shadow: false, failClosed: false, waitForApproval: true }),
                 timeout: timeoutSec,
-                ...(failClosedDefault ? { failClosed: true } : {}),
             });
             json.hooks[hookKey] = list;
         }
@@ -213,8 +217,10 @@ async function installCursorHookCommand(args, config) {
             delete json.hooks[key];
     }
     for (const e of events) {
-        const { hookKey, flag, failClosedDefault, timeoutSec } = EVENT_MAP[e];
-        const failClosed = e === 'prompt' ? false : (args.failClosed !== undefined ? args.failClosed === 'true' : failClosedDefault);
+        const { hookKey, flag, timeoutSec } = EVENT_MAP[e];
+        // No explicit flag => the hook runtime applies the server-authoritative
+        // stance from the runtime bundle (same behavior as the Claude hook).
+        const failClosed = e === 'prompt' ? false : args.failClosed === 'true';
         const entry = {
             command: buildHookCommand(flag, { shadow, failClosed, waitForApproval: e !== 'prompt' }),
             timeout: timeoutSec,

package/dist/commands/login.d.ts

@@ -3,6 +3,8 @@ export interface LoginArgs {
     /** Reusable, non-expiring fleet enrollment token (or FCD_ENROLL_TOKEN env). */
     token?: string;
     apiUrl?: string;
+    /** Admin-facing friendly machine name shown next to the hostname in the console. */
+    nickname?: string;
 }
 /**
  * `fullcourtdefense login` — zero-paste machine enrollment.

package/dist/commands/login.js

@@ -21,8 +21,11 @@ async function loginCommand(args, config) {
     }
     const identity = (0, machineIdentity_1.getMachineIdentity)();
     const shieldName = (0, machineIdentity_1.suggestedShieldName)(identity);
+    const nickname = (args.nickname || process.env.FCD_MACHINE_NICKNAME || '').trim().slice(0, 80) || undefined;
     console.log('\x1b[1mEnrolling this machine…\x1b[0m');
     console.log(`  Device:  ${identity.developerName}`);
+    if (nickname)
+        console.log(`  Name:    ${nickname}`);
     console.log(`  OS:      ${identity.osFriendly}`);
     console.log(`  Shield:  ${shieldName}`);
     const resp = await fetch(`${apiUrl}/api/cli/enroll`, {
@@ -39,6 +42,7 @@ async function loginCommand(args, config) {
             osFriendly: identity.osFriendly,
             platform: identity.platform,
             shieldName,
+            nickname,
         }),
     });
     const data = (await resp.json().catch(() => ({})));

package/dist/commands/mcpGateway.js

@@ -579,18 +579,34 @@ class AgentGuardApi {
     }
     async waitForApproval(actionId) {
         const deadline = Date.now() + this.config.approvalTimeoutMs;
+        // Tolerate transient poll blips, but fail FAST on a dead backend: waiting
+        // out the full approval window against a server that answers nothing just
+        // hangs the developer's tool call for minutes.
+        const MAX_CONSECUTIVE_POLL_ERRORS = 3;
+        let consecutiveErrors = 0;
         while (Date.now() <= deadline) {
-            const status = await this.get(`/api/agent-security/runtime/approvals/${encodeURIComponent(actionId)}?shieldId=${encodeURIComponent(this.config.shieldId)}`);
-            const approval = status.data?.approval;
-            if (approval?.approvalStatus === 'approved') {
-                if (approval.executionStatus === 'executed')
-                    throw new Error(`Approval ${actionId} was already executed.`);
-                return;
+            try {
+                const status = await this.get(`/api/agent-security/runtime/approvals/${encodeURIComponent(actionId)}?shieldId=${encodeURIComponent(this.config.shieldId)}`);
+                consecutiveErrors = 0;
+                const approval = status.data?.approval;
+                if (approval?.approvalStatus === 'approved') {
+                    if (approval.executionStatus === 'executed')
+                        throw new Error(`Approval ${actionId} was already executed.`);
+                    return;
+                }
+                if (approval?.approvalStatus === 'rejected')
+                    throw new Error(`Approval rejected for ${approval.toolName}.`);
+                if (approval?.approvalStatus === 'expired')
+                    throw new Error(`Approval expired for ${approval.toolName}.`);
+            }
+            catch (error) {
+                if (error instanceof Error && /rejected|expired|already executed/.test(error.message))
+                    throw error;
+                consecutiveErrors += 1;
+                if (consecutiveErrors >= MAX_CONSECUTIVE_POLL_ERRORS) {
+                    throw new Error(`Approval status could not be checked (${consecutiveErrors} consecutive failures) — the control plane is unreachable. The request stays pending; retry once connectivity is restored.`);
+                }
             }
-            if (approval?.approvalStatus === 'rejected')
-                throw new Error(`Approval rejected for ${approval.toolName}.`);
-            if (approval?.approvalStatus === 'expired')
-                throw new Error(`Approval expired for ${approval.toolName}.`);
             await new Promise(resolve => setTimeout(resolve, Math.min(this.config.approvalPollMs, Math.max(0, deadline - Date.now()))));
         }
         throw new Error(`Approval timed out. Request ${actionId} is still waiting for review.`);
@@ -609,7 +625,10 @@ class AgentGuardApi {
             agentName: this.config.agentName,
             operation: input.operation,
             toolArgs: input.toolArgs,
-        });
+            // Large tool outputs can legitimately take longer than policy checks
+            // (full Shield pipeline incl. AI judge) — but still far below the old
+            // 120s, which read as a frozen IDE.
+        }, 20_000);
         if (!response.success && response.error)
             throw new Error(response.error);
         const data = response.data;
@@ -620,23 +639,26 @@ class AgentGuardApi {
             ? { content: [{ type: 'text', text: data.safeResponse }] }
             : input.result;
     }
-    async post(pathValue, body) {
+    // Tight timeouts on purpose: the gateway sits INSIDE the IDE's tool-call
+    // path, so a slow/hung backend must degrade into the offline stance in
+    // seconds — a 2-minute hang looks like a frozen IDE to the developer.
+    async post(pathValue, body, timeoutMs = 10_000) {
         const resp = await fetch(`${this.config.apiUrl}${pathValue}`, {
             method: 'POST',
             headers: this.headers(),
             body: JSON.stringify(body),
-            signal: AbortSignal.timeout(120000),
+            signal: AbortSignal.timeout(timeoutMs),
         });
         const data = await resp.json().catch(() => ({}));
         if (!resp.ok)
             return { success: false, error: data.error || `AgentGuard API error (${resp.status})` };
         return data;
     }
-    async get(pathValue) {
+    async get(pathValue, timeoutMs = 10_000) {
         const resp = await fetch(`${this.config.apiUrl}${pathValue}`, {
             method: 'GET',
             headers: this.headers(),
-            signal: AbortSignal.timeout(120000),
+            signal: AbortSignal.timeout(timeoutMs),
         });
         const data = await resp.json().catch(() => ({}));
         if (!resp.ok)
@@ -753,7 +775,9 @@ class McpGatewayServer {
         try {
             // The runtime bundle carries the org's current Local Safety policy hash —
             // passing it as `expectedPolicyHash` makes a console policy edit take
-            // effect on the very next tool call instead of waiting out the cache TTL.
+            // effect within the 60s cache TTL. NOT forced: a forced network round
+            // trip on EVERY tool call would add latency and a hang point to the
+            // IDE's hot path; the TTL'd cache refreshes with a 1.5s cap instead.
             // Offline this resolves from the cached bundle (stale-while-error).
             let expectedPolicyHash;
             try {
@@ -763,7 +787,6 @@ class McpGatewayServer {
                     shieldKey: this.gatewayConfig.shieldKey,
                     developerName: this.gatewayConfig.developerName,
                     machineName: os.hostname(),
-                    force: true,
                 });
                 if (bundle.source !== 'default') {
                     expectedPolicyHash = bundle.policyHash || bundle.version;

package/dist/commands/onboard.d.ts

@@ -3,6 +3,8 @@ import { InstallAllArgs } from './installAll';
 export interface OnboardArgs extends InstallAllArgs {
     /** Fleet enrollment token (or FCD_ENROLL_TOKEN env). Optional when already enrolled. */
     token?: string;
+    /** Admin-facing friendly machine name (or FCD_MACHINE_NICKNAME env) shown in the console. */
+    nickname?: string;
     /** Continue a persisted onboarding transaction. */
     resume?: string;
     /** Re-run completed install steps to repair changed machine state. */

package/dist/commands/onboard.js

@@ -50,6 +50,8 @@ const posixShellGuard_1 = require("./posixShellGuard");
 const notify_1 = require("../notify");
 const daemon_1 = require("./daemon");
 const machineIdentity_1 = require("../machineIdentity");
+const integrity_1 = require("../integrity");
+const telemetry_1 = require("../telemetry");
 const onboardingJournal_1 = require("./onboardingJournal");
 const GREEN = '\x1b[32m';
 const RED = '\x1b[31m';
@@ -249,7 +251,7 @@ async function onboardCommand(args, config) {
         mark('enrollment', 'skipped', alreadyEnrolled ? 'would reuse existing per-machine Shield credentials' : 'would enroll with supplied token');
     }
     else if (token) {
-        await (0, login_1.loginCommand)({ token, apiUrl: args.apiUrl }, config);
+        await (0, login_1.loginCommand)({ token, apiUrl: args.apiUrl, nickname: args.nickname }, config);
         mark('enrollment', 'completed', 'machine enrolled');
     }
     else if (alreadyEnrolled) {
@@ -349,6 +351,34 @@ async function onboardCommand(args, config) {
     console.log(`\n${BOLD}[6/6] Verifying protection surfaces…${RESET}`);
     mark('verification', 'running');
     const postCreds = (0, config_1.resolveCliCredentials)((0, config_1.loadConfig)(), { apiUrl });
+    // Immediate heartbeat: the machine must appear ONLINE in the fleet console
+    // the moment onboarding finishes — not whenever the daemon's first 5-minute
+    // tick or the daily discovery job happens to fire. Carries the local
+    // integrity verdict so the console shows agent health right away too.
+    let firstHeartbeatOk = false;
+    if (!dryRun && postCreds.shieldId) {
+        try {
+            const integrity = (0, integrity_1.getLocalIntegrityReport)();
+            let agentVersion;
+            try {
+                agentVersion = JSON.parse(fs.readFileSync(path.resolve(__dirname, '..', '..', 'package.json'), 'utf8')).version;
+            }
+            catch { /* version is optional on the heartbeat */ }
+            const flush = await (0, telemetry_1.flushSpool)({
+                apiUrl,
+                shieldId: postCreds.shieldId,
+                shieldKey: postCreds.shieldKey,
+                heartbeat: true,
+                agentVersion,
+                integrityOk: integrity.ok,
+                integrityReasons: integrity.reasons,
+                integrityCheckedAt: integrity.checkedAt,
+                timeoutMs: 8_000,
+            });
+            firstHeartbeatOk = flush !== null;
+        }
+        catch { /* the daemon heartbeat remains the backstop */ }
+    }
     const checks = [
         reachable,
         {
@@ -371,6 +401,16 @@ async function onboardCommand(args, config) {
             optional: true,
             detail: (0, discoverSchedule_1.isDiscoverScheduleInstalled)() ? undefined : 'run discover --schedule daily',
         },
+        {
+            // Informational: protection is local, so a flaky first ping must never
+            // fail onboarding — the daemon heartbeat retries within 5 minutes.
+            label: 'First heartbeat delivered',
+            ok: firstHeartbeatOk,
+            optional: true,
+            detail: firstHeartbeatOk
+                ? 'this machine now shows ONLINE in the fleet console'
+                : dryRun ? 'skipped (dry run)' : 'not delivered yet — the daemon retries within 5 minutes',
+        },
     ];
     console.log('');
     for (const check of checks)
@@ -388,6 +428,24 @@ async function onboardCommand(args, config) {
     else {
         console.log(`${YELLOW}${BOLD}Onboarding finished with ${requiredFailures.length} unresolved surface(s).${RESET} Fix the ✗ lines above and re-run ${BOLD}fullcourtdefense onboard${RESET}.`);
         mark('verification', 'failed', undefined, `${requiredFailures.length} critical protection surfaces unresolved`);
+        // Surface the partial install in the fleet console, not just locally: spool
+        // a failed-install event (flushed with the heartbeat above or by the daemon)
+        // so admins see WHICH surfaces are missing without touching the laptop.
+        if (!dryRun && postCreds.shieldId) {
+            try {
+                (0, telemetry_1.spoolEvent)({
+                    type: 'verdict',
+                    decision: 'allow',
+                    source: 'builtin',
+                    toolName: 'onboarding',
+                    operation: 'install_verification_failed',
+                    reason: `Onboarding finished with unresolved surfaces: ${requiredFailures.map(check => check.label).join(', ')}`,
+                    severity: 'high',
+                });
+                await (0, telemetry_1.flushSpool)({ apiUrl, shieldId: postCreds.shieldId, shieldKey: postCreds.shieldKey, timeoutMs: 5_000 });
+            }
+            catch { /* best-effort */ }
+        }
         report('Fix the failed required surfaces, then run fullcourtdefense onboard --resume --repair.');
         process.exitCode = 1;
     }

package/dist/index.js

@@ -506,6 +506,7 @@ async function main() {
             const args = {
                 token: flags.token || flags['enroll-token'],
                 apiUrl: flags['api-url'],
+                nickname: flags.nickname || flags['machine-name'],
             };
             await (0, login_1.loginCommand)(args, config);
             break;
@@ -646,6 +647,7 @@ async function main() {
             const args = {
                 ...buildInstallArgs(),
                 token: flags.token || flags['enroll-token'],
+                nickname: flags.nickname || flags['machine-name'],
                 hooks: flags.hooks,
                 discover: flags.discover,
                 autoProtect: flags['auto-protect'],

package/dist/runtimeConfig.d.ts

@@ -28,10 +28,15 @@ export interface RuntimeBundle {
     extraScanRoots?: string[];
     /** Default scan folders the admin explicitly removed from this machine's posture sweep. */
     disabledScanRoots?: string[];
+    /** Org auto-update policy: silently upgrade the CLI to targetVersion. */
+    autoUpdate?: {
+        enabled: boolean;
+        targetVersion?: string;
+    };
     /** One constrained, auditable action queued for the resident daemon. */
     machineAction?: {
         id: string;
-        type: 'health_check' | 'policy_refresh' | 'discovery_scan' | 'repair_protection';
+        type: 'health_check' | 'policy_refresh' | 'discovery_scan' | 'repair_protection' | 'upgrade_cli';
         reason: string;
         createdAt: string;
         expiresAt: string;

package/dist/runtimeConfig.js

@@ -72,7 +72,7 @@ async function getRuntimeBundle(input) {
     const cached = cache[input.shieldId];
     const fresh = cached && Date.now() - cached.fetchedAt < ttl;
     if (cached && fresh && !input.force) {
-        return { mode: cached.mode, version: cached.version, policyHash: cached.policyHash, policyCount: cached.policyCount, pollIntervalMs: cached.pollIntervalMs, failClosed: cached.failClosed, suspended: cached.suspended, extraScanRoots: cached.extraScanRoots, disabledScanRoots: cached.disabledScanRoots, machineAction: cached.machineAction, source: 'cache' };
+        return { mode: cached.mode, version: cached.version, policyHash: cached.policyHash, policyCount: cached.policyCount, pollIntervalMs: cached.pollIntervalMs, failClosed: cached.failClosed, suspended: cached.suspended, extraScanRoots: cached.extraScanRoots, disabledScanRoots: cached.disabledScanRoots, autoUpdate: cached.autoUpdate, machineAction: cached.machineAction, source: 'cache' };
     }
     try {
         const headers = { 'Content-Type': 'application/json' };
@@ -92,7 +92,7 @@ async function getRuntimeBundle(input) {
         if (resp.status === 304 && cached) {
             cache[input.shieldId] = { ...cached, fetchedAt: Date.now() };
             writeCacheFile(cache);
-            return { mode: cached.mode, version: cached.version, policyHash: cached.policyHash, policyCount: cached.policyCount, pollIntervalMs: cached.pollIntervalMs, failClosed: cached.failClosed, suspended: cached.suspended, extraScanRoots: cached.extraScanRoots, disabledScanRoots: cached.disabledScanRoots, machineAction: cached.machineAction, source: 'cache' };
+            return { mode: cached.mode, version: cached.version, policyHash: cached.policyHash, policyCount: cached.policyCount, pollIntervalMs: cached.pollIntervalMs, failClosed: cached.failClosed, suspended: cached.suspended, extraScanRoots: cached.extraScanRoots, disabledScanRoots: cached.disabledScanRoots, autoUpdate: cached.autoUpdate, machineAction: cached.machineAction, source: 'cache' };
         }
         if (resp.ok) {
             const body = await resp.json().catch(() => ({}));
@@ -111,6 +111,12 @@ async function getRuntimeBundle(input) {
                     disabledScanRoots: Array.isArray(body.data.disabledScanRoots)
                         ? body.data.disabledScanRoots.filter((root) => typeof root === 'string').slice(0, 20)
                         : undefined,
+                    autoUpdate: body.data.autoUpdate && typeof body.data.autoUpdate === 'object'
+                        ? {
+                            enabled: body.data.autoUpdate.enabled === true,
+                            targetVersion: typeof body.data.autoUpdate.targetVersion === 'string' ? body.data.autoUpdate.targetVersion : undefined,
+                        }
+                        : undefined,
                     machineAction: body.data.machineAction,
                     fetchedAt: Date.now(),
                 };
@@ -122,7 +128,7 @@ async function getRuntimeBundle(input) {
     }
     catch { /* fall through to cache / default */ }
     if (cached) {
-        return { mode: cached.mode, version: cached.version, policyHash: cached.policyHash, policyCount: cached.policyCount, pollIntervalMs: cached.pollIntervalMs, failClosed: cached.failClosed, suspended: cached.suspended, extraScanRoots: cached.extraScanRoots, disabledScanRoots: cached.disabledScanRoots, machineAction: cached.machineAction, source: 'cache' };
+        return { mode: cached.mode, version: cached.version, policyHash: cached.policyHash, policyCount: cached.policyCount, pollIntervalMs: cached.pollIntervalMs, failClosed: cached.failClosed, suspended: cached.suspended, extraScanRoots: cached.extraScanRoots, disabledScanRoots: cached.disabledScanRoots, autoUpdate: cached.autoUpdate, machineAction: cached.machineAction, source: 'cache' };
     }
     return { mode: 'block', version: '', source: 'default' };
 }

package/dist/selfUpdate.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Silent CLI self-update.
+ *
+ * Two install kinds, two upgrade paths:
+ *   - npm  — `npm install -g fullcourtdefense-cli@<version>` replaces the
+ *            global files in place; a freshly spawned daemon then supersedes
+ *            the running one via the pid-lock version takeover.
+ *   - msi  — the CLI runs from Program Files with a bundled node.exe; a
+ *            normal-user process cannot rewrite those files, so upgrades go
+ *            through the elevated "FullCourtDefense Updater" scheduled task
+ *            registered at MSI install time (downloads + verifies + msiexec).
+ *
+ * The org-level auto-update policy (on/off/pinned) arrives on the runtime
+ * bundle; the daemon calls maybeSelfUpdate() on its poll ticks.
+ */
+export declare const MSI_UPDATER_TASK_NAME = "FullCourtDefense Updater";
+export type InstallKind = 'msi' | 'npm';
+/** MSI installs run the bundled runtime\node.exe from the install folder. */
+export declare function detectInstallKind(): InstallKind;
+/** Semver compare; returns >0 when a is newer than b. Unparseable = oldest. */
+export declare function compareCliVersions(a?: string, b?: string): number;
+export interface SelfUpdateResult {
+    started: boolean;
+    kind: InstallKind;
+    detail: string;
+}
+/**
+ * Upgrade this machine to targetVersion if it is newer than currentVersion.
+ * Cheap no-op when already current, when a kick is still pending, or when the
+ * platform path is unavailable. Never throws.
+ */
+export declare function maybeSelfUpdate(input: {
+    currentVersion?: string;
+    targetVersion?: string;
+    enabled?: boolean;
+    log?: (message: string) => void;
+    /** Skip while a remote machine action is executing (never upgrade mid-action). */
+    busy?: boolean;
+}): SelfUpdateResult | undefined;
+/** Version the MSI updater script reads from the installed package.json. */
+export declare function installedMsiVersion(installFolder: string): string | undefined;

package/dist/selfUpdate.js

@@ -0,0 +1,180 @@
+"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.MSI_UPDATER_TASK_NAME = void 0;
+exports.detectInstallKind = detectInstallKind;
+exports.compareCliVersions = compareCliVersions;
+exports.maybeSelfUpdate = maybeSelfUpdate;
+exports.installedMsiVersion = installedMsiVersion;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+/**
+ * Silent CLI self-update.
+ *
+ * Two install kinds, two upgrade paths:
+ *   - npm  — `npm install -g fullcourtdefense-cli@<version>` replaces the
+ *            global files in place; a freshly spawned daemon then supersedes
+ *            the running one via the pid-lock version takeover.
+ *   - msi  — the CLI runs from Program Files with a bundled node.exe; a
+ *            normal-user process cannot rewrite those files, so upgrades go
+ *            through the elevated "FullCourtDefense Updater" scheduled task
+ *            registered at MSI install time (downloads + verifies + msiexec).
+ *
+ * The org-level auto-update policy (on/off/pinned) arrives on the runtime
+ * bundle; the daemon calls maybeSelfUpdate() on its poll ticks.
+ */
+exports.MSI_UPDATER_TASK_NAME = 'FullCourtDefense Updater';
+/** MSI installs run the bundled runtime\node.exe from the install folder. */
+function detectInstallKind() {
+    const execPath = process.execPath.replace(/\\/g, '/').toLowerCase();
+    if (execPath.includes('/fullcourtdefense/runtime/node'))
+        return 'msi';
+    const entry = (process.argv[1] || '').replace(/\\/g, '/').toLowerCase();
+    if (entry.includes('/fullcourtdefense/dist/'))
+        return 'msi';
+    return 'npm';
+}
+/** Semver compare; returns >0 when a is newer than b. Unparseable = oldest. */
+function compareCliVersions(a, b) {
+    const parse = (value) => String(value || '0').replace(/^v/, '').split('.').map(part => parseInt(part, 10) || 0);
+    const [pa, pb] = [parse(a), parse(b)];
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const diff = (pa[i] || 0) - (pb[i] || 0);
+        if (diff !== 0)
+            return diff;
+    }
+    return 0;
+}
+function npmCommand() {
+    return process.platform === 'win32' ? 'npm.cmd' : 'npm';
+}
+/**
+ * Kick off an npm global upgrade in a detached child, then (once npm exits 0)
+ * spawn a fresh daemon from the same entry path — the new build reads the
+ * updated package.json, wins the version-takeover in acquirePidLock(), and
+ * stops the old daemon. The old process never kills itself mid-upgrade, so a
+ * failed npm install leaves the machine exactly as it was.
+ */
+function startNpmSelfUpdate(targetVersion, log) {
+    const entry = path.resolve(process.argv[1] || '');
+    const script = [
+        `"${npmCommand()}" install -g fullcourtdefense-cli@${targetVersion}`,
+        // Relaunch the daemon from the (now replaced) global entry. The pid-lock
+        // takeover in the new daemon stops this one.
+        `&& "${process.execPath}" "${entry}" daemon`,
+    ].join(' ');
+    try {
+        const child = process.platform === 'win32'
+            ? (0, child_process_1.spawn)('cmd.exe', ['/d', '/s', '/c', script], { detached: true, stdio: 'ignore', windowsHide: true })
+            : (0, child_process_1.spawn)('/bin/sh', ['-c', script], { detached: true, stdio: 'ignore' });
+        child.unref();
+        log(`Self-update: npm upgrade to ${targetVersion} started (detached).`);
+        return { started: true, kind: 'npm', detail: `npm install -g fullcourtdefense-cli@${targetVersion} started; the new daemon supersedes this one when ready.` };
+    }
+    catch (error) {
+        const message = error.message;
+        log(`Self-update: could not start npm upgrade: ${message}`);
+        return { started: false, kind: 'npm', detail: `Could not start npm upgrade: ${message}` };
+    }
+}
+/**
+ * MSI path: run the elevated updater task registered at install time. Running
+ * an existing task does not require elevation for the task's own principal,
+ * but group policy can deny it — in that case the daily trigger remains the
+ * backstop and we report that honestly.
+ */
+function startMsiSelfUpdate(targetVersion, log) {
+    const query = (0, child_process_1.spawnSync)('schtasks', ['/Query', '/TN', exports.MSI_UPDATER_TASK_NAME], { stdio: 'ignore', windowsHide: true, timeout: 10_000 });
+    if (query.status !== 0) {
+        log('Self-update: MSI updater task is not registered on this machine — reinstall the MSI to enable silent updates.');
+        return {
+            started: false,
+            kind: 'msi',
+            detail: `The "${exports.MSI_UPDATER_TASK_NAME}" scheduled task is missing. Reinstall the latest MSI (or redeploy via MDM) to restore silent updates.`,
+        };
+    }
+    const run = (0, child_process_1.spawnSync)('schtasks', ['/Run', '/TN', exports.MSI_UPDATER_TASK_NAME], { stdio: 'ignore', windowsHide: true, timeout: 20_000 });
+    if (run.status === 0) {
+        log(`Self-update: MSI updater task triggered (target ${targetVersion}).`);
+        return { started: true, kind: 'msi', detail: `Updater task triggered; it downloads, verifies, and installs ${targetVersion} silently.` };
+    }
+    log('Self-update: could not trigger the MSI updater task now — its daily schedule remains the backstop.');
+    return {
+        started: false,
+        kind: 'msi',
+        detail: `Could not trigger the "${exports.MSI_UPDATER_TASK_NAME}" task immediately; it still runs on its daily schedule.`,
+    };
+}
+let updateInFlightSince = 0;
+const UPDATE_RETRY_COOLDOWN_MS = 60 * 60_000; // don't re-kick a pending upgrade for an hour
+/**
+ * Upgrade this machine to targetVersion if it is newer than currentVersion.
+ * Cheap no-op when already current, when a kick is still pending, or when the
+ * platform path is unavailable. Never throws.
+ */
+function maybeSelfUpdate(input) {
+    const log = input.log || (() => { });
+    if (!input.enabled || !input.targetVersion)
+        return undefined;
+    if (input.busy)
+        return undefined;
+    if (compareCliVersions(input.targetVersion, input.currentVersion) <= 0)
+        return undefined;
+    if (Date.now() - updateInFlightSince < UPDATE_RETRY_COOLDOWN_MS)
+        return undefined;
+    updateInFlightSince = Date.now();
+    log(`Self-update: CLI ${input.currentVersion || 'unknown'} -> ${input.targetVersion} (org auto-update).`);
+    const kind = detectInstallKind();
+    const result = kind === 'msi'
+        ? startMsiSelfUpdate(input.targetVersion, log)
+        : startNpmSelfUpdate(input.targetVersion, log);
+    if (!result.started) {
+        // Allow another attempt on the next tick after a shorter cooldown when we
+        // never managed to start anything.
+        updateInFlightSince = Date.now() - UPDATE_RETRY_COOLDOWN_MS + 10 * 60_000;
+    }
+    return result;
+}
+/** Version the MSI updater script reads from the installed package.json. */
+function installedMsiVersion(installFolder) {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(installFolder, 'package.json'), 'utf8'));
+        return typeof pkg.version === 'string' ? pkg.version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/telemetry.js

@@ -58,6 +58,15 @@ const SPOOL_PATH = path.join(os.homedir(), '.fullcourtdefense-spool.jsonl');
 const FLUSH_MARKER = path.join(os.homedir(), '.fullcourtdefense-flush.ts');
 const FLUSH_THROTTLE_MS = 30_000; // don't spawn a flusher more than this often
 const MAX_BATCH = 200;
+/**
+ * Hard cap on spooled events. A machine that stays offline for weeks must not
+ * grow an unbounded file on the developer's disk; when full, the OLDEST events
+ * are dropped — the newest decisions are the ones an admin needs after a
+ * reconnect. ~2k events ≈ single-digit MB worst case.
+ */
+const MAX_SPOOL_EVENTS = 2_000;
+/** Cheap pre-check: skip the trim parse entirely until the file is plausibly over cap. */
+const SPOOL_TRIM_BYTES = 2 * 1024 * 1024;
 /** Append one decision to the spool. Never throws (telemetry must not break the hook). */
 function spoolEvent(event) {
     try {
@@ -81,6 +90,19 @@ function spoolEvent(event) {
             offlineEnforced: event.offlineEnforced,
         };
         fs.appendFileSync(SPOOL_PATH, JSON.stringify(full) + '\n', { encoding: 'utf-8', mode: 0o600 });
+        enforceSpoolCap();
+    }
+    catch { /* best-effort */ }
+}
+/** Drop-oldest cap so a long-offline machine never grows an unbounded spool. */
+function enforceSpoolCap() {
+    try {
+        if (fs.statSync(SPOOL_PATH).size < SPOOL_TRIM_BYTES)
+            return;
+        const events = readSpool();
+        if (events.length <= MAX_SPOOL_EVENTS)
+            return;
+        rewriteSpool(events.slice(events.length - MAX_SPOOL_EVENTS));
     }
     catch { /* best-effort */ }
 }

package/dist/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "1.15.12"
+  "version": "1.17.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fullcourtdefense-cli",
-  "version": "1.15.12",
+  "version": "1.17.0",
   "description": "Full Court Defense CLI — security scanning for AI agents from your terminal",
   "main": "dist/index.js",
   "bin": {