@alan-ai-hq/agent-manager 0.1.97 → 0.1.98

package/dist/index.cjs

@@ -3404,7 +3404,7 @@ var require_websocket = __commonJS({
     var http2 = require("http");
     var net = require("net");
     var tls = require("tls");
-    var { randomBytes: randomBytes13, createHash: createHash18 } = require("crypto");
+    var { randomBytes: randomBytes13, createHash: createHash19 } = require("crypto");
     var { Duplex, Readable: Readable2 } = require("stream");
     var { URL: URL2 } = require("url");
     var PerMessageDeflate = require_permessage_deflate();
@@ -4061,7 +4061,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash18("sha1").update(key + GUID).digest("base64");
+        const digest = createHash19("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -4428,7 +4428,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = require("events");
     var http2 = require("http");
     var { Duplex } = require("stream");
-    var { createHash: createHash18 } = require("crypto");
+    var { createHash: createHash19 } = require("crypto");
     var extension = require_extension();
     var PerMessageDeflate = require_permessage_deflate();
     var subprotocol = require_subprotocol();
@@ -4725,7 +4725,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash18("sha1").update(key + GUID).digest("base64");
+        const digest = createHash19("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -15460,7 +15460,7 @@ function describeError(error61) {
 }
 
 // src/version.ts
-var AGENT_VERSION = "0.1.97";
+var AGENT_VERSION = "0.1.98";
 
 // src/daemon-worktree.ts
 var import_node_child_process3 = require("child_process");
@@ -49619,6 +49619,16 @@ async function probeLocalDaemon(port, token, timeoutMs = 750) {
   const probe = await probeLocalDaemonEndpoint(port, token, timeoutMs);
   return probe.state === "running" ? probe.status : null;
 }
+function requestLocalDaemonShutdown(port, token) {
+  return fetch(`http://127.0.0.1:${port}/shutdown?force=1`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${token}`,
+      "x-alan-shutdown-reason": "runtime_shutdown"
+    },
+    signal: AbortSignal.timeout(5e3)
+  });
+}
 async function adoptLocalDaemonControl(input2) {
   const timeoutMs = input2.timeoutMs ?? 750;
   try {
@@ -76706,13 +76716,13 @@ var RuntimeRunJournal = class {
    * Keep the exact interruption outcome until a durable authenticated control
    * channel can prove both identity and ownership.
    */
-  assessRecovery(runId, isProcessAlive) {
+  assessRecovery(runId, isProcessAlive2) {
     const entry = this.entries.get(runId);
     if (!entry) return void 0;
     if (entry.providerPid === void 0) {
       return { reattachable: false, reason: "provider_not_recorded" };
     }
-    if (!isProcessAlive(entry.providerPid)) {
+    if (!isProcessAlive2(entry.providerPid)) {
       return {
         reattachable: false,
         reason: "provider_not_running",
@@ -76766,7 +76776,8 @@ var RuntimeSetupGrantExpiredError = class extends Error {
     this.name = "RuntimeSetupGrantExpiredError";
   }
 };
-async function createRuntimeSetupGrant(input2) {
+async function createRuntimeSetupGrant(input2, signal) {
+  signal?.throwIfAborted();
   const response = await fetch(`${input2.apiUrl}/public/runtimes/setup-tokens`, {
     method: "POST",
     headers: {
@@ -76778,7 +76789,7 @@ async function createRuntimeSetupGrant(input2) {
       ...input2.scope === "team" ? { teamId: input2.teamId } : {},
       ttlMinutes: 5
     }),
-    signal: AbortSignal.timeout(1e4)
+    signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(1e4)]) : AbortSignal.timeout(1e4)
   });
   const body = await response.json();
   if (!response.ok || typeof body.setupToken !== "string") {
@@ -76787,9 +76798,10 @@ async function createRuntimeSetupGrant(input2) {
   }
   return body.setupToken;
 }
-async function exchangeRuntimeSetupGrant(input2) {
+async function exchangeRuntimeSetupGrant(input2, setupSignal) {
+  setupSignal?.throwIfAborted();
   const registrationAttemptId = getOrCreateSetupAttemptId(input2.setupToken);
-  const signal = AbortSignal.timeout(15e3);
+  const signal = setupSignal ? AbortSignal.any([setupSignal, AbortSignal.timeout(15e3)]) : AbortSignal.timeout(15e3);
   const registrationInit = {
     method: "POST",
     headers: { "content-type": "application/json" },
@@ -76814,6 +76826,7 @@ async function exchangeRuntimeSetupGrant(input2) {
   let response;
   let transportError;
   for (let attempt = 1; attempt <= 3; attempt += 1) {
+    signal.throwIfAborted();
     try {
       response = await fetch(
         `${input2.apiUrl}/public/runtimes/register-with-setup-token`,
@@ -76821,6 +76834,7 @@ async function exchangeRuntimeSetupGrant(input2) {
       );
       transportError = void 0;
     } catch (error61) {
+      signal.throwIfAborted();
       transportError = error61;
     }
     const retriable = response && (response.status === 408 || response.status === 429 || response.status >= 500);
@@ -76858,6 +76872,7 @@ async function exchangeRuntimeSetupGrant(input2) {
   };
 }
 async function handoffRuntimeSetupGrant(input2) {
+  input2.signal?.throwIfAborted();
   const response = await fetch(`http://127.0.0.1:${input2.port}/credentials/setup`, {
     method: "POST",
     headers: {
@@ -76865,7 +76880,7 @@ async function handoffRuntimeSetupGrant(input2) {
       "content-type": "application/json"
     },
     body: JSON.stringify(input2.setup),
-    signal: AbortSignal.timeout(input2.timeoutMs ?? 2e4)
+    signal: input2.signal ? AbortSignal.any([input2.signal, AbortSignal.timeout(input2.timeoutMs ?? 2e4)]) : AbortSignal.timeout(input2.timeoutMs ?? 2e4)
   });
   const body = await response.json();
   if (!response.ok) {
@@ -80459,7 +80474,20 @@ async function runLocalDaemonRecoveryLadder(input2) {
     error: "The local daemon exhausted its reconnect and safe-restart recovery budget."
   };
 }
-async function setupDaemon(args) {
+function writeRegisteredRuntimeConfig(args, previousConfig, registered) {
+  writeConfig({
+    ...registered,
+    localApiPort: getLocalApiPort(args, {}),
+    localApiToken: previousConfig.localApiToken ?? (0, import_node_crypto19.randomBytes)(24).toString("hex"),
+    localServiceId: previousConfig.localServiceId ?? (0, import_node_crypto19.randomUUID)(),
+    localServiceSecret: previousConfig.localServiceSecret ?? (0, import_node_crypto19.randomBytes)(32).toString("base64url"),
+    eventSpoolKey: previousConfig.eventSpoolKey ?? (0, import_node_crypto19.randomBytes)(32).toString("base64url"),
+    daemonEpoch: previousConfig.daemonEpoch
+  });
+}
+async function setupDaemon(args, options = {}) {
+  const { signal } = options;
+  signal?.throwIfAborted();
   bindConfigPath(args);
   const previousConfig = readConfigForRegistration();
   const { apiUrl, wsUrl, endpointProfile } = resolveEndpoints(args);
@@ -80477,12 +80505,15 @@ async function setupDaemon(args) {
       "setup requires --setup-token <token> or --token <Alan access token>.\nFor normal setup, copy the setup token from Alan and run: alan-agent setup --setup-token <token>\nFor browser authorization, run: alan-agent login"
     );
   }
-  const registrationGrant = setupToken ?? await createRuntimeSetupGrant({
-    apiUrl,
-    accessToken: token,
-    scope,
-    teamId
-  });
+  const registrationGrant = setupToken ?? await createRuntimeSetupGrant(
+    {
+      apiUrl,
+      accessToken: token,
+      scope,
+      teamId
+    },
+    signal
+  );
   const setup = {
     apiUrl,
     wsUrl,
@@ -80492,13 +80523,16 @@ async function setupDaemon(args) {
     displayName,
     installationId
   };
+  signal?.throwIfAborted();
   let liveConfig = previousConfig;
   const localApiPort = getLocalApiPort(args, liveConfig);
   let live = liveConfig.localApiToken ? await probeLocalDaemon(localApiPort, liveConfig.localApiToken) : null;
+  signal?.throwIfAborted();
   if (!live && liveConfig.localServiceId && liveConfig.localServiceSecret) {
     live = await adoptConfiguredLocalDaemon(args);
     liveConfig = readConfigForRegistration();
   }
+  signal?.throwIfAborted();
   if (live) {
     if (!liveConfig.localApiToken) {
       throw new Error("running daemon could not be authenticated for credential setup");
@@ -80512,14 +80546,16 @@ async function setupDaemon(args) {
     const body2 = await handoffRuntimeSetupGrant({
       port: localApiPort,
       localApiToken: liveConfig.localApiToken,
-      setup: liveSetup
+      setup: liveSetup,
+      signal
     });
+    signal?.throwIfAborted();
     console.info("[alan-agent] Runtime credentials adopted by running daemon", {
       runtimeId: body2.runtimeId,
       credentialGeneration: body2.credentialGeneration,
       configPath: getConfigPath()
     });
-    return { daemonAlreadyRunning: true };
+    return body2.runtimeId !== liveConfig.runtimeId;
   }
   if (readLocalDaemonOwnerLease(getConfigPath())) {
     throw new Error(
@@ -80528,28 +80564,27 @@ async function setupDaemon(args) {
   }
   let body;
   try {
-    body = await exchangeRuntimeSetupGrant(setup);
+    body = await exchangeRuntimeSetupGrant(setup, signal);
   } catch (error61) {
+    signal?.throwIfAborted();
     if (setupToken && error61 instanceof RuntimeSetupGrantExpiredError) {
+      if (signal) {
+        throw new Error("Setup link expired. Run alan-agent login to authorize in your browser.");
+      }
       console.info("[alan-agent] Setup link expired; continuing with browser authorization");
       await loginWithDeviceCode(args);
-      return { daemonAlreadyRunning: false };
+      return false;
     }
     throw error61;
   }
-  writeConfig({
+  signal?.throwIfAborted();
+  writeRegisteredRuntimeConfig(args, previousConfig, {
     apiUrl,
     wsUrl,
     endpointProfile,
     runtimeId: body.runtimeId,
     runtimeToken: body.runtimeToken,
     runtimeRenewalToken: body.runtimeRenewalToken,
-    localApiPort: getLocalApiPort(args, {}),
-    localApiToken: previousConfig.localApiToken ?? (0, import_node_crypto19.randomBytes)(24).toString("hex"),
-    localServiceId: previousConfig.localServiceId ?? (0, import_node_crypto19.randomUUID)(),
-    localServiceSecret: previousConfig.localServiceSecret ?? (0, import_node_crypto19.randomBytes)(32).toString("base64url"),
-    eventSpoolKey: previousConfig.eventSpoolKey ?? (0, import_node_crypto19.randomBytes)(32).toString("base64url"),
-    daemonEpoch: previousConfig.daemonEpoch,
     displayName: body.displayName,
     installationId
   });
@@ -80558,7 +80593,7 @@ async function setupDaemon(args) {
     runtimeId: body.runtimeId,
     configPath: getConfigPath()
   });
-  return { daemonAlreadyRunning: false };
+  return false;
 }
 async function loginWithDeviceCode(args) {
   bindConfigPath(args);
@@ -80647,19 +80682,13 @@ async function loginWithDeviceCode(args) {
       if (ownedPending?.operationId !== operation.id) {
         throw new Error("browser authorization sidecar ownership was lost before finalization");
       }
-      writeConfig({
+      writeRegisteredRuntimeConfig(args, previousConfig, {
         apiUrl,
         wsUrl,
         endpointProfile,
         runtimeId: body.runtime.id,
         runtimeToken: body.runtimeToken,
         runtimeRenewalToken: body.runtimeRenewalToken,
-        localApiPort: getLocalApiPort(args, {}),
-        localApiToken: previousConfig.localApiToken ?? (0, import_node_crypto19.randomBytes)(24).toString("hex"),
-        localServiceId: previousConfig.localServiceId ?? (0, import_node_crypto19.randomUUID)(),
-        localServiceSecret: previousConfig.localServiceSecret ?? (0, import_node_crypto19.randomBytes)(32).toString("base64url"),
-        eventSpoolKey: previousConfig.eventSpoolKey ?? (0, import_node_crypto19.randomBytes)(32).toString("base64url"),
-        daemonEpoch: previousConfig.daemonEpoch,
         displayName: body.runtime.displayName ?? displayName,
         installationId
       });
@@ -80698,14 +80727,7 @@ async function stopDaemon(args) {
     console.info("[alan-agent] No daemon listening", { port: localApiPort });
     return;
   }
-  const response = await fetch(`http://127.0.0.1:${localApiPort}/shutdown?force=1`, {
-    method: "POST",
-    headers: {
-      authorization: `Bearer ${localApiToken}`,
-      "x-alan-shutdown-reason": "runtime_shutdown"
-    },
-    signal: AbortSignal.timeout(5e3)
-  });
+  const response = await requestLocalDaemonShutdown(localApiPort, localApiToken);
   if (!response.ok) {
     throw new Error(`Failed to stop daemon: HTTP ${response.status}`);
   }
@@ -80850,14 +80872,7 @@ async function drainAndStopLocalDaemonBeforeCredentialCleanup(args, stored) {
       `Logout could not safely drain the local daemon (HTTP ${prepare.status}). Stop or update the local service before removing credentials.`
     );
   }
-  const shutdown = await fetch(`http://127.0.0.1:${localApiPort}/shutdown?force=1`, {
-    method: "POST",
-    headers: {
-      authorization: `Bearer ${localApiToken}`,
-      "x-alan-shutdown-reason": "runtime_shutdown"
-    },
-    signal: AbortSignal.timeout(5e3)
-  });
+  const shutdown = await requestLocalDaemonShutdown(localApiPort, localApiToken);
   if (!shutdown.ok) {
     throw new Error(`Logout could not stop the local daemon (HTTP ${shutdown.status}).`);
   }
@@ -81018,6 +81033,9 @@ async function printDoctor(args = []) {
   );
 }
 
+// src/install-command.ts
+var import_promises6 = require("timers/promises");
+
 // src/mcp-config-adapters.ts
 var import_node_crypto20 = require("crypto");
 var import_node_fs23 = require("fs");
@@ -82402,12 +82420,14 @@ function runMcpIntegrationCommand(args, options = {}) {
 
 // src/service-manager.ts
 var import_node_child_process9 = require("child_process");
+var import_node_crypto21 = require("crypto");
 var import_node_fs25 = require("fs");
 var import_node_os16 = require("os");
 var import_node_path27 = require("path");
 var SERVICE_LABEL = "ai.tryalan.agent";
 var SYSTEMD_UNIT = "alan-agent.service";
 var WINDOWS_TASK = "Alan Agent";
+var STOP_POLL_INTERVAL_MS = 200;
 function xml(value2) {
   return value2.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
 }
@@ -82417,6 +82437,18 @@ function systemdArg(value2) {
 function powershellLiteral(value2) {
   return `'${value2.replaceAll("'", "''")}'`;
 }
+function powershellCommand(script, tolerateFailure = false) {
+  return {
+    command: "powershell.exe",
+    args: ["-NoProfile", "-NonInteractive", "-Command", script],
+    tolerateFailure
+  };
+}
+function windowsCommandLineArgument(value2) {
+  if (value2 && !/[\s"]/u.test(value2)) return value2;
+  const escaped = value2.replace(/(\\*)"/gu, (_match, slashes) => `${slashes}${slashes}\\"`).replace(/\\+$/u, (slashes) => `${slashes}${slashes}`);
+  return `"${escaped}"`;
+}
 function serviceNames(profile) {
   if (profile === "production") {
     return { launchd: SERVICE_LABEL, systemd: SYSTEMD_UNIT, windows: WINDOWS_TASK };
@@ -82438,7 +82470,7 @@ function buildDaemonServicePlan(input2) {
     const domain2 = `gui/${userId}`;
     const serviceTarget = `${domain2}/${names.launchd}`;
     const manifestPath = (0, import_node_path27.join)(input2.homeDir, "Library", "LaunchAgents", `${names.launchd}.plist`);
-    const logDir = (0, import_node_path27.join)(resolveAgentConfigDirectory(input2.profile, input2.homeDir), "logs");
+    const logDir2 = (0, import_node_path27.join)(resolveAgentConfigDirectory(input2.profile, input2.homeDir), "logs");
     const programArguments = daemonArgs.map((arg) => `    <string>${xml(arg)}</string>`).join("\n");
     const environmentEntries = Object.entries(input2.environment ?? {}).map(([key, value2]) => `    <key>${xml(key)}</key>
     <string>${xml(value2)}</string>`).join("\n");
@@ -82467,9 +82499,9 @@ ${environmentBlock}  <key>RunAtLoad</key>
   <key>ThrottleInterval</key>
   <integer>5</integer>
   <key>StandardOutPath</key>
-  <string>${xml((0, import_node_path27.join)(logDir, "daemon.log"))}</string>
+  <string>${xml((0, import_node_path27.join)(logDir2, "daemon.log"))}</string>
   <key>StandardErrorPath</key>
-  <string>${xml((0, import_node_path27.join)(logDir, "daemon-error.log"))}</string>
+  <string>${xml((0, import_node_path27.join)(logDir2, "daemon-error.log"))}</string>
 </dict>
 </plist>
 `;
@@ -82477,7 +82509,7 @@ ${environmentBlock}  <key>RunAtLoad</key>
       platform: "darwin",
       manifestPath,
       manifest,
-      logDirectory: logDir,
+      logDirectory: logDir2,
       loadDefinitionCommands: [
         {
           command: "launchctl",
@@ -82518,23 +82550,6 @@ ${environmentBlock}  <key>RunAtLoad</key>
           tolerateFailure: true
         }
       ],
-      replaceCommands: [
-        {
-          command: "launchctl",
-          args: ["bootout", domain2, manifestPath],
-          tolerateFailure: true
-        },
-        {
-          command: "launchctl",
-          args: ["bootstrap", domain2, manifestPath],
-          tolerateFailure: false
-        },
-        {
-          command: "launchctl",
-          args: ["kickstart", "-k", serviceTarget],
-          tolerateFailure: false
-        }
-      ],
       uninstallCommands: [
         {
           command: "launchctl",
@@ -82551,8 +82566,7 @@ ${environmentBlock}  <key>RunAtLoad</key>
         command: "launchctl",
         args: ["print", serviceTarget],
         tolerateFailure: true
-      },
-      lingerStatusCommand: null
+      }
     };
   }
   if (input2.platform === "linux") {
@@ -82615,18 +82629,6 @@ WantedBy=default.target
           tolerateFailure: true
         }
       ],
-      replaceCommands: [
-        {
-          command: "systemctl",
-          args: ["--user", "daemon-reload"],
-          tolerateFailure: false
-        },
-        {
-          command: "systemctl",
-          args: ["--user", "restart", names.systemd],
-          tolerateFailure: false
-        }
-      ],
       uninstallCommands: [
         {
           command: "systemctl",
@@ -82648,117 +82650,174 @@ WantedBy=default.target
         command: "systemctl",
         args: ["--user", "is-active", names.systemd],
         tolerateFailure: true
-      },
-      lingerStatusCommand: {
-        command: "loginctl",
-        args: ["show-user", "$(id -un)", "-p", "Linger"],
-        tolerateFailure: true
       }
     };
   }
-  const environmentPrefix = Object.entries(input2.environment ?? {}).map(([key, value2]) => `$env:${key} = ${powershellLiteral(value2)}`).join("; ");
-  const directArgument = [input2.cliEntry, "daemon", "--profile", input2.profile].map((part) => part.includes(" ") ? `"${part}"` : part).join(" ");
-  const executable = powershellLiteral(environmentPrefix ? "powershell.exe" : input2.nodeExecutable);
-  const argument = powershellLiteral(
-    environmentPrefix ? `-NoProfile -NonInteractive -WindowStyle Hidden -Command "${environmentPrefix}; & ${powershellLiteral(input2.nodeExecutable)} ${powershellLiteral(input2.cliEntry)} daemon --profile ${input2.profile}"` : directArgument
+  const logDir = import_node_path27.win32.join(resolveAgentConfigDirectory(input2.profile, input2.homeDir), "logs");
+  const legacyEnvironmentPrefix = Object.entries(input2.environment ?? {}).map(([key, value2]) => `$env:${key} = ${powershellLiteral(value2)}`).join("; ");
+  const legacyDirectArguments = [input2.cliEntry, "daemon", "--profile", input2.profile].map((part) => part.includes(" ") ? `"${part}"` : part).join(" ");
+  const legacyExecutable = legacyEnvironmentPrefix ? "powershell.exe" : input2.nodeExecutable;
+  const legacyArguments = legacyEnvironmentPrefix ? `-NoProfile -NonInteractive -WindowStyle Hidden -Command "${legacyEnvironmentPrefix}; & ${powershellLiteral(input2.nodeExecutable)} ${powershellLiteral(input2.cliEntry)} daemon --profile ${input2.profile}"` : legacyDirectArguments;
+  const daemonArguments = [input2.cliEntry, "daemon", "--profile", input2.profile].map(windowsCommandLineArgument).join(" ");
+  const environmentStatements = Object.entries(input2.environment ?? {}).map(
+    ([key, value2]) => `$startInfo.EnvironmentVariables[${powershellLiteral(key)}] = ${powershellLiteral(value2)}`
   );
+  const launcherScript = [
+    "$ErrorActionPreference = 'Stop'",
+    "$startInfo = [System.Diagnostics.ProcessStartInfo]::new()",
+    `$startInfo.FileName = ${powershellLiteral(input2.nodeExecutable)}`,
+    `$startInfo.Arguments = ${powershellLiteral(daemonArguments)}`,
+    `$startInfo.WorkingDirectory = ${powershellLiteral(import_node_path27.win32.dirname(input2.cliEntry))}`,
+    "$startInfo.UseShellExecute = $false",
+    "$startInfo.CreateNoWindow = $true",
+    "$startInfo.RedirectStandardOutput = $true",
+    "$startInfo.RedirectStandardError = $true",
+    ...environmentStatements,
+    `$stdout = [System.IO.File]::Open(${powershellLiteral(import_node_path27.win32.join(logDir, "daemon-launcher.log"))}, [System.IO.FileMode]::Create, [System.IO.FileAccess]::Write, [System.IO.FileShare]::ReadWrite)`,
+    `$stderr = [System.IO.File]::Open(${powershellLiteral(import_node_path27.win32.join(logDir, "daemon-launcher-error.log"))}, [System.IO.FileMode]::Create, [System.IO.FileAccess]::Write, [System.IO.FileShare]::ReadWrite)`,
+    "$process = [System.Diagnostics.Process]::new()",
+    "$process.StartInfo = $startInfo",
+    "try { if (-not $process.Start()) { throw 'Alan daemon process did not start' }; $stdoutCopy = $process.StandardOutput.BaseStream.CopyToAsync($stdout); $stderrCopy = $process.StandardError.BaseStream.CopyToAsync($stderr); $process.WaitForExit(); [System.Threading.Tasks.Task]::WaitAll([System.Threading.Tasks.Task[]]@($stdoutCopy, $stderrCopy)); $exitCode = $process.ExitCode } finally { $stdout.Dispose(); $stderr.Dispose(); $process.Dispose() }",
+    "exit $exitCode"
+  ].join("; ");
+  const executable = powershellLiteral("powershell.exe");
+  const launcherArguments = `-NoProfile -NonInteractive -WindowStyle Hidden -EncodedCommand ${Buffer.from(launcherScript, "utf16le").toString("base64")}`;
+  const settingsScript = "New-ScheduledTaskSettingsSet -RestartCount 3 -RestartInterval (New-TimeSpan -Minutes 1) -ExecutionTimeLimit ([TimeSpan]::Zero) -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries";
+  const ownerMarker = `Alan daemon owner v1 ${(0, import_node_crypto21.createHash)("sha256").update(
+    JSON.stringify({
+      executable: input2.nodeExecutable,
+      cliEntry: input2.cliEntry,
+      profile: input2.profile,
+      taskBaseName: names.windows
+    })
+  ).digest("hex")}`;
+  const definitionMarker = `${ownerMarker}; definition v3 ${(0, import_node_crypto21.createHash)("sha256").update(
+    JSON.stringify({
+      executable: "powershell.exe",
+      launcherArguments,
+      workingDirectory: import_node_path27.win32.dirname(input2.cliEntry),
+      settingsScript,
+      taskBaseName: names.windows
+    })
+  ).digest("hex")}`;
+  const windowsDefinitionContext = [
+    `$expectedLauncherArguments = ${powershellLiteral(launcherArguments)}`,
+    `$expectedWorkingDirectory = ${powershellLiteral(import_node_path27.win32.dirname(input2.cliEntry))}`,
+    `$expectedOwnerMarker = ${powershellLiteral(`${ownerMarker};`)}`,
+    `$expectedDefinitionMarker = ${powershellLiteral(definitionMarker)}`,
+    `$expectedLegacyExecutable = ${powershellLiteral(legacyExecutable)}`,
+    `$expectedLegacyArguments = ${powershellLiteral(legacyArguments)}`
+  ].join("; ");
+  const taskContext = [
+    "$currentIdentity = [System.Security.Principal.WindowsIdentity]::GetCurrent()",
+    "$currentUser = $currentIdentity.Name",
+    "$currentSid = $currentIdentity.User.Value",
+    `$taskName = ${powershellLiteral(names.windows)} + ' ' + $currentSid`
+  ].join("; ");
+  const resolveTaskSid = "function Resolve-TaskSid([string]$value) { try { return ([System.Security.Principal.NTAccount]$value).Translate([System.Security.Principal.SecurityIdentifier]).Value } catch { try { return [System.Security.Principal.SecurityIdentifier]::new($value).Value } catch { return '' } } }";
+  const currentLookup = "$task = @(Get-ScheduledTask -ErrorAction Stop | Where-Object { $_.TaskPath -eq '\\' -and $_.TaskName -eq $taskName })[0]";
+  const checkCurrentOwnership = [
+    currentLookup,
+    "$currentOwned = $false",
+    "if ($null -ne $task) { try {",
+    "$taskAction = @($task.Actions)[0]",
+    "$currentOwned = @($task.Actions).Count -eq 1 -and (Resolve-TaskSid ([string]$task.Principal.UserId)) -eq $currentSid -and (([string]$task.Description).StartsWith($expectedOwnerMarker, [System.StringComparison]::Ordinal) -or (([string]$taskAction.Execute) -ieq 'powershell.exe' -and ([string]$taskAction.Arguments) -ceq $expectedLauncherArguments -and ([string]$taskAction.WorkingDirectory) -ieq $expectedWorkingDirectory))",
+    "} catch { $currentOwned = $false } }"
+  ].join("; ");
+  const legacyLookup = `$legacyTask = @(Get-ScheduledTask -ErrorAction Stop | Where-Object { $_.TaskPath -eq '\\' -and $_.TaskName -eq ${powershellLiteral(names.windows)} })[0]`;
+  const checkLegacyOwnership = [
+    legacyLookup,
+    "$legacyOwned = $false",
+    "$legacyState = 'Missing'",
+    "if ($null -ne $legacyTask) { try {",
+    "$legacyState = [string]$legacyTask.State",
+    "$legacySid = Resolve-TaskSid ([string]$legacyTask.Principal.UserId)",
+    "$legacyAction = @($legacyTask.Actions)[0]",
+    "if ($null -ne $legacyAction) {",
+    "$legacyOwned = $legacySid -eq $currentSid -and @($legacyTask.Actions).Count -eq 1 -and ((([string]$legacyAction.Execute) -ieq $expectedLegacyExecutable -and ([string]$legacyAction.Arguments) -ieq $expectedLegacyArguments -and ([string]$legacyAction.WorkingDirectory) -eq '') -or (([string]$legacyAction.Execute) -ieq 'powershell.exe' -and ([string]$legacyAction.Arguments) -ceq $expectedLauncherArguments -and ([string]$legacyAction.WorkingDirectory) -ieq $expectedWorkingDirectory))",
+    "}",
+    "} catch { $legacyOwned = $false } }"
+  ].join("; ");
+  const assertOwnedTasks = [
+    checkCurrentOwnership,
+    checkLegacyOwnership,
+    `if ($null -ne $task -and -not $currentOwned) { throw ${powershellLiteral(`${names.windows} task is not owned by this Alan installation`)} }`,
+    `if ($null -ne $legacyTask -and -not $legacyOwned) { throw ${powershellLiteral(`Legacy ${names.windows} task is not owned by this Alan installation`)} }`,
+    "if ($null -ne $task -and @('Ready', 'Disabled', 'Queued') -notcontains ([string]$task.State)) { throw 'Alan daemon task became active or has unknown state' }",
+    "if ($null -ne $legacyTask -and @('Ready', 'Disabled', 'Queued') -notcontains ([string]$legacyTask.State)) { throw 'Legacy Alan daemon task became active or has unknown state' }"
+  ].join("; ");
+  const cleanupLegacyTask = [
+    checkLegacyOwnership,
+    `if ($null -ne $legacyTask -and -not $legacyOwned) { throw ${powershellLiteral(`Legacy ${names.windows} task is not owned by this Alan installation`)} }`,
+    "if ($null -ne $legacyTask -and @('Ready', 'Disabled', 'Queued') -notcontains ([string]$legacyTask.State)) { throw 'Legacy Alan daemon task became active or has unknown state' }",
+    `if ($null -ne $legacyTask) { Unregister-ScheduledTask -TaskName ${powershellLiteral(names.windows)} -TaskPath '\\' -Confirm:$false -ErrorAction Stop }`,
+    `$legacyRemaining = @(Get-ScheduledTask -ErrorAction Stop | Where-Object { $_.TaskPath -eq '\\' -and $_.TaskName -eq ${powershellLiteral(names.windows)} })[0]`,
+    "if ($null -ne $legacyRemaining) { throw 'Legacy Alan daemon task still exists after migration' }"
+  ].join("; ");
   const registerScript = [
-    "$currentUser = [System.Security.Principal.WindowsIdentity]::GetCurrent().Name",
-    `$action = New-ScheduledTaskAction -Execute ${executable} -Argument ${argument}`,
+    taskContext,
+    resolveTaskSid,
+    windowsDefinitionContext,
+    `$action = New-ScheduledTaskAction -Execute ${executable} -Argument $expectedLauncherArguments -WorkingDirectory $expectedWorkingDirectory`,
     "$trigger = New-ScheduledTaskTrigger -AtLogOn -User $currentUser",
     "$principal = New-ScheduledTaskPrincipal -UserId $currentUser -LogonType Interactive -RunLevel Limited",
-    "$settings = New-ScheduledTaskSettingsSet -RestartCount 3 -RestartInterval (New-TimeSpan -Minutes 1) -ExecutionTimeLimit ([TimeSpan]::Zero)",
-    `Register-ScheduledTask -TaskName ${powershellLiteral(names.windows)} -Action $action -Trigger $trigger -Principal $principal -Settings $settings -Force | Out-Null`
+    `$settings = ${settingsScript}`,
+    assertOwnedTasks,
+    "Register-ScheduledTask -TaskName $taskName -Description $expectedDefinitionMarker -Action $action -Trigger $trigger -Principal $principal -Settings $settings -Force -ErrorAction Stop | Out-Null",
+    cleanupLegacyTask,
+    "$registeredTask = @(Get-ScheduledTask -ErrorAction Stop | Where-Object { $_.TaskPath -eq '\\' -and $_.TaskName -eq $taskName })[0]",
+    "if ($null -eq $registeredTask -or $registeredTask.Description -cne $expectedDefinitionMarker) { throw 'Alan daemon task definition was not applied' }"
+  ].join("; ");
+  const uninstallScript = [
+    taskContext,
+    resolveTaskSid,
+    windowsDefinitionContext,
+    assertOwnedTasks,
+    "if ($null -ne $legacyTask) { Unregister-ScheduledTask -TaskName $legacyTask.TaskName -TaskPath $legacyTask.TaskPath -Confirm:$false -ErrorAction Stop }",
+    "$task = @(Get-ScheduledTask -ErrorAction Stop | Where-Object { $_.TaskPath -eq '\\' -and $_.TaskName -eq $taskName })[0]",
+    "if ($null -ne $task) { Unregister-ScheduledTask -TaskName $taskName -TaskPath '\\' -Confirm:$false -ErrorAction Stop }",
+    "$remaining = @(Get-ScheduledTask -ErrorAction Stop | Where-Object { $_.TaskPath -eq '\\' -and ($_.TaskName -eq $taskName -or $_.TaskName -eq $legacyTask.TaskName) })",
+    "if ($remaining.Count -gt 0) { throw 'Alan daemon task still exists after unregister' }"
   ].join("; ");
+  const statusScript = [
+    taskContext,
+    resolveTaskSid,
+    windowsDefinitionContext,
+    checkCurrentOwnership,
+    checkLegacyOwnership,
+    "$definitionMatches = $false",
+    "if ($null -eq $task) { Write-Output 'State: Missing' } else {",
+    "$taskTrigger = @($task.Triggers)[0]",
+    "$definitionMatches = @($task.Actions).Count -eq 1 -and @($task.Triggers).Count -eq 1 -and $task.Description -ceq $expectedDefinitionMarker -and (Resolve-TaskSid ([string]$task.Principal.UserId)) -eq $currentSid -and [string]$task.Principal.LogonType -eq 'Interactive' -and [string]$task.Principal.RunLevel -eq 'Limited' -and [string]$taskAction.Execute -ieq 'powershell.exe' -and [string]$taskAction.Arguments -ceq $expectedLauncherArguments -and [string]$taskAction.WorkingDirectory -ieq $expectedWorkingDirectory -and $taskTrigger.CimClass.CimClassName -eq 'MSFT_TaskLogonTrigger' -and (Resolve-TaskSid ([string]$taskTrigger.UserId)) -eq $currentSid -and -not $task.Settings.DisallowStartIfOnBatteries -and -not $task.Settings.StopIfGoingOnBatteries -and $task.Settings.RestartCount -eq 3 -and [string]$task.Settings.RestartInterval -eq 'PT1M' -and [string]$task.Settings.ExecutionTimeLimit -eq 'PT0S'",
+    "Write-Output ('TaskName: ' + $task.TaskName); Write-Output ('State: ' + $task.State); Write-Output ('Definition: ' + $task.Description)",
+    "}",
+    "Write-Output ('DefinitionMatch: ' + $definitionMatches)",
+    "Write-Output ('CurrentOwned: ' + $currentOwned)",
+    "$legacyPresent = $null -ne $legacyTask",
+    "Write-Output ('LegacyTask: ' + $legacyPresent)",
+    "Write-Output ('LegacyOwned: ' + $legacyOwned)",
+    "Write-Output ('LegacyState: ' + $legacyState)"
+  ].join("; ");
+  const registerCommand = powershellCommand(registerScript);
   return {
     platform: "win32",
     manifestPath: null,
     manifest: null,
-    logDirectory: null,
-    loadDefinitionCommands: [
-      {
-        command: "powershell.exe",
-        args: ["-NoProfile", "-NonInteractive", "-Command", registerScript],
-        tolerateFailure: false
-      }
-    ],
-    reloadDefinitionCommands: [
-      {
-        command: "powershell.exe",
-        args: ["-NoProfile", "-NonInteractive", "-Command", registerScript],
-        tolerateFailure: false
-      }
-    ],
+    logDirectory: logDir,
+    loadDefinitionCommands: [registerCommand],
+    reloadDefinitionCommands: [registerCommand],
     enableCommands: [],
-    startCommands: [
-      {
-        command: "powershell.exe",
-        args: [
-          "-NoProfile",
-          "-NonInteractive",
-          "-Command",
-          `Start-ScheduledTask -TaskName ${powershellLiteral(names.windows)}`
-        ],
-        tolerateFailure: false
-      }
-    ],
+    startCommands: [powershellCommand(`${taskContext}; Start-ScheduledTask -TaskName $taskName`)],
     stopCommands: [
-      {
-        command: "powershell.exe",
-        args: [
-          "-NoProfile",
-          "-NonInteractive",
-          "-Command",
-          `Stop-ScheduledTask -TaskName ${powershellLiteral(names.windows)} -ErrorAction SilentlyContinue`
-        ],
-        tolerateFailure: true
-      }
-    ],
-    replaceCommands: [
-      {
-        command: "powershell.exe",
-        args: [
-          "-NoProfile",
-          "-NonInteractive",
-          "-Command",
-          `${registerScript}; Start-ScheduledTask -TaskName ${powershellLiteral(names.windows)}`
-        ],
-        tolerateFailure: false
-      }
-    ],
-    uninstallCommands: [
-      {
-        command: "powershell.exe",
-        args: [
-          "-NoProfile",
-          "-NonInteractive",
-          "-Command",
-          `Unregister-ScheduledTask -TaskName ${powershellLiteral(names.windows)} -Confirm:$false -ErrorAction SilentlyContinue`
-        ],
-        tolerateFailure: true
-      }
+      powershellCommand(
+        `${taskContext}; Stop-ScheduledTask -TaskName $taskName -ErrorAction SilentlyContinue`,
+        true
+      )
     ],
-    statusCommand: {
-      command: "powershell.exe",
-      args: [
-        "-NoProfile",
-        "-NonInteractive",
-        "-Command",
-        `Get-ScheduledTask -TaskName ${powershellLiteral(names.windows)} | Format-List TaskName,State`
-      ],
-      tolerateFailure: true
-    },
-    isActiveCommand: {
-      command: "powershell.exe",
-      args: [
-        "-NoProfile",
-        "-NonInteractive",
-        "-Command",
-        `(Get-ScheduledTask -TaskName ${powershellLiteral(names.windows)} -ErrorAction SilentlyContinue).State`
-      ],
-      tolerateFailure: true
-    },
-    lingerStatusCommand: null
+    uninstallCommands: [powershellCommand(uninstallScript)],
+    statusCommand: powershellCommand(statusScript, true),
+    isActiveCommand: powershellCommand(statusScript, true),
+    definitionMarker
   };
 }
 function resolveCurrentPlatform() {
@@ -82768,16 +82827,16 @@ function resolveCurrentPlatform() {
   }
   return currentPlatform;
 }
-function currentServicePlan(args, runtime) {
-  const currentPlatform = resolveCurrentPlatform();
+function currentServicePlan(args, runtime, options = {}) {
+  const currentPlatform = options.platform ?? resolveCurrentPlatform();
   const profile = resolveEndpointProfileFromArgs(args);
   const cliEntry = runtime?.cliEntry ?? process.argv[1];
   if (!cliEntry) throw new Error("Cannot determine the alan-agent executable path");
   return buildDaemonServicePlan({
     platform: currentPlatform,
-    homeDir: (0, import_node_os16.homedir)(),
+    homeDir: options.homeDir ?? (0, import_node_os16.homedir)(),
     nodeExecutable: runtime?.executable ?? process.execPath,
-    cliEntry: (0, import_node_path27.resolve)(cliEntry),
+    cliEntry: currentPlatform === "win32" ? import_node_path27.win32.resolve(cliEntry) : (0, import_node_path27.resolve)(cliEntry),
     profile,
     environment: runtime?.environment
   });
@@ -82797,10 +82856,14 @@ function defaultReadManifest(path2) {
   if (!(0, import_node_fs25.existsSync)(path2)) return null;
   return (0, import_node_fs25.readFileSync)(path2, "utf8");
 }
-function runServiceCommand(command) {
-  const result = (0, import_node_child_process9.spawnSync)(command.command, command.args, { encoding: "utf8", shell: false });
+function runServiceCommand(command, timeoutMs = 15e3) {
+  const result = (0, import_node_child_process9.spawnSync)(command.command, command.args, {
+    encoding: "utf8",
+    shell: false,
+    ...(0, import_node_os16.platform)() === "win32" ? { timeout: timeoutMs, windowsHide: true } : {}
+  });
   const status = result.status ?? 1;
-  const output2 = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
+  const output2 = `${result.stdout ?? ""}${result.stderr ?? ""}${result.error?.message ?? ""}`.trim();
   if (status !== 0 && !command.tolerateFailure) {
     throw new Error(
       `Service command failed (${command.command} ${command.args.join(" ")}): ${output2 || `exit ${status}`}`
@@ -82813,6 +82876,23 @@ function defaultSleep(ms) {
     setTimeout(resolveSleep, ms);
   });
 }
+function isProcessAlive(pid) {
+  if (pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error61) {
+    return error61.code === "EPERM";
+  }
+}
+async function requestWindowsDaemonShutdown(owner) {
+  try {
+    const response = await requestLocalDaemonShutdown(owner.localApiPort, owner.localApiToken);
+    return response.ok ? "accepted" : "rejected";
+  } catch {
+    return "unreachable";
+  }
+}
 function parseServiceHostState(servicePlatform, result) {
   const output2 = result.output;
   if (servicePlatform === "linux") {
@@ -82838,9 +82918,69 @@ function parseServiceHostState(servicePlatform, result) {
   const stateMatch = output2.match(/\b(?:State|state)\s*[:=]\s*(\w+)/);
   const state = (stateMatch?.[1] ?? output2.trim()).toLowerCase();
   if (state === "running") return "running";
-  if (state === "ready" || state === "disabled" || state === "queued") return "stopped";
+  if (state === "queued") return "starting";
+  if (state === "ready" || state === "disabled") return "stopped";
   return "unknown";
 }
+function parseWindowsTaskInspection(result) {
+  if (result.status !== 0) {
+    throw new Error("Cannot inspect Windows daemon task definition");
+  }
+  const value2 = (name) => {
+    const match = result.output.match(new RegExp(`^${name}:\\s*(.*)$`, "imu"));
+    if (!match) throw new Error(`Incomplete Windows daemon task inspection: missing ${name}`);
+    return match[1]?.trim() ?? "";
+  };
+  const boolean4 = (name) => {
+    const parsed = value2(name).toLowerCase();
+    if (parsed === "true") return true;
+    if (parsed === "false") return false;
+    throw new Error(`Incomplete Windows daemon task inspection: invalid ${name}`);
+  };
+  const currentPresent = /^TaskName:\s*.+$/imu.test(result.output);
+  const currentStateValue = value2("State");
+  const currentOwned = boolean4("CurrentOwned");
+  const definitionMatches = boolean4("DefinitionMatch");
+  const legacyPresent = boolean4("LegacyTask");
+  const legacyOwned = boolean4("LegacyOwned");
+  const legacyStateValue = value2("LegacyState");
+  if (currentPresent !== (currentStateValue.toLowerCase() !== "missing")) {
+    throw new Error("Incomplete Windows daemon task inspection: inconsistent current task state");
+  }
+  if (!currentPresent && (currentOwned || definitionMatches)) {
+    throw new Error(
+      "Incomplete Windows daemon task inspection: absent current task is marked owned"
+    );
+  }
+  if (legacyPresent !== (legacyStateValue.toLowerCase() !== "missing") || !legacyPresent && legacyOwned) {
+    throw new Error("Incomplete Windows daemon task inspection: inconsistent legacy task state");
+  }
+  return {
+    currentPresent,
+    currentOwned,
+    currentState: currentPresent ? parseServiceHostState("win32", { status: 0, output: currentStateValue }) : "stopped",
+    definitionMatches,
+    definitionMarker: result.output.match(/^Definition:\s*(.+)$/imu)?.[1]?.trim(),
+    legacyPresent,
+    legacyOwned,
+    legacyState: legacyPresent ? parseServiceHostState("win32", { status: 0, output: legacyStateValue }) : "stopped"
+  };
+}
+function windowsTaskHostState(tasks) {
+  const states = [tasks.currentState, tasks.legacyState];
+  if (states.includes("unknown")) return "unknown";
+  if (states.includes("running")) return "running";
+  if (states.includes("starting")) return "starting";
+  return "stopped";
+}
+function assertWindowsTaskOwnership(tasks) {
+  if (tasks.currentPresent && !tasks.currentOwned) {
+    throw new Error("Windows daemon task is not owned by this Alan installation");
+  }
+  if (tasks.legacyPresent && !tasks.legacyOwned) {
+    throw new Error("Legacy Windows daemon task is not owned by this Alan installation");
+  }
+}
 function resolveEnsureDefinitionOutcome(input2) {
   if (!input2.definitionChanged) {
     return { changed: false, updatePending: false };
@@ -82850,9 +82990,6 @@ function resolveEnsureDefinitionOutcome(input2) {
   }
   return { changed: true, updatePending: false };
 }
-function shouldStartOnInstall(hostState) {
-  return hostState === "stopped";
-}
 function resolveUsername(options) {
   if (options?.username) return options.username;
   try {
@@ -82861,17 +82998,14 @@ function resolveUsername(options) {
     return process.env.USER || process.env.USERNAME || "unknown";
   }
 }
-function buildLingerStatusCommand(username) {
-  return {
-    command: "loginctl",
-    args: ["show-user", username, "-p", "Linger"],
-    tolerateFailure: true
-  };
-}
 function assertSystemdUserLingerEnabled(options = {}) {
   const username = resolveUsername(options);
   const run = options.runCommand ?? runServiceCommand;
-  const result = run(buildLingerStatusCommand(username));
+  const result = run({
+    command: "loginctl",
+    args: ["show-user", username, "-p", "Linger"],
+    tolerateFailure: true
+  });
   if (result.status !== 0) {
     throw new Error(
       `Cannot verify systemd user linger for ${username} (loginctl failed). For durable headless VM boot run: sudo loginctl enable-linger ${username}`
@@ -82885,10 +83019,18 @@ function assertSystemdUserLingerEnabled(options = {}) {
 }
 function createHostContext(options = {}) {
   const args = options.args ?? [];
-  const plan = currentServicePlan(args, options.runtime);
-  const run = options.runCommand ?? runServiceCommand;
-  const sleep4 = options.sleep ?? defaultSleep;
+  const plan = currentServicePlan(args, options.runtime, options);
+  const sleep5 = options.sleep ?? defaultSleep;
   const nowMs = options.nowMs ?? Date.now;
+  const run = (command) => {
+    const remainingMs = options.deadlineMs === void 0 ? 15e3 : options.deadlineMs - nowMs();
+    if (remainingMs <= 0) throw new Error("Windows service setup deadline expired");
+    const result = options.runCommand ? options.runCommand(command) : runServiceCommand(command, Math.min(15e3, remainingMs));
+    if (options.deadlineMs !== void 0 && nowMs() >= options.deadlineMs) {
+      throw new Error("Windows service setup deadline expired");
+    }
+    return result;
+  };
   const readManifest = options.readManifest ?? defaultReadManifest;
   const writeManifest = options.writeManifest ?? writeManifestAtomic;
   const removeManifest = options.removeManifest ?? ((path2) => (0, import_node_fs25.rmSync)(path2, { force: true }));
@@ -82899,19 +83041,37 @@ function createHostContext(options = {}) {
     args,
     plan,
     run,
-    sleep: sleep4,
+    sleep: sleep5,
     nowMs,
     readManifest,
     writeManifest,
     removeManifest,
     ensureLogDir,
-    profile: resolveEndpointProfileFromArgs(args)
+    configPath: options.configPath ?? resolveAgentConfigPath({ profile: resolveEndpointProfileFromArgs(args) }),
+    readOwner: options.readOwner ?? readLocalDaemonOwnerLease,
+    isProcessAlive: options.isProcessAlive ?? isProcessAlive,
+    probeEndpoint: options.probeEndpoint ?? probeLocalDaemonEndpoint,
+    requestWindowsShutdown: options.requestWindowsShutdown ?? requestWindowsDaemonShutdown,
+    inspectJournal: options.inspectJournal ?? inspectLocalDaemonRunJournal,
+    acquireMaintenance: options.acquireMaintenance ?? acquireLocalDaemonMaintenanceLease,
+    releaseMaintenance: options.releaseMaintenance ?? releaseLocalDaemonMaintenanceLease
   };
 }
 function inspectDaemonService(options = {}) {
   const { plan, run, nowMs } = createHostContext(options);
   const result = run(plan.isActiveCommand);
-  const state = parseServiceHostState(plan.platform, result);
+  let state;
+  if (plan.platform === "win32") {
+    try {
+      const tasks = parseWindowsTaskInspection(result);
+      assertWindowsTaskOwnership(tasks);
+      state = windowsTaskHostState(tasks);
+    } catch {
+      state = "unknown";
+    }
+  } else {
+    state = parseServiceHostState(plan.platform, result);
+  }
   return {
     state,
     platform: plan.platform,
@@ -82921,8 +83081,9 @@ function inspectDaemonService(options = {}) {
 }
 function ensureDaemonServiceDefinition(options = {}) {
   const ctx = createHostContext(options);
-  const { plan, run, readManifest, writeManifest, ensureLogDir } = ctx;
+  const { plan, run, nowMs, readManifest, writeManifest, ensureLogDir } = ctx;
   let definitionChanged = false;
+  let inspection;
   if (plan.manifestPath && plan.manifest) {
     ensureLogDir();
     const existing = readManifest(plan.manifestPath);
@@ -82931,20 +83092,37 @@ function ensureDaemonServiceDefinition(options = {}) {
       writeManifest(plan.manifestPath, plan.manifest);
     }
   } else if (plan.platform === "win32") {
-    definitionChanged = true;
+    ensureLogDir();
+    const result = run(plan.statusCommand);
+    const tasks = parseWindowsTaskInspection(result);
+    assertWindowsTaskOwnership(tasks);
+    if (tasks.currentPresent && tasks.currentState === "unknown" || tasks.legacyPresent && tasks.legacyState === "unknown") {
+      throw new Error("Cannot safely update a Windows daemon task with unknown state");
+    }
+    definitionChanged = tasks.definitionMarker !== plan.definitionMarker || !tasks.definitionMatches || tasks.legacyPresent;
+    inspection = {
+      state: windowsTaskHostState(tasks),
+      platform: plan.platform,
+      detail: result.output || void 0,
+      observedAtMs: nowMs()
+    };
   }
-  const inspection = inspectDaemonService(options);
+  inspection ??= inspectDaemonService(options);
+  const definitionHostState = plan.platform === "win32" && inspection.state === "starting" ? "stopped" : inspection.state;
   const outcome = resolveEnsureDefinitionOutcome({
     definitionChanged,
-    hostState: inspection.state
+    hostState: definitionHostState
   });
   if (outcome.updatePending) {
     return outcome;
   }
-  if (inspection.state === "running" || inspection.state === "starting") {
+  if (plan.platform === "win32" && !outcome.changed) {
     return outcome;
   }
-  const definitionCommands = inspection.state === "stopped" ? plan.reloadDefinitionCommands : plan.loadDefinitionCommands;
+  if (definitionHostState === "running" || definitionHostState === "starting") {
+    return outcome;
+  }
+  const definitionCommands = definitionHostState === "stopped" ? plan.reloadDefinitionCommands : plan.loadDefinitionCommands;
   for (const command of definitionCommands) run(command);
   return outcome;
 }
@@ -82956,10 +83134,140 @@ function startDaemonService(options = {}) {
   const { plan, run } = createHostContext(options);
   for (const command of plan.startCommands) run(command);
 }
-function uninstallDaemonService(args = [], options = {}) {
+async function stopDaemonServiceAndWait(identity, timeoutMs, options = {}) {
+  const {
+    plan,
+    run,
+    sleep: sleep5,
+    nowMs,
+    configPath,
+    readOwner,
+    isProcessAlive: processIsAlive,
+    probeEndpoint,
+    requestWindowsShutdown: requestShutdown
+  } = createHostContext(options);
+  let owner;
+  try {
+    owner = readOwner(configPath);
+  } catch {
+    return "identity_changed";
+  }
+  const ownerMatches = (candidate) => candidate.pid === identity.pid && candidate.daemonSessionId === identity.daemonSessionId && candidate.localApiPort === identity.port && (identity.serviceId === void 0 || candidate.localServiceId === identity.serviceId) && (identity.startedAtMs === void 0 || candidate.startedAtMs === identity.startedAtMs);
+  if (!owner || !ownerMatches(owner)) {
+    return "identity_changed";
+  }
+  if (plan.platform === "win32") {
+    const shutdown = await requestShutdown(owner);
+    if (shutdown === "rejected") return "identity_changed";
+    if (shutdown === "unreachable") {
+      for (const command of plan.stopCommands) run(command);
+    }
+    const deadline2 = nowMs() + timeoutMs;
+    while (nowMs() < deadline2) {
+      let currentOwner;
+      try {
+        currentOwner = readOwner(configPath);
+      } catch {
+        return "identity_changed";
+      }
+      if (currentOwner && !ownerMatches(currentOwner)) {
+        return "identity_changed";
+      }
+      if (!processIsAlive(identity.pid)) {
+        const endpoint = await probeEndpoint(identity.port, owner.localApiToken, 250);
+        if (endpoint.state === "absent") return "exited";
+        if (endpoint.state === "listening_unauthorized" || endpoint.status.daemonSessionId !== identity.daemonSessionId) {
+          return "identity_changed";
+        }
+      }
+      await sleep5(STOP_POLL_INTERVAL_MS);
+    }
+    return "timeout";
+  }
+  for (const command of plan.stopCommands) run(command);
+  const deadline = nowMs() + timeoutMs;
+  while (nowMs() < deadline) {
+    const result = run(plan.isActiveCommand);
+    const state = parseServiceHostState(plan.platform, result);
+    if (state === "stopped") return "exited";
+    if (state === "unknown") {
+    } else if (identity.pid > 0) {
+      try {
+        process.kill(identity.pid, 0);
+      } catch {
+        return "exited";
+      }
+    }
+    await sleep5(STOP_POLL_INTERVAL_MS);
+  }
+  return "timeout";
+}
+async function uninstallDaemonService(args = [], options = {}) {
   const ctx = createHostContext({ ...options, args: options.args ?? args });
-  for (const command of ctx.plan.uninstallCommands) ctx.run(command);
-  if (ctx.plan.manifestPath) ctx.removeManifest(ctx.plan.manifestPath);
+  if (ctx.plan.platform === "win32") {
+    const ownership = ctx.run(ctx.plan.statusCommand);
+    let tasks;
+    try {
+      tasks = parseWindowsTaskInspection(ownership);
+    } catch (error61) {
+      throw new Error(
+        `Cannot inspect Windows daemon task ownership before uninstall: ${error61 instanceof Error ? error61.message : String(error61)}`
+      );
+    }
+    assertWindowsTaskOwnership(tasks);
+    if (!tasks.currentPresent && !tasks.legacyPresent) {
+      console.info("[alan-agent] Per-user daemon service removed");
+      return;
+    }
+    const acquired = ctx.acquireMaintenance(ctx.configPath, "watchdog", 3e4);
+    if (!acquired.acquired) {
+      throw new Error("Cannot uninstall the Windows daemon service while maintenance is active");
+    }
+    try {
+      const journal = ctx.inspectJournal(ctx.configPath);
+      if (!journal.safeToRestart) {
+        throw new Error(
+          `Windows daemon service uninstall is deferred while ${journal.activeRunCount} active run${journal.activeRunCount === 1 ? "" : "s"} finish`
+        );
+      }
+      let owner;
+      try {
+        owner = ctx.readOwner(ctx.configPath);
+      } catch (error61) {
+        throw new Error(
+          `Cannot verify Windows daemon ownership before uninstall: ${error61 instanceof Error ? error61.message : String(error61)}`
+        );
+      }
+      if (owner) {
+        const stopped = await stopDaemonServiceAndWait(
+          {
+            pid: owner.pid,
+            serviceId: owner.localServiceId,
+            daemonSessionId: owner.daemonSessionId,
+            port: owner.localApiPort,
+            startedAtMs: owner.startedAtMs
+          },
+          1e4,
+          { ...options, args: ctx.args }
+        );
+        if (stopped !== "exited") {
+          throw new Error(
+            stopped === "identity_changed" ? "Windows daemon ownership changed before uninstall" : "Timed out waiting for the Windows daemon to stop before uninstall"
+          );
+        }
+      } else {
+        if (tasks.currentState !== "stopped" || tasks.legacyState !== "stopped") {
+          throw new Error("Cannot uninstall a running Windows daemon without verified ownership");
+        }
+      }
+      for (const command of ctx.plan.uninstallCommands) ctx.run(command);
+    } finally {
+      ctx.releaseMaintenance(ctx.configPath, acquired.lease.id);
+    }
+  } else {
+    for (const command of ctx.plan.uninstallCommands) ctx.run(command);
+    if (ctx.plan.manifestPath) ctx.removeManifest(ctx.plan.manifestPath);
+  }
   console.info("[alan-agent] Per-user daemon service removed");
 }
 function installDaemonService(args = [], runtime, options = {}) {
@@ -82987,7 +83295,7 @@ function installDaemonService(args = [], runtime, options = {}) {
     });
     return;
   }
-  if (!shouldStartOnInstall(inspection.state)) {
+  if (inspection.state !== "stopped") {
     console.info("[alan-agent] Per-user daemon service already present", {
       profile,
       state: inspection.state
@@ -83011,13 +83319,81 @@ ${result.output}
 }
 
 // src/install-command.ts
-async function runInstallCommand(commandArgs) {
+var WINDOWS_SETUP_READY_TIMEOUT_MS = 9e3;
+async function setupWindowsRuntime(commandArgs) {
+  const deadlineMs = Date.now() + WINDOWS_SETUP_READY_TIMEOUT_MS;
+  const controller = new AbortController();
+  const timeoutError = new Error(
+    "Windows runtime did not become ready within 9 seconds. Credential setup may still complete in the running daemon; it has not been rolled back. Check runtime status and retry the same setup command to reconcile."
+  );
+  let timer;
+  const timeout = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => {
+      controller.abort(timeoutError);
+      reject(timeoutError);
+    }, WINDOWS_SETUP_READY_TIMEOUT_MS);
+  });
+  const remainingMs = () => {
+    const remaining = deadlineMs - Date.now();
+    if (remaining <= 0) throw timeoutError;
+    controller.signal.throwIfAborted();
+    return remaining;
+  };
+  try {
+    const runtimeIdentityChanged = await Promise.race([
+      setupDaemon(commandArgs, { signal: controller.signal }),
+      timeout
+    ]);
+    remainingMs();
+    const { runtimeId, localApiPort, localApiToken } = readConfig();
+    if (!runtimeId || !localApiPort || !localApiToken) {
+      throw new Error("Windows runtime setup completed without a local readiness endpoint");
+    }
+    const probe = () => probeLocalDaemon(localApiPort, localApiToken, Math.min(250, remainingMs()));
+    const poll = () => (0, import_promises6.setTimeout)(Math.min(100, remainingMs()), void 0, { signal: controller.signal });
+    if (runtimeIdentityChanged) {
+      while (true) {
+        const status = await probe();
+        if (status?.runtimeId === runtimeId && status.connected) break;
+        if (!status) {
+          const service = inspectDaemonService({ args: commandArgs, deadlineMs });
+          if (service.state !== "running" && service.state !== "starting") break;
+        }
+        await poll();
+      }
+    }
+    remainingMs();
+    installDaemonService(commandArgs, void 0, { deadlineMs });
+    while (true) {
+      const status = await probe();
+      remainingMs();
+      if (status?.runtimeId === runtimeId && status.connected) return;
+      await poll();
+    }
+  } catch (error61) {
+    if (controller.signal.aborted || Date.now() >= deadlineMs) {
+      controller.abort(timeoutError);
+      throw timeoutError;
+    }
+    throw error61;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function runInstallCommand(commandArgs, currentPlatform = process.platform) {
+  if (currentPlatform === "win32" && commandArgs.includes("--headless")) {
+    throw new Error("--headless is only supported on Linux systemd user services");
+  }
   bindConfigPath(commandArgs);
   const configured = readConfig();
   const configurationMode = resolveInstallConfigurationMode(commandArgs, configured);
-  if (configurationMode === "setup") await setupDaemon(commandArgs);
-  if (configurationMode === "login") await loginWithDeviceCode(commandArgs);
-  installDaemonService(commandArgs);
+  if (currentPlatform === "win32" && configurationMode === "setup") {
+    await setupWindowsRuntime(commandArgs);
+  } else {
+    if (configurationMode === "setup") await setupDaemon(commandArgs);
+    if (configurationMode === "login") await loginWithDeviceCode(commandArgs);
+    installDaemonService(commandArgs);
+  }
   runMcpIntegrationCommand(["reconcile", ...commandArgs]);
 }
 
@@ -86395,7 +86771,7 @@ var REQUEST_STATE_ONLY_LEG_PACING_MS2 = 250;
 function inputRequiredRoundsExceededMessage2(method, maxRounds) {
   return `Multi-round-trip request '${method}' still required input after ${maxRounds} rounds (inputRequired.maxRounds)`;
 }
-function sleep3(ms, signal) {
+function sleep4(ms, signal) {
   return new Promise((resolve15, reject) => {
     if (signal?.aborted) {
       reject(signal.reason instanceof SdkError2 ? signal.reason : new SdkError2(SdkErrorCode2.RequestTimeout, String(signal.reason)));
@@ -94662,7 +95038,7 @@ var LegacyInputRequiredShim = class {
         } finally {
           roundAbort.dispose();
         }
-      } else await sleep3(REQUEST_STATE_ONLY_LEG_PACING_MS2, outerSignal);
+      } else await sleep4(REQUEST_STATE_ONLY_LEG_PACING_MS2, outerSignal);
       let ctxNext = {
         ...ctx,
         mcpReq: {
@@ -95459,7 +95835,7 @@ async function runMcpStdioProxy(env = process.env, local = new StdioServerTransp
 }
 
 // src/native-hook-command.ts
-var import_node_crypto21 = require("crypto");
+var import_node_crypto22 = require("crypto");
 var import_node_fs27 = require("fs");
 var import_node_os17 = require("os");
 var import_node_path29 = require("path");
@@ -95828,7 +96204,7 @@ function parseNativeHookEnvelope(input2) {
   const projectPin = eventType === "session_start" && resolvedCwd ? readAlanProjectPin(resolvedCwd) : void 0;
   return {
     schemaVersion: 1,
-    eventId: (0, import_node_crypto21.randomUUID)(),
+    eventId: (0, import_node_crypto22.randomUUID)(),
     provider: capability.provider,
     eventType,
     observedAt: (input2.now ?? /* @__PURE__ */ new Date()).toISOString(),
@@ -96324,7 +96700,7 @@ function delay2(ms) {
 }
 
 // src/web-presenter.ts
-var import_node_crypto22 = require("crypto");
+var import_node_crypto23 = require("crypto");
 var WebPresenter = class {
   constructor(wsClient, conversationId, cwd) {
     this.conversationId = conversationId;
@@ -96510,7 +96886,7 @@ var WebPresenter = class {
     this.applicationProblem = createAlanProblem({
       domain: "application",
       code: input2.code,
-      id: (0, import_node_crypto22.randomUUID)(),
+      id: (0, import_node_crypto23.randomUUID)(),
       title: APPLICATION_PROBLEM_TITLES[input2.code],
       detail: input2.message,
       // The schema's slot for the technical cause, so the problem carries it
@@ -96580,7 +96956,7 @@ var WebPresenter = class {
 };
 
 // src/ws-client.ts
-var import_node_crypto24 = require("crypto");
+var import_node_crypto25 = require("crypto");
 
 // ../shared/dist/agent-liveness.js
 var AGENT_LIVENESS_PROTOCOL_VERSION = 1;
@@ -96776,13 +97152,13 @@ var AgentResourceSampler = class {
 };
 
 // src/sandbox-outbox.ts
-var import_node_crypto23 = require("crypto");
+var import_node_crypto24 = require("crypto");
 var import_node_fs29 = require("fs");
 function deriveSandboxOutboxKey(sessionToken) {
   if (!sessionToken) {
     throw new Error("sandbox event outbox requires ALAN_SESSION_TOKEN for key derivation");
   }
-  return (0, import_node_crypto23.createHash)("sha256").update(sessionToken, "utf8").digest("base64url");
+  return (0, import_node_crypto24.createHash)("sha256").update(sessionToken, "utf8").digest("base64url");
 }
 function sandboxOutboxSpoolPath(conversationId) {
   return `/tmp/alan-agent-outbox-${conversationId}.enc`;
@@ -96959,7 +97335,7 @@ var WSClient = class {
   }
   socket;
   /** Stable id for this agent process; fences stale heartbeats server-side. */
-  agentSessionId = (0, import_node_crypto24.randomUUID)();
+  agentSessionId = (0, import_node_crypto25.randomUUID)();
   /** Monotonic heartbeat sequence — advances on every hello + heartbeat. */
   heartbeatSeq = 0;
   heartbeatTimer = null;
@@ -97795,7 +98171,7 @@ async function runSandbox(config2) {
 }
 
 // src/skills/skill-cli.ts
-var import_promises6 = require("fs/promises");
+var import_promises7 = require("fs/promises");
 var import_node_os20 = require("os");
 var import_node_path31 = require("path");
 async function runSkillsCommand(args) {
@@ -97842,7 +98218,7 @@ async function defaultScanInput(homeDirectory2) {
 }
 async function readProtectedJson(path2) {
   const absolutePath = (0, import_node_path31.resolve)(path2);
-  const stat2 = await (0, import_promises6.lstat)(absolutePath);
+  const stat2 = await (0, import_promises7.lstat)(absolutePath);
   if (!stat2.isFile()) throw new Error(`Skill input is not a regular file: ${absolutePath}`);
   if (process.platform !== "win32" && (stat2.mode & 63) !== 0) {
     throw new Error(`Skill input must not be accessible by group or other users: ${absolutePath}`);
@@ -97851,7 +98227,7 @@ async function readProtectedJson(path2) {
     throw new Error(`Skill input must be owned by the current user: ${absolutePath}`);
   }
   if (stat2.size > 2 * 1024 * 1024) throw new Error("Skill input exceeds 2 MiB");
-  return JSON.parse(await (0, import_promises6.readFile)(absolutePath, "utf8"));
+  return JSON.parse(await (0, import_promises7.readFile)(absolutePath, "utf8"));
 }
 function option(args, name) {
   const index = args.indexOf(name);
@@ -98009,7 +98385,7 @@ async function main() {
     return;
   }
   if (command === "service" && commandArgs[0] === "uninstall") {
-    uninstallDaemonService(commandArgs.slice(1));
+    await uninstallDaemonService(commandArgs.slice(1));
     return;
   }
   if (command === "service" && commandArgs[0] === "status") {