fullcourtdefense-cli 1.22.3 → 1.22.5

package/dist/commands/daemon.js

@@ -75,6 +75,7 @@ const cmdGuard_1 = require("./cmdGuard");
 const machineActionVerify_1 = require("../machineActionVerify");
 const desktopChatGuard_1 = require("./desktopChatGuard");
 const honeypot_1 = require("../honeypot");
+const windowsAudit_1 = require("./windowsAudit");
 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',
@@ -1157,6 +1158,21 @@ async function runDaemon(args, config) {
     }, RESCAN_INTERVAL_MS);
     const bundleTimer = setInterval(() => { void pollBundle(); }, BUNDLE_POLL_MS);
     const heartbeatTimer = setInterval(() => { void heartbeat(); }, HEARTBEAT_INTERVAL_MS);
+    // PowerShell transcript retention (Windows): the Transcription policy FCD
+    // enables writes a file per session forever — prune anything older than the
+    // retention window once a day (plus once shortly after boot, so laptops
+    // that never stay up 24h still get cleaned). Only touches FCD-managed
+    // transcript folders; see pruneTranscripts.
+    const runTranscriptPrune = () => {
+        try {
+            const result = (0, windowsAudit_1.pruneTranscripts)();
+            if (result.pruned > 0)
+                log(`Transcript retention: pruned ${result.pruned} transcript file(s) older than ${(0, windowsAudit_1.transcriptRetentionDays)()} day(s).`);
+        }
+        catch { /* never let housekeeping hurt the daemon */ }
+    };
+    const transcriptPruneBootTimer = setTimeout(runTranscriptPrune, 5 * 60_000);
+    const transcriptPruneTimer = setInterval(runTranscriptPrune, 24 * 60 * 60_000);
     const shutdown = (signal) => {
         if (stopped)
             return;
@@ -1165,6 +1181,8 @@ async function runDaemon(args, config) {
         clearInterval(rescanTimer);
         clearInterval(bundleTimer);
         clearInterval(heartbeatTimer);
+        clearTimeout(transcriptPruneBootTimer);
+        clearInterval(transcriptPruneTimer);
         clearTimeout(discoverCatchUpBootTimer);
         clearInterval(discoverCatchUpTimer);
         if (initialDiscoverTimer)

package/dist/commands/mcpGateway.js

@@ -84,6 +84,17 @@ const CLIENT_LABELS = {
     windsurf: 'Windsurf',
     vscode: 'VS Code',
 };
+/**
+ * Default configured-context template per client. Single source of truth —
+ * protect-all wraps configs for EVERY client from one shared GatewayConfig,
+ * and deriving the objective from that shared config gave Codex/Claude/etc.
+ * entries the Cursor template ("from Cursor" on a Codex event — a customer-
+ * reported labeling bug). This is a CONFIGURED template, not observed
+ * behavior; the console labels it accordingly.
+ */
+function defaultUserObjective(agentClient) {
+    return `Developer requested this action from ${CLIENT_LABELS[agentClient] || 'an MCP client'}.`;
+}
 function parseHeadersFlag(value) {
     if (!value?.trim())
         return undefined;
@@ -206,7 +217,8 @@ function resolveGatewayConfig(args, config, defaults = {}) {
         agentClient,
         developerName,
         environment: args.environment || process.env.FCD_ENVIRONMENT || 'developer-workstation',
-        userObjective: args.userObjective || process.env.FCD_USER_OBJECTIVE || defaults.userObjective || 'Developer requested this action from Cursor.',
+        userObjective: args.userObjective || process.env.FCD_USER_OBJECTIVE || defaults.userObjective || defaultUserObjective(agentClient),
+        userObjectiveExplicit: !!(args.userObjective || process.env.FCD_USER_OBJECTIVE),
         authority: args.authority || process.env.FCD_AUTHORITY || 'developer',
         approvalMode: args.approvalMode === 'block' ? 'block' : 'wait',
         approvalTimeoutMs: Number(args.approvalTimeoutMs) > 0 ? Number(args.approvalTimeoutMs) : 900000,
@@ -606,7 +618,11 @@ class AgentGuardApi {
             agentName: this.config.agentName,
             toolName: input.toolName,
             operation: input.operation,
-            toolArgs: input.toolArgs,
+            // Data minimization: this is a pure audit-record call (the decision was
+            // already made by check-tool-call), and the backend persists only
+            // argsSummary — so the RAW arguments are redacted/truncated ON THIS
+            // MACHINE and never sent here. Raw args still travel on the policy
+            // check itself, where the evaluation genuinely needs them.
             argsSummary: summarizeToolArgs(input.toolArgs, this.config.developerName, this.config.agentClient),
             environment: this.config.environment,
             userObjective: this.config.userObjective,
@@ -1352,7 +1368,6 @@ async function installCursorMcpGatewayCommand(args, config) {
     const baseGatewayConfig = resolveGatewayConfig(args, config, {
         agentClient: 'cursor',
         agentNamePrefix: 'cursor',
-        userObjective: 'Developer requested this action from Cursor.',
     });
     const projectScope = args.project === 'true';
     const file = cursorMcpPath(projectScope);
@@ -1743,6 +1758,22 @@ function applyPerServerAgentName(gatewayConfig, args, serverName) {
         agentName: perServerAgentName(gatewayConfig.developerName, gatewayConfig.agentClient, serverName),
     };
 }
+/**
+ * The per-server config protect-all bakes into each wrapped entry. The shared
+ * base config was resolved ONCE (defaulting to Cursor), so every client-
+ * specific field must be re-derived here: the client itself, the per-server
+ * agent name, and the user-objective template — a Codex entry must say
+ * "from Codex", not inherit the base config's Cursor text. An explicit
+ * --user-objective / FCD_USER_OBJECTIVE still wins for all clients.
+ */
+function perServerGatewayConfig(gatewayConfig, agentClient, serverName) {
+    return {
+        ...gatewayConfig,
+        agentClient,
+        agentName: perServerAgentName(gatewayConfig.developerName, agentClient, serverName),
+        userObjective: gatewayConfig.userObjectiveExplicit ? gatewayConfig.userObjective : defaultUserObjective(agentClient),
+    };
+}
 function wrapJsonConfigFile(file, gatewayConfig, agentClient, dryRun) {
     const stats = newWrapStats();
     let json;
@@ -1773,7 +1804,7 @@ function wrapJsonConfigFile(file, gatewayConfig, agentClient, dryRun) {
                     const credentialPairStale = existingArgs.includes('--shield-id') && !existingArgs.includes('--shield-key');
                     const downstream = credentialPairStale ? extractFullyUnwrappedDownstream(entry) : null;
                     if (!credentialPairStale || downstream) {
-                        const perServer = { ...gatewayConfig, agentClient, agentName: perServerAgentName(gatewayConfig.developerName, agentClient, name) };
+                        const perServer = perServerGatewayConfig(gatewayConfig, agentClient, name);
                         entry.command = nodeExe;
                         // Path-only upgrades preserve every downstream/config flag exactly.
                         // The credential-pair bug requires a safe rebuild from downstream.
@@ -1788,7 +1819,7 @@ function wrapJsonConfigFile(file, gatewayConfig, agentClient, dryRun) {
                 stats.skippedManaged.push(name);
                 continue;
             }
-            const perServer = { ...gatewayConfig, agentClient, agentName: perServerAgentName(gatewayConfig.developerName, agentClient, name) };
+            const perServer = perServerGatewayConfig(gatewayConfig, agentClient, name);
             if (typeof entry.command !== 'string' || !entry.command) {
                 // Remote HTTP/SSE MCP: wrap the URL behind a local stdio gateway that
                 // enforces policies, then forwards over Streamable HTTP. Original url,
@@ -2003,7 +2034,7 @@ function transformCodexToml(file, mode, gatewayConfig, dryRun) {
                 }
                 continue;
             }
-            const perServer = { ...gatewayConfig, agentClient: 'codex', agentName: perServerAgentName(gatewayConfig.developerName, 'codex', section.name) };
+            const perServer = perServerGatewayConfig(gatewayConfig, 'codex', section.name);
             const wrappedArgs = buildGatewayCommandArgs(perServer, { kind: 'stdio', command: section.command, args: section.args || [] }, INSTALL_GATEWAY_ARGS);
             const indent = lines[section.cmdLine].match(/^\s*/)?.[0] || '';
             lines[section.cmdLine] = `${indent}command = ${JSON.stringify(nodeExe)}`;
@@ -2187,7 +2218,6 @@ async function installClaudeCodeMcpGatewayCommand(args, config) {
     const baseGatewayConfig = resolveGatewayConfig(args, config, {
         agentClient: 'claude-code',
         agentNamePrefix: 'claude-code',
-        userObjective: 'Developer requested this action from Claude Code.',
     });
     const scope = normalizeClaudeCodeScope(args.scope);
     const nodeExe = process.execPath;
@@ -2251,7 +2281,6 @@ async function installClaudeDesktopMcpGatewayCommand(args, config) {
     const baseGatewayConfig = resolveGatewayConfig(args, config, {
         agentClient: 'claude-desktop',
         agentNamePrefix: 'claude-desktop',
-        userObjective: 'Developer requested this action from Claude Desktop.',
     });
     const targets = (0, discoverPaths_1.claudeDesktopInstallTargets)(args.configPath);
     const nodeExe = process.execPath;
@@ -2274,7 +2303,6 @@ async function installCodexMcpGatewayCommand(args, config) {
     const baseGatewayConfig = resolveGatewayConfig(args, config, {
         agentClient: 'codex',
         agentNamePrefix: 'codex',
-        userObjective: 'Developer requested this action from Codex.',
     });
     const projectScope = args.project === 'true';
     const file = codexConfigPath(projectScope);
@@ -2293,7 +2321,6 @@ async function installGeminiMcpGatewayCommand(args, config) {
     const baseGatewayConfig = resolveGatewayConfig(args, config, {
         agentClient: 'gemini-cli',
         agentNamePrefix: 'gemini',
-        userObjective: 'Developer requested this action from Gemini CLI.',
     });
     const projectScope = args.project === 'true';
     const file = geminiSettingsPath(projectScope);
@@ -2312,7 +2339,6 @@ async function installWindsurfMcpGatewayCommand(args, config) {
     const baseGatewayConfig = resolveGatewayConfig(args, config, {
         agentClient: 'windsurf',
         agentNamePrefix: 'windsurf',
-        userObjective: 'Developer requested this action from Windsurf.',
     });
     const file = windsurfConfigPath();
     const nodeExe = process.execPath;
@@ -2330,7 +2356,6 @@ async function installVscodeMcpGatewayCommand(args, config) {
     const baseGatewayConfig = resolveGatewayConfig(args, config, {
         agentClient: 'vscode',
         agentNamePrefix: 'vscode',
-        userObjective: 'Developer requested this action from VS Code.',
     });
     const projectScope = args.project !== 'false';
     const nodeExe = process.execPath;

package/dist/commands/windowsAudit.d.ts

@@ -24,6 +24,22 @@ export declare function getWindowsAuditStatus(): WindowsAuditStatus;
  * Never throws — telemetry/discovery must not break on a probe failure.
  */
 export declare function getShellAuditReport(): ShellAuditReport | undefined;
+export interface AuditPreInstallSnapshot {
+    capturedAt: string;
+    scriptBlockLogging: {
+        present: boolean;
+        enableValue?: number;
+    };
+    transcription: {
+        present: boolean;
+        enableValue?: number;
+        invocationHeader?: number;
+        outputDirectory?: string;
+    };
+}
+export declare function auditPreInstallSnapshotPath(): string;
+/** Record the audit keys as they were BEFORE FCD changes them (first contact only). Best-effort, never throws. */
+export declare function captureAuditPreInstallSnapshot(): void;
 export interface EnableWindowsAuditResult {
     ok: boolean;
     status: WindowsAuditStatus;
@@ -32,6 +48,13 @@ export interface EnableWindowsAuditResult {
     /** True when the user saw (and answered) a UAC elevation prompt. */
     promptShown: boolean;
 }
+/**
+ * Disable ScriptBlock Logging + Transcription (removes the HKLM policy keys)
+ * via one UAC prompt. Mirrors enableWindowsAudit's fail-open contract. If the
+ * keys are enforced by GPO/Intune they will reappear on the next policy sync
+ * — the message says so.
+ */
+export declare function disableWindowsAudit(): EnableWindowsAuditResult;
 /**
  * Enable ScriptBlock Logging + Transcription via ONE UAC elevation prompt.
  * Skips silently when already fully enabled. Never throws; on any failure
@@ -39,8 +62,23 @@ export interface EnableWindowsAuditResult {
  * message — callers must treat that as non-blocking.
  */
 export declare function enableWindowsAudit(): EnableWindowsAuditResult;
+export interface TranscriptPruneResult {
+    /** Files deleted in this run. */
+    pruned: number;
+    /** Set when pruning was skipped entirely (not enabled / foreign dir / non-Windows). */
+    skipped?: string;
+}
+/** Retention window in days — env override for fleets that want tighter/looser. */
+export declare function transcriptRetentionDays(): number;
+/**
+ * Delete transcript files older than the retention window. Never throws;
+ * locked/in-use files (an open PowerShell session's live transcript) are
+ * skipped and picked up on a later run. Empty date folders are removed.
+ */
+export declare function pruneTranscripts(maxAgeDays?: number, dirOverride?: string): TranscriptPruneResult;
 export interface WindowsAuditArgs {
     enable?: string;
+    disable?: string;
 }
 /**
  * `fullcourtdefense windows-audit` — show (default) or enable (--enable)

package/dist/commands/windowsAudit.js

@@ -35,7 +35,12 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getWindowsAuditStatus = getWindowsAuditStatus;
 exports.getShellAuditReport = getShellAuditReport;
+exports.auditPreInstallSnapshotPath = auditPreInstallSnapshotPath;
+exports.captureAuditPreInstallSnapshot = captureAuditPreInstallSnapshot;
+exports.disableWindowsAudit = disableWindowsAudit;
 exports.enableWindowsAudit = enableWindowsAudit;
+exports.transcriptRetentionDays = transcriptRetentionDays;
+exports.pruneTranscripts = pruneTranscripts;
 exports.windowsAuditCommand = windowsAuditCommand;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
@@ -132,6 +137,56 @@ function defaultTranscriptDir() {
     const programData = process.env.ProgramData || 'C:\\ProgramData';
     return path.join(programData, 'FullCourtDefense', 'Transcripts');
 }
+function auditPreInstallSnapshotPath() {
+    const programData = process.env.ProgramData || 'C:\\ProgramData';
+    return path.join(programData, 'FullCourtDefense', 'audit-preinstall.json');
+}
+/** Record the audit keys as they were BEFORE FCD changes them (first contact only). Best-effort, never throws. */
+function captureAuditPreInstallSnapshot() {
+    try {
+        const file = auditPreInstallSnapshotPath();
+        const trDir = regString(TRANSCRIPTION_KEY, 'OutputDirectory');
+        // Upgrade guard: when transcription already points at OUR folder, the
+        // current keys are FCD's own configuration written by a pre-snapshot
+        // version (<=1.22.3) — NOT a pre-install state. Recording it would make
+        // uninstall "restore" FCD's keys instead of removing them. Skip the
+        // snapshot; uninstall's conservative heuristic handles FCD-provenance
+        // keys correctly.
+        const fcdProvenance = typeof trDir === 'string' && /FullCourtDefense/i.test(trDir);
+        if (fs.existsSync(file)) {
+            // Self-heal snapshots already written by 1.22.4.0 on upgraded machines:
+            // a "pre-install" transcription directory inside an FCD folder is
+            // provably bogus (FCD did not exist before FCD was installed).
+            try {
+                const existing = JSON.parse(fs.readFileSync(file, 'utf8'));
+                const dir = existing?.transcription?.outputDirectory;
+                if (typeof dir === 'string' && /FullCourtDefense/i.test(dir))
+                    fs.unlinkSync(file);
+            }
+            catch { /* unreadable snapshot: leave it — the uninstall branch parses defensively */ }
+            if (fs.existsSync(file))
+                return;
+        }
+        if (fcdProvenance)
+            return;
+        const sblValue = regDword(SBL_KEY, 'EnableScriptBlockLogging');
+        const trValue = regDword(TRANSCRIPTION_KEY, 'EnableTranscripting');
+        const trHeader = regDword(TRANSCRIPTION_KEY, 'EnableInvocationHeader');
+        const snapshot = {
+            capturedAt: new Date().toISOString(),
+            scriptBlockLogging: { present: sblValue !== undefined, enableValue: sblValue },
+            transcription: {
+                present: trValue !== undefined || trHeader !== undefined || trDir !== undefined,
+                enableValue: trValue,
+                invocationHeader: trHeader,
+                outputDirectory: trDir,
+            },
+        };
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, JSON.stringify(snapshot, null, 2), 'utf8');
+    }
+    catch { /* best-effort: without a snapshot, uninstall falls back to the conservative heuristic */ }
+}
 /** The elevated payload: sets both policy keys + creates the transcript dir. */
 function buildEnableScript(transcriptDir) {
     return [
@@ -148,6 +203,74 @@ function buildEnableScript(transcriptDir) {
         `New-ItemProperty -Path $tr -Name OutputDirectory -Value $dir -PropertyType String -Force | Out-Null`,
     ].join('\r\n') + '\r\n';
 }
+/** The elevated disable payload: removes both policy keys (audit off machine-wide). */
+function buildDisableScript() {
+    return [
+        `$ErrorActionPreference = 'SilentlyContinue'`,
+        `Remove-Item -Path 'HKLM:\\SOFTWARE\\Policies\\Microsoft\\Windows\\PowerShell\\ScriptBlockLogging' -Recurse -Force`,
+        `Remove-Item -Path 'HKLM:\\SOFTWARE\\Policies\\Microsoft\\Windows\\PowerShell\\Transcription' -Recurse -Force`,
+        `exit 0`,
+    ].join('\r\n') + '\r\n';
+}
+/**
+ * Disable ScriptBlock Logging + Transcription (removes the HKLM policy keys)
+ * via one UAC prompt. Mirrors enableWindowsAudit's fail-open contract. If the
+ * keys are enforced by GPO/Intune they will reappear on the next policy sync
+ * — the message says so.
+ */
+function disableWindowsAudit() {
+    const before = getWindowsAuditStatus();
+    if (!before.supported) {
+        return { ok: false, status: before, promptShown: false, message: 'PowerShell audit logging is a Windows feature — skipped on this OS.' };
+    }
+    if (!before.scriptBlockLogging && !before.transcription) {
+        return { ok: true, status: before, promptShown: false, message: 'PowerShell audit logging is already disabled.' };
+    }
+    const scriptPath = path.join(os.tmpdir(), `fcd-disable-audit-${process.pid}.ps1`);
+    const elevatePath = path.join(os.tmpdir(), `fcd-elevate-disable-audit-${process.pid}.ps1`);
+    let promptShown = false;
+    try {
+        fs.writeFileSync(scriptPath, buildDisableScript(), 'utf8');
+        const quotedPayload = `"${scriptPath}"`.replace(/'/g, "''");
+        fs.writeFileSync(elevatePath, [
+            `$ErrorActionPreference = 'Stop'`,
+            `try {`,
+            `  $p = Start-Process -FilePath 'powershell.exe' -Verb RunAs -Wait -PassThru -WindowStyle Hidden -ArgumentList @('-NoProfile','-ExecutionPolicy','Bypass','-File','${quotedPayload}')`,
+            `  exit $p.ExitCode`,
+            `} catch {`,
+            `  exit 1`,
+            `}`,
+        ].join('\r\n') + '\r\n', 'utf8');
+        promptShown = true;
+        (0, child_process_1.spawnSync)('powershell.exe', [
+            '-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', elevatePath,
+        ], { encoding: 'utf8', windowsHide: true, timeout: 120000 });
+        const after = getWindowsAuditStatus();
+        if (!after.scriptBlockLogging && !after.transcription) {
+            return { ok: true, status: after, promptShown, message: 'PowerShell audit logging disabled — both policy keys removed. Existing transcripts were NOT deleted.' };
+        }
+        return {
+            ok: false, status: after, promptShown,
+            message: 'PowerShell audit logging is still enabled — the admin prompt was declined, or the keys are enforced by GPO/Intune (they re-apply on policy sync). Ask IT to disable via GPO in that case.',
+        };
+    }
+    catch (error) {
+        return {
+            ok: false, status: getWindowsAuditStatus(), promptShown,
+            message: `PowerShell audit logging could not be disabled (${error instanceof Error ? error.message : String(error)}).`,
+        };
+    }
+    finally {
+        try {
+            fs.unlinkSync(scriptPath);
+        }
+        catch { /* best effort */ }
+        try {
+            fs.unlinkSync(elevatePath);
+        }
+        catch { /* best effort */ }
+    }
+}
 /**
  * Enable ScriptBlock Logging + Transcription via ONE UAC elevation prompt.
  * Skips silently when already fully enabled. Never throws; on any failure
@@ -159,6 +282,9 @@ function enableWindowsAudit() {
     if (!before.supported) {
         return { ok: false, status: before, promptShown: false, message: 'PowerShell audit logging is a Windows feature — skipped on this OS.' };
     }
+    // Snapshot BEFORE any change (and before the already-enabled early return:
+    // "already enabled by the org" is exactly the state uninstall must restore).
+    captureAuditPreInstallSnapshot();
     if (before.scriptBlockLogging && before.transcription) {
         return { ok: true, status: before, promptShown: false, message: 'PowerShell audit logging already enabled (ScriptBlock Logging + Transcription).' };
     }
@@ -219,6 +345,66 @@ function enableWindowsAudit() {
         catch { /* best effort */ }
     }
 }
+// ── Transcript retention ────────────────────────────────────────────────────
+// Transcription writes a file per PowerShell session into date-named
+// subfolders; on a busy developer machine that grows unbounded (a customer
+// audit finding). The daemon prunes files older than the retention window
+// once a day. Deliberately conservative: it only ever touches a directory
+// that FCD itself configured (path contains "FullCourtDefense") — an
+// org-managed transcript share set via GPO is never cleaned by us.
+const DEFAULT_TRANSCRIPT_RETENTION_DAYS = 30;
+/** Retention window in days — env override for fleets that want tighter/looser. */
+function transcriptRetentionDays() {
+    const raw = Number(process.env.FCD_TRANSCRIPT_RETENTION_DAYS);
+    return Number.isFinite(raw) && raw >= 1 ? Math.floor(raw) : DEFAULT_TRANSCRIPT_RETENTION_DAYS;
+}
+/**
+ * Delete transcript files older than the retention window. Never throws;
+ * locked/in-use files (an open PowerShell session's live transcript) are
+ * skipped and picked up on a later run. Empty date folders are removed.
+ */
+function pruneTranscripts(maxAgeDays = transcriptRetentionDays(), dirOverride) {
+    if (process.platform !== 'win32' && !dirOverride)
+        return { pruned: 0, skipped: 'non-Windows' };
+    const dir = dirOverride ?? getWindowsAuditStatus().transcriptionPath;
+    if (!dir)
+        return { pruned: 0, skipped: 'transcription not configured' };
+    if (!/fullcourtdefense/i.test(dir))
+        return { pruned: 0, skipped: `transcript dir not FCD-managed (${dir})` };
+    if (!fs.existsSync(dir))
+        return { pruned: 0, skipped: 'transcript dir does not exist' };
+    const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
+    let pruned = 0;
+    const pruneDir = (target, depth) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(target, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(target, entry.name);
+            try {
+                if (entry.isDirectory()) {
+                    if (depth < 2)
+                        pruneDir(full, depth + 1);
+                    try {
+                        fs.rmdirSync(full);
+                    }
+                    catch { /* not empty — keep */ }
+                }
+                else if (fs.statSync(full).mtimeMs < cutoff) {
+                    fs.unlinkSync(full);
+                    pruned += 1;
+                }
+            }
+            catch { /* locked (live session transcript) or race — next run */ }
+        }
+    };
+    pruneDir(dir, 0);
+    return { pruned };
+}
 /**
  * `fullcourtdefense windows-audit` — show (default) or enable (--enable)
  * Windows PowerShell audit coverage on this machine.
@@ -235,6 +421,13 @@ async function windowsAuditCommand(args) {
         console.log(result.ok ? `\x1b[32m✓ ${result.message}\x1b[0m` : `\x1b[33m⚠ ${result.message}\x1b[0m`);
         return;
     }
+    if (args.disable === 'true') {
+        console.log('Disabling PowerShell audit logging (removes both HKLM policy keys)…');
+        console.log('\x1b[2mWindows will show an admin approval prompt (UAC).\x1b[0m');
+        const result = disableWindowsAudit();
+        console.log(result.ok ? `\x1b[32m✓ ${result.message}\x1b[0m` : `\x1b[33m⚠ ${result.message}\x1b[0m`);
+        return;
+    }
     const status = getWindowsAuditStatus();
     const mark = (on) => (on ? '\x1b[32m✓ enabled\x1b[0m' : '\x1b[31m✗ disabled\x1b[0m');
     console.log('\n\x1b[1mWindows PowerShell audit coverage\x1b[0m');

package/dist/index.js

@@ -150,7 +150,8 @@ function printHelp() {
                 or --mcp-command needed. Use --hooks false to skip runtime hooks.
     install     Alias for install-all.
     windows-audit  Show Windows PowerShell audit coverage (ScriptBlock Logging +
-                Transcription). Use --enable to turn it on (one admin prompt).
+                Transcription). Use --enable to turn it on, --disable to remove
+                both policy keys (one admin prompt either way).
     install-shell-guard    Block dangerous commands typed in a terminal (real-time,
                 offline rule cache): PowerShell on Windows, bash + zsh on macOS/Linux.
                 uninstall-shell-guard removes it; shell-guard-status shows coverage.
@@ -698,7 +699,7 @@ async function main() {
             break;
         }
         case 'windows-audit': {
-            const args = { enable: flags.enable };
+            const args = { enable: flags.enable, disable: flags.disable };
             await (0, windowsAudit_1.windowsAuditCommand)(args);
             break;
         }

package/dist/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "1.22.3"
+  "version": "1.22.5"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fullcourtdefense-cli",
-  "version": "1.22.3",
+  "version": "1.22.5",
   "description": "Full Court Defense CLI — security scanning for AI agents from your terminal",
   "main": "dist/index.js",
   "bin": {
@@ -24,6 +24,7 @@
     "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",
+    "test:audit-restore": "node scripts/test-audit-restore.js",
     "test:shell-guard": "npm run build && node scripts/test-shell-guard.js",
     "test:cmd-guard": "npm run build && node scripts/test-cmd-guard.js",
     "test:posix-guard": "npm run build && node scripts/test-posix-guard.js",
@@ -32,6 +33,7 @@
     "test:realworld-posture": "npm run build && node scripts/test-realworld-posture-fixtures.js",
     "test:discover-stdio-mcp": "npm run build && node scripts/test-discover-stdio-mcp-tools.js",
     "test:per-server-agent-name": "npm run build && node scripts/test-per-server-agent-name.js",
+    "test:user-objective-labels": "npm run build && node scripts/test-user-objective-labels.js",
     "test:remote-mcp-gateway": "npm run build && node scripts/test-remote-mcp-gateway.js",
     "test:e2e-onboarding-personas": "npm run build && node scripts/test-e2e-onboarding-personas.js",
     "test:onboarding-transaction": "npm run build && node scripts/test-onboarding-transaction.js",