@alan-ai-hq/agent-manager 0.1.113 → 0.1.115

package/dist/__tests__/service-manager.test.js

@@ -0,0 +1,769 @@
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import { buildDaemonServicePlan, ensureDaemonServiceDefinition, forceStopDaemonServiceAndWait, inspectDaemonService, ownerMatchesDaemonIdentity, parseServiceHostState, resolveEnsureDefinitionOutcome, runServiceCommand, stopDaemonServiceAndWait, uninstallDaemonService, } from "../service-manager.js";
+const baseInput = {
+    homeDir: "/Users/Test Person",
+    nodeExecutable: "/opt/node bin/node",
+    cliEntry: "/opt/alan agent/index.cjs",
+    profile: "production",
+    userId: 501,
+};
+function decodeWindowsLauncher(registerCommand) {
+    const encoded = registerCommand.match(/-EncodedCommand ([A-Za-z0-9+/=]+)/u)?.[1];
+    expect(encoded).toBeDefined();
+    return Buffer.from(encoded, "base64").toString("utf16le");
+}
+describe("buildDaemonServicePlan", () => {
+    it("reloads a stopped launchd definition without force-killing a running service", () => {
+        const plan = buildDaemonServicePlan({ ...baseInput, platform: "darwin" });
+        expect(plan.manifestPath).toBe(join(baseInput.homeDir, "Library", "LaunchAgents", "ai.tryalan.agent.plist"));
+        expect(plan.manifest).toContain("<key>KeepAlive</key>");
+        expect(plan.manifest).toContain("<key>ThrottleInterval</key>");
+        expect(plan.manifest).toContain("/opt/node bin/node");
+        expect(plan.startCommands).toEqual([
+            {
+                command: "launchctl",
+                args: ["kickstart", "gui/501/ai.tryalan.agent"],
+                tolerateFailure: false,
+            },
+        ]);
+        expect(plan.loadDefinitionCommands.some((command) => command.args.includes("bootout"))).toBe(false);
+        expect(plan.reloadDefinitionCommands).toEqual([
+            {
+                command: "launchctl",
+                args: [
+                    "bootout",
+                    "gui/501",
+                    join(baseInput.homeDir, "Library", "LaunchAgents", "ai.tryalan.agent.plist"),
+                ],
+                tolerateFailure: true,
+            },
+            {
+                command: "launchctl",
+                args: [
+                    "bootstrap",
+                    "gui/501",
+                    join(baseInput.homeDir, "Library", "LaunchAgents", "ai.tryalan.agent.plist"),
+                ],
+                tolerateFailure: false,
+            },
+        ]);
+        expect(plan.startCommands.some((command) => command.args.includes("-k"))).toBe(false);
+        expect(plan.forceStopCommands).toEqual([
+            {
+                command: "launchctl",
+                args: [
+                    "bootout",
+                    "gui/501",
+                    join(baseInput.homeDir, "Library", "LaunchAgents", "ai.tryalan.agent.plist"),
+                ],
+                tolerateFailure: true,
+            },
+        ]);
+    });
+    it("configures Electron as a Node runtime for a desktop-delivered service", () => {
+        const runtime = {
+            ...baseInput,
+            platform: "darwin",
+            nodeExecutable: "/Applications/Alan.app/Contents/MacOS/Alan",
+            cliEntry: "/Applications/Alan.app/Contents/Resources/alan-agent/index.cjs",
+            environment: { ELECTRON_RUN_AS_NODE: "1" },
+        };
+        const launchd = buildDaemonServicePlan(runtime);
+        const systemd = buildDaemonServicePlan({ ...runtime, platform: "linux" });
+        expect(launchd.manifest).toContain("<key>ELECTRON_RUN_AS_NODE</key>");
+        expect(launchd.manifest).toContain("<string>1</string>");
+        expect(systemd.manifest).toContain('Environment="ELECTRON_RUN_AS_NODE=1"');
+    });
+    it("enables systemd without starting it", () => {
+        const plan = buildDaemonServicePlan({ ...baseInput, platform: "linux" });
+        expect(plan.manifestPath).toBe(join(baseInput.homeDir, ".config", "systemd", "user", "alan-agent.service"));
+        expect(plan.manifest).toContain("Restart=on-failure");
+        expect(plan.manifest).toContain("RestartSec=5");
+        expect(plan.manifest).toContain('ExecStart="/opt/node bin/node" "/opt/alan agent/index.cjs" "daemon" "--profile" "production"');
+        expect(plan.enableCommands).toContainEqual({
+            command: "systemctl",
+            args: ["--user", "enable", "alan-agent.service"],
+            tolerateFailure: false,
+        });
+        expect(plan.enableCommands.some((command) => command.args.includes("--now"))).toBe(false);
+    });
+    it("registers a Windows task without forcing start in loadDefinition", () => {
+        const plan = buildDaemonServicePlan({
+            ...baseInput,
+            platform: "win32",
+            homeDir: "C:\\Users\\Test Person",
+            nodeExecutable: "C:\\Program Files\\nodejs\\node.exe",
+            cliEntry: "C:\\Users\\Test Person\\alan-agent\\index.cjs",
+            environment: { ELECTRON_RUN_AS_NODE: "1" },
+        });
+        expect(plan.manifestPath).toBeNull();
+        expect(plan.loadDefinitionCommands).toHaveLength(1);
+        expect(plan.loadDefinitionCommands[0]?.command).toBe("powershell.exe");
+        const registerCommand = plan.loadDefinitionCommands[0]?.args.join(" ") ?? "";
+        expect(registerCommand).toContain("RestartCount 3");
+        expect(registerCommand).toContain("-AllowStartIfOnBatteries");
+        expect(registerCommand).toContain("-DontStopIfGoingOnBatteries");
+        expect(registerCommand).toContain("$currentIdentity = [System.Security.Principal.WindowsIdentity]::GetCurrent()");
+        expect(registerCommand).toContain("$currentUser = $currentIdentity.Name");
+        expect(registerCommand).toContain("$currentSid = $currentIdentity.User.Value");
+        expect(registerCommand).toContain("$taskName = 'Alan Agent' + ' ' + $currentSid");
+        expect(registerCommand).toContain("New-ScheduledTaskTrigger -AtLogOn -User $currentUser");
+        expect(registerCommand).toContain("New-ScheduledTaskPrincipal -UserId $currentUser -LogonType Interactive -RunLevel Limited");
+        expect(registerCommand).toContain("Register-ScheduledTask -TaskName $taskName -Description");
+        expect(registerCommand).toContain("-Principal $principal");
+        expect(registerCommand).toContain("$legacySid -eq $currentSid");
+        expect(registerCommand).toContain("Legacy Alan Agent task is not owned");
+        const launcher = decodeWindowsLauncher(registerCommand);
+        expect(launcher).toContain("[System.Diagnostics.ProcessStartInfo]::new()");
+        expect(launcher).toContain("$startInfo.UseShellExecute = $false");
+        expect(launcher).toContain("$startInfo.CreateNoWindow = $true");
+        expect(launcher).toContain("$startInfo.RedirectStandardOutput = $true");
+        expect(launcher).toContain("$startInfo.RedirectStandardError = $true");
+        expect(launcher).toContain("$startInfo.EnvironmentVariables['ELECTRON_RUN_AS_NODE'] = '1'");
+        expect(launcher).toContain("$process.StandardOutput.BaseStream.CopyToAsync");
+        expect(launcher).toContain("$process.StandardError.BaseStream.CopyToAsync");
+        expect(launcher).toContain("$process.WaitForExit()");
+        expect(launcher).toContain("exit $exitCode");
+        expect(launcher).toContain("C:\\Users\\Test Person\\.alan\\agent\\logs");
+        expect(launcher).not.toContain("; & '");
+        expect(plan.startCommands[0]?.args.join(" ")).toContain("$taskName = 'Alan Agent' + ' ' + $currentSid; Start-ScheduledTask -TaskName $taskName");
+        expect(plan.definitionMarker).toMatch(/^Alan daemon owner v1 [a-f0-9]{64}; definition v3 [a-f0-9]{64}$/u);
+    });
+    it("uses the hidden supervised launcher for a standalone Node installation", () => {
+        const plan = buildDaemonServicePlan({
+            ...baseInput,
+            platform: "win32",
+            homeDir: "C:\\Users\\O'Brien",
+            nodeExecutable: "C:\\Program Files\\nodejs\\node.exe",
+            cliEntry: "C:\\Users\\O'Brien\\alan agent\\index.cjs",
+        });
+        const registerCommand = plan.loadDefinitionCommands[0]?.args.at(-1) ?? "";
+        expect(registerCommand).toContain("New-ScheduledTaskAction -Execute 'powershell.exe'");
+        const launcher = decodeWindowsLauncher(registerCommand);
+        expect(launcher).toContain("$startInfo.FileName = 'C:\\Program Files\\nodejs\\node.exe'");
+        expect(launcher).toContain("\"C:\\Users\\O''Brien\\alan agent\\index.cjs\"");
+        expect(launcher).toContain("$startInfo.WorkingDirectory = 'C:\\Users\\O''Brien\\alan agent'");
+        expect(launcher).toContain("$startInfo.CreateNoWindow = $true");
+        expect(launcher).toContain("exit $exitCode");
+    });
+    it.runIf(process.platform === "win32")("returns failure when launcher logs cannot be opened", async () => {
+        const tempDir = mkdtempSync(join(tmpdir(), "alan-launcher-log-failure-"));
+        try {
+            const blockedHome = join(tempDir, "blocked-home");
+            const fixture = join(tempDir, "fixture.cjs");
+            writeFileSync(blockedHome, "not a directory");
+            writeFileSync(fixture, "process.exit(37);\n");
+            const plan = buildDaemonServicePlan({
+                platform: "win32",
+                homeDir: blockedHome,
+                nodeExecutable: process.execPath,
+                cliEntry: fixture,
+                profile: "production",
+            });
+            const registerCommand = plan.loadDefinitionCommands[0]?.args.at(-1) ?? "";
+            const launcher = decodeWindowsLauncher(registerCommand);
+            const result = spawnSync("powershell.exe", [
+                "-NoProfile",
+                "-NonInteractive",
+                "-WindowStyle",
+                "Hidden",
+                "-EncodedCommand",
+                Buffer.from(launcher, "utf16le").toString("base64"),
+            ], { encoding: "utf8", windowsHide: true, timeout: 15_000 });
+            expect(launcher).toContain("$ErrorActionPreference = 'Stop'");
+            expect(result.status).not.toBe(0);
+        }
+        finally {
+            rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+    it.runIf(process.platform === "win32")("recognizes only exact legacy Windows actions as owned", async () => {
+        const nodeExecutable = "C:\\Program Files\\Alan QA\\Alan.exe";
+        const cliEntry = "C:\\Users\\O'Brien\\Alan Agent\\index.cjs";
+        const plan = buildDaemonServicePlan({
+            platform: "win32",
+            homeDir: "C:\\Users\\O'Brien",
+            nodeExecutable,
+            cliEntry,
+            profile: "production",
+            environment: { ELECTRON_RUN_AS_NODE: "1" },
+        });
+        const registerCommand = plan.loadDefinitionCommands[0]?.args.at(-1) ?? "";
+        const encoded = registerCommand.match(/-EncodedCommand ([A-Za-z0-9+/=]+)/u)?.[1];
+        expect(encoded).toBeDefined();
+        const currentArguments = `-NoProfile -NonInteractive -WindowStyle Hidden -EncodedCommand ${encoded}`;
+        const oldArguments = `-NoProfile -NonInteractive -WindowStyle Hidden -Command "$env:ELECTRON_RUN_AS_NODE = '1'; & '${nodeExecutable}' '${cliEntry.replaceAll("'", "''")}' daemon --profile production"`;
+        const cases = [
+            {
+                name: "old-exact",
+                state: "Running",
+                execute: "powershell.exe",
+                arguments: oldArguments,
+                workDir: "",
+                owned: true,
+            },
+            {
+                name: "current-exact",
+                state: "Queued",
+                execute: "powershell.exe",
+                arguments: currentArguments,
+                workDir: dirname(cliEntry),
+                owned: true,
+            },
+            {
+                name: "wrong-executable",
+                execute: "cmd.exe",
+                arguments: oldArguments,
+                workDir: "",
+                owned: false,
+            },
+            {
+                name: "suffix",
+                execute: "powershell.exe",
+                arguments: `${oldArguments}-foreign`,
+                workDir: "",
+                owned: false,
+            },
+            {
+                name: "extra-command",
+                execute: "powershell.exe",
+                arguments: `${oldArguments}; calc.exe`,
+                workDir: "",
+                owned: false,
+            },
+        ];
+        const statusScript = plan.isActiveCommand.args.at(-1) ?? "";
+        const powershell = `
+$statusSource = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${Buffer.from(statusScript).toString("base64")}'))
+$cases = ConvertFrom-Json ([Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${Buffer.from(JSON.stringify(cases)).toString("base64")}')))
+$results = foreach ($case in $cases) {
+  $identity = [Security.Principal.WindowsIdentity]::GetCurrent()
+  $script:fakeTask = [pscustomobject]@{
+    TaskPath = '\\'; TaskName = 'Alan Agent'; State = $(if ($case.state) { $case.state } else { 'Ready' })
+    Principal = [pscustomobject]@{ UserId = $identity.Name }
+    Actions = @([pscustomobject]@{ Execute = $case.execute; Arguments = $case.arguments; WorkingDirectory = $case.workDir })
+  }
+  function Get-ScheduledTask { [CmdletBinding()] param(); return $script:fakeTask }
+  $output = @(& ([scriptblock]::Create($statusSource)))
+  [pscustomobject]@{ name = $case.name; owned = [bool]($output -contains 'LegacyOwned: True'); output = ($output -join "\`n") }
+}
+$results | ConvertTo-Json -Compress
+`;
+        const result = spawnSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", powershell], { encoding: "utf8", windowsHide: true, timeout: 15_000 });
+        expect(result.status).toBe(0);
+        const results = JSON.parse(result.stdout);
+        expect(results.map(({ name, owned }) => ({ name, owned }))).toEqual(cases.map(({ name, owned }) => ({ name, owned })));
+        for (const result of results) {
+            const inspection = await inspectDaemonService({
+                platform: "win32",
+                runtime: { executable: nodeExecutable, cliEntry },
+                runCommand: () => ({ status: 0, output: result.output }),
+            });
+            expect(inspection.state).toBe(!result.owned ? "unknown" : result.name === "old-exact" ? "running" : "starting");
+        }
+    });
+    it("isolates non-production services from production on every host platform", () => {
+        const launchd = buildDaemonServicePlan({
+            ...baseInput,
+            profile: "local",
+            platform: "darwin",
+        });
+        const systemd = buildDaemonServicePlan({
+            ...baseInput,
+            profile: "local",
+            platform: "linux",
+        });
+        const windows = buildDaemonServicePlan({
+            ...baseInput,
+            profile: "local",
+            platform: "win32",
+        });
+        expect(launchd.manifestPath).toBe(join(baseInput.homeDir, "Library", "LaunchAgents", "ai.tryalan.agent.local.plist"));
+        expect(launchd.manifest).toContain("<string>ai.tryalan.agent.local</string>");
+        expect(launchd.manifest).toContain(join(baseInput.homeDir, ".alan-dev", "agent", "logs"));
+        expect(launchd.logDirectory).toBe(join(baseInput.homeDir, ".alan-dev", "agent", "logs"));
+        expect(systemd.manifestPath).toBe(join(baseInput.homeDir, ".config", "systemd", "user", "alan-agent-local.service"));
+        expect(systemd.statusCommand.args).toContain("alan-agent-local.service");
+        expect(windows.statusCommand.args.join(" ")).toContain("'Alan Agent Local'");
+    });
+    it("restarts a failed identity handoff on every supported service host", () => {
+        const launchd = buildDaemonServicePlan({ ...baseInput, platform: "darwin" });
+        const systemd = buildDaemonServicePlan({ ...baseInput, platform: "linux" });
+        const windows = buildDaemonServicePlan({ ...baseInput, platform: "win32" });
+        expect(launchd.manifest).toContain("<key>SuccessfulExit</key>\n    <false/>");
+        expect(systemd.manifest).toContain("Restart=on-failure");
+        expect(windows.loadDefinitionCommands[0]?.args.join(" ")).toContain("RestartCount 3");
+    });
+});
+describe("forced macOS daemon stop", () => {
+    const identity = {
+        pid: 4242,
+        daemonSessionId: "session-a",
+        serviceId: "svc-1",
+        port: 4123,
+        startedAtMs: 1_000,
+    };
+    const owner = {
+        version: 1,
+        id: "owner-session-a",
+        daemonSessionId: "session-a",
+        pid: 4242,
+        startedAtMs: 1_000,
+        runtimeId: "runtime-1",
+        localServiceId: "svc-1",
+        localApiPort: 4123,
+        localApiToken: "token",
+    };
+    const runtime = {
+        executable: "/Applications/Alan.app/Contents/MacOS/Alan",
+        cliEntry: "/Applications/Alan.app/Contents/Resources/alan-agent/index.cjs",
+    };
+    it("matches every available owner-lease identity field", () => {
+        expect(ownerMatchesDaemonIdentity(owner, identity)).toBe(true);
+        expect(ownerMatchesDaemonIdentity({ ...owner, pid: 5252 }, identity)).toBe(false);
+        expect(ownerMatchesDaemonIdentity({ ...owner, daemonSessionId: "session-b" }, identity)).toBe(false);
+        expect(ownerMatchesDaemonIdentity({ ...owner, localApiPort: 4999 }, identity)).toBe(false);
+        expect(ownerMatchesDaemonIdentity({ ...owner, localServiceId: "svc-2" }, identity)).toBe(false);
+        expect(ownerMatchesDaemonIdentity({ ...owner, startedAtMs: 2_000 }, identity)).toBe(false);
+    });
+    it("boots out the service and proves both the captured PID and launchd job exited", async () => {
+        const commands = [];
+        const outcome = await forceStopDaemonServiceAndWait(identity, 1_000, {
+            platform: "darwin",
+            homeDir: "/Users/Test Person",
+            userId: 501,
+            configPath: "/Users/Test Person/.alan/agent/config.json",
+            args: ["--profile", "production"],
+            runtime,
+            runCommand: (command) => {
+                commands.push(command);
+                return command.args[0] === "print"
+                    ? { status: 113, output: "Could not find service" }
+                    : { status: 0, output: "" };
+            },
+            readOwner: () => owner,
+            isProcessAlive: () => false,
+            nowMs: () => 0,
+            sleep: async () => { },
+        });
+        expect(outcome).toBe("exited");
+        expect(commands[0]?.command).toBe("launchctl");
+        expect(commands[0]?.args[0]).toBe("bootout");
+        expect(commands[0]?.args.at(-1)).toContain("ai.tryalan.agent.plist");
+        expect(commands[1]?.args[0]).toBe("print");
+    });
+    it("does not boot out anything when the owner identity changed", async () => {
+        const commands = [];
+        const outcome = await forceStopDaemonServiceAndWait(identity, 1_000, {
+            platform: "darwin",
+            homeDir: "/Users/Test Person",
+            userId: 501,
+            configPath: "/Users/Test Person/.alan/agent/config.json",
+            args: ["--profile", "production"],
+            runtime,
+            runCommand: (command) => {
+                commands.push(command.command);
+                return { status: 0, output: "" };
+            },
+            readOwner: () => ({ ...owner, daemonSessionId: "session-b" }),
+            isProcessAlive: () => false,
+            nowMs: () => 0,
+            sleep: async () => { },
+        });
+        expect(outcome).toBe("identity_changed");
+        expect(commands).toHaveLength(0);
+    });
+});
+describe("ensure/install admission helpers", () => {
+    const windowsRuntime = {
+        executable: "C:\\Program Files\\nodejs\\node.exe",
+        cliEntry: "C:\\Alan QA\\index.cjs",
+    };
+    const runWindowsEnsure = (output, commands = [], status = 0) => ensureDaemonServiceDefinition({
+        platform: "win32",
+        homeDir: "C:\\Users\\QA",
+        runtime: windowsRuntime,
+        ensureLogDir: () => undefined,
+        runCommand: (command) => {
+            commands.push(command.args.join(" "));
+            return { status, output };
+        },
+    });
+    it("bounds hung service commands while keeping the event loop responsive", async () => {
+        let ticks = 0;
+        const timer = setInterval(() => {
+            ticks++;
+        }, 10);
+        const started = Date.now();
+        try {
+            await expect(runServiceCommand({
+                command: process.execPath,
+                args: ["-e", "setInterval(() => {}, 1000)"],
+                tolerateFailure: true,
+            }, { commandTimeoutMs: 150 })).rejects.toThrow("Service command failed");
+            expect(ticks).toBeGreaterThan(2);
+            expect(Date.now() - started).toBeLessThan(2_000);
+        }
+        finally {
+            clearInterval(timer);
+        }
+    });
+    it("reports denied commands and supports cancellation and bounded output", async () => {
+        const command = {
+            command: process.execPath,
+            args: ["-e", "process.exit(5)"],
+            tolerateFailure: true,
+        };
+        expect(await runServiceCommand(command)).toMatchObject({ status: 5 });
+        await expect(runServiceCommand({ ...command, tolerateFailure: false })).rejects.toThrow();
+        await expect(runServiceCommand({ ...command, args: ["-e", "setInterval(() => {}, 1000)"] }, { signal: AbortSignal.timeout(100) })).rejects.toThrow();
+        await expect(runServiceCommand({
+            ...command,
+            tolerateFailure: false,
+            args: ["-e", "process.stdout.write('x'.repeat(1024 * 1024))"],
+        })).rejects.toThrow();
+    });
+    it("awaits service status without blocking other daemon work", async () => {
+        let heartbeat = false;
+        const inspection = inspectDaemonService({
+            platform: "linux",
+            runCommand: async () => {
+                await new Promise((resolve) => setTimeout(resolve, 25));
+                return { status: 0, output: "active" };
+            },
+        });
+        setTimeout(() => {
+            heartbeat = true;
+        }, 0);
+        expect(await inspection).toMatchObject({ state: "running" });
+        expect(heartbeat).toBe(true);
+    });
+    it("marks definition updates pending while the host is running", () => {
+        expect(resolveEnsureDefinitionOutcome({ definitionChanged: true, hostState: "running" })).toEqual({
+            changed: true,
+            updatePending: true,
+        });
+        expect(resolveEnsureDefinitionOutcome({ definitionChanged: true, hostState: "stopped" })).toEqual({
+            changed: true,
+            updatePending: false,
+        });
+    });
+    it("recognizes systemd inactive and failed output despite the expected nonzero exit", () => {
+        expect(parseServiceHostState("linux", { status: 3, output: "inactive" })).toBe("stopped");
+        expect(parseServiceHostState("linux", { status: 3, output: "failed" })).toBe("stopped");
+        expect(parseServiceHostState("linux", { status: 1, output: "permission denied" })).toBe("unknown");
+    });
+    it("preserves a queued Windows task as pending startup evidence", () => {
+        expect(parseServiceHostState("win32", { status: 0, output: "Queued" })).toBe("starting");
+    });
+    it("keeps a matching per-user Windows task definition unchanged", async () => {
+        const plan = buildDaemonServicePlan({
+            platform: "win32",
+            homeDir: "C:\\Users\\QA",
+            nodeExecutable: windowsRuntime.executable,
+            cliEntry: windowsRuntime.cliEntry,
+            profile: "production",
+        });
+        const commands = [];
+        const result = await runWindowsEnsure(`TaskName: Alan Agent S-1-5-21-test\nState: Ready\nDefinition: ${plan.definitionMarker}\nDefinitionMatch: True\nCurrentOwned: True\nLegacyTask: False\nLegacyOwned: False\nLegacyState: Missing`, commands);
+        expect(result).toEqual({ changed: false, updatePending: false });
+        expect(commands).toHaveLength(1);
+        expect(commands[0]).not.toContain("Register-ScheduledTask");
+    });
+    it("migrates a stale queued Windows definition instead of leaving it pending", async () => {
+        const commands = [];
+        const result = await runWindowsEnsure("TaskName: Alan Agent S-1-5-21-test\nState: Queued\nDefinition: stale\nDefinitionMatch: False\nCurrentOwned: True\nLegacyTask: False\nLegacyOwned: False\nLegacyState: Missing", commands);
+        expect(result).toEqual({ changed: true, updatePending: false });
+        expect(commands).toHaveLength(2);
+        expect(commands[1]).toContain("Register-ScheduledTask");
+    });
+    it("defers a stale Windows definition while its task is running", async () => {
+        const commands = [];
+        const result = await runWindowsEnsure("TaskName: Alan Agent S-1-5-21-test\nState: Running\nDefinition: stale\nDefinitionMatch: False\nCurrentOwned: True\nLegacyTask: False\nLegacyOwned: False\nLegacyState: Missing", commands);
+        expect(result).toEqual({ changed: true, updatePending: true });
+        expect(commands).toHaveLength(1);
+        expect(commands[0]).not.toContain("Register-ScheduledTask");
+    });
+    it("fails closed when Windows task inspection is incomplete", async () => {
+        await expect(runWindowsEnsure("Access denied", [], 1)).rejects.toThrow("Cannot inspect Windows daemon task definition");
+    });
+    it("refuses to replace an unowned per-user Windows task", async () => {
+        await expect(runWindowsEnsure("TaskName: Alan Agent S-1-5-21-test\nState: Ready\nDefinition: foreign\nDefinitionMatch: False\nCurrentOwned: False\nLegacyTask: False\nLegacyOwned: False\nLegacyState: Missing")).rejects.toThrow("not owned by this Alan installation");
+    });
+    it("refuses a foreign legacy task before deferring a running current task", async () => {
+        await expect(runWindowsEnsure("TaskName: Alan Agent S-1-5-21-test\nState: Running\nDefinition: current\nDefinitionMatch: True\nCurrentOwned: True\nLegacyTask: True\nLegacyOwned: False\nLegacyState: Ready")).rejects.toThrow("Legacy Windows daemon task is not owned");
+    });
+    it.each([
+        ["Running", "running"],
+        ["Queued", "starting"],
+        ["Ready", "stopped"],
+        ["Disabled", "stopped"],
+        ["Unrecognized", "unknown"],
+    ])("includes a legacy-only %s task in lifecycle inspection", async (legacyState, expected) => {
+        const inspection = await inspectDaemonService({
+            platform: "win32",
+            runtime: windowsRuntime,
+            runCommand: () => ({
+                status: 0,
+                output: `State: Missing\nDefinitionMatch: False\nCurrentOwned: False\nLegacyTask: True\nLegacyOwned: True\nLegacyState: ${legacyState}`,
+            }),
+        });
+        expect(inspection.state).toBe(expected);
+    });
+    it("keeps a foreign legacy task blocked during lifecycle inspection", async () => {
+        const inspection = await inspectDaemonService({
+            platform: "win32",
+            runtime: windowsRuntime,
+            runCommand: () => ({
+                status: 0,
+                output: "State: Missing\nDefinitionMatch: False\nCurrentOwned: False\nLegacyTask: True\nLegacyOwned: False\nLegacyState: Running",
+            }),
+        });
+        expect(inspection.state).toBe("unknown");
+    });
+    it("defers migration while an owned legacy Windows task is running", async () => {
+        const commands = [];
+        const result = await runWindowsEnsure("State: Missing\nDefinitionMatch: False\nCurrentOwned: False\nLegacyTask: True\nLegacyOwned: True\nLegacyState: Running", commands);
+        expect(result).toEqual({ changed: true, updatePending: true });
+        expect(commands).toHaveLength(1);
+    });
+});
+describe("Windows stop verification", () => {
+    const identity = {
+        pid: 4242,
+        daemonSessionId: "daemon-session-1",
+        serviceId: "service-1",
+        port: 48734,
+        startedAtMs: 1_000,
+    };
+    const owner = {
+        version: 1,
+        id: "owner-1",
+        daemonSessionId: identity.daemonSessionId,
+        pid: identity.pid,
+        startedAtMs: identity.startedAtMs,
+        runtimeId: "runtime-1",
+        localServiceId: identity.serviceId,
+        localApiPort: identity.port,
+        localApiToken: "test-local-token",
+    };
+    const runtime = {
+        executable: "C:\\Program Files\\nodejs\\node.exe",
+        cliEntry: "C:\\Alan QA\\index.cjs",
+    };
+    function clock() {
+        let now = 0;
+        return {
+            nowMs: () => now,
+            sleep: async (ms) => {
+                now += ms;
+            },
+        };
+    }
+    it("does not claim exit from scheduler Ready while the captured process lives", async () => {
+        const commands = [];
+        const result = await stopDaemonServiceAndWait(identity, 400, {
+            ...clock(),
+            platform: "win32",
+            homeDir: "C:\\Users\\QA",
+            runtime,
+            configPath: "C:\\Alan QA\\config.json",
+            readOwner: () => owner,
+            isProcessAlive: () => true,
+            requestWindowsShutdown: async () => "unreachable",
+            probeEndpoint: async () => ({ state: "absent" }),
+            runCommand: (command) => {
+                commands.push(command.args.join(" "));
+                return { status: 0, output: "Ready" };
+            },
+        });
+        expect(result).toBe("timeout");
+        expect(commands.some((command) => command.includes("Stop-ScheduledTask"))).toBe(true);
+    });
+    it("confirms exit only when the captured process and authenticated endpoint are absent", async () => {
+        let reads = 0;
+        const result = await stopDaemonServiceAndWait(identity, 400, {
+            ...clock(),
+            platform: "win32",
+            homeDir: "C:\\Users\\QA",
+            runtime,
+            configPath: "C:\\Alan QA\\config.json",
+            readOwner: () => (reads++ === 0 ? owner : null),
+            isProcessAlive: () => false,
+            requestWindowsShutdown: async () => "accepted",
+            probeEndpoint: async () => ({ state: "absent" }),
+            runCommand: () => ({ status: 0, output: "Ready" }),
+        });
+        expect(result).toBe("exited");
+    });
+    it("fails closed when Windows daemon ownership changes during stop", async () => {
+        let reads = 0;
+        const result = await stopDaemonServiceAndWait(identity, 400, {
+            ...clock(),
+            platform: "win32",
+            homeDir: "C:\\Users\\QA",
+            runtime,
+            configPath: "C:\\Alan QA\\config.json",
+            readOwner: () => (reads++ === 0 ? owner : { ...owner, daemonSessionId: "daemon-session-2" }),
+            isProcessAlive: () => false,
+            requestWindowsShutdown: async () => "accepted",
+            probeEndpoint: async () => ({ state: "absent" }),
+            runCommand: () => ({ status: 0, output: "Ready" }),
+        });
+        expect(result).toBe("identity_changed");
+    });
+});
+describe("Windows service uninstall", () => {
+    const runtime = {
+        executable: "C:\\Program Files\\nodejs\\node.exe",
+        cliEntry: "C:\\Alan QA\\index.cjs",
+    };
+    const owner = {
+        version: 1,
+        id: "owner-1",
+        daemonSessionId: "daemon-session-1",
+        pid: 4242,
+        startedAtMs: 1_000,
+        runtimeId: "runtime-1",
+        localServiceId: "service-1",
+        localApiPort: 48734,
+        localApiToken: "test-local-token",
+    };
+    const maintenance = {
+        acquireMaintenance: () => ({
+            acquired: true,
+            lease: {
+                version: 1,
+                id: "maintenance-1",
+                reason: "watchdog",
+                expiresAtMs: Date.now() + 30_000,
+            },
+        }),
+        releaseMaintenance: () => { },
+    };
+    const ownedTaskStatus = "TaskName: Alan Agent S-1-5-21-test\nState: Ready\nDefinitionMatch: True\nCurrentOwned: True\nLegacyTask: False\nLegacyOwned: False\nLegacyState: Missing";
+    function serviceResult(command) {
+        return {
+            status: 0,
+            output: command.args.join(" ").includes("DefinitionMatch") ? ownedTaskStatus : "Ready",
+        };
+    }
+    it("refuses to unregister while active work is protected", async () => {
+        const commands = [];
+        await expect(uninstallDaemonService([], {
+            ...maintenance,
+            platform: "win32",
+            homeDir: "C:\\Users\\QA",
+            runtime,
+            configPath: "C:\\Alan QA\\config.json",
+            inspectJournal: () => ({ safeToRestart: false, activeRunCount: 1 }),
+            readOwner: () => owner,
+            runCommand: (command) => {
+                commands.push(command.args.join(" "));
+                return serviceResult(command);
+            },
+        })).rejects.toThrow("active run");
+        expect(commands.some((command) => command.includes("Unregister-ScheduledTask"))).toBe(false);
+    });
+    it("stops the owned daemon before unregistering the Windows task", async () => {
+        const events = [];
+        await uninstallDaemonService([], {
+            ...maintenance,
+            platform: "win32",
+            homeDir: "C:\\Users\\QA",
+            runtime,
+            configPath: "C:\\Alan QA\\config.json",
+            inspectJournal: () => ({ safeToRestart: true, activeRunCount: 0 }),
+            readOwner: () => owner,
+            isProcessAlive: () => false,
+            requestWindowsShutdown: async () => {
+                events.push("shutdown");
+                return "accepted";
+            },
+            probeEndpoint: async () => {
+                events.push("endpoint-absent");
+                return { state: "absent" };
+            },
+            runCommand: (command) => {
+                if (command.args.join(" ").includes("Unregister-ScheduledTask")) {
+                    events.push("unregister");
+                }
+                return serviceResult(command);
+            },
+        });
+        expect(events).toEqual(["shutdown", "endpoint-absent", "unregister"]);
+    });
+    it("surfaces Windows task access denial instead of printing success", async () => {
+        await expect(uninstallDaemonService([], {
+            ...maintenance,
+            platform: "win32",
+            homeDir: "C:\\Users\\QA",
+            runtime,
+            configPath: "C:\\Alan QA\\config.json",
+            inspectJournal: () => ({ safeToRestart: true, activeRunCount: 0 }),
+            readOwner: () => null,
+            runCommand: (command) => {
+                if (command.args.join(" ").includes("Unregister-ScheduledTask")) {
+                    throw new Error("Access denied");
+                }
+                return serviceResult(command);
+            },
+        })).rejects.toThrow("Access denied");
+    });
+    it("does not stop a same-user task owned by another Alan installation", async () => {
+        const shutdown = vi.fn();
+        await expect(uninstallDaemonService([], {
+            platform: "win32",
+            homeDir: "C:\\Users\\QA",
+            runtime,
+            configPath: "C:\\Alan QA\\config.json",
+            requestWindowsShutdown: shutdown,
+            runCommand: () => ({
+                status: 0,
+                output: "TaskName: Alan Agent S-1-5-21-test\nState: Running\nDefinitionMatch: False\nCurrentOwned: False\nLegacyTask: False\nLegacyOwned: False\nLegacyState: Missing",
+            }),
+        })).rejects.toThrow("not owned by this Alan installation");
+        expect(shutdown).not.toHaveBeenCalled();
+    });
+    it("treats an already-absent Windows service as successfully removed", async () => {
+        const acquireMaintenance = vi.fn();
+        await uninstallDaemonService([], {
+            platform: "win32",
+            homeDir: "C:\\Users\\QA",
+            runtime,
+            configPath: "C:\\Alan QA\\config.json",
+            acquireMaintenance,
+            runCommand: () => ({
+                status: 0,
+                output: "State: Missing\nDefinitionMatch: False\nCurrentOwned: False\nLegacyTask: False\nLegacyOwned: False\nLegacyState: Missing",
+            }),
+        });
+        expect(acquireMaintenance).not.toHaveBeenCalled();
+    });
+    it("refuses to unregister an ownerless running legacy task", async () => {
+        const unregister = vi.fn();
+        await expect(uninstallDaemonService([], {
+            ...maintenance,
+            platform: "win32",
+            homeDir: "C:\\Users\\QA",
+            runtime,
+            configPath: "C:\\Alan QA\\config.json",
+            inspectJournal: () => ({ safeToRestart: true, activeRunCount: 0 }),
+            readOwner: () => null,
+            runCommand: (command) => {
+                if (command.args.join(" ").includes("Unregister-ScheduledTask"))
+                    unregister();
+                return {
+                    status: 0,
+                    output: "State: Missing\nDefinitionMatch: False\nCurrentOwned: False\nLegacyTask: True\nLegacyOwned: True\nLegacyState: Running",
+                };
+            },
+        })).rejects.toThrow("without verified ownership");
+        expect(unregister).not.toHaveBeenCalled();
+    });
+});
+//# sourceMappingURL=service-manager.test.js.map