@indigoai-us/hq-cli 5.345.147 → 5.345.149

package/dist/lib/agent-kit/run/inbox.js

@@ -20,7 +20,8 @@ import * as path from "node:path";
 import { vaultApiFetch } from "../../../utils/vault-api.js";
 import { writeComponentStatus } from "../creds.js";
 import { pendingInbox } from "../inbox-state.js";
-import { writePrivateFile } from "./../private-file.js";
+import { redactAgentInboxItem, scrubInboxMirror, withInboxMirrorLock } from "../inbox-redact.js";
+import { mkdirPrivate, writePrivateFile } from "./../private-file.js";
 import { createAgentKitInboxBackoffFlagReader } from "../inbox-poll-backoff-flag.js";
 import { buildWakeNotice, currentWakeState, fireWake, readWakeConfig, shouldWake, } from "../wake.js";
 export const SEEN_IDS_NAME = "seen-ids.json";
@@ -79,12 +80,22 @@ function inboxJournalContains(paths, id) {
 }
 export function mirrorInboxItem(paths, item) {
     const dest = path.join(paths.inboxDir, `${item.id}.json`);
-    const recoveringInterruptedMirror = fs.existsSync(dest);
-    writePrivateFile(dest, `${JSON.stringify(item.raw, null, 2)}\n`, 0o600);
-    if (!recoveringInterruptedMirror || !inboxJournalContains(paths, item.id)) {
-        fs.appendFileSync(path.join(paths.inboxDir, INBOX_JSONL_NAME), `${JSON.stringify({ id: item.id, mirroredAt: new Date().toISOString(), ...item.raw })}\n`, { mode: 0o600 });
-    }
-    return dest;
+    // One redaction covers the per-id file and the journal line. The journal
+    // spreads this object, so a credential left on `raw` would be written twice.
+    const safeRaw = redactAgentInboxItem(item.raw);
+    const write = () => {
+        const recoveringInterruptedMirror = fs.existsSync(dest);
+        writePrivateFile(dest, `${JSON.stringify(safeRaw, null, 2)}\n`, 0o600);
+        if (!recoveringInterruptedMirror || !inboxJournalContains(paths, item.id)) {
+            fs.appendFileSync(path.join(paths.inboxDir, INBOX_JSONL_NAME), `${JSON.stringify({ id: item.id, mirroredAt: new Date().toISOString(), ...safeRaw })}\n`, { mode: 0o600 });
+        }
+        return dest;
+    };
+    // Create the directory first so the scrub lock has somewhere to live.
+    // The write still runs without the lock if the directory cannot be locked;
+    // dropping the message is worse than a rare overlapping rewrite.
+    mkdirPrivate(paths.inboxDir);
+    return withInboxMirrorLock(paths.inboxDir, 10_000, write) ?? write();
 }
 export const INBOX_ERROR_BODY_MAX = 300;
 /**
@@ -142,6 +153,24 @@ export function defaultAckItem(agentUid, apiBaseUrl) {
 export async function pollInboxOnce(deps) {
     if (deps.signal?.aborted)
         return { ok: false, mirrored: 0 };
+    // Mirrors written before credential redaction are scrubbed on the next poll,
+    // before a wake can send the bot at the files. A write or rename error is
+    // counted and retried on the next poll. The log is a count and errno codes,
+    // never a path or a file byte.
+    try {
+        scrubInboxMirror(deps.paths, (report) => {
+            if (report.scrubbed > 0) {
+                deps.log("info", `inbox scrubbed ${report.scrubbed} mirrored record(s) containing delegated credentials`);
+            }
+            if (report.failures > 0) {
+                const codes = report.codes.length > 0 ? report.codes.join(",") : "ERR";
+                deps.log("warn", `inbox scrub failed for ${report.failures} file(s) (${codes})`);
+            }
+        });
+    }
+    catch {
+        deps.log("warn", "inbox scrub failed for 1 file(s) (ERR)");
+    }
     const fetchInbox = deps.fetchInbox ?? defaultFetchInbox(deps.agentUid, deps.apiBaseUrl);
     const ackItem = deps.ackItem ?? defaultAckItem(deps.agentUid, deps.apiBaseUrl);
     // No default cache warm: the human conversation routes 403 for agent callers.

package/dist/lib/anywhere-runtime-flag-key.d.ts

@@ -1,6 +1,9 @@
 /** hq-flags key for the staged HQ Anywhere runtime. The registry default is on. */
 export declare const HQ_ANYWHERE_RUNTIME_FLAG = "hq-anywhere-runtime";
 export declare const HQ_ANYWHERE_RUNTIME_REVOCATION_MARKER = "hq-anywhere-runtime.revoked";
+export declare const HQ_ANYWHERE_RUNTIME_FALSE_MAX_AGE_MS: number;
+/** An old disable decision must not survive an unavailable registry indefinitely. */
+export declare function freshAnywhereRuntimeFlags(flags: Record<string, boolean>, fetchedAt: number, now?: number): Record<string, boolean>;
 /** The HQ Anywhere environment kill switch stays compatible with managed provider wrappers. */
 export declare function hqAnywhereRuntimeLocallyDisabled(env?: NodeJS.ProcessEnv): boolean;
 //# sourceMappingURL=anywhere-runtime-flag-key.d.ts.map

package/dist/lib/anywhere-runtime-flag-key.js

@@ -1,6 +1,15 @@
 /** hq-flags key for the staged HQ Anywhere runtime. The registry default is on. */
 export const HQ_ANYWHERE_RUNTIME_FLAG = "hq-anywhere-runtime";
 export const HQ_ANYWHERE_RUNTIME_REVOCATION_MARKER = "hq-anywhere-runtime.revoked";
+export const HQ_ANYWHERE_RUNTIME_FALSE_MAX_AGE_MS = 60 * 60 * 1000;
+/** An old disable decision must not survive an unavailable registry indefinitely. */
+export function freshAnywhereRuntimeFlags(flags, fetchedAt, now = Date.now()) {
+    if (flags[HQ_ANYWHERE_RUNTIME_FLAG] !== false || now - fetchedAt < HQ_ANYWHERE_RUNTIME_FALSE_MAX_AGE_MS)
+        return flags;
+    const fresh = { ...flags };
+    delete fresh[HQ_ANYWHERE_RUNTIME_FLAG];
+    return fresh;
+}
 /** The HQ Anywhere environment kill switch stays compatible with managed provider wrappers. */
 export function hqAnywhereRuntimeLocallyDisabled(env = process.env) {
     const value = env.HQ_FLAG_HQ_ANYWHERE_RUNTIME;

package/dist/lib/billing/usage-cost.d.ts

@@ -201,14 +201,44 @@ export interface UsageReport {
     freeItems: string;
     drivers: Driver[];
     noSyncGuideUrl: string;
+    /** Set by `hq billing usage`: the account is on usage pricing, so meters are priced. */
+    onUsagePricing?: true;
     readOnly: true;
 }
+/** One meter's reading with no price attached. */
+export interface MeterReadingRow {
+    key: UsageMeterKey;
+    displayName: string;
+    /** In billed units (GB for storage). Null unless measured. */
+    value: number | null;
+    state: MeterState;
+}
+/**
+ * The report for an account that is not on usage pricing (a flat plan, or the
+ * server did not say). Readings only: no rates, no cost, no projected bill.
+ */
+export interface UsageReadingsReport {
+    scope: UsageScope;
+    source: MonthUsage["source"];
+    /** False: flat plan, meters are not billed. Null: HQ did not say. */
+    onUsagePricing: false | null;
+    period: MonthUsage["period"];
+    meters: MeterReadingRow[];
+    storage?: StorageSplit;
+    /** The one line that says why no cost is shown. */
+    notice: string;
+    readOnly: true;
+}
+export type BillingUsageReport = UsageReport | UsageReadingsReport;
+export declare function isReadingsReport(r: BillingUsageReport): r is UsageReadingsReport;
+/** Readings for an account not on usage pricing. Never prices a meter. */
+export declare function buildReadingsReport(usage: MonthUsage, onUsagePricing: false | null): UsageReadingsReport;
 export declare function buildReport(usage: MonthUsage, rates: {
     rates: readonly UsageMeterRate[];
     allowanceUsd: number;
     source: "published" | "bundled";
     card?: UsageCard;
 }): UsageReport;
-export declare function formatReport(r: UsageReport): string;
+export declare function formatReport(r: BillingUsageReport): string;
 export {};
 //# sourceMappingURL=usage-cost.d.ts.map

package/dist/lib/billing/usage-cost.js

@@ -362,6 +362,38 @@ export function findDrivers(usage, bill) {
 // ── Report ──────────────────────────────────────────────────────────────────
 /** The self-hosted / no-sync guide the usage card links (feed `signup.selfHosted.url`). */
 export const NO_SYNC_GUIDE_URL = SELF_HOSTED_GUIDE_URL;
+export function isReadingsReport(r) {
+    return !("bill" in r);
+}
+function readingsNotice(scope, onUsagePricing) {
+    if (onUsagePricing === false) {
+        return scope.kind === "company"
+            ? `${scope.companySlug} is on a flat plan, so usage meters are not billed.`
+            : "Your personal account is on a flat plan, so usage meters are not billed.";
+    }
+    const who = scope.kind === "company" ? scope.companySlug : "your personal account";
+    return `HQ did not say whether ${who} is on usage pricing, so no costs are shown.`;
+}
+/** Readings for an account not on usage pricing. Never prices a meter. */
+export function buildReadingsReport(usage, onUsagePricing) {
+    const byKey = new Map(usage.meters.map((m) => [m.key, m]));
+    const meters = BUNDLED_USAGE_METER_RATES.map((rate) => {
+        const reading = byKey.get(rate.key);
+        return reading && reading.state === "measured" && reading.value !== null
+            ? { key: rate.key, displayName: rate.displayName, value: reading.value, state: "measured" }
+            : { key: rate.key, displayName: rate.displayName, value: null, state: reading?.state ?? "not-available" };
+    });
+    return {
+        scope: usage.scope,
+        source: usage.source,
+        onUsagePricing,
+        period: usage.period,
+        meters,
+        ...(usage.storage ? { storage: usage.storage } : {}),
+        notice: readingsNotice(usage.scope, onUsagePricing),
+        readOnly: true,
+    };
+}
 export function buildReport(usage, rates) {
     const bill = computeBill(usage, rates.rates, rates.allowanceUsd);
     return {
@@ -394,7 +426,21 @@ function valueText(m) {
         return `${Math.round(m.value)} vault${Math.round(m.value) === 1 ? "" : "s"}`;
     return `${Math.round(m.value)}`;
 }
+function formatReadingsReport(r) {
+    const who = r.scope.kind === "company" ? r.scope.companySlug : "your personal HQ";
+    const lines = [];
+    lines.push(`Usage for ${who}, ${r.period.start.slice(0, 7)} (as of ${r.period.asOf.slice(0, 10)})`);
+    lines.push("");
+    const nameW = Math.max(...r.meters.map((m) => m.displayName.length));
+    for (const m of r.meters)
+        lines.push(`  ${m.displayName.padEnd(nameW)}  ${valueText(m)}`);
+    lines.push("");
+    lines.push(r.notice);
+    return lines.join("\n");
+}
 export function formatReport(r) {
+    if (isReadingsReport(r))
+        return formatReadingsReport(r);
     const who = r.scope.kind === "company" ? r.scope.companySlug : "your personal HQ";
     const month = r.period.start.slice(0, 7);
     const lines = [];

package/dist/lib/company-skill-wrapper.js

@@ -1,5 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { removeEntryNoFollow } from "../utils/safe-link.js";
 const WIN32_RESERVED_CHARS = /[<>:"/\\|?*]/;
 const WIN32_DEVICE_NAME = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\..*)?$/i;
 const LOCAL_SLUG = /^[a-z0-9][a-z0-9-]*$/;
@@ -227,7 +228,8 @@ function pruneStaleNamespacedWrappers(runtimeRoot, currentWrapperName, hqRoot, c
         if (LOCAL_SLUG.test(skillSlug) &&
             !fs.existsSync(canonicalSkill) &&
             isGeneratedNamespacedWrapper(candidate, hqRoot, companySlug)) {
-            fs.rmSync(candidate, { recursive: true, force: false });
+            // A Windows wrapper is a junction; never recurse into its target.
+            removeEntryNoFollow(candidate);
             removeGeneratedMarker(candidate);
         }
     }
@@ -340,7 +342,7 @@ export function surfaceCompanySkill(input) {
         }
         if (previousMoved) {
             try {
-                fs.rmSync(backupPath, { recursive: true, force: true });
+                removeEntryNoFollow(backupPath, { force: true });
             }
             catch {
                 // The new wrapper is already committed. A hidden generated backup is
@@ -354,13 +356,13 @@ export function surfaceCompanySkill(input) {
             for (const legacyPath of [legacyBase, `${legacyBase}.md`]) {
                 if (legacyPath !== wrapperPath &&
                     isGeneratedLegacyEntry(legacyPath, sourceDir, skillFile)) {
-                    fs.rmSync(legacyPath, { recursive: true, force: false });
+                    removeEntryNoFollow(legacyPath);
                 }
             }
         }
     }
     catch (error) {
-        fs.rmSync(stagingPath, { recursive: true, force: true });
+        removeEntryNoFollow(stagingPath, { force: true });
         throw error;
     }
     return { status: 0, wrapperPath };

package/dist/lib/daemon/install.d.ts

@@ -16,6 +16,7 @@
  * never touch launchctl, systemctl or schtasks.
  */
 import { type RunCommand, type SleepFn } from "../service-manager/launchd.js";
+import { type PidLockRecord } from "../mesh/live/daemon/pid-lock.js";
 import type { MachineType } from "./machine-type.js";
 export declare const DAEMON_LAUNCHD_LABEL = "ai.getindigo.hq-daemon";
 export declare const DAEMON_SYSTEMD_UNIT = "hq-daemon.service";
@@ -60,12 +61,28 @@ export interface DaemonUnitResult {
     running: boolean;
     error?: string;
     manualCommand?: string;
+    /**
+     * Windows: the task is registered but no new daemon process appeared within
+     * WINDOWS_START_WAIT_MS of `schtasks /Run`. With no interactive session the
+     * logon trigger starts it at the next sign-in; with one, it did not start.
+     * The caller decides which, since only it can check the session.
+     */
+    startPending?: true;
+    /** Windows: an older daemon may still be running; HQ could not verify it, so did not stop it. */
+    warning?: string;
 }
 export interface InstallDeps {
     run: RunCommand;
-    /** Blocking sleep for the launchd reload wait (tests inject). */
+    /** Blocking sleep for the launchd reload wait and the Windows start wait (tests inject). */
     sleep?: SleepFn;
+    /**
+     * The running daemon's lock record (pid and start time), or null. Default:
+     * the daemon lock, when it names a live `hq daemon run` process.
+     */
+    runningDaemon?: () => PidLockRecord | null;
 }
+/** How long install waits for the Windows task to start a daemon process. */
+export declare const WINDOWS_START_WAIT_MS = 10000;
 export declare const ROOT_REFUSAL = "hq daemon runs its services as the machine's login user, never as root.";
 /**
  * Why the daemon must not run here as root, or null when it may. Agent kits
@@ -76,10 +93,39 @@ export declare function daemonRootRefusal(isRoot: boolean, machineType: MachineT
 /** Boxes run the daemon as a system unit; everything else per user. */
 export declare function installScopeFor(machineType: MachineType): InstallScope;
 export declare function planDaemonUnit(host: DaemonHost, options: InstallOptions): DaemonUnitPlan;
+/** What to tell the user when HQ did not stop pid `pid` because it could not verify it. */
+export declare function oldDaemonWarning(pid: number, reason: string): string;
 export declare function installDaemonUnit(host: DaemonHost, options: InstallOptions, deps: InstallDeps): DaemonUnitResult;
+/**
+ * PowerShell script that lists Windows sessions as `id|state|DOMAIN\user`
+ * lines through WTSEnumerateSessions and WTSQuerySessionInformation. State is
+ * the numeric WTS_CONNECTSTATE_CLASS (0 = WTSActive), so the output does not
+ * depend on the display language, and it needs no query.exe (absent on
+ * Windows Home). Constrained Language Mode refuses Add-Type, so there the
+ * script prints `unavailable|<mode>` and lists nothing.
+ */
+export declare const WINDOWS_SESSIONS_SCRIPT: string;
+/** One Windows session from WINDOWS_SESSIONS_SCRIPT output. */
+export interface WindowsSession {
+    id: number;
+    /** WTS_CONNECTSTATE_CLASS: 0 is WTSActive. */
+    state: number;
+    /** `DOMAIN\user`, a bare user name, or "" when nobody is signed in to it. */
+    user: string;
+}
+export declare function parseWindowsSessions(stdout: string): WindowsSession[];
+/**
+ * Whether `user` (`DOMAIN\user` or a bare name) has an active Windows session.
+ * A disconnected session does not count: an interactive-token task cannot
+ * start in it. Returns "unavailable" when PowerShell runs in Constrained
+ * Language Mode, which refuses the check, and null when the check failed in
+ * any other way.
+ */
+export declare function windowsInteractiveSession(run: RunCommand, user: string): boolean | null | "unavailable";
 export declare function uninstallDaemonUnit(host: DaemonHost, options: InstallOptions, deps: InstallDeps): {
     kind: DaemonUnitPlan["kind"];
     unitPath: string;
     removed: boolean;
+    warning?: string;
 };
 //# sourceMappingURL=install.d.ts.map

package/dist/lib/daemon/install.js

@@ -17,15 +17,20 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { activateLaunchd, deactivateLaunchd, defaultRunCommand, installLaunchdPlist, launchdIsLoaded, launchdPlistPath, renderLaunchdPlist, } from "../service-manager/launchd.js";
+import { activateLaunchd, blockingSleep, deactivateLaunchd, defaultRunCommand, installLaunchdPlist, launchdIsLoaded, launchdPlistPath, renderLaunchdPlist, } from "../service-manager/launchd.js";
 import { activateSystemd, deactivateSystemd, renderSystemdUserUnit, systemdUnitPath, } from "../service-manager/systemd.js";
 import { escapeXml, shellQuote } from "../service-manager/types.js";
 import { readPidLock } from "../mesh/live/daemon/pid-lock.js";
 import { userToolDirs } from "./tools.js";
+import { liveDaemonLock, verifyDaemonForKill } from "./lock.js";
+import { daemonPaths } from "./paths.js";
 export const DAEMON_LAUNCHD_LABEL = "ai.getindigo.hq-daemon";
 export const DAEMON_SYSTEMD_UNIT = "hq-daemon.service";
 export const DAEMON_WINDOWS_TASK = "ai.getindigo.hq-daemon";
 export const SYSTEM_UNIT_DIR = "/etc/systemd/system";
+/** How long install waits for the Windows task to start a daemon process. */
+export const WINDOWS_START_WAIT_MS = 10_000;
+const WINDOWS_START_POLL_MS = 500;
 export const ROOT_REFUSAL = "hq daemon runs its services as the machine's login user, never as root.";
 /**
  * Why the daemon must not run here as root, or null when it may. Agent kits
@@ -209,7 +214,39 @@ export function planDaemonUnit(host, options) {
 function commandError(what, r) {
     return new Error(`${what} failed: ${r.stderr.trim() || r.stdout.trim() || `exit ${r.status}`}`);
 }
-function activate(plan, host, run, sleep) {
+/**
+ * Stop the Windows task and the recorded daemon's whole process tree. Ending
+ * the task stops only its root process (conhost when --headless is used);
+ * node and the services it runs keep going.
+ *
+ * The pid comes from the lock file, which can be stale: after the daemon
+ * exits, Windows may give its pid to another program. The process is checked
+ * immediately before the kill and killed only when it is verifiably the
+ * daemon. Returns a warning when a process was left running unverified.
+ */
+function endWindowsDaemon(run, owner) {
+    run("schtasks.exe", ["/End", "/TN", DAEMON_WINDOWS_TASK]);
+    if (!owner || owner.pid === process.pid)
+        return undefined;
+    const check = verifyDaemonForKill(owner, run);
+    if (check.verdict === "daemon") {
+        run("taskkill.exe", ["/PID", String(owner.pid), "/T", "/F"]);
+        return undefined;
+    }
+    if (check.verdict === "gone")
+        return undefined;
+    return oldDaemonWarning(owner.pid, check.reason);
+}
+/** What to tell the user when HQ did not stop pid `pid` because it could not verify it. */
+export function oldDaemonWarning(pid, reason) {
+    return [
+        `An older HQ daemon may still be running. HQ did not stop process ${pid} because ${reason}.`,
+        "To find a running HQ daemon:",
+        `  powershell -NoProfile -Command "Get-CimInstance Win32_Process | Where-Object CommandLine -match 'daemon run' | Select-Object ProcessId,CommandLine"`,
+        "Stop the process it lists with: taskkill /PID <ProcessId> /T /F",
+    ].join("\n");
+}
+function activate(plan, host, run, sleep, previous = null) {
     switch (plan.kind) {
         case "launchd":
             activateLaunchd(plan.unitPath, run, host.uid, { sleep });
@@ -231,13 +268,17 @@ function activate(plan, host, run, sleep) {
             const create = run("schtasks.exe", ["/Create", "/TN", DAEMON_WINDOWS_TASK, "/XML", plan.unitPath, "/F"]);
             if (create.status !== 0)
                 throw commandError("schtasks /Create", create);
+            // `/Create /F` leaves a running instance alone and `/Run` is ignored
+            // while one runs, so a daemon from an earlier install would keep the old
+            // settings. Stop it first so `/Run` starts a new one.
+            const warning = previous ? endWindowsDaemon(run, previous) : undefined;
             const start = run("schtasks.exe", ["/Run", "/TN", DAEMON_WINDOWS_TASK]);
             if (start.status !== 0)
                 throw commandError("schtasks /Run", start);
-            return;
+            return warning;
         }
         case "manual":
-            return;
+            return undefined;
     }
 }
 export function installDaemonUnit(host, options, deps) {
@@ -286,8 +327,32 @@ export function installDaemonUnit(host, options, deps) {
     else
         fs.writeFileSync(plan.unitPath, plan.rendered, { mode: plan.kind === "systemd-system" ? 0o644 : 0o600 });
     try {
-        if (plan.kind !== "launchd")
-            activate(plan, host, deps.run, deps.sleep);
+        const lockPath = daemonPaths(host.home, { HQ_DAEMON_DIR: host.daemonDir }).lockPath;
+        const runningDaemon = deps.runningDaemon ?? (() => liveDaemonLock(lockPath));
+        const previous = plan.kind === "schtasks" ? runningDaemon() : null;
+        const warning = plan.kind !== "launchd" ? activate(plan, host, deps.run, deps.sleep, previous) : undefined;
+        const warn = warning ? { warning } : {};
+        if (plan.kind === "schtasks") {
+            // schtasks /Run exits 0 even when the task cannot run: an
+            // InteractiveToken task with no signed-in session stays at "has not yet
+            // run" (267011). Report running only once a daemon started by this
+            // install holds the lock; a daemon from before the install does not count.
+            const outcome = waitForNewDaemon(runningDaemon, previous, deps.sleep ?? blockingSleep);
+            if (outcome === "started")
+                return { kind: plan.kind, unitPath: plan.unitPath, installed: true, running: true, ...warn };
+            if (outcome === "previous") {
+                return {
+                    kind: plan.kind,
+                    unitPath: plan.unitPath,
+                    installed: true,
+                    running: false,
+                    error: `the daemon from before this install (pid ${previous?.pid}) is still running, ` +
+                        "so the new task did not start. Run hq daemon uninstall, then hq daemon install",
+                    ...warn,
+                };
+            }
+            return { kind: plan.kind, unitPath: plan.unitPath, installed: true, running: false, startPending: true, ...warn };
+        }
         return { kind: plan.kind, unitPath: plan.unitPath, installed: true, running: true };
     }
     catch (err) {
@@ -300,6 +365,112 @@ export function installDaemonUnit(host, options, deps) {
         };
     }
 }
+/** A lock record names a different daemon than `previous` (new pid or new start time). */
+function isNewDaemon(now, previous) {
+    return !previous || now.pid !== previous.pid || now.ts !== previous.ts;
+}
+/**
+ * Wait up to WINDOWS_START_WAIT_MS for a daemon started after `previous`.
+ * "previous" means the daemon from before the install still holds the lock at
+ * the end of the wait; "none" means no daemon is running.
+ */
+function waitForNewDaemon(runningDaemon, previous, sleep) {
+    for (let waited = 0;; waited += WINDOWS_START_POLL_MS) {
+        const now = runningDaemon();
+        if (now && isNewDaemon(now, previous))
+            return "started";
+        if (waited >= WINDOWS_START_WAIT_MS)
+            return now ? "previous" : "none";
+        sleep(WINDOWS_START_POLL_MS);
+    }
+}
+/**
+ * PowerShell script that lists Windows sessions as `id|state|DOMAIN\user`
+ * lines through WTSEnumerateSessions and WTSQuerySessionInformation. State is
+ * the numeric WTS_CONNECTSTATE_CLASS (0 = WTSActive), so the output does not
+ * depend on the display language, and it needs no query.exe (absent on
+ * Windows Home). Constrained Language Mode refuses Add-Type, so there the
+ * script prints `unavailable|<mode>` and lists nothing.
+ */
+export const WINDOWS_SESSIONS_SCRIPT = [
+    "$ErrorActionPreference = 'Stop'",
+    "$mode = [string]$ExecutionContext.SessionState.LanguageMode",
+    "if ($mode -ne 'FullLanguage') { 'unavailable|' + $mode; exit 0 }",
+    "Add-Type -TypeDefinition @'",
+    "using System;",
+    "using System.Runtime.InteropServices;",
+    "public static class HqWts {",
+    '  [DllImport("wtsapi32.dll", SetLastError = true)]',
+    "  public static extern bool WTSEnumerateSessionsW(IntPtr server, int reserved, int version, out IntPtr info, out int count);",
+    '  [DllImport("wtsapi32.dll", SetLastError = true)]',
+    "  public static extern bool WTSQuerySessionInformationW(IntPtr server, int sessionId, int infoClass, out IntPtr buffer, out int bytes);",
+    '  [DllImport("wtsapi32.dll")]',
+    "  public static extern void WTSFreeMemory(IntPtr memory);",
+    "  static string Query(int id, int infoClass) {",
+    "    IntPtr buffer; int bytes;",
+    '    if (!WTSQuerySessionInformationW(IntPtr.Zero, id, infoClass, out buffer, out bytes)) return "";',
+    "    try { return Marshal.PtrToStringUni(buffer); } finally { WTSFreeMemory(buffer); }",
+    "  }",
+    "  public static string[] List() {",
+    "    IntPtr info; int count;",
+    '    if (!WTSEnumerateSessionsW(IntPtr.Zero, 0, 1, out info, out count)) throw new System.ComponentModel.Win32Exception();',
+    "    try {",
+    "      int size = 3 * IntPtr.Size;",
+    "      string[] lines = new string[count];",
+    "      for (int i = 0; i < count; i++) {",
+    "        IntPtr row = new IntPtr(info.ToInt64() + (long)i * size);",
+    "        int id = Marshal.ReadInt32(row);",
+    "        int state = Marshal.ReadInt32(row, 2 * IntPtr.Size);",
+    "        string user = Query(id, 5);",
+    "        string domain = Query(id, 7);",
+    '        lines[i] = id + "|" + state + "|" + (domain.Length > 0 ? domain + "\\\\" + user : user);',
+    "      }",
+    "      return lines;",
+    "    } finally { WTSFreeMemory(info); }",
+    "  }",
+    "}",
+    "'@",
+    "[HqWts]::List() | ForEach-Object { $_ }",
+].join("\n");
+const WTS_ACTIVE = 0;
+export function parseWindowsSessions(stdout) {
+    const sessions = [];
+    for (const line of stdout.split(/\r?\n/)) {
+        const match = /^(\d+)\|(\d+)\|(.*)$/.exec(line.trim());
+        if (match)
+            sessions.push({ id: Number(match[1]), state: Number(match[2]), user: match[3].trim() });
+    }
+    return sessions;
+}
+/**
+ * Whether `user` (`DOMAIN\user` or a bare name) has an active Windows session.
+ * A disconnected session does not count: an interactive-token task cannot
+ * start in it. Returns "unavailable" when PowerShell runs in Constrained
+ * Language Mode, which refuses the check, and null when the check failed in
+ * any other way.
+ */
+export function windowsInteractiveSession(run, user) {
+    const encoded = Buffer.from(WINDOWS_SESSIONS_SCRIPT, "utf16le").toString("base64");
+    const r = run("powershell.exe", ["-NoProfile", "-NonInteractive", "-EncodedCommand", encoded]);
+    if (r.status !== 0)
+        return null;
+    if (/^unavailable\|/m.test(r.stdout.trim()))
+        return "unavailable";
+    const sessions = parseWindowsSessions(r.stdout);
+    if (sessions.length === 0)
+        return null;
+    const wanted = user.trim().toLowerCase();
+    const bare = (wanted.split("\\").pop() ?? "").trim();
+    if (!bare)
+        return null;
+    return sessions.some((s) => {
+        if (s.state !== WTS_ACTIVE || !s.user)
+            return false;
+        const name = s.user.toLowerCase();
+        // Compare the full DOMAIN\user when both sides have a domain.
+        return name.includes("\\") && wanted.includes("\\") ? name === wanted : name.split("\\").pop() === bare;
+    });
+}
 export function uninstallDaemonUnit(host, options, deps) {
     // A system uninstall does not need the login user; only the unit path matters.
     const plan = host.platform === "linux" && options.scope === "system"
@@ -312,6 +483,7 @@ export function uninstallDaemonUnit(host, options, deps) {
         (plan.kind === "schtasks" && deps.run("schtasks.exe", ["/Query", "/TN", DAEMON_WINDOWS_TASK]).status === 0);
     if (!present)
         return { kind: plan.kind, unitPath: plan.unitPath, removed: false };
+    let warning;
     switch (plan.kind) {
         case "launchd":
             deactivateLaunchd(plan.unitPath, deps.run, host.uid);
@@ -330,14 +502,8 @@ export function uninstallDaemonUnit(host, options, deps) {
             break;
         }
         case "schtasks": {
-            deps.run("schtasks.exe", ["/End", "/TN", DAEMON_WINDOWS_TASK]);
-            // Ending the task stops only its root process (conhost when --headless is
-            // used); node and the services it runs keep going. End the recorded
-            // daemon's whole process tree.
-            const owner = readPidLock(path.join(host.daemonDir, "daemon.pid"));
-            if (owner && owner.pid !== process.pid) {
-                deps.run("taskkill.exe", ["/PID", String(owner.pid), "/T", "/F"]);
-            }
+            // The lock may be stale; endWindowsDaemon kills only a verified daemon.
+            warning = endWindowsDaemon(deps.run, readPidLock(path.join(host.daemonDir, "daemon.pid")));
             const del = deps.run("schtasks.exe", ["/Delete", "/TN", DAEMON_WINDOWS_TASK, "/F"]);
             // Keep the XML so a later uninstall still finds the task.
             if (del.status !== 0)
@@ -346,6 +512,6 @@ export function uninstallDaemonUnit(host, options, deps) {
         }
     }
     fs.rmSync(plan.unitPath, { force: true });
-    return { kind: plan.kind, unitPath: plan.unitPath, removed: true };
+    return { kind: plan.kind, unitPath: plan.unitPath, removed: true, ...(warning ? { warning } : {}) };
 }
 //# sourceMappingURL=install.js.map

package/dist/lib/daemon/lock.d.ts

@@ -31,8 +31,38 @@ export interface DaemonProcessDeps {
  * The pid is alive and is an `hq daemon run`. After a reboot the pid in an old
  * lock file often belongs to an unrelated program; that must not keep the
  * daemon from starting.
+ *
+ * An unreadable command line counts as the daemon here, so a second daemon is
+ * never started next to one HQ cannot inspect. Never use this to decide a
+ * kill: use `verifyDaemonForKill`, which treats an unreadable command line as
+ * "not the daemon".
  */
 export declare function isDaemonProcess(pid: number, deps?: DaemonProcessDeps): boolean;
+/**
+ * PowerShell that prints a Windows process's creation time (UTC, ISO 8601) on
+ * the first line and its command line on the rest, or nothing when no process
+ * has that id. It uses only a cmdlet and DateTime methods, so it also runs in
+ * Constrained Language Mode. `-ErrorAction Stop` makes a WMI failure exit
+ * non-zero, so it reads as "could not read", never as "no such process".
+ */
+export declare function windowsProcessIdentityScript(pid: number): string;
+export type DaemonKillCheck = {
+    verdict: "daemon";
+} | {
+    verdict: "gone";
+} | {
+    verdict: "unverified";
+    reason: string;
+};
+/**
+ * Decide whether the Windows process in `owner` may be killed as the HQ
+ * daemon. Run this immediately before the kill. It is the daemon only when the
+ * process exists, its command line is readable and is `hq daemon run`, and it
+ * was created no later than the lock was written. A process created after the
+ * lock took over a pid the old daemon left behind. Anything that cannot be
+ * read is "unverified", and the caller must not kill.
+ */
+export declare function verifyDaemonForKill(owner: PidLockRecord, run: RunCommand): DaemonKillCheck;
 export type DaemonLockResult = {
     ok: true;
 } | {
@@ -41,6 +71,8 @@ export type DaemonLockResult = {
 };
 export declare function acquireDaemonLock(lockPath: string, pid?: number, alive?: (pid: number) => boolean, now?: () => number): DaemonLockResult;
 export declare function releaseDaemonLock(lockPath: string, pid?: number): void;
+/** The live supervisor's lock record (pid and start time), or null when none is running. */
+export declare function liveDaemonLock(lockPath: string, alive?: (pid: number) => boolean): PidLockRecord | null;
 /** The live supervisor's pid, or null when none is running. */
 export declare function runningDaemonPid(lockPath: string, alive?: (pid: number) => boolean): number | null;
 export {};