fullcourtdefense-cli 1.34.21 → 1.34.22

package/README.md

@@ -73,6 +73,7 @@ fullcourtdefense init
 - `fullcourtdefense help` — shows the full onboarding flow and command reference.
 - `fullcourtdefense onboard --token <token>` — resumable machine transaction: preflight + login + protection + optional discovery + verification. `--json true` prints final machine-readable status; exits non-zero only when a critical step fails.
 - `fullcourtdefense doctor` — confirms outbound HTTPS to FullCourtDefense is open before scanning.
+- `fullcourtdefense hotfix-status` — shows the loaded detector revision and whether fallback is active. Available from 1.34.22. Updates arrive through the background daemon; this command reads local status and does not force a download. Acceptance alone does not prove that a reported false alarm was corrected.
 - `fullcourtdefense login --token <token>` — enrolls this machine with a fleet token and saves per-machine Shield credentials (no copy/paste).
 - `fullcourtdefense install-all` — wraps every configured MCP server, installs IDE hooks and terminal guards, uploads discovery, schedules daily rescans.
 - `fullcourtdefense configure` — legacy/manual setup: saves org API key, Shield ID, Shield key, and API URL to `.fullcourtdefense.yml` (use `login` instead when you have a fleet token).

package/dist/actionPolicyEngine.d.ts

@@ -234,5 +234,10 @@ export declare function inferToolContext(toolName: string, args: Record<string,
     operation: string;
     context: Record<string, string>;
 };
+/** Exported for reproducible detector artifacts; policy decisions are not packaged. */
+export declare function inferBundledToolContext(toolName: string, args: Record<string, any>): {
+    operation: string;
+    context: Record<string, string>;
+};
 /** Static inventory match — same operation rules as runtime, without constraint context. */
 export declare function inventoryToolMatchesActionPolicy(toolName: string, toolActions: string[] | undefined, policies: EngineActionPolicy[]): boolean;

package/dist/actionPolicyEngine.js

@@ -29,6 +29,7 @@ __export(actionPolicyEngine_exports, {
   detectSecretKind: () => detectSecretKind,
   effectiveApprovalScope: () => effectiveApprovalScope,
   evaluateActionPolicies: () => evaluateActionPolicies,
+  inferBundledToolContext: () => inferBundledToolContext,
   inferToolContext: () => inferToolContext,
   inventoryToolMatchesActionPolicy: () => inventoryToolMatchesActionPolicy,
   isLocalFileContentAction: () => isLocalFileContentAction,
@@ -5740,6 +5741,7 @@ function parse3(input, options) {
 
 // src/actionPolicyEngine.ts
 var import_detectionData = require("./detectionData");
+var import_detectorRuntime = require("./detectorRuntime");
 function isFirestoreQueryUrl(target) {
   try {
     const url = new URL(target);
@@ -7053,6 +7055,8 @@ function shellUrlActionText(command) {
   if (command.length > 65536) return command;
   const originalSegments = splitShellSegments(command);
   const localPaths = /* @__PURE__ */ new Map();
+  const literalValues = /* @__PURE__ */ new Map();
+  const dataAssignments = /* @__PURE__ */ new Set();
   const pathAssignments = /* @__PURE__ */ new Set();
   let expandedSize = command.length;
   let expansionOverflow = false;
@@ -7065,6 +7069,11 @@ function shellUrlActionText(command) {
     return value;
   };
   const segments = originalSegments.map((segment, index) => {
+    const dataAssignment = /^\$([A-Za-z_][\w]*)\s*=\s*(@'\r?\n[\s\S]*?\r?\n'@|'(?:[^']|'')*')$/.exec(segment);
+    if (dataAssignment && !literalValues.has(dataAssignment[1].toLowerCase()) && literalValues.size < 32) {
+      literalValues.set(dataAssignment[1].toLowerCase(), dataAssignment[2]);
+      dataAssignments.add(index);
+    }
     const assignment = /^\$([A-Za-z_][\w]*)\s*=\s*(?:'([^']*)'|"([^"$`]*)")$/.exec(segment);
     if (assignment) {
       const name = assignment[1].toLowerCase();
@@ -7086,7 +7095,14 @@ function shellUrlActionText(command) {
       const value = localPaths.get(name.toLowerCase());
       return value ? expand(match, `"${value}"`) : match;
     });
-    return prefix + tail;
+    const expanded = prefix + tail;
+    return expanded.replace(
+      /^(Set-Content|Add-Content|Out-File)(\s+[\s\S]*?\s+-(?:Value|InputObject)\s+)\$([A-Za-z_][\w]*)\s*$/i,
+      (match, writer, options, name) => {
+        const value = literalValues.get(name.toLowerCase());
+        return value ? expand(match, writer + options + value) : match;
+      }
+    );
   });
   if (expansionOverflow) return command;
   const filtered = segments.map((segment) => {
@@ -7121,6 +7137,7 @@ function shellUrlActionText(command) {
     return tail;
   });
   const onlyStoredData = segments.every((segment, index) => {
+    if (dataAssignments.has(index)) return true;
     if (pathAssignments.has(index)) return true;
     if (filtered[index] !== segment) return true;
     const directory = /^New-Item\s+-ItemType\s+Directory\s+(?:-Force\s+)?-(?:LiteralPath|Path)\s+(?:'([^']*)'|"([^"$`]*)")\s*(?:\|\s*Out-Null)?$/i.exec(segment);
@@ -7129,7 +7146,7 @@ function shellUrlActionText(command) {
     if (!/[$`|;&(){}<>]/.test(segment) && /^(?:(?:cd|pushd|set-location)\s+[^\r\n]+|(?:pwd|popd|get-location)|git\s+status(?:\s+[^\r\n]+)?)$/i.test(segment)) return true;
     return !/[$`]/.test(segment) && /^\(Get-Content\s+(?:[A-Za-z]:[\\/])?[\w./\\-]+\s+-Raw\)\.Replace\("",\s*""\)\s*\|\s*Set-Content\s+(?:[A-Za-z]:[\\/])?[\w./\\-]+\s+-Encoding\s+utf8\s*$/i.test(words);
   });
-  return onlyStoredData && filtered.some((value, index) => value !== segments[index]) ? filtered.join("\n") : command;
+  return onlyStoredData && filtered.some((value, index) => value !== segments[index]) ? filtered.filter((_, index) => !dataAssignments.has(index)).join("\n") : command;
 }
 function splitShellSegments(command, alsoOnPipe = false) {
   const out = [];
@@ -7723,6 +7740,9 @@ function evaluateActionPolicies(policies, toolName, operation, context = {}, dec
   return worstResult;
 }
 function inferToolContext(toolName, args) {
+  return (0, import_detectorRuntime.updatedDetectorFacts)(toolName, args) || inferBundledToolContext(toolName, args);
+}
+function inferBundledToolContext(toolName, args) {
   const context = {};
   let operation = toolName;
   const toolNameLower = toolName.toLowerCase();
@@ -7863,6 +7883,7 @@ function inventoryToolMatchesActionPolicy(toolName, toolActions, policies) {
   detectSecretKind,
   effectiveApprovalScope,
   evaluateActionPolicies,
+  inferBundledToolContext,
   inferToolContext,
   inventoryToolMatchesActionPolicy,
   isLocalFileContentAction,

package/dist/commands/daemon.js

@@ -1206,6 +1206,7 @@ async function runDaemon(args, config) {
         if (!creds.shieldId)
             return;
         void localDetectionUpdates_1.localDetectionUpdates.refresh();
+        void localDetectionUpdates_1.localDetectorUpdates.refresh();
         if (!creds.shieldKey) {
             // Credential-broken machine: stay reachable via the key-less signed-
             // action channel while credential recovery keeps retrying.

package/dist/commands/hook.js

@@ -757,6 +757,7 @@ function tryDeveloperConfirmation(ctx, call, verdict, payload, where) {
     if (ctx.shadow)
         return false; // monitor machines never prompt — the caller records would-approve
     const prepared = prepareDeveloperConfirmation(ctx.event, call, payload, {
+        policyHash: ctx.effectivePolicyHash,
         policyId: verdict.policyId,
         policyName: verdict.policyName,
         matchedRule: verdict.matchedRule,
@@ -800,6 +801,8 @@ function prepareDeveloperConfirmation(event, call, payload, source) {
         spoolCallEvent(call, {
             decision: 'allow',
             reason: `developer confirmed earlier (${remembered.remember} memory)${policyLabel}`,
+            ruleId: source.policyId || source.localFinding?.ruleId,
+            policyHash: source.policyHash || source.localFinding?.policyHash,
             approvalScope: 'developer',
             approvedBy: 'developer',
             offlineEnforced,
@@ -822,6 +825,8 @@ function prepareDeveloperConfirmation(event, call, payload, source) {
     (0, hookIo_1.dbg)({ phase: 'dev_confirm_ask', event, tool: call.toolName, operation, key: marker.key, remember: source.remember, where: source.where });
     spoolCallEvent(call, {
         decision: 'approval',
+        ruleId: source.policyId || source.localFinding?.ruleId,
+        policyHash: source.policyHash || source.localFinding?.policyHash,
         reason: `developer confirmation requested via IDE prompt${policyLabel}${source.reason ? `: ${source.reason}` : ''}`,
         approvalScope: 'developer',
         offlineEnforced,
@@ -916,14 +921,14 @@ function tryLocalPolicyEnforcement(ctx, call, detail, opts = {}) {
         if (ctx.shadow) {
             // Truth-in-reporting: the action RAN — 'warn' (advisory), never 'allow'
             // (which hides the would-block from the console) and never 'block'.
-            spoolCallEvent(call, { decision: 'warn', reason: `[monitor] local policy would ${local.verdict} (offline): ${reason}`, offlineEnforced: true });
+            spoolCallEvent(call, { decision: 'warn', ruleId: local.policyId, policyHash: ctx.effectivePolicyHash, reason: `[monitor] local policy would ${local.verdict} (offline): ${reason}`, offlineEnforced: true });
             (0, telemetry_1.triggerFlush)(false);
             ctx.respond(false, undefined, `[FullCourtDefense shadow] would ${local.verdict === 'block' ? 'block' : 'require approval for'} ${call.toolName} (offline, locally cached policy): ${reason}`);
         }
         const approvalNote = local.verdict === 'require_approval'
             ? ' This action requires human approval, which is not possible while the policy service is unreachable.'
             : '';
-        spoolCallEvent(call, { decision: 'block', reason: `local policy (offline): ${reason}`, offlineEnforced: true });
+        spoolCallEvent(call, { decision: 'block', ruleId: local.policyId, policyHash: ctx.effectivePolicyHash, reason: `local policy (offline): ${reason}`, offlineEnforced: true });
         (0, telemetry_1.triggerFlush)(true);
         const explained = explainPolicyStop('block', ctx.event, call, local, policies, `Enforced from the locally cached policy while the policy service is unreachable (${detail}).${approvalNote}`);
         ctx.respond(true, explained.userMessage, `${explained.agentMessage} Do not retry until the connection is restored or the policy allows it.`);
@@ -939,7 +944,7 @@ function tryLocalPolicyEnforcement(ctx, call, detail, opts = {}) {
             ? warning.agentMsg
             : `${warning.agentMsg} (policy service unreachable — evaluated from the locally cached org policies).`);
     }
-    spoolCallEvent(call, { decision: 'allow', reason: `local policy allow (${monitorPath ? 'monitor' : 'offline'}): ${detail}`, offlineEnforced: true });
+    spoolCallEvent(call, { decision: 'allow', ruleId: local.policyId, policyHash: ctx.effectivePolicyHash, reason: `local policy allow (${monitorPath ? 'monitor' : 'offline'}): ${detail}`, offlineEnforced: true });
     (0, telemetry_1.triggerFlush)(false);
     ctx.respond(false, undefined, monitorPath
         ? undefined
@@ -1947,7 +1952,7 @@ async function enforceActionPolicy(ctx) {
                 // read "N blocked of N recent" with every allow missing. Same delivery
                 // as a block: spool (sync file append) + detached flusher that outlives
                 // this process. The IDE is not kept waiting on the network.
-                spoolCallEvent(call, { decision: 'allow', reason: 'local policy allow (block mode, local-first)' });
+                spoolCallEvent(call, { decision: 'allow', policyHash: effectivePolicyHash, ruleId: localVerdict.policyId, reason: 'local policy allow (block mode, local-first)' });
                 (0, telemetry_1.triggerFlush)(true);
                 respond(false);
                 return;
@@ -1958,7 +1963,7 @@ async function enforceActionPolicy(ctx) {
             void fetch(gateUrl, { method: 'POST', headers, body: gateBody, signal: AbortSignal.timeout(4000) })
                 .then(() => (0, policyGateHealth_1.recordGateSuccess)())
                 .catch(() => {
-                spoolCallEvent(call, { decision: 'allow', reason: 'local policy allow (block mode, local-first); gate report failed — spooled', offlineEnforced: true });
+                spoolCallEvent(call, { decision: 'allow', policyHash: effectivePolicyHash, ruleId: localVerdict.policyId, reason: 'local policy allow (block mode, local-first); gate report failed — spooled', offlineEnforced: true });
                 (0, telemetry_1.triggerFlush)(false);
             });
             respond(false);
@@ -1966,7 +1971,7 @@ async function enforceActionPolicy(ctx) {
         }
         if (localVerdict.verdict === 'block') {
             const reason = localVerdict.reason || `${call.toolName}: blocked by org Action Policy`;
-            spoolCallEvent(call, { decision: 'block', reason: `local policy (block mode, local-first): ${reason}`, offlineEnforced: true });
+            spoolCallEvent(call, { decision: 'block', policyHash: effectivePolicyHash, ruleId: localVerdict.policyId, reason: `local policy (block mode, local-first): ${reason}`, offlineEnforced: true });
             (0, telemetry_1.triggerFlush)(true);
             const explained = explainPolicyStop('block', event, call, localVerdict, ctx.localPolicies);
             respond(true, explained.userMessage, explained.agentMessage);
@@ -1980,7 +1985,7 @@ async function enforceActionPolicy(ctx) {
             return;
         }
         // require_approval, developer scope + human present → IDE-native ask (no org queue).
-        if (tryDeveloperConfirmation({ event, respond, shadow, localPolicies: ctx.localPolicies }, call, localVerdict, payload, 'local-first'))
+        if (tryDeveloperConfirmation({ event, respond, shadow, effectivePolicyHash, localPolicies: ctx.localPolicies }, call, localVerdict, payload, 'local-first'))
             return;
         // require_approval (org scope) → synchronous gate below creates the approval action.
     }

package/dist/detectionUpdates.d.ts

@@ -1,12 +1,31 @@
+import { verifyDetectionEnvelope } from './detectionData';
+export interface SignedUpdateAdapter<T extends {
+    revision: number;
+}> {
+    url: string;
+    maxBytes: number;
+    bundledRevision: number;
+    current(): Readonly<T>;
+    verify(raw: string, now: number, key: string): T;
+    activate(data: T): boolean;
+    eligible?(data: T): boolean;
+    /** Runs only for eligible, newer content, before it replaces the cache. */
+    prepare?(data: T): {
+        activate(): boolean;
+        dispose(): void;
+    };
+}
 export declare const DETECTION_UPDATE_URL = "https://storage.googleapis.com/fullcourtdefense-cli-releases/detection/stable.json";
 export interface DetectionUpdateStatus {
     revision: number;
     bundledRevision: number;
     source: 'bundled' | 'update';
     lastCheckedAt?: string;
-    state: 'bundled' | 'current' | 'unavailable' | 'rejected';
+    state: 'bundled' | 'current' | 'unavailable' | 'rejected' | 'not_targeted';
 }
-export declare class DetectionUpdates {
+export declare class DetectionUpdates<T extends {
+    revision: number;
+} = ReturnType<typeof verifyDetectionEnvelope>> {
     private readonly cachePath;
     private readonly publicKey;
     private readonly channel;
@@ -14,7 +33,8 @@ export declare class DetectionUpdates {
     private nextLocalRead;
     private pending?;
     private status;
-    constructor(cachePath: string, publicKey?: string, channel?: 'stable' | 'staging');
+    private readonly adapter;
+    constructor(cachePath: string, publicKey?: string, channel?: 'stable' | 'staging', adapter?: SignedUpdateAdapter<T>);
     getStatus(): DetectionUpdateStatus;
     private readCache;
     private cachedData;

package/dist/detectionUpdates.js

@@ -49,18 +49,23 @@ class DetectionUpdates {
     pending;
     status = { revision: detectionData_1.BUNDLED_DETECTION_DATA.revision,
         bundledRevision: detectionData_1.BUNDLED_DETECTION_DATA.revision, source: 'bundled', state: 'bundled' };
-    constructor(cachePath, publicKey = detectionData_1.DETECTION_PUBLIC_KEY, channel = 'stable') {
+    adapter;
+    constructor(cachePath, publicKey = detectionData_1.DETECTION_PUBLIC_KEY, channel = 'stable', adapter) {
         this.cachePath = cachePath;
         this.publicKey = publicKey;
         this.channel = channel;
+        this.adapter = adapter || { url: exports.DETECTION_UPDATE_URL, maxBytes: detectionData_1.MAX_DETECTION_BYTES,
+            bundledRevision: detectionData_1.BUNDLED_DETECTION_DATA.revision, current: detectionData_1.getDetectionData,
+            verify: detectionData_1.verifyDetectionEnvelope, activate: detectionData_1.activateDetectionData };
+        this.status.revision = this.status.bundledRevision = this.adapter.bundledRevision;
     }
     getStatus() {
-        const revision = (0, detectionData_1.getDetectionData)().revision;
-        return { ...this.status, revision, source: revision > detectionData_1.BUNDLED_DETECTION_DATA.revision ? 'update' : 'bundled' };
+        const revision = this.adapter.current().revision;
+        return { ...this.status, revision, source: revision > this.adapter.bundledRevision ? 'update' : 'bundled' };
     }
     readCache() {
         try {
-            if (fs.statSync(this.cachePath).size > detectionData_1.MAX_DETECTION_BYTES)
+            if (fs.statSync(this.cachePath).size > this.adapter.maxBytes)
                 return undefined;
             return fs.readFileSync(this.cachePath, 'utf8');
         }
@@ -72,7 +77,7 @@ class DetectionUpdates {
         // Expiration gates first acceptance, not continued offline use. Authenticate
         // the signed validity period before using the last verified cache after restart.
         const payload = JSON.parse(JSON.parse(raw).payload);
-        return (0, detectionData_1.verifyDetectionEnvelope)(raw, Math.min(Date.now(), payload.issuedAt), this.publicKey);
+        return this.adapter.verify(raw, Math.min(Date.now(), payload.issuedAt), this.publicKey);
     }
     loadLocal() {
         if (Date.now() < this.nextLocalRead)
@@ -82,7 +87,24 @@ class DetectionUpdates {
         if (!raw)
             return;
         try {
-            (0, detectionData_1.activateDetectionData)(this.cachedData(raw));
+            const data = this.cachedData(raw);
+            if (this.adapter.eligible && !this.adapter.eligible(data)) {
+                this.status.state = 'not_targeted';
+                return;
+            }
+            if (data.revision === this.adapter.current().revision && JSON.stringify(data) !== JSON.stringify(this.adapter.current()))
+                throw new Error('Cached revision reused for different content');
+            if (data.revision > this.adapter.current().revision) {
+                const prepared = this.adapter.prepare?.(data);
+                try {
+                    prepared ? prepared.activate() : this.adapter.activate(data);
+                }
+                finally {
+                    prepared?.dispose();
+                }
+            }
+            if (data.revision === this.adapter.current().revision)
+                this.status.state = 'current';
         }
         catch {
             this.status.state = 'rejected';
@@ -102,7 +124,7 @@ class DetectionUpdates {
         this.status.lastCheckedAt = new Date().toISOString();
         let raw;
         try {
-            const response = await fetch(this.channel === 'staging' ? exports.DETECTION_UPDATE_URL.replace('/stable.json', '/staging.json') : exports.DETECTION_UPDATE_URL, { redirect: 'error', signal: AbortSignal.timeout(3000) });
+            const response = await fetch(this.channel === 'staging' ? this.adapter.url.replace('/stable.json', '/staging.json') : this.adapter.url, { redirect: 'error', signal: AbortSignal.timeout(3000) });
             if (!response.ok || !response.body)
                 throw new Error('Unavailable');
             const reader = response.body.getReader();
@@ -114,7 +136,7 @@ class DetectionUpdates {
                     if (done)
                         break;
                     size += value.byteLength;
-                    if (size > detectionData_1.MAX_DETECTION_BYTES)
+                    if (size > this.adapter.maxBytes)
                         throw new Error('Oversized');
                     chunks.push(value);
                 }
@@ -131,8 +153,13 @@ class DetectionUpdates {
         }
         let lock;
         let temporary;
+        let prepared;
         try {
-            const data = (0, detectionData_1.verifyDetectionEnvelope)(raw, Date.now(), this.publicKey);
+            const data = this.adapter.verify(raw, Date.now(), this.publicKey);
+            if (this.adapter.eligible && !this.adapter.eligible(data)) {
+                this.status.state = 'not_targeted';
+                return;
+            }
             fs.mkdirSync(path.dirname(this.cachePath), { recursive: true });
             const lockPath = this.cachePath + '.lock';
             try {
@@ -160,14 +187,15 @@ class DetectionUpdates {
             }
             catch { /* recover corrupt cache */ }
             const cachedRevision = cached?.revision ?? 0;
-            const currentRevision = Math.max(cachedRevision, (0, detectionData_1.getDetectionData)().revision);
+            const currentRevision = Math.max(cachedRevision, this.adapter.current().revision);
             if (data.revision < currentRevision)
                 throw new Error('Revision downgrade');
             if (cached && data.revision === cached.revision && JSON.stringify(data) !== JSON.stringify(cached))
                 throw new Error('Cached revision reused for different content');
-            if (data.revision === (0, detectionData_1.getDetectionData)().revision && JSON.stringify(data) !== JSON.stringify((0, detectionData_1.getDetectionData)()))
+            if (data.revision === this.adapter.current().revision && JSON.stringify(data) !== JSON.stringify(this.adapter.current()))
                 throw new Error('Revision reused for different content');
             if (data.revision > currentRevision) {
+                prepared = this.adapter.prepare?.(data);
                 temporary = this.cachePath + '.' + (0, crypto_1.randomUUID)() + '.tmp';
                 const fd = fs.openSync(temporary, 'wx', 0o600);
                 try {
@@ -179,10 +207,12 @@ class DetectionUpdates {
                 }
                 fs.renameSync(temporary, this.cachePath);
                 temporary = undefined;
-                (0, detectionData_1.activateDetectionData)(data);
+                prepared ? prepared.activate() : this.adapter.activate(data);
+            }
+            else if (cached && cached.revision > this.adapter.current().revision) {
+                prepared = this.adapter.prepare?.(cached);
+                prepared ? prepared.activate() : this.adapter.activate(cached);
             }
-            else if (cached)
-                (0, detectionData_1.activateDetectionData)(cached);
             this.status.state = 'current';
         }
         catch {
@@ -190,6 +220,7 @@ class DetectionUpdates {
             this.nextCheck = Date.now() + 5 * 60_000;
         }
         finally {
+            prepared?.dispose();
             if (temporary) {
                 try {
                     fs.unlinkSync(temporary);

package/dist/detectorArtifact.d.ts

@@ -0,0 +1,17 @@
+export declare const DETECTOR_ABI = 1;
+export declare const MAX_DETECTOR_BYTES: number;
+export declare const DETECTOR_DOMAIN = "fullcourtdefense/reviewed-detector/v1\n";
+export interface DetectorArtifact {
+    abi: 1;
+    revision: number;
+    issuedAt: number;
+    expiresAt: number;
+    sourceCommit: string;
+    issueNumber: number;
+    sha256: string;
+    code: string;
+    /** null = approved fleet-wide rollout; otherwise explicit enrolled machine IDs. */
+    machineIds: string[] | null;
+}
+/** Official reviewed code, not user-supplied rules or tool content. */
+export declare function verifyDetectorArtifact(raw: string, now?: number, publicKey?: string): DetectorArtifact;

package/dist/detectorArtifact.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DETECTOR_DOMAIN = exports.MAX_DETECTOR_BYTES = exports.DETECTOR_ABI = void 0;
+exports.verifyDetectorArtifact = verifyDetectorArtifact;
+const crypto_1 = require("crypto");
+const detectionData_1 = require("./detectionData");
+exports.DETECTOR_ABI = 1;
+exports.MAX_DETECTOR_BYTES = 2 * 1024 * 1024;
+exports.DETECTOR_DOMAIN = 'fullcourtdefense/reviewed-detector/v1\n';
+/** Official reviewed code, not user-supplied rules or tool content. */
+function verifyDetectorArtifact(raw, now = Date.now(), publicKey = detectionData_1.DETECTION_PUBLIC_KEY) {
+    if (Buffer.byteLength(raw) > exports.MAX_DETECTOR_BYTES)
+        throw new Error('Detector artifact oversized');
+    const envelope = JSON.parse(raw);
+    if (!envelope || Object.keys(envelope).sort().join(',') !== 'payload,signature' || typeof envelope.payload !== 'string'
+        || typeof envelope.signature !== 'string' || !/^[A-Za-z0-9+/]{86}==$/.test(envelope.signature))
+        throw new Error('Invalid detector envelope');
+    if (!(0, crypto_1.verify)(null, Buffer.from(exports.DETECTOR_DOMAIN + envelope.payload), (0, crypto_1.createPublicKey)(publicKey), Buffer.from(envelope.signature, 'base64')))
+        throw new Error('Invalid detector signature');
+    const data = JSON.parse(envelope.payload);
+    if (!data || Object.keys(data).sort().join(',') !== 'abi,code,expiresAt,issueNumber,issuedAt,machineIds,revision,sha256,sourceCommit'
+        || data.abi !== exports.DETECTOR_ABI || !Number.isSafeInteger(data.revision) || data.revision < 1
+        || !Number.isSafeInteger(data.issueNumber) || data.issueNumber < 1
+        || typeof data.sourceCommit !== 'string' || !/^[a-f0-9]{40}$/.test(data.sourceCommit) || typeof data.code !== 'string' || !data.code
+        || typeof data.sha256 !== 'string' || !/^[a-f0-9]{64}$/.test(data.sha256)
+        || (0, crypto_1.createHash)('sha256').update(data.code).digest('hex') !== data.sha256
+        || !Number.isSafeInteger(data.issuedAt) || !Number.isSafeInteger(data.expiresAt)
+        || data.issuedAt > now + 60_000 || data.expiresAt <= now || data.expiresAt <= data.issuedAt
+        || data.expiresAt - data.issuedAt > 90 * 86400_000)
+        throw new Error('Invalid detector artifact or compatibility');
+    if (data.machineIds !== null && (!Array.isArray(data.machineIds) || data.machineIds.length < 1 || data.machineIds.length > 64
+        || data.machineIds.some(id => typeof id !== 'string' || !/^[a-zA-Z0-9_.:-]{1,64}$/.test(id)) || new Set(data.machineIds).size !== data.machineIds.length))
+        throw new Error('Invalid detector rollout cohort');
+    return data;
+}

package/dist/detectorBaseline.d.ts

@@ -0,0 +1,4 @@
+/** Updated by the baseline incorporation command after a stable release.
+ * Empty only for the first bootstrap. The signature is retained in the CLI.
+ */
+export declare const BUNDLED_DETECTOR_ENVELOPE = "";

package/dist/detectorBaseline.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUNDLED_DETECTOR_ENVELOPE = void 0;
+/** Updated by the baseline incorporation command after a stable release.
+ * Empty only for the first bootstrap. The signature is retained in the CLI.
+ */
+exports.BUNDLED_DETECTOR_ENVELOPE = '';

package/dist/detectorModule.d.ts

@@ -0,0 +1,9 @@
+import type { DetectorArtifact } from './detectorArtifact';
+import { type DetectorFacts } from './detectorRuntime';
+/** Authenticated first-party code only. This is not a hostile-code sandbox:
+ * signatures/review are the trust boundary. Separate V8 heap, bounded output
+ * and wall time contain ordinary detector bugs. Tool text remains JSON data.
+ */
+export declare function compileDetector(artifact: DetectorArtifact): ((tool: string, args: Record<string, any>) => DetectorFacts) & {
+    dispose(): void;
+};

package/dist/detectorModule.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileDetector = compileDetector;
+const worker_threads_1 = require("worker_threads");
+const detectorRuntime_1 = require("./detectorRuntime");
+const detectionData_1 = require("./detectionData");
+/** Authenticated first-party code only. This is not a hostile-code sandbox:
+ * signatures/review are the trust boundary. Separate V8 heap, bounded output
+ * and wall time contain ordinary detector bugs. Tool text remains JSON data.
+ */
+function compileDetector(artifact) {
+    const readyBuffer = new SharedArrayBuffer(8);
+    const ready = new Int32Array(readyBuffer);
+    const worker = new worker_threads_1.Worker(`
+    const {workerData,parentPort}=require('worker_threads');
+    const {Script,createContext}=require('vm');
+    const ready=new Int32Array(workerData.ready);
+    let context,evaluate;
+    try {
+      context=createContext(Object.create(null),{codeGeneration:{strings:false,wasm:false}});
+      // Expose parsed scalar fields, not Node's host URL constructor or native
+      // exceptions. The wrapper and all values visible to code belong to the VM.
+      const makeUrl=new Script('(parse => class URL { constructor(input, base) { const fields=JSON.parse(parse(String(input), base===undefined?undefined:String(base))); if(fields.error)throw new TypeError("Invalid URL"); Object.assign(this,fields); } toString(){return this.href;} })').runInContext(context,{timeout:1000});
+      context.URL=makeUrl((input,base)=>{
+        try {
+          if(typeof input!=='string'||input.length>256*1024||(base!==undefined&&(typeof base!=='string'||base.length>256*1024)))return '{"error":true}';
+          const value=new URL(input,base),fields={};
+          for(const key of ['href','origin','protocol','username','password','host','hostname','port','pathname','search','hash'])fields[key]=value[key];
+          return JSON.stringify(fields);
+        } catch { return '{"error":true}'; }
+      });
+      new Script(workerData.code).runInContext(context,{timeout:1000});
+      new Script('if(typeof FcdDetector?.inferToolContext!=="function")throw new Error("Missing export")').runInContext(context,{timeout:1000});
+      evaluate=new Script('JSON.stringify(FcdDetector.inferToolContext(...JSON.parse(inputJson)))');
+      Atomics.store(ready,0,1);
+    } catch { Atomics.store(ready,0,-1); }
+    Atomics.notify(ready,0);
+    parentPort.on('message',({input,buffer})=>{
+      const state=new Int32Array(buffer,0,2),output=new Uint8Array(buffer,8);
+      try {
+        context.inputJson=input;
+        const text=evaluate.runInContext(context,{timeout:250});
+        if(typeof text!=='string')throw new Error('Invalid output');
+        const bytes=Buffer.from(text);
+        if(bytes.length>output.length)throw new Error('Output too large');
+        output.set(bytes); Atomics.store(state,1,bytes.length); Atomics.store(state,0,1);
+      } catch { Atomics.store(state,0,-1); }
+      finally { if(context)delete context.inputJson; Atomics.notify(state,0); }
+    });
+  `, { eval: true, workerData: { code: artifact.code, ready: readyBuffer },
+        resourceLimits: { maxOldGenerationSizeMb: 48, maxYoungGenerationSizeMb: 8, stackSizeMb: 4 } });
+    let stopped = false;
+    const dispose = () => { if (!stopped) {
+        stopped = true;
+        void worker.terminate();
+    } };
+    worker.on('error', () => { stopped = true; });
+    worker.on('exit', () => { stopped = true; });
+    worker.unref();
+    Atomics.wait(ready, 0, 0, 4000);
+    if (Atomics.load(ready, 0) !== 1) {
+        dispose();
+        throw new Error('Detector initialization failed');
+    }
+    const invoke = (tool, args) => {
+        if (stopped)
+            throw new detectorRuntime_1.DetectorWorkerUnavailable('Detector worker unavailable');
+        const input = JSON.stringify([tool, args, (0, detectionData_1.getDetectionData)()]);
+        if (Buffer.byteLength(input) > 256 * 1024)
+            throw new Error('Detector input exceeds bound');
+        const buffer = new SharedArrayBuffer(512 * 1024 + 8);
+        const state = new Int32Array(buffer, 0, 2);
+        worker.postMessage({ input, buffer });
+        // VM deadlines count wall time, including time descheduled by Windows.
+        // Allow scheduling headroom while retaining a hard half-second fallback.
+        Atomics.wait(state, 0, 0, 500);
+        if (Atomics.load(state, 0) !== 1) {
+            dispose();
+            throw new detectorRuntime_1.DetectorWorkerUnavailable('Detector timed out or failed');
+        }
+        return JSON.parse(Buffer.from(new Uint8Array(buffer, 8, Atomics.load(state, 1))).toString('utf8'));
+    };
+    return Object.assign(invoke, { dispose });
+}

package/dist/detectorRuntime.d.ts

@@ -0,0 +1,21 @@
+/** In-memory detector contract. No downloads, file reads or model calls here. */
+export interface DetectorFacts {
+    operation: string;
+    context: Record<string, string>;
+}
+/** A terminated worker cannot recover on the next action. */
+export declare class DetectorWorkerUnavailable extends Error {
+}
+type Detector = ((tool: string, args: Record<string, any>) => DetectorFacts) & {
+    dispose?(): void;
+};
+export declare function detectorRuntimeStatus(): {
+    revision: number;
+    failures: number;
+    active: boolean;
+};
+export declare function installDetector(next: Detector, nextRevision: number): void;
+export declare function updatedDetectorFacts(tool: string, args: Record<string, any>): DetectorFacts | undefined;
+/** Shared validation for smoke tests and every actual inference result. */
+export declare function validateDetectorFacts(result: DetectorFacts): DetectorFacts;
+export {};

package/dist/detectorRuntime.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DetectorWorkerUnavailable = void 0;
+exports.detectorRuntimeStatus = detectorRuntimeStatus;
+exports.installDetector = installDetector;
+exports.updatedDetectorFacts = updatedDetectorFacts;
+exports.validateDetectorFacts = validateDetectorFacts;
+/** A terminated worker cannot recover on the next action. */
+class DetectorWorkerUnavailable extends Error {
+}
+exports.DetectorWorkerUnavailable = DetectorWorkerUnavailable;
+let detector;
+let revision = 0;
+let failures = 0;
+function detectorRuntimeStatus() { return { revision, failures, active: Boolean(detector) }; }
+function installDetector(next, nextRevision) {
+    if (!Number.isSafeInteger(nextRevision) || nextRevision <= revision)
+        throw new Error('Detector revision must increase');
+    detector?.dispose?.();
+    detector = next;
+    revision = nextRevision;
+    failures = 0;
+}
+function updatedDetectorFacts(tool, args) {
+    if (!detector)
+        return undefined;
+    try {
+        return validateDetectorFacts(detector(tool, args));
+    }
+    catch (error) {
+        failures++;
+        if (error instanceof DetectorWorkerUnavailable || failures >= 3) {
+            detector?.dispose?.();
+            detector = undefined;
+        }
+        return undefined;
+    }
+}
+/** Shared validation for smoke tests and every actual inference result. */
+function validateDetectorFacts(result) {
+    if (!result || typeof result.operation !== 'string' || !result.operation || result.operation.length > 100
+        || !result.context || typeof result.context !== 'object' || Array.isArray(result.context))
+        throw new Error('Invalid detector result');
+    const entries = Object.entries(result.context);
+    if (entries.length > 200 || entries.some(([key, value]) => key.length > 160 || typeof value !== 'string' || value.length > 100_000
+        || /^(?:__proto__|constructor|prototype|verdict|decision|approval)$/i.test(key)))
+        throw new Error('Invalid detector facts');
+    return { operation: result.operation, context: Object.fromEntries(entries) };
+}

package/dist/detectorUpdates.d.ts

@@ -0,0 +1,21 @@
+import { DetectionUpdates } from './detectionUpdates';
+import { type DetectorArtifact } from './detectorArtifact';
+type Snapshot = DetectorArtifact | {
+    revision: 0;
+};
+export declare class DetectorUpdates extends DetectionUpdates<Snapshot> {
+    constructor(cachePath: string, publicKey?: string, channel?: 'stable' | 'staging', machineId?: string);
+    getDetectorStatus(): {
+        active: boolean;
+        failures: number;
+        baselineRejected: boolean;
+        sha256: string | undefined;
+        sourceCommit: string | undefined;
+        revision: number;
+        bundledRevision: number;
+        source: "bundled" | "update";
+        lastCheckedAt?: string;
+        state: "bundled" | "current" | "unavailable" | "rejected" | "not_targeted";
+    };
+}
+export {};

package/dist/detectorUpdates.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DetectorUpdates = void 0;
+const detectionUpdates_1 = require("./detectionUpdates");
+const detectorArtifact_1 = require("./detectorArtifact");
+const detectorModule_1 = require("./detectorModule");
+const detectorRuntime_1 = require("./detectorRuntime");
+const detectorBaseline_1 = require("./detectorBaseline");
+let current = { revision: 0 };
+let baselineRejected = false;
+/** Compile once: the smoke-tested worker is the worker adopted after persistence. */
+function prepareDetector(data) {
+    if (!('code' in data))
+        throw new Error('Missing detector code');
+    const infer = (0, detectorModule_1.compileDetector)(data);
+    let adopted = false;
+    try {
+        (0, detectorRuntime_1.validateDetectorFacts)(infer('read_file', { path: 'sample.txt' }));
+    }
+    catch (error) {
+        infer.dispose();
+        throw error;
+    }
+    return {
+        activate() {
+            if (data.revision <= current.revision)
+                return false;
+            (0, detectorRuntime_1.installDetector)(infer, data.revision);
+            adopted = true;
+            current = Object.freeze({ ...data });
+            return true;
+        },
+        dispose() { if (!adopted)
+            infer.dispose(); },
+    };
+}
+if (detectorBaseline_1.BUNDLED_DETECTOR_ENVELOPE) {
+    try {
+        const issuedAt = JSON.parse(JSON.parse(detectorBaseline_1.BUNDLED_DETECTOR_ENVELOPE).payload).issuedAt;
+        const bundled = (0, detectorArtifact_1.verifyDetectorArtifact)(detectorBaseline_1.BUNDLED_DETECTOR_ENVELOPE, Math.min(Date.now(), issuedAt));
+        if (bundled.machineIds !== null)
+            throw new Error('CLI baseline must be approved for the full fleet');
+        const prepared = prepareDetector(bundled);
+        try {
+            prepared.activate();
+        }
+        finally {
+            prepared.dispose();
+        }
+    }
+    catch {
+        baselineRejected = true;
+    } // Preserve compiled-in inference and CLI startup.
+}
+const bundledRevision = current.revision;
+const adapter = {
+    url: 'https://storage.googleapis.com/fullcourtdefense-cli-releases/detectors/v1/stable.json',
+    maxBytes: detectorArtifact_1.MAX_DETECTOR_BYTES, bundledRevision,
+    current: () => current,
+    verify: detectorArtifact_1.verifyDetectorArtifact,
+    prepare: prepareDetector,
+    activate: data => {
+        if (data.revision <= current.revision)
+            return false;
+        const prepared = prepareDetector(data);
+        try {
+            return prepared.activate();
+        }
+        finally {
+            prepared.dispose();
+        }
+    },
+};
+class DetectorUpdates extends detectionUpdates_1.DetectionUpdates {
+    constructor(cachePath, publicKey, channel = 'stable', machineId) {
+        super(cachePath, publicKey, channel, { ...adapter,
+            eligible: data => !('machineIds' in data) || data.machineIds === null || Boolean(machineId && data.machineIds.includes(machineId)) });
+    }
+    getDetectorStatus() {
+        const { active, failures } = (0, detectorRuntime_1.detectorRuntimeStatus)();
+        return { ...this.getStatus(), active, failures, baselineRejected,
+            sha256: 'sha256' in current ? current.sha256 : undefined,
+            sourceCommit: 'sourceCommit' in current ? current.sourceCommit : undefined };
+    }
+}
+exports.DetectorUpdates = DetectorUpdates;

package/dist/frictionRollout.js

@@ -0,0 +1,103 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../backend/src/modules/discovery/friction-rollout.ts
+var friction_rollout_exports = {};
+__export(friction_rollout_exports, {
+  assessFrictionRollout: () => assessFrictionRollout
+});
+module.exports = __toCommonJS(friction_rollout_exports);
+function assessFrictionRollout(input) {
+  const value = input;
+  if (!value || typeof value.baselineVersion !== "string" || typeof value.candidateVersion !== "string" || !/^\d+\.\d+\.\d+$/.test(value.baselineVersion) || !/^\d+\.\d+\.\d+$/.test(value.candidateVersion) || !["replay", "real_hook", "real_ide", "production"].includes(String(value.evidenceLevel)) || !Array.isArray(value.observations) || value.observations.length > 2e3) throw new Error("Invalid paired evidence");
+  const artifact = (raw, bundled = false) => {
+    const item = raw;
+    if (!item || !Number.isSafeInteger(item.revision) || Number(item.revision) < (bundled ? 0 : 1) || typeof item.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(item.sha256)) throw new Error("Invalid detector artifact identity");
+    return { revision: Number(item.revision), sha256: item.sha256 };
+  };
+  const hasDetection = value.baselineDetection !== void 0 || value.candidateDetection !== void 0;
+  const baselineDetection = hasDetection ? artifact(value.baselineDetection, true) : void 0;
+  const candidateDetection = hasDetection ? artifact(value.candidateDetection) : void 0;
+  const sameCli = value.baselineVersion === value.candidateVersion;
+  if (baselineDetection && candidateDetection) {
+    if (candidateDetection.revision < baselineDetection.revision || candidateDetection.revision === baselineDetection.revision && candidateDetection.sha256 !== baselineDetection.sha256) {
+      throw new Error("Detector revision downgrade or reuse");
+    }
+  }
+  if (sameCli && (!baselineDetection || !candidateDetection || candidateDetection.revision <= baselineDetection.revision || candidateDetection.sha256 === baselineDetection.sha256)) throw new Error("Same CLI requires distinct, increasing detector artifacts");
+  const verdicts = ["allow", "block", "require_approval"];
+  const seen = /* @__PURE__ */ new Set();
+  let fixed = 0, regressed = 0, unchanged = 0, missingEffects = 0, remainingErrors = 0;
+  let benign = 0, guarded = 0, baselineInterruptions = 0, candidateInterruptions = 0;
+  const families = /* @__PURE__ */ new Set();
+  const machines = /* @__PURE__ */ new Set();
+  for (const row of value.observations) {
+    if (!row || !["caseId", "family", "machineId", "policyHash"].every((key2) => typeof row[key2] === "string" && /^[a-zA-Z0-9_.:-]{1,100}$/.test(row[key2])) || ![row.expected, row.baseline, row.candidate].every((v) => verdicts.includes(v)) || typeof row.sideEffectVerified !== "boolean") throw new Error("Invalid observation");
+    const key = JSON.stringify([row.machineId, row.caseId, row.policyHash]);
+    if (seen.has(key)) throw new Error("Duplicate paired observation");
+    seen.add(key);
+    families.add(row.family);
+    machines.add(row.machineId);
+    const before = row.baseline === row.expected, after = row.candidate === row.expected;
+    if (!before && after) fixed++;
+    else if (before && !after) regressed++;
+    else unchanged++;
+    if (!after) remainingErrors++;
+    if (!row.sideEffectVerified) missingEffects++;
+    if (row.expected === "allow") {
+      benign++;
+      if (row.baseline !== "allow") baselineInterruptions++;
+      if (row.candidate !== "allow") candidateInterruptions++;
+    } else guarded++;
+  }
+  const reasons = [];
+  if (!benign || !guarded) reasons.push("Both benign actions and prohibited/approval counterparts are required");
+  if (!fixed) reasons.push("No measured correction");
+  if (regressed || remainingErrors) reasons.push("Candidate has regressions or unresolved mismatches");
+  if (missingEffects) reasons.push("Actual side-effect verification is missing");
+  if (value.evidenceLevel !== "production") reasons.push("This evidence cannot establish production improvement");
+  return {
+    schema: "fcd.paired-feedback.v1",
+    baselineVersion: value.baselineVersion,
+    candidateVersion: value.candidateVersion,
+    ...hasDetection ? { baselineDetection, candidateDetection } : {},
+    changeKind: sameCli ? "detector_only" : hasDetection && baselineDetection.sha256 !== candidateDetection.sha256 ? "cli_and_detector" : "cli",
+    evidenceLevel: value.evidenceLevel,
+    cases: seen.size,
+    families: families.size,
+    machines: machines.size,
+    fixed,
+    regressed,
+    unchanged,
+    remainingErrors,
+    missingEffects,
+    benign,
+    guarded,
+    baselineInterruptions,
+    candidateInterruptions,
+    eligibleForOwnerReview: reasons.length === 0,
+    reasons,
+    automaticPublication: false,
+    note: "Labels and side effects are reviewer-supplied evidence, not independently verified by this gate. Publication requires reviewed signed release evidence."
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assessFrictionRollout
+});

package/dist/index.js

@@ -137,6 +137,7 @@ function printHelp() {
                 Exits 1 when remnants are found. Works via npx after the CLI
                 itself is uninstalled.
     doctor      First step. Checks outbound HTTPS access to FullCourtDefense.
+    hotfix-status  Show loaded detector revision, update state and fallback status.
                 --perf measures this machine's real per-event overhead
                 (hook latency, spawn floor, cmd-guard cost, disk footprint).
                 --health prints an mdatp-health-style per-subsystem status
@@ -553,6 +554,13 @@ async function main() {
             await doctorCommand(args, config);
             break;
         }
+        case 'hotfix-status': {
+            const { localDetectorUpdates } = await Promise.resolve().then(() => __importStar(require('./localDetectionUpdates')));
+            const { cliVersion } = await Promise.resolve().then(() => __importStar(require('./cliVersion')));
+            console.log(JSON.stringify({ cliVersion: cliVersion(), detector: localDetectorUpdates.getDetectorStatus(),
+                note: 'Acceptance is not proof of correction. Compare the reported action and prohibited counterparts under the same policy.' }, null, 2));
+            break;
+        }
         case 'demo-actions': {
             const { demoActionsCommand } = await Promise.resolve().then(() => __importStar(require('./commands/demoActions')));
             await demoActionsCommand({ live: flags.live, json: flags.json, demoPolicies: flags['demo-policies'], timeout: flags.timeout }, config);

package/dist/localDetectionUpdates.d.ts

@@ -1,2 +1,4 @@
 import { DetectionUpdates } from './detectionUpdates';
-export declare const localDetectionUpdates: DetectionUpdates;
+import { DetectorUpdates } from './detectorUpdates';
+export declare const localDetectionUpdates: DetectionUpdates<import("./detectionData").DetectionData>;
+export declare const localDetectorUpdates: DetectorUpdates;

package/dist/localDetectionUpdates.js

@@ -33,9 +33,16 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.localDetectionUpdates = void 0;
+exports.localDetectorUpdates = exports.localDetectionUpdates = void 0;
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const detectionUpdates_1 = require("./detectionUpdates");
+const detectorUpdates_1 = require("./detectorUpdates");
+const machineIdentity_1 = require("./machineIdentity");
 exports.localDetectionUpdates = new detectionUpdates_1.DetectionUpdates(path.join(os.homedir(), '.fullcourtdefense', 'detection-update.json'));
 exports.localDetectionUpdates.loadLocal();
+exports.localDetectorUpdates = new detectorUpdates_1.DetectorUpdates(path.join(os.homedir(), '.fullcourtdefense', 'detector-update-v1.json'), undefined, 'stable', (0, machineIdentity_1.getMachineIdentity)().machineId);
+exports.localDetectorUpdates.loadLocal();
+// Long-running gateways observe the daemon's accepted cache without a restart.
+// This timer is background-only and never keeps a short-lived hook alive.
+setInterval(() => { exports.localDetectionUpdates.loadLocal(); exports.localDetectorUpdates.loadLocal(); }, 30_000).unref();

package/dist/telemetry.d.ts

@@ -1,5 +1,10 @@
 import { type ActionIdentity } from './actionIdentity';
 export interface SpoolEvent extends ActionIdentity {
+    cliVersion?: string;
+    detectorRevision?: number;
+    detectorSha256?: string;
+    /** Loaded module state when recording, not proof this module decided the action. */
+    detectorActive?: boolean;
     agentClient?: string;
     eventId: string;
     type: 'verdict';

package/dist/telemetry.js

@@ -52,6 +52,8 @@ const path = __importStar(require("path"));
 const machineIdentity_1 = require("./machineIdentity");
 const actionIdentity_1 = require("./actionIdentity");
 const localDetectionUpdates_1 = require("./localDetectionUpdates");
+const cliVersion_1 = require("./cliVersion");
+const installedCliVersion = (0, cliVersion_1.cliVersion)();
 /**
  * Local-first telemetry: every enforcement decision is appended to an on-disk
  * spool (instant, offline-safe) and flushed to the backend in batches. Critical
@@ -194,7 +196,12 @@ function spoolEvent(event) {
         // took. Absent when a caller spools outside a hook evaluation (guards,
         // onboard) — the backend treats missing fields as "no sample".
         const timing = verdictTiming.getStore();
+        const detector = localDetectionUpdates_1.localDetectorUpdates.getDetectorStatus();
         const full = {
+            cliVersion: installedCliVersion,
+            detectorRevision: detector.revision,
+            detectorSha256: detector.sha256,
+            detectorActive: detector.active,
             ...(0, actionIdentity_1.captureActionIdentity)(),
             ...timing?.identity,
             eventId: crypto.randomUUID(),
@@ -366,6 +373,7 @@ async function flushSpoolLocked(input) {
                     ? {
                         agentVersion: input.agentVersion,
                         detectionUpdates: localDetectionUpdates_1.localDetectionUpdates.getStatus(),
+                        detectorUpdates: localDetectionUpdates_1.localDetectorUpdates.getDetectorStatus(),
                         integrityOk: input.integrityOk,
                         integrityReasons: input.integrityReasons,
                         integrityCheckedAt: input.integrityCheckedAt,

package/dist/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "1.34.21"
+  "version": "1.34.22"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fullcourtdefense-cli",
-  "version": "1.34.21",
+  "version": "1.34.22",
   "description": "Full Court Defense CLI — security scanning for AI agents from your terminal",
   "main": "dist/index.js",
   "bin": {
@@ -13,6 +13,7 @@
     "README.md"
   ],
   "scripts": {
+    "test:detector-updates": "npm run build && node scripts/test-detector-artifacts.js && node scripts/test-detector-publication.js && node scripts/test-detection-updates.js && node scripts/test-detection-cache.js",
     "test:native-hooks": "npm run build && node scripts/test-codex-activation.js && node scripts/test-native-hook-launch.js && node scripts/test-native-hook-edges.js && node scripts/test-client-telemetry.js && node scripts/test-native-hook-clients.js",
     "test:endpoint-approvals": "npm run build && node scripts/audit-endpoint-mcp-shell.js",
     "test:endpoint-clients": "npm run build && node scripts/test-endpoint-client-matrix.js && node scripts/test-copilot-hook-install.js",
@@ -96,7 +97,7 @@
     "test:ide-fp-corpus:hook": "npm run build && node scripts/test-ide-fp-corpus.js --hook",
     "test:msi-payload-deps": "npm run build && node scripts/test-msi-payload-deps.js",
     "build:msi": "powershell -NoProfile -ExecutionPolicy Bypass -File installer/windows/Build-Msi.ps1",
-    "prepublishOnly": "npm run build && node scripts/check-detection-baseline.js && node scripts/test-detection-updates.js && node scripts/test-detection-cache.js && node scripts/test-msi-payload-deps.js && node scripts/test-shell-parity.js && node scripts/test-terminal-mcp-ask.js"
+    "prepublishOnly": "npm run build && node scripts/check-detection-baseline.js && node scripts/check-detector-baseline.js && node scripts/test-detector-artifacts.js && node scripts/test-detector-publication.js && node scripts/test-detection-updates.js && node scripts/test-detection-cache.js && node scripts/test-msi-payload-deps.js && node scripts/test-shell-parity.js && node scripts/test-terminal-mcp-ask.js"
   },
   "keywords": [
     "llm",