fullcourtdefense-cli 1.21.25 → 1.21.26

package/dist/commands/cmdGuard.d.ts

@@ -18,3 +18,12 @@ export declare function installCmdGuardCommand(_args?: InstallCmdGuardArgs): Pro
 export declare function uninstallCmdGuardCommand(): Promise<void>;
 /** Refresh shared rules JSON when cmd guard is installed. */
 export declare function refreshCmdGuardRules(): void;
+/**
+ * Self-heal a stale cmd-guard AutoRun: if the registry still references our
+ * autorun script but the file was deleted (manual cleanup, interrupted
+ * uninstall), EVERY cmd.exe on the machine errors on startup and — worse —
+ * poisons `cmd /c` exit codes to 1, making healthy installs/commands look
+ * failed. Strips only OUR fragment; a customer's own AutoRun entries survive.
+ * Returns true when a repair was applied.
+ */
+export declare function repairStaleCmdAutorun(): boolean;

package/dist/commands/cmdGuard.js

@@ -38,6 +38,7 @@ exports.getCmdGuardStatus = getCmdGuardStatus;
 exports.installCmdGuardCommand = installCmdGuardCommand;
 exports.uninstallCmdGuardCommand = uninstallCmdGuardCommand;
 exports.refreshCmdGuardRules = refreshCmdGuardRules;
+exports.repairStaleCmdAutorun = repairStaleCmdAutorun;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
@@ -264,3 +265,35 @@ function refreshCmdGuardRules() {
     }
     catch { /* best-effort */ }
 }
+/**
+ * Self-heal a stale cmd-guard AutoRun: if the registry still references our
+ * autorun script but the file was deleted (manual cleanup, interrupted
+ * uninstall), EVERY cmd.exe on the machine errors on startup and — worse —
+ * poisons `cmd /c` exit codes to 1, making healthy installs/commands look
+ * failed. Strips only OUR fragment; a customer's own AutoRun entries survive.
+ * Returns true when a repair was applied.
+ */
+function repairStaleCmdAutorun() {
+    try {
+        if (process.platform !== 'win32')
+            return false;
+        const current = readCurrentAutorun();
+        if (!current.includes(AUTORUN_MARKER))
+            return false;
+        if (fs.existsSync(AUTORUN_BAT_PATH))
+            return false;
+        const next = stripAutorunValue(current);
+        if (next) {
+            setRegString(CMD_AUTORUN_KEY, AUTORUN_VALUE, next);
+        }
+        else {
+            (0, child_process_1.execFileSync)('reg', ['delete', CMD_AUTORUN_KEY, '/v', AUTORUN_VALUE, '/f'], {
+                windowsHide: true, timeout: 10000, stdio: ['ignore', 'pipe', 'ignore'],
+            });
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/commands/daemon.js

@@ -55,6 +55,7 @@ const discoveryMarker_1 = require("../discoveryMarker");
 const selfUpdate_1 = require("../selfUpdate");
 const machineActionVerify_1 = require("../machineActionVerify");
 const desktopChatGuard_1 = require("./desktopChatGuard");
+const honeypot_1 = require("../honeypot");
 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',
@@ -732,6 +733,30 @@ async function runDaemon(args, config) {
                     log,
                 });
             }
+            // Honeypot decoys: org-controlled via fleet settings. Planting is
+            // idempotent (a decoy deleted by an attacker is re-planted on the next
+            // poll); disabling removes only files we created.
+            if (bundle.honeypot?.enabled) {
+                try {
+                    const result = (0, honeypot_1.plantHoneypots)();
+                    if (result.planted.length > 0) {
+                        log(`Honeypot: planted ${result.planted.length} decoy credential file(s).`);
+                    }
+                }
+                catch (error) {
+                    log(`Honeypot: planting failed: ${error.message}`);
+                }
+            }
+            else if (bundle.honeypot && !bundle.honeypot.enabled && (0, honeypot_1.getHoneypotPaths)().length > 0) {
+                try {
+                    const removed = (0, honeypot_1.removeHoneypots)();
+                    if (removed.length > 0)
+                        log(`Honeypot: removed ${removed.length} decoy file(s) (disabled by org policy).`);
+                }
+                catch (error) {
+                    log(`Honeypot: removal failed: ${error.message}`);
+                }
+            }
         }
         catch { /* offline — cached stance applies */ }
     };

package/dist/commands/deterministicGuard.d.ts

@@ -1,5 +1,5 @@
 export type DeterministicDirection = 'request' | 'response';
-export type DeterministicCategory = 'sensitive_file' | 'metadata_ssrf' | 'destructive_command' | 'destructive_sql' | 'infra_destroy' | 'reverse_shell' | 'secret_exfiltration';
+export type DeterministicCategory = 'sensitive_file' | 'metadata_ssrf' | 'destructive_command' | 'destructive_sql' | 'infra_destroy' | 'reverse_shell' | 'secret_exfiltration' | 'honeypot';
 export interface DeterministicFinding {
     blocked: true;
     ruleId: string;
@@ -24,6 +24,8 @@ export interface LocalSafetyScanOptions {
     policyHash?: string;
     cwd?: string;
     inspectScripts?: boolean;
+    /** Absolute paths of planted honeypot decoy files — ANY reference blocks. */
+    honeypotPaths?: string[];
 }
 export declare function scanDeterministicToolCall(toolName: string, toolArgs: Record<string, unknown>, options?: LocalSafetyScanOptions): DeterministicFinding | undefined;
 export declare function scanDeterministicTextResponse(text: string, options?: LocalSafetyScanOptions): DeterministicFinding | undefined;

package/dist/commands/deterministicGuard.js

@@ -37,6 +37,7 @@ exports.scanDeterministicToolCall = scanDeterministicToolCall;
 exports.scanDeterministicTextResponse = scanDeterministicTextResponse;
 exports.scanDeterministicPrompt = scanDeterministicPrompt;
 const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const SECRET_PATTERNS = [
     { itemId: 'private_key_material', label: 'private key material', re: /-----BEGIN (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----/i },
@@ -262,6 +263,43 @@ function builtIn(itemId, categoryId, category, ruleId, reason, findingEvidence,
         policyHash: options?.policyHash,
     };
 }
+/**
+ * Honeypot decoy touch — the highest-precision signal the guard has. The decoy
+ * paths are machine-local absolute paths planted by the daemon; matching is on
+ * the normalized absolute path or its home-anchored `~/relative` form, so a
+ * repo file that merely shares a basename (e.g. a project-local `.env.bak`)
+ * never matches. Fires regardless of tool context: no legitimate workflow
+ * references these files at all.
+ */
+function honeypotTouch(value, options) {
+    const paths = options?.honeypotPaths;
+    if (!paths || paths.length === 0)
+        return undefined;
+    const text = normalizeForPath(value);
+    const home = normalizeForPath(os.homedir());
+    for (const decoyPath of paths) {
+        const decoy = normalizeForPath(decoyPath);
+        if (!decoy)
+            continue;
+        const candidates = [decoy];
+        if (home && decoy.startsWith(home + '/'))
+            candidates.push('~' + decoy.slice(home.length));
+        if (candidates.some(candidate => text.includes(candidate))) {
+            return {
+                blocked: true,
+                ruleId: 'local-honeypot',
+                category: 'honeypot',
+                categoryId: 'honeypot',
+                itemId: 'honeypot_decoy_access',
+                source: 'builtin',
+                reason: 'Blocked access to a decoy credential file (honeypot). No legitimate tool uses this file — this indicates credential-hunting behavior.',
+                evidence: evidence(value),
+                policyHash: options?.policyHash,
+            };
+        }
+    }
+    return undefined;
+}
 function customBlock(value, options) {
     const lower = value.toLowerCase();
     for (const block of options?.customBlocks || []) {
@@ -441,6 +479,9 @@ function isSensitivePathContext(toolName, candidate) {
     return /(?:path|file|filename|dir|directory|target|source|src|dest|location|glob|pattern|uri|url)/i.test(lastKey);
 }
 function scanTextValue(toolName, value, options) {
+    const honeypot = honeypotTouch(value, options);
+    if (honeypot)
+        return honeypot;
     const custom = customBlock(value, options);
     if (custom)
         return custom;
@@ -505,7 +546,13 @@ function scanDeterministicToolCall(toolName, toolArgs, options) {
             continue;
         if (finding.category === 'sensitive_file' && !isSensitivePathContext(toolName, candidate))
             continue;
-        if (isCommandContext(toolName, candidate) || finding.category === 'sensitive_file' || finding.category === 'metadata_ssrf')
+        // Honeypot decoy paths block in ANY context where the string can act —
+        // path access, command execution, or outbound egress (a decoy path inside
+        // a request body is exfiltration staging). Inert file-content mentions
+        // still pass, consistent with the other path rules.
+        if (finding.category === 'honeypot' && !(isActionableContext(toolName, candidate) || outbound))
+            continue;
+        if (isCommandContext(toolName, candidate) || finding.category === 'sensitive_file' || finding.category === 'metadata_ssrf' || finding.category === 'honeypot')
             return finding;
     }
     for (const candidate of candidates) {

package/dist/commands/onboard.js

@@ -248,6 +248,13 @@ async function onboardCommand(args, config) {
     // 1. Connectivity.
     console.log(`${BOLD}[1/6] Checking compatibility and connectivity…${RESET}`);
     mark('preflight', 'running');
+    // A stale cmd-guard AutoRun (registry points at a deleted autorun script)
+    // poisons every cmd.exe exit code on the machine — child spawns and the MSI's
+    // .cmd shim would report failure for successful work. Heal it before anything
+    // else runs.
+    if ((0, cmdGuard_1.repairStaleCmdAutorun)()) {
+        console.log(`  ${DIM}Repaired a stale cmd.exe AutoRun entry left by an earlier uninstall.${RESET}`);
+    }
     const reachable = await checkBackendReachable(apiUrl);
     const compatible = checkCompatibility();
     printCheck(compatible);

package/dist/honeypot.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Honeypot decoy credentials.
+ *
+ * When the org enables honeypots (fleet settings → delivered via the runtime
+ * bundle), the daemon plants a small set of decoy credential files in
+ * locations a credential-hunting agent would search. No legitimate tool ever
+ * reads these files, so ANY tool call touching one is a near-zero-false-
+ * positive compromise signal: the deterministic guard blocks it on-device and
+ * the resulting event (categoryId "honeypot") lets the backend auto-contain
+ * the machine.
+ *
+ * Safety rules:
+ *   - A decoy is only created where NO file exists. If a real file is already
+ *     at a decoy path we skip it and never track it — we must never overwrite
+ *     or later delete a user's real file.
+ *   - Only files recorded in the state file (i.e. files WE created) are ever
+ *     removed when the feature is disabled.
+ */
+export interface HoneypotDecoyState {
+    path: string;
+    itemId: string;
+}
+export interface HoneypotState {
+    version: 1;
+    enabled: boolean;
+    plantedAt: string;
+    decoys: HoneypotDecoyState[];
+}
+export interface PlantResult {
+    planted: string[];
+    existing: string[];
+    skipped: string[];
+}
+/**
+ * Plant (or re-plant) decoys. Idempotent — safe to call on every bundle poll.
+ * Never overwrites a file we did not create.
+ */
+export declare function plantHoneypots(): PlantResult;
+/** Remove decoys WE planted (state-tracked only) and clear the state file. */
+export declare function removeHoneypots(): string[];
+/**
+ * Absolute paths of active decoys, for the deterministic guard. Fast (one
+ * small JSON read), never throws — enforcement surfaces call this per scan.
+ */
+export declare function getHoneypotPaths(): string[];

package/dist/honeypot.js

@@ -0,0 +1,190 @@
+"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.plantHoneypots = plantHoneypots;
+exports.removeHoneypots = removeHoneypots;
+exports.getHoneypotPaths = getHoneypotPaths;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const STATE_DIR = path.join(os.homedir(), '.fullcourtdefense');
+const STATE_FILE = path.join(STATE_DIR, 'honeypots.json');
+function randomToken(length, alphabet) {
+    const bytes = crypto.randomBytes(length);
+    let out = '';
+    for (let i = 0; i < length; i++)
+        out += alphabet[bytes[i] % alphabet.length];
+    return out;
+}
+const UPPER_NUM = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
+const BASE64ISH = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+// PEM armor markers assembled at runtime so this source file (and the built
+// bundle) never contains contiguous key-material signatures — our own secret
+// scanners and third-party ones must not flag the decoy GENERATOR.
+function pemMarker(kind) {
+    return ['-'.repeat(5) + kind, 'OPENSSH', 'PRIVATE', 'KEY' + '-'.repeat(5)].join(' ');
+}
+/** Decoy definitions. Content is random per machine so a leaked copy is traceable to this plant. */
+function decoyDefinitions() {
+    const home = os.homedir();
+    return [
+        {
+            absPath: path.join(home, '.aws', 'credentials.bak'),
+            itemId: 'honeypot_aws_credentials',
+            content: () => [
+                '[default]',
+                `aws_access_key_id = ${'AKIA'}${randomToken(16, UPPER_NUM)}`,
+                `aws_secret_access_key = ${randomToken(40, BASE64ISH)}`,
+                '',
+                '[prod]',
+                `aws_access_key_id = ${'AKIA'}${randomToken(16, UPPER_NUM)}`,
+                `aws_secret_access_key = ${randomToken(40, BASE64ISH)}`,
+                '',
+            ].join('\n'),
+        },
+        {
+            absPath: path.join(home, '.ssh', 'id_rsa.bak'),
+            itemId: 'honeypot_ssh_key',
+            content: () => {
+                const lines = [pemMarker('BEGIN')];
+                for (let i = 0; i < 24; i++)
+                    lines.push(randomToken(70, BASE64ISH));
+                lines.push(`${randomToken(28, BASE64ISH)}==`);
+                lines.push(pemMarker('END'));
+                lines.push('');
+                return lines.join('\n');
+            },
+        },
+        {
+            absPath: path.join(home, '.env.bak'),
+            itemId: 'honeypot_env_backup',
+            content: () => [
+                '# production backup',
+                `DATABASE_URL=postgres://app:${randomToken(24, BASE64ISH)}@db-prod.internal:5432/main`,
+                `STRIPE_SECRET_KEY=${'sk_live_'}${randomToken(24, BASE64ISH)}`,
+                `JWT_SECRET=${randomToken(48, BASE64ISH)}`,
+                `ADMIN_API_TOKEN=${randomToken(32, BASE64ISH)}`,
+                '',
+            ].join('\n'),
+        },
+    ];
+}
+function readState() {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+        if (!parsed || parsed.version !== 1 || !Array.isArray(parsed.decoys))
+            return undefined;
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeState(state) {
+    fs.mkdirSync(STATE_DIR, { recursive: true });
+    fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2), { encoding: 'utf8', mode: 0o600 });
+}
+/**
+ * Plant (or re-plant) decoys. Idempotent — safe to call on every bundle poll.
+ * Never overwrites a file we did not create.
+ */
+function plantHoneypots() {
+    const previous = readState();
+    const tracked = new Set((previous?.decoys || []).map(decoy => decoy.path));
+    const result = { planted: [], existing: [], skipped: [] };
+    const decoys = [];
+    for (const def of decoyDefinitions()) {
+        const exists = fs.existsSync(def.absPath);
+        if (exists && !tracked.has(def.absPath)) {
+            // A real user file lives here — leave it alone and never track it.
+            result.skipped.push(def.absPath);
+            continue;
+        }
+        if (exists) {
+            decoys.push({ path: def.absPath, itemId: def.itemId });
+            result.existing.push(def.absPath);
+            continue;
+        }
+        try {
+            fs.mkdirSync(path.dirname(def.absPath), { recursive: true });
+            fs.writeFileSync(def.absPath, def.content(), { encoding: 'utf8', mode: 0o600 });
+            decoys.push({ path: def.absPath, itemId: def.itemId });
+            result.planted.push(def.absPath);
+        }
+        catch {
+            // Unwritable location (permissions) — skip; other decoys still count.
+            result.skipped.push(def.absPath);
+        }
+    }
+    writeState({
+        version: 1,
+        enabled: true,
+        plantedAt: previous?.plantedAt || new Date().toISOString(),
+        decoys,
+    });
+    return result;
+}
+/** Remove decoys WE planted (state-tracked only) and clear the state file. */
+function removeHoneypots() {
+    const state = readState();
+    if (!state)
+        return [];
+    const removed = [];
+    for (const decoy of state.decoys) {
+        try {
+            if (fs.existsSync(decoy.path)) {
+                fs.unlinkSync(decoy.path);
+                removed.push(decoy.path);
+            }
+        }
+        catch { /* best-effort — a locked file stays but detection also stays */ }
+    }
+    try {
+        fs.unlinkSync(STATE_FILE);
+    }
+    catch { /* already gone */ }
+    return removed;
+}
+/**
+ * Absolute paths of active decoys, for the deterministic guard. Fast (one
+ * small JSON read), never throws — enforcement surfaces call this per scan.
+ */
+function getHoneypotPaths() {
+    const state = readState();
+    if (!state || state.enabled !== true)
+        return [];
+    return state.decoys.map(decoy => decoy.path).filter(Boolean);
+}

package/dist/localSafetySnapshot.js

@@ -40,6 +40,7 @@ const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
+const honeypot_1 = require("./honeypot");
 const CACHE_TTL_MS = 60_000;
 const CACHE_DIR = path.join(os.homedir(), '.fullcourtdefense');
 function cachePath(input) {
@@ -132,6 +133,10 @@ function snapshotToScanOptions(snapshot, extra = {}) {
         disabledBuiltInItemIds: snapshot?.disabledBuiltInItemIds,
         customBlocks: snapshot?.customBlocks,
         policyHash: snapshot?.policyHash,
+        // Machine-local decoy paths planted by the daemon — every enforcement
+        // surface (hooks, MCP gateway, desktop chat guard) gets honeypot
+        // detection through this single seam.
+        honeypotPaths: (0, honeypot_1.getHoneypotPaths)(),
         ...extra,
     };
 }

package/dist/runtimeConfig.d.ts

@@ -33,6 +33,10 @@ export interface RuntimeBundle {
         enabled: boolean;
         targetVersion?: string;
     };
+    /** Org honeypot policy: the daemon plants/removes decoy credential files. */
+    honeypot?: {
+        enabled: boolean;
+    };
     /** One constrained, auditable action queued for the resident daemon. */
     machineAction?: {
         id: 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, autoUpdate: cached.autoUpdate, 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, honeypot: cached.honeypot, 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, autoUpdate: cached.autoUpdate, 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, honeypot: cached.honeypot, machineAction: cached.machineAction, source: 'cache' };
         }
         if (resp.ok) {
             const body = await resp.json().catch(() => ({}));
@@ -117,6 +117,9 @@ async function getRuntimeBundle(input) {
                             targetVersion: typeof body.data.autoUpdate.targetVersion === 'string' ? body.data.autoUpdate.targetVersion : undefined,
                         }
                         : undefined,
+                    honeypot: body.data.honeypot && typeof body.data.honeypot === 'object'
+                        ? { enabled: body.data.honeypot.enabled === true }
+                        : undefined,
                     machineAction: body.data.machineAction,
                     fetchedAt: Date.now(),
                 };
@@ -128,7 +131,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, autoUpdate: cached.autoUpdate, 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, honeypot: cached.honeypot, machineAction: cached.machineAction, source: 'cache' };
     }
     return { mode: 'block', version: '', source: 'default' };
 }

package/dist/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "1.21.25"
+  "version": "1.21.26"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fullcourtdefense-cli",
-  "version": "1.21.25",
+  "version": "1.21.26",
   "description": "Full Court Defense CLI — security scanning for AI agents from your terminal",
   "main": "dist/index.js",
   "bin": {
@@ -16,6 +16,7 @@
     "build": "tsc && node scripts/copy-attack-corpus.js",
     "test:deterministic-guard": "npm run build && node scripts/test-deterministic-guard.js",
     "test:guard-content-context": "npm run build && node scripts/test-guard-content-context.js",
+    "test:honeypot": "npm run build && node scripts/test-honeypot.js",
     "test:browser-credentials-rule": "npm run build && node scripts/test-browser-credentials-rule.js",
     "test:taint-ledger": "npm run build && node scripts/test-taint-ledger.js",
     "test:shell-audit": "npm run build && node scripts/test-shell-audit.js",