fullcourtdefense-cli 1.21.40 → 1.22.1

package/dist/commands/autoProtect.js

@@ -39,6 +39,7 @@ const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 const mcpGateway_1 = require("./mcpGateway");
+const daemon_1 = require("./daemon");
 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',
@@ -54,38 +55,40 @@ function launcherDir() {
         : path.join(os.homedir(), '.fullcourtdefense');
     return path.join(base, 'FullCourtDefense');
 }
-/** On Windows, write a hidden VBS launcher so the scheduled run doesn't flash a console window. */
-function ensureWindowsLauncher() {
-    const dir = launcherDir();
-    fs.mkdirSync(dir, { recursive: true });
-    const vbs = path.join(dir, 'auto-protect.vbs');
-    const node = process.execPath;
-    const cli = cliEntry();
-    // WScript.Shell.Run with window style 0 = hidden, wait = false. Run node
-    // directly — `cmd /c` breaks quote parsing under paths with spaces.
-    const inner = `"${node}" "${cli}" protect-all`;
-    const content = `CreateObject("WScript.Shell").Run "${inner.replace(/"/g, '""')}", 0, False\n`;
-    fs.writeFileSync(vbs, content, 'utf8');
-    return vbs;
-}
+// No VBS/wscript launcher here — Windows Defender's Commando.A!ml heuristic
+// flags "scheduled task -> wscript runs a user-writable script on an interval"
+// as script persistence. The task runs node.exe directly, hidden via task XML
+// (shared helpers in daemon.ts).
 function installWindows(intervalMinutes, onLogon) {
-    const vbs = ensureWindowsLauncher();
-    const tr = `wscript.exe "${vbs}"`;
-    const baseArgs = ['/Create', '/TN', TASK_NAME, '/TR', tr, '/F', '/RL', 'LIMITED'];
+    const trigger = onLogon
+        ? `    <LogonTrigger>
+      <Enabled>true</Enabled>
+      <UserId>${(0, daemon_1.xmlEscape)((0, daemon_1.taskUserId)())}</UserId>
+    </LogonTrigger>`
+        : `    <TimeTrigger>
+      <Enabled>true</Enabled>
+      <StartBoundary>${(0, daemon_1.taskLocalTimestamp)(new Date(Date.now() - 60_000))}</StartBoundary>
+      <Repetition>
+        <Interval>PT${Math.max(1, intervalMinutes)}M</Interval>
+        <StopAtDurationEnd>false</StopAtDurationEnd>
+      </Repetition>
+    </TimeTrigger>`;
     const schedArgs = onLogon
-        ? ['/SC', 'ONLOGON']
-        : ['/SC', 'MINUTE', '/MO', String(intervalMinutes)];
-    const result = (0, child_process_1.spawnSync)('schtasks', [...baseArgs, ...schedArgs], { stdio: 'inherit' });
-    return result.status === 0;
+        ? ['/SC', 'ONLOGON', '/RL', 'LIMITED']
+        : ['/SC', 'MINUTE', '/MO', String(Math.max(1, intervalMinutes)), '/RL', 'LIMITED'];
+    return (0, daemon_1.registerHiddenTask)(TASK_NAME, (0, daemon_1.buildTaskXml)('protect-all', trigger), 'protect-all', schedArgs);
 }
 function uninstallWindows() {
     const result = (0, child_process_1.spawnSync)('schtasks', ['/Delete', '/TN', TASK_NAME, '/F'], { stdio: 'inherit' });
-    const vbs = path.join(launcherDir(), 'auto-protect.vbs');
-    try {
-        if (fs.existsSync(vbs))
-            fs.unlinkSync(vbs);
+    // Legacy VBS launcher from pre-1.22.1 installs + the current task XML.
+    for (const name of ['auto-protect.vbs', `${TASK_NAME.replace(/[^A-Za-z0-9]+/g, '_')}.task.xml`]) {
+        const file = path.join(launcherDir(), name);
+        try {
+            if (fs.existsSync(file))
+                fs.unlinkSync(file);
+        }
+        catch { /* ignore */ }
     }
-    catch { /* ignore */ }
     return result.status === 0;
 }
 function statusWindows() {

package/dist/commands/cmdGuard.js

@@ -117,14 +117,15 @@ function buildGuardJs(nodePath, cliEntry) {
         `const SPOOL_PATH=${JSON.stringify(path.join(os.homedir(), '.fullcourtdefense-spool.jsonl'))};`,
         `const NODE_PATH=${JSON.stringify(nodePath)};`,
         `const CLI_ENTRY=${JSON.stringify(cliEntry)};`,
-        `function loadRules(){try{const raw=JSON.parse(fs.readFileSync(RULES_PATH,'utf8'));const rules=(raw.rules||[]).map(r=>{try{return{id:r.id,category:r.category,severity:r.severity,reason:r.reason,source:r.source,re:new RegExp(r.pattern,'i')};}catch{return null;}}).filter(Boolean);return{mode:raw.mode==='monitor'?'monitor':'block',rules};}catch{return{mode:'block',rules:[]};}}`,
-        `function matchLine(line,rules){const n=line.replace(/\\s+/g,' ').trim();for(const r of rules){try{if(r.re.test(n)||r.re.test(line))return r;}catch{}}return null;}`,
+        `function loadRules(){try{const raw=JSON.parse(fs.readFileSync(RULES_PATH,'utf8'));const rules=(raw.rules||[]).map(r=>{try{return{id:r.id,category:r.category,severity:r.severity,reason:r.reason,source:r.source,action:r.action==='warn'?'warn':'block',re:new RegExp(r.pattern,'i')};}catch{return null;}}).filter(Boolean);return{mode:raw.mode==='monitor'?'monitor':'block',rules};}catch{return{mode:'block',rules:[]};}}`,
+        `function matchLine(line,rules){const n=line.replace(/\\s+/g,' ').trim();let warnHit=null;for(const r of rules){try{if(r.re.test(n)||r.re.test(line)){if(r.action!=='warn')return r;if(!warnHit)warnHit=r;}}catch{}}return warnHit;}`,
         `function spoolEvent(rule,line,decision){try{const ev=line.trim();const evidence=ev.length>180?ev.slice(0,180)+'...':ev;const event={eventId:crypto.randomUUID(),type:'verdict',decision,toolName:'cmd_terminal',operation:'shell_command',reason:'Shell guard: '+rule.reason,ruleId:rule.id,category:rule.category,severity:rule.severity,source:rule.source,evidence,occurredAt:new Date().toISOString()};fs.appendFileSync(SPOOL_PATH,JSON.stringify(event)+'\\n',{encoding:'utf8',mode:0o600});if(fs.existsSync(NODE_PATH)&&fs.existsSync(CLI_ENTRY)){spawnSync(NODE_PATH,[CLI_ENTRY,'flush-spool','--heartbeat','true'],{stdio:'ignore',windowsHide:true});}}catch{}}`,
         `function delegate(args){const r=spawnSync(process.env.ComSpec||'cmd.exe',['/d','/c',...args],{stdio:'inherit',windowsHide:true});process.exit(typeof r.status==='number'?r.status:1);}`,
         `const args=process.argv.slice(2);if(!args.length)process.exit(0);if(process.env.FCD_CMD_GUARD==='off')delegate(args);`,
         `const line=args.join(' ');const{mode,rules}=loadRules();const hit=matchLine(line,rules);`,
         `if(!hit)delegate(args);`,
         `if(mode==='monitor'){console.error('[FullCourtDefense] monitor: would block ['+(hit.severity||'')+'] '+hit.reason+' (rule '+hit.id+')');spoolEvent(hit,line,'allow');delegate(args);}`,
+        `if(hit.action==='warn'){console.error('[FullCourtDefense] warning ['+(hit.severity||'')+']: '+hit.reason+' (rule '+hit.id+') — allowed by org policy, reported to your security dashboard.');spoolEvent(hit,line,'warn');delegate(args);}`,
         `console.error('[FullCourtDefense] BLOCKED ['+(hit.severity||'')+']: '+hit.reason+' (rule '+hit.id+')');`,
         `console.error('This command was not executed. Reported to your security dashboard.');`,
         `spoolEvent(hit,line,'block');process.exit(1);`,

package/dist/commands/daemon.d.ts

@@ -32,6 +32,33 @@ export declare function discoverSweepCredentialEnv(credentials?: {
     shieldKey?: string;
     apiUrl?: string;
 }): Record<string, string>;
+/** Fully-qualified current user (DOMAIN\\user) for the task principal. */
+export declare function taskUserId(): string;
+/** Local wall-clock timestamp (no ms, no tz) as Task Scheduler expects. */
+export declare function taskLocalTimestamp(date: Date): string;
+/**
+ * Task Scheduler XML that runs `node.exe <cliEntry> <command>` hidden.
+ *
+ * @param command   CLI subcommand ('daemon' | 'watchdog').
+ * @param triggers  Inner <Triggers> XML — logon for the daemon, a repeating
+ *                  time trigger for the 5-minute watchdog.
+ */
+export declare function buildTaskXml(command: string, triggers: string): string;
+/**
+ * Register a scheduled task from XML (node run directly, window hidden). Falls
+ * back to a plain `/TR node …` task if XML registration fails — that variant
+ * may briefly flash a console window but still contains NO script host, so the
+ * malware fingerprint never returns. Returns true if either path succeeds.
+ *
+ * @param taskName      Scheduled-task name.
+ * @param xml           Full Task Scheduler XML (from buildDaemon/Watchdog).
+ * @param command       CLI subcommand for the /TR fallback ('daemon'|'watchdog').
+ * @param scheduleArgs  schtasks schedule flags for the fallback (e.g. ['/SC','MINUTE','/MO','5']).
+ */
+export declare function registerHiddenTask(taskName: string, xml: string, command: string, scheduleArgs: string[]): boolean;
+/** True when an existing scheduled task's action still runs wscript/cscript
+ *  (the pre-1.22.1 VBS launcher) — the migration trigger. */
+export declare function windowsTaskReferencesScriptHost(taskName: string): boolean;
 /** Snapshot of the resident daemon for out-of-process callers (watchdog/status). */
 export interface DaemonRuntimeState {
     alive: boolean;
@@ -45,6 +72,7 @@ export declare function spawnDetachedDaemon(): boolean;
 /** Pid-alive check shared with the watchdog (EPERM still means alive). */
 export declare function pidIsAlive(pid: number): boolean;
 export declare function macosLaunchdPath(currentPath?: string, execPath?: string): string;
+export declare function xmlEscape(value: string): string;
 /** Whether the daemon has been registered to start automatically. */
 /** Is the 5-minute watchdog scheduled task registered? (Windows-only feature.) */
 export declare function isWatchdogTaskInstalled(): boolean;

package/dist/commands/daemon.js

@@ -36,10 +36,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.daemonDiscoverSweepArgs = daemonDiscoverSweepArgs;
 exports.summarizeDiscoverStderr = summarizeDiscoverStderr;
 exports.discoverSweepCredentialEnv = discoverSweepCredentialEnv;
+exports.taskUserId = taskUserId;
+exports.taskLocalTimestamp = taskLocalTimestamp;
+exports.buildTaskXml = buildTaskXml;
+exports.registerHiddenTask = registerHiddenTask;
+exports.windowsTaskReferencesScriptHost = windowsTaskReferencesScriptHost;
 exports.daemonRuntimeState = daemonRuntimeState;
 exports.spawnDetachedDaemon = spawnDetachedDaemon;
 exports.pidIsAlive = pidIsAlive;
 exports.macosLaunchdPath = macosLaunchdPath;
+exports.xmlEscape = xmlEscape;
 exports.isWatchdogTaskInstalled = isWatchdogTaskInstalled;
 exports.isDaemonAutostartInstalled = isDaemonAutostartInstalled;
 exports.daemonCommand = daemonCommand;
@@ -718,23 +724,22 @@ async function runDaemon(args, config) {
         executingActionIds.add(action.id);
         // Cryptographic gate: never execute an action the control plane didn't
         // sign — a Firestore/backend compromise must not become fleet-wide RCE.
-        const verdict = (0, machineActionVerify_1.verifyMachineAction)(action);
+        // Machine binding is enforced too: a correctly signed action targeting a
+        // DIFFERENT machine is rejected (bundle fetches send this machine's id, so
+        // a mismatch means misrouting/replay, not normal operation). Legacy fleets
+        // whose enrolled fingerprint drifted can set FCD_MACHINE_ACTION_ANY_MACHINE_OK=1
+        // locally while they re-enroll.
+        const localIdentity = (0, machineIdentity_1.getMachineIdentity)();
+        const verdict = (0, machineActionVerify_1.verifyMachineAction)(action, { localMachineId: localIdentity.machineId });
         if (!verdict.ok) {
             log(`Remote action REJECTED: ${action.type} (${action.id}) — ${verdict.reason}`);
-            await reportMachineAction(action.id, 'failed', { error: `Signature verification failed: ${verdict.reason}` });
+            await reportMachineAction(action.id, 'failed', { error: `Action verification failed: ${verdict.reason}` });
             executingActionIds.delete(action.id);
             await uploadLogTail();
             return;
         }
         if (verdict.reason)
-            log(`Remote action signature notice: ${verdict.reason}`);
-        const localIdentity = (0, machineIdentity_1.getMachineIdentity)();
-        if (action.machineId && action.machineId !== localIdentity.machineId) {
-            // Warn-only for now: enrolled machines can carry legacy fingerprints that
-            // differ from the freshly computed identity. Tighten to reject once the
-            // fleet is fully on stable machine ids.
-            log(`Remote action machine-binding notice: action targets ${action.machineId}, local id is ${localIdentity.machineId}.`);
-        }
+            log(`Remote action verification notice: ${verdict.reason}`);
         await reportMachineAction(action.id, 'running');
         log(`Remote action started: ${action.type} (${action.id}).`);
         await uploadLogTail();
@@ -1185,29 +1190,198 @@ async function runDaemon(args, config) {
 // ---------------------------------------------------------------------------
 // Autostart install / uninstall / status
 // ---------------------------------------------------------------------------
-/** Hidden VBS launcher so the logon task doesn't flash a console window. */
-function writeHiddenLauncher(fileName, cliCommand) {
-    const base = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
-    const dir = path.join(base, 'FullCourtDefense');
-    fs.mkdirSync(dir, { recursive: true });
-    const vbs = path.join(dir, fileName);
-    // Run node directly — routing through `cmd /c` breaks cmd's quote parsing
-    // when node/CLI live under a path with spaces (e.g. Program Files).
-    const inner = `"${process.execPath}" "${cliEntry()}" ${cliCommand}`;
-    const content = `CreateObject("WScript.Shell").Run "${inner.replace(/"/g, '""')}", 0, False\n`;
-    fs.writeFileSync(vbs, content, 'utf8');
-    return vbs;
+// ---------------------------------------------------------------------------
+// Windows autostart launchers
+//
+// HISTORY: we used to run `wscript.exe <script>.vbs` from the scheduled tasks
+// to launch node with no console-window flash. Windows Defender's ML heuristic
+// (`Trojan:Win32/Commando.A!ml`) flags "schtasks task -> wscript runs a script
+// from a user-writable dir on a short recurring interval" as script-based
+// persistence — a textbook malware pattern — and quarantined our own watchdog.
+//
+// FIX: no VBS, no wscript, no PowerShell anywhere in the autostart chain. The
+// scheduled tasks run the bundled `node.exe` DIRECTLY, and the console window
+// is suppressed the supported way — Task Scheduler XML `<Hidden>true</Hidden>`
+// with an InteractiveToken principal (needs no password, no elevation).
+// ---------------------------------------------------------------------------
+/** Fully-qualified current user (DOMAIN\\user) for the task principal. */
+function taskUserId() {
+    const domain = process.env.USERDOMAIN;
+    let user = process.env.USERNAME;
+    if (!user) {
+        try {
+            user = os.userInfo().username;
+        }
+        catch {
+            user = undefined;
+        }
+    }
+    if (user && domain)
+        return `${domain}\\${user}`;
+    if (user)
+        return user;
+    return os.hostname();
 }
-function ensureWindowsLauncher() {
-    return writeHiddenLauncher('daemon.vbs', 'daemon');
+/** Local wall-clock timestamp (no ms, no tz) as Task Scheduler expects. */
+function taskLocalTimestamp(date) {
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}` +
+        `T${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
 }
 /**
- * Watchdog launcher: runs the `watchdog` command (liveness beacon + daemon
- * revival + crash post-mortem) instead of blindly starting the daemon — the
- * beacon is what lets the console tell "daemon dead" apart from "machine off".
+ * Task Scheduler XML that runs `node.exe <cliEntry> <command>` hidden.
+ *
+ * @param command   CLI subcommand ('daemon' | 'watchdog').
+ * @param triggers  Inner <Triggers> XML — logon for the daemon, a repeating
+ *                  time trigger for the 5-minute watchdog.
  */
-function ensureWindowsWatchdogLauncher() {
-    return writeHiddenLauncher('watchdog.vbs', 'watchdog');
+function buildTaskXml(command, triggers) {
+    const userId = xmlEscape(taskUserId());
+    const nodeExe = xmlEscape(process.execPath);
+    const args = xmlEscape(`"${cliEntry()}" ${command}`);
+    return `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Description>FullCourtDefense ${command} — runs node directly, hidden, no script host.</Description>
+  </RegistrationInfo>
+  <Triggers>
+${triggers}
+  </Triggers>
+  <Principals>
+    <Principal id="Author">
+      <UserId>${userId}</UserId>
+      <LogonType>InteractiveToken</LogonType>
+      <RunLevel>LeastPrivilege</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <Hidden>true</Hidden>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
+    <AllowHardTerminate>true</AllowHardTerminate>
+    <AllowStartOnDemand>true</AllowStartOnDemand>
+    <Enabled>true</Enabled>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <IdleSettings>
+      <StopOnIdleEnd>false</StopOnIdleEnd>
+      <RestartOnIdle>false</RestartOnIdle>
+    </IdleSettings>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>${nodeExe}</Command>
+      <Arguments>${args}</Arguments>
+    </Exec>
+  </Actions>
+</Task>
+`;
+}
+/** Daemon task: start at logon (node run hidden, no repetition). */
+function buildDaemonTaskXml() {
+    const trigger = `    <LogonTrigger>
+      <Enabled>true</Enabled>
+      <UserId>${xmlEscape(taskUserId())}</UserId>
+    </LogonTrigger>`;
+    return buildTaskXml('daemon', trigger);
+}
+/**
+ * Watchdog task: run the `watchdog` command every 5 minutes (liveness beacon +
+ * daemon revival + crash post-mortem) — the beacon is what lets the console
+ * tell "daemon dead" apart from "machine off". A repeating time trigger with a
+ * past start boundary fires promptly and keeps repeating across reboots.
+ */
+function buildWatchdogTaskXml() {
+    const start = taskLocalTimestamp(new Date(Date.now() - 60_000));
+    const trigger = `    <TimeTrigger>
+      <Enabled>true</Enabled>
+      <StartBoundary>${start}</StartBoundary>
+      <Repetition>
+        <Interval>PT5M</Interval>
+        <StopAtDurationEnd>false</StopAtDurationEnd>
+      </Repetition>
+    </TimeTrigger>`;
+    return buildTaskXml('watchdog', trigger);
+}
+/**
+ * Register a scheduled task from XML (node run directly, window hidden). Falls
+ * back to a plain `/TR node …` task if XML registration fails — that variant
+ * may briefly flash a console window but still contains NO script host, so the
+ * malware fingerprint never returns. Returns true if either path succeeds.
+ *
+ * @param taskName      Scheduled-task name.
+ * @param xml           Full Task Scheduler XML (from buildDaemon/Watchdog).
+ * @param command       CLI subcommand for the /TR fallback ('daemon'|'watchdog').
+ * @param scheduleArgs  schtasks schedule flags for the fallback (e.g. ['/SC','MINUTE','/MO','5']).
+ */
+function registerHiddenTask(taskName, xml, command, scheduleArgs) {
+    const base = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+    const dir = path.join(base, 'FullCourtDefense');
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    catch { /* ignore */ }
+    const xmlPath = path.join(dir, `${taskName.replace(/[^A-Za-z0-9]+/g, '_')}.task.xml`);
+    try {
+        // schtasks /XML insists the file encoding matches the XML declaration and
+        // rejects UTF-8 ("unable to switch the encoding") — write UTF-16LE + BOM.
+        fs.writeFileSync(xmlPath, `\ufeff${xml}`, 'utf16le');
+        const created = (0, child_process_1.spawnSync)('schtasks', ['/Create', '/TN', taskName, '/XML', xmlPath, '/F'], {
+            stdio: 'ignore', windowsHide: true, timeout: 20_000,
+        });
+        if (created.status === 0)
+            return true;
+    }
+    catch { /* fall through to /TR */ }
+    // Fallback: node directly via /TR (no wscript, no VBS). node/CLI may live
+    // under a path with spaces (Program Files), so quote each and let schtasks
+    // pass the whole /TR string through.
+    const tr = `"${process.execPath}" "${cliEntry()}" ${command}`;
+    const fallback = (0, child_process_1.spawnSync)('schtasks', [
+        '/Create', '/TN', taskName, '/TR', tr, ...scheduleArgs, '/F',
+    ], { stdio: 'ignore', windowsHide: true, timeout: 20_000 });
+    return fallback.status === 0;
+}
+/** Remove legacy VBS launchers left by pre-1.22.1 installs. */
+function removeLegacyWindowsLaunchers() {
+    const launcherDir = path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local'), 'FullCourtDefense');
+    for (const launcher of ['daemon.vbs', 'watchdog.vbs']) {
+        try {
+            fs.unlinkSync(path.join(launcherDir, launcher));
+        }
+        catch { /* already gone */ }
+    }
+}
+/** True when an existing scheduled task's action still runs wscript/cscript
+ *  (the pre-1.22.1 VBS launcher) — the migration trigger. */
+function windowsTaskReferencesScriptHost(taskName) {
+    try {
+        const query = (0, child_process_1.spawnSync)('schtasks', ['/Query', '/TN', taskName, '/XML'], {
+            encoding: 'utf8', windowsHide: true, timeout: 10_000,
+        });
+        if (query.status !== 0 || typeof query.stdout !== 'string')
+            return false;
+        return /wscript|cscript|\.vbs/i.test(query.stdout);
+    }
+    catch {
+        return false;
+    }
+}
+/** True when the per-user Run-key fallback still names wscript/a .vbs. */
+function windowsRunKeyReferencesScriptHost() {
+    try {
+        const query = (0, child_process_1.spawnSync)('reg', ['query', WINDOWS_RUN_KEY, '/v', WINDOWS_RUN_VALUE], {
+            encoding: 'utf8', windowsHide: true, timeout: 5_000,
+        });
+        if (query.status !== 0 || typeof query.stdout !== 'string')
+            return false;
+        return /wscript|cscript|\.vbs/i.test(query.stdout);
+    }
+    catch {
+        return false;
+    }
 }
 const WINDOWS_RUN_KEY = 'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run';
 const WINDOWS_RUN_VALUE = 'FullCourtDefenseDaemon';
@@ -1220,7 +1394,7 @@ function isWindowsRunKeyInstalled() {
 /** Launch the daemon right now, outside our own process tree. WMI process
  *  creation escapes the Windows Installer job object, which would otherwise
  *  kill the daemon the moment an MSI custom action finishes. */
-function startDaemonNowWindows(vbs, viaTask = false) {
+function startDaemonNowWindows(viaTask = false) {
     try {
         const existing = Number(fs.readFileSync(pidFile(), 'utf8').trim());
         if (Number.isFinite(existing) && existing > 0 && isPidAlive(existing)) {
@@ -1243,42 +1417,41 @@ function startDaemonNowWindows(vbs, viaTask = false) {
         if (run.status === 0)
             return;
     }
-    const escaped = vbs.replace(/'/g, "''");
+    // WMI process creation escapes the MSI job object. Runs node.exe DIRECTLY —
+    // no wscript/VBS (Defender's Commando.A!ml heuristic) — with a hidden window.
+    const nodeEsc = process.execPath.replace(/'/g, "''");
+    const entryEsc = cliEntry().replace(/'/g, "''");
     (0, child_process_1.spawnSync)('powershell', [
         '-NoProfile', '-NonInteractive', '-Command',
-        `Invoke-CimMethod -ClassName Win32_Process -MethodName Create -Arguments @{ CommandLine = ('wscript.exe \"' + '${escaped}' + '\"') } | Out-Null`,
+        `Invoke-CimMethod -ClassName Win32_Process -MethodName Create -Arguments @{ CommandLine = ('\"' + '${nodeEsc}' + '\" \"' + '${entryEsc}' + '\" daemon') } | Out-Null`,
     ], { stdio: 'ignore', windowsHide: true, timeout: 20_000 });
 }
 function installWindows() {
-    const vbs = ensureWindowsLauncher();
-    // Preferred: Scheduled Task at logon. Creating a logon-trigger task requires
-    // admin rights, so this fails for standard users and unelevated installs.
-    const task = (0, child_process_1.spawnSync)('schtasks', [
-        '/Create', '/TN', TASK_NAME, '/TR', `wscript.exe "${vbs}"`,
-        '/SC', 'ONLOGON', '/F', '/RL', 'LIMITED',
-    ], { stdio: 'ignore', windowsHide: true });
-    const taskOk = task.status === 0;
+    removeLegacyWindowsLaunchers();
+    // Preferred: Scheduled Task at logon, running node.exe directly and hidden
+    // via task XML. Creating a logon-trigger task can require rights, so this may
+    // fail for some standard-user/unelevated installs.
+    const taskOk = registerHiddenTask(TASK_NAME, buildDaemonTaskXml(), 'daemon', ['/SC', 'ONLOGON', '/RL', 'LIMITED']);
     let ok = taskOk;
     if (!ok) {
         // Fallback: per-user Run key — no elevation needed, runs at every logon.
+        // node.exe directly (no wscript). May flash briefly at logon in this rare
+        // fallback, but carries no script-host persistence fingerprint.
         const reg = (0, child_process_1.spawnSync)('reg', [
             'add', WINDOWS_RUN_KEY, '/v', WINDOWS_RUN_VALUE, '/t', 'REG_SZ',
-            '/d', `wscript.exe "${vbs}"`, '/f',
+            '/d', `"${process.execPath}" "${cliEntry()}" daemon`, '/f',
         ], { stdio: 'ignore', windowsHide: true });
         ok = reg.status === 0;
     }
     // Watchdog: logon triggers only START the daemon — nothing restarts it if it
-    // is killed or crashes mid-session. A time-based per-user task (no elevation
-    // needed, unlike ONLOGON) runs the `watchdog` command every 5 minutes: it
-    // beacons daemon liveness to the console (so "daemon dead" is visible even
-    // when the daemon can't say so itself) and revives a dead daemon within one
-    // tick. Best-effort: a missing watchdog never fails the install.
-    (0, child_process_1.spawnSync)('schtasks', [
-        '/Create', '/TN', WATCHDOG_TASK_NAME, '/TR', `wscript.exe "${ensureWindowsWatchdogLauncher()}"`,
-        '/SC', 'MINUTE', '/MO', '5', '/F',
-    ], { stdio: 'ignore', windowsHide: true });
+    // is killed or crashes mid-session. A time-based task runs the `watchdog`
+    // command every 5 minutes: it beacons daemon liveness to the console (so
+    // "daemon dead" is visible even when the daemon can't say so itself) and
+    // revives a dead daemon within one tick. Best-effort: a missing watchdog
+    // never fails the install.
+    registerHiddenTask(WATCHDOG_TASK_NAME, buildWatchdogTaskXml(), 'watchdog', ['/SC', 'MINUTE', '/MO', '5']);
     if (ok)
-        startDaemonNowWindows(vbs, taskOk);
+        startDaemonNowWindows(taskOk);
     return ok;
 }
 /**
@@ -1297,29 +1470,43 @@ function ensureWindowsAutostartHealthy(logFn) {
     if (process.env.FCD_DAEMON_NO_TASK_SELF_HEAL === '1')
         return;
     try {
-        const vbs = ensureWindowsLauncher();
-        const watchdogVbs = ensureWindowsWatchdogLauncher();
+        // Migration: pre-1.22.1 installs registered wscript/VBS-based tasks that
+        // Defender flags as Trojan:Win32/Commando.A!ml. If the existing task still
+        // references a script host, force-replace it with the node-direct XML task.
+        const legacyDaemon = windowsTaskReferencesScriptHost(TASK_NAME);
+        const legacyWatchdog = windowsTaskReferencesScriptHost(WATCHDOG_TASK_NAME);
+        if (legacyDaemon || legacyWatchdog) {
+            logFn('Self-heal: replacing legacy wscript-based autostart task(s) with node-direct hidden tasks (Defender false-positive fix).');
+        }
         const daemonTask = (0, child_process_1.spawnSync)('schtasks', ['/Query', '/TN', TASK_NAME], { stdio: 'ignore', windowsHide: true, timeout: 10_000 });
-        if (daemonTask.status !== 0 && !isWindowsRunKeyInstalled()) {
-            const created = (0, child_process_1.spawnSync)('schtasks', [
-                '/Create', '/TN', TASK_NAME, '/TR', `wscript.exe "${vbs}"`,
-                '/SC', 'ONLOGON', '/F', '/RL', 'LIMITED',
-            ], { stdio: 'ignore', windowsHide: true, timeout: 20_000 });
-            if (created.status !== 0) {
+        if (legacyDaemon || (daemonTask.status !== 0 && !isWindowsRunKeyInstalled())) {
+            const created = registerHiddenTask(TASK_NAME, buildDaemonTaskXml(), 'daemon', ['/SC', 'ONLOGON', '/RL', 'LIMITED']);
+            if (!created) {
                 (0, child_process_1.spawnSync)('reg', [
                     'add', WINDOWS_RUN_KEY, '/v', WINDOWS_RUN_VALUE, '/t', 'REG_SZ',
-                    '/d', `wscript.exe "${vbs}"`, '/f',
+                    '/d', `"${process.execPath}" "${cliEntry()}" daemon`, '/f',
                 ], { stdio: 'ignore', windowsHide: true, timeout: 10_000 });
             }
-            logFn('Self-heal: daemon autostart entry was missing — recreated.');
+            if (daemonTask.status !== 0)
+                logFn('Self-heal: daemon autostart entry was missing — recreated.');
         }
-        const watchdog = (0, child_process_1.spawnSync)('schtasks', [
-            '/Create', '/TN', WATCHDOG_TASK_NAME, '/TR', `wscript.exe "${watchdogVbs}"`,
-            '/SC', 'MINUTE', '/MO', '5', '/F',
-        ], { stdio: 'ignore', windowsHide: true, timeout: 20_000 });
-        if (watchdog.status !== 0) {
-            logFn('Self-heal: could not (re)create the watchdog task — daemon revival relies on logon autostart only.');
+        // Rewrite the watchdog whenever it's missing OR still script-host based.
+        const watchdogQuery = (0, child_process_1.spawnSync)('schtasks', ['/Query', '/TN', WATCHDOG_TASK_NAME], { stdio: 'ignore', windowsHide: true, timeout: 10_000 });
+        if (legacyWatchdog || watchdogQuery.status !== 0) {
+            const ok = registerHiddenTask(WATCHDOG_TASK_NAME, buildWatchdogTaskXml(), 'watchdog', ['/SC', 'MINUTE', '/MO', '5']);
+            if (!ok) {
+                logFn('Self-heal: could not (re)create the watchdog task — daemon revival relies on logon autostart only.');
+            }
         }
+        // A stale Run-key fallback from an older install may still name wscript.
+        if (windowsRunKeyReferencesScriptHost()) {
+            (0, child_process_1.spawnSync)('reg', [
+                'add', WINDOWS_RUN_KEY, '/v', WINDOWS_RUN_VALUE, '/t', 'REG_SZ',
+                '/d', `"${process.execPath}" "${cliEntry()}" daemon`, '/f',
+            ], { stdio: 'ignore', windowsHide: true, timeout: 10_000 });
+            logFn('Self-heal: rewrote legacy wscript Run-key entry to run node directly.');
+        }
+        removeLegacyWindowsLaunchers();
     }
     catch { /* self-heal is best-effort — never blocks daemon boot */ }
 }
@@ -1358,10 +1545,12 @@ function uninstallWindows() {
     const task = (0, child_process_1.spawnSync)('schtasks', ['/Delete', '/TN', TASK_NAME, '/F'], { stdio: 'ignore', windowsHide: true });
     (0, child_process_1.spawnSync)('schtasks', ['/Delete', '/TN', WATCHDOG_TASK_NAME, '/F'], { stdio: 'ignore', windowsHide: true });
     const reg = (0, child_process_1.spawnSync)('reg', ['delete', WINDOWS_RUN_KEY, '/v', WINDOWS_RUN_VALUE, '/f'], { stdio: 'ignore', windowsHide: true });
+    removeLegacyWindowsLaunchers();
+    // Clean up the node-direct task XML we now drop next to the launchers.
     const launcherDir = path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local'), 'FullCourtDefense');
-    for (const launcher of ['daemon.vbs', 'watchdog.vbs']) {
+    for (const name of [TASK_NAME, WATCHDOG_TASK_NAME]) {
         try {
-            fs.unlinkSync(path.join(launcherDir, launcher));
+            fs.unlinkSync(path.join(launcherDir, `${name.replace(/[^A-Za-z0-9]+/g, '_')}.task.xml`));
         }
         catch { /* ignore */ }
     }