@huynle/hub 0.9.0 → 0.9.1

package/packages/cli/dist/hub-cli.js

@@ -7,7 +7,7 @@ import { createInterface } from "readline";
 // packages/cli/package.json
 var package_default = {
   name: "@huynle/hub-cli",
-  version: "0.9.0",
+  version: "0.9.1",
   private: true,
   description: "The hub CLI (`hub` / `hubctl`) for agents and scripts (internal; bundled into @huynle/hub, not published on its own).",
   license: "MIT",
@@ -1695,7 +1695,7 @@ var SUPPORTED_TARGETS = Object.freeze([
   { target: "darwin-x64", platform: "darwin", arch: "x64", libc: "none", serviceManager: "launchd", bunTarget: "bun-darwin-x64-baseline" },
   { target: "linux-x64", platform: "linux", arch: "x64", libc: "glibc", serviceManager: "systemd-user", bunTarget: "bun-linux-x64-baseline" },
   { target: "linux-arm64", platform: "linux", arch: "arm64", libc: "glibc", serviceManager: "systemd-user", bunTarget: "bun-linux-arm64" },
-  { target: "windows-x64", platform: "windows", arch: "x64", libc: "none", serviceManager: "none", bunTarget: "bun-windows-x64-baseline" }
+  { target: "windows-x64", platform: "windows", arch: "x64", libc: "none", serviceManager: "task-scheduler", bunTarget: "bun-windows-x64-baseline" }
 ]);
 var UNSUPPORTED_TARGETS = Object.freeze([
   { target: "windows-arm64", reason: "Windows on arm64 has no hubctl build yet (only windows-x64 is built)" },
@@ -1716,7 +1716,7 @@ function checkTarget(target) {
   return fail("", "unsupported_platform", known ? `${target} is not supported: ${known.reason}` : `${target} is not a supported target (supported: ${SUPPORTED_TARGETS.map((t) => t.target).join(", ")})`);
 }
 // packages/cli/src/bootstrap/contracts/paths.ts
-var ROOT_IDS = ["home", "config", "state", "data", "user-bin", "launch-agents", "systemd-user", "system-bin"];
+var ROOT_IDS = ["home", "config", "state", "data", "user-bin", "launch-agents", "systemd-user", "system-bin", "task-defs"];
 var ELEVATED_ROOTS = ["system-bin"];
 var BAD_REL = /[\u0000-\u001f\u007f\\]/;
 function isSafeRel(rel) {
@@ -1798,7 +1798,8 @@ var EMBEDDED_ASSETS = Object.freeze({
   "service/launchd/claude-code": { kind: "launchd-plist", service: "claude-code", manager: "launchd", source: "scripts/io.github.huynle.hub-claude-code.plist", installAs: "io.github.huynle.hub-claude-code.plist" },
   "service/systemd-user/claude-code": { kind: "systemd-unit", service: "claude-code", manager: "systemd-user", source: "scripts/hub-claude-code.service", installAs: "hub-claude-code.service" },
   "service/launchd/codex-spoke": { kind: "launchd-plist", service: "codex-spoke", manager: "launchd", source: "scripts/io.github.huynle.hub-codex-spoke.plist", installAs: "io.github.huynle.hub-codex-spoke.plist" },
-  "service/systemd-user/codex-spoke": { kind: "systemd-unit", service: "codex-spoke", manager: "systemd-user", source: "scripts/hub-codex-spoke.service", installAs: "hub-codex-spoke.service" }
+  "service/systemd-user/codex-spoke": { kind: "systemd-unit", service: "codex-spoke", manager: "systemd-user", source: "scripts/hub-codex-spoke.service", installAs: "hub-codex-spoke.service" },
+  "service/task-scheduler/node": { kind: "task-xml", service: "node", manager: "task-scheduler", source: "scripts/hub-node.task.xml", installAs: "hub-node.xml" }
 });
 // packages/cli/src/bootstrap/contracts/harness.ts
 var HARNESS_ORDER = ["opencode", "claude-code", "codex"];
@@ -1884,6 +1885,7 @@ function createAdapterRegistry() {
 // packages/cli/src/bootstrap/contracts/actions.ts
 var EXEC_KEYS = ["command", "cmd", "commands", "shell", "script", "scripts", "exec", "execute", "argv", "args", "arguments", "run", "eval", "sh", "bash", "program", "spawn", "hook", "hooks"];
 var CONFIG_OWNERS = ["user", "hub", ...HARNESS_ORDER.map((h) => `harness:${h}`)];
+var SERVICE_MANAGERS = ["launchd", "systemd-user", "task-scheduler"];
 var harnessVersionRef = (harness, version) => ({ root: "data", rel: `hub/harnesses/${harness}/${version}` });
 var harnessCurrentRef = (harness) => ({ root: "data", rel: `hub/harnesses/${harness}/current` });
 var COMMON2 = ["id", "kind", "escalation", "summary"];
@@ -1912,7 +1914,7 @@ var ASSET_ID = /^[a-z0-9][a-z0-9._-]*(?:\/[a-z0-9][a-z0-9._-]*)*$/;
 var MACHINE_NAME = /^[A-Za-z0-9._-]{1,64}$/;
 var MCP_NAME = /^[a-z0-9][a-z0-9-]{0,31}$/;
 var JSON_POINTER = /^(?:\/(?:[^~/]|~[01])*)+$/;
-var SERVICE_ROOT = { launchd: "launch-agents", "systemd-user": "systemd-user" };
+var SERVICE_ROOT = Object.freeze({ launchd: "launch-agents", "systemd-user": "systemd-user", "task-scheduler": "task-defs" });
 var EXEC = new Set(EXEC_KEYS);
 function findExecKeys(value, base = "") {
   const found = [];
@@ -2099,7 +2101,7 @@ function checkAction(c, path, value) {
       break;
     case "install-service": {
       oneOf(c, at("service"), r.service, SERVICE_IDS);
-      oneOf(c, at("manager"), r.manager, ["launchd", "systemd-user"]);
+      oneOf(c, at("manager"), r.manager, SERVICE_MANAGERS);
       ref("path");
       digest(c, at("sha256"), r.sha256);
       const asset = typeof r.asset === "string" ? EMBEDDED_ASSETS[r.asset] : undefined;
@@ -2112,18 +2114,18 @@ function checkAction(c, path, value) {
     }
     case "deactivate-service":
       oneOf(c, at("service"), r.service, SERVICE_IDS);
-      oneOf(c, at("manager"), r.manager, ["launchd", "systemd-user"]);
+      oneOf(c, at("manager"), r.manager, SERVICE_MANAGERS);
       break;
     case "remove-service":
       oneOf(c, at("service"), r.service, SERVICE_IDS);
-      oneOf(c, at("manager"), r.manager, ["launchd", "systemd-user"]);
+      oneOf(c, at("manager"), r.manager, SERVICE_MANAGERS);
       ref("path");
       digest(c, at("sha256"), r.sha256);
       checkServiceUnitPath(c, at, r);
       break;
     case "activate-service":
       oneOf(c, at("service"), r.service, SERVICE_IDS);
-      oneOf(c, at("manager"), r.manager, ["launchd", "systemd-user"]);
+      oneOf(c, at("manager"), r.manager, SERVICE_MANAGERS);
       if (r.confirm !== "explicit")
         c.add(at("confirm"), "invalid_value", "services are only activated on explicit confirmation");
       break;
@@ -2257,12 +2259,14 @@ function validateDiscoverySnapshot(value) {
       semver(c, pointer(p, "version"), rt.version);
       absPath(c, pointer(p, "path"), rt.path);
     });
-    oneOf(c, "/managers/service", managers.service, ["launchd", "systemd-user", "none"]);
+    oneOf(c, "/managers/service", managers.service, ["launchd", "systemd-user", "task-scheduler", "none"]);
     const platform = host?.platform;
     if (managers.service === "launchd" && platform !== "darwin")
       c.add("/managers/service", "inconsistent", "launchd is macOS only");
     if (managers.service === "systemd-user" && platform !== "linux")
       c.add("/managers/service", "inconsistent", "systemd is Linux only");
+    if (managers.service === "task-scheduler" && platform !== "win32")
+      c.add("/managers/service", "inconsistent", "Task Scheduler is Windows only");
   }
   list(c, "/harnesses", r.harnesses, HARNESS_ORDER.length, (p, v) => checkHarness(c, p, v), (v) => v?.id);
   list(c, "/runtimes", r.runtimes, RUNTIME_IDS.length, (p, v) => {
@@ -2280,7 +2284,7 @@ function validateDiscoverySnapshot(value) {
       return;
     absPath(c, pointer(p, "path"), cf.path);
     oneOf(c, pointer(p, "owner"), cf.owner, [...CONFIG_OWNERS, "package-manager"]);
-    oneOf(c, pointer(p, "format"), cf.format, ["json", "jsonc", "toml", "plist", "unit"]);
+    oneOf(c, pointer(p, "format"), cf.format, ["json", "jsonc", "toml", "plist", "unit", "xml"]);
     if (cf.sha256 !== null)
       digest(c, pointer(p, "sha256"), cf.sha256);
   }, (v) => v?.path);
@@ -3354,6 +3358,99 @@ function parseFrame(raw) {
   }
 }
 
+// packages/protocol/src/launch.ts
+var WORKSPACE_MODES = ["worktree", "checkout", "clone"];
+var RUNTIME_KINDS = ["host", "openshell"];
+var LAUNCH_END_WHEN = ["idle", "asked", "never"];
+var CLEANUP_POLICIES = ["keep", "remove"];
+var PATH_MAX = 4096;
+var REF_MAX = 200;
+var REMOTE_MAX = 2048;
+var LABELS_MAX = 32;
+var LABEL_VALUE_MAX = 256;
+var LABEL_KEY = /^[A-Za-z0-9][A-Za-z0-9._/-]{0,62}$/;
+function isAbsolutePath2(v) {
+  if (typeof v !== "string" || v.length > PATH_MAX || UNSAFE_CHARS.test(v))
+    return false;
+  if (WINDOWS_ROOT2.test(v))
+    return !v.includes("\\") && normalSegments(v.slice(2));
+  if (!v.startsWith("/"))
+    return false;
+  return normalSegments(v);
+}
+function normalSegments(rest) {
+  if (!rest.startsWith("/"))
+    return false;
+  if (rest === "/")
+    return true;
+  return rest.slice(1).replace(/\/$/, "").split("/").every((part) => part !== "" && part !== "." && part !== "..");
+}
+var WINDOWS_ROOT2 = /^[A-Z]:(?=\/)/;
+var isWindowsAbsolutePath = (v) => typeof v === "string" && WINDOWS_ROOT2.test(v) && isAbsolutePath2(v);
+function canonicalNativePath(value) {
+  if (typeof value !== "string")
+    return;
+  let p = value.replace(/^(\\\\\?\\|\\\?\?\\)(?=[A-Za-z]:\\)/, "");
+  if (/^[A-Za-z]:[\\/]/.test(p))
+    p = p[0].toUpperCase() + p.slice(1).replace(/\\/g, "/");
+  else if (!p.startsWith("/") || p.startsWith("//"))
+    return;
+  p = p.replace(/\/{2,}/g, "/");
+  if (p.endsWith("/") && p !== "/" && !/^[A-Z]:\/$/.test(p))
+    p = p.slice(0, -1);
+  return isAbsolutePath2(p) ? p : undefined;
+}
+function isRefName(v) {
+  if (typeof v !== "string" || v.length === 0 || v.length > REF_MAX)
+    return false;
+  if (!/^[A-Za-z0-9._/-]+$/.test(v) || v.startsWith("-") || v.endsWith(".") || v.includes(".."))
+    return false;
+  return v.split("/").every((part) => part !== "" && !part.startsWith(".") && !part.endsWith(".lock"));
+}
+function isGitRemote(v) {
+  if (typeof v !== "string" || v.length === 0 || v.length > REMOTE_MAX || v.startsWith("-") || /[\s\p{Cc}\p{Cf}]/u.test(v))
+    return false;
+  if (/^[A-Za-z0-9][A-Za-z0-9._-]*@[A-Za-z0-9][A-Za-z0-9.-]*:[^-:][^:]*$/.test(v))
+    return true;
+  try {
+    const url = new URL(v);
+    return (url.protocol === "https:" || url.protocol === "ssh:") && url.hostname.length > 0 && !url.hostname.startsWith("-") && url.pathname.length > 1;
+  } catch {
+    return false;
+  }
+}
+function launchWorkspaceProblem(v) {
+  if (!isObj(v))
+    return "workspace must be an object";
+  if (!isAbsolutePath2(v.repo))
+    return `workspace.repo must be an absolute path of at most ${PATH_MAX} characters without . or .. segments`;
+  if (!WORKSPACE_MODES.includes(v.mode))
+    return `workspace.mode must be one of ${WORKSPACE_MODES.join(", ")}`;
+  if (v.branch !== undefined && !isRefName(v.branch))
+    return "workspace.branch must be a valid branch name (letters, digits, . _ / -; not starting with -)";
+  if (v.base !== undefined && !isRefName(v.base))
+    return "workspace.base must be a valid branch name (letters, digits, . _ / -; not starting with -)";
+  if (v.remote !== undefined && !isGitRemote(v.remote))
+    return "workspace.remote must be an https or ssh git remote";
+  if (v.mode === "clone" && v.remote === undefined)
+    return "workspace.remote is required for a clone";
+  return;
+}
+function labelsProblem(v) {
+  if (!isObj(v))
+    return "labels must be an object";
+  const entries = Object.entries(v);
+  if (entries.length > LABELS_MAX)
+    return `at most ${LABELS_MAX} labels`;
+  for (const [key, value] of entries) {
+    if (!LABEL_KEY.test(key))
+      return `label key ${JSON.stringify(key.slice(0, 80))} must be 1–63 letters, digits, . _ / - (starting with a letter or digit)`;
+    if (typeof value !== "string" || value.length > LABEL_VALUE_MAX || UNSAFE_CHARS.test(value))
+      return `label ${key} must be text of at most ${LABEL_VALUE_MAX} printable characters`;
+  }
+  return;
+}
+
 // packages/protocol/src/contracts.ts
 var SLUG = /^[a-z0-9-]{2,40}$/;
 var isSlug = (v) => typeof v === "string" && SLUG.test(v);
@@ -3740,74 +3837,6 @@ function harnessEventProblem(event) {
     return "event data must be an object";
   return CHECKS[event.type](event.data);
 }
-// packages/protocol/src/launch.ts
-var WORKSPACE_MODES = ["worktree", "checkout", "clone"];
-var RUNTIME_KINDS = ["host", "openshell"];
-var LAUNCH_END_WHEN = ["idle", "asked", "never"];
-var CLEANUP_POLICIES = ["keep", "remove"];
-var PATH_MAX = 4096;
-var REF_MAX = 200;
-var REMOTE_MAX = 2048;
-var LABELS_MAX = 32;
-var LABEL_VALUE_MAX = 256;
-var LABEL_KEY = /^[A-Za-z0-9][A-Za-z0-9._/-]{0,62}$/;
-function isAbsolutePath2(v) {
-  if (typeof v !== "string" || !v.startsWith("/") || v.length > PATH_MAX || UNSAFE_CHARS.test(v))
-    return false;
-  if (v === "/")
-    return true;
-  return v.slice(1).replace(/\/$/, "").split("/").every((part) => part !== "" && part !== "." && part !== "..");
-}
-function isRefName(v) {
-  if (typeof v !== "string" || v.length === 0 || v.length > REF_MAX)
-    return false;
-  if (!/^[A-Za-z0-9._/-]+$/.test(v) || v.startsWith("-") || v.endsWith(".") || v.includes(".."))
-    return false;
-  return v.split("/").every((part) => part !== "" && !part.startsWith(".") && !part.endsWith(".lock"));
-}
-function isGitRemote(v) {
-  if (typeof v !== "string" || v.length === 0 || v.length > REMOTE_MAX || v.startsWith("-") || /[\s\p{Cc}\p{Cf}]/u.test(v))
-    return false;
-  if (/^[A-Za-z0-9][A-Za-z0-9._-]*@[A-Za-z0-9][A-Za-z0-9.-]*:[^-:][^:]*$/.test(v))
-    return true;
-  try {
-    const url = new URL(v);
-    return (url.protocol === "https:" || url.protocol === "ssh:") && url.hostname.length > 0 && !url.hostname.startsWith("-") && url.pathname.length > 1;
-  } catch {
-    return false;
-  }
-}
-function launchWorkspaceProblem(v) {
-  if (!isObj(v))
-    return "workspace must be an object";
-  if (!isAbsolutePath2(v.repo))
-    return `workspace.repo must be an absolute path of at most ${PATH_MAX} characters without . or .. segments`;
-  if (!WORKSPACE_MODES.includes(v.mode))
-    return `workspace.mode must be one of ${WORKSPACE_MODES.join(", ")}`;
-  if (v.branch !== undefined && !isRefName(v.branch))
-    return "workspace.branch must be a valid branch name (letters, digits, . _ / -; not starting with -)";
-  if (v.base !== undefined && !isRefName(v.base))
-    return "workspace.base must be a valid branch name (letters, digits, . _ / -; not starting with -)";
-  if (v.remote !== undefined && !isGitRemote(v.remote))
-    return "workspace.remote must be an https or ssh git remote";
-  if (v.mode === "clone" && v.remote === undefined)
-    return "workspace.remote is required for a clone";
-  return;
-}
-function labelsProblem(v) {
-  if (!isObj(v))
-    return "labels must be an object";
-  const entries = Object.entries(v);
-  if (entries.length > LABELS_MAX)
-    return `at most ${LABELS_MAX} labels`;
-  for (const [key, value] of entries) {
-    if (!LABEL_KEY.test(key))
-      return `label key ${JSON.stringify(key.slice(0, 80))} must be 1–63 letters, digits, . _ / - (starting with a letter or digit)`;
-    if (typeof value !== "string" || value.length > LABEL_VALUE_MAX || UNSAFE_CHARS.test(value))
-      return `label ${key} must be text of at most ${LABEL_VALUE_MAX} printable characters`;
-  }
-  return;
-}
 // packages/protocol/src/node.ts
 var NODE_ROLE = "node";
 var NODE_FEATURES = ["sandbox"];
@@ -4433,7 +4462,7 @@ function isServerRequest(v) {
     case "expose":
       return nonEmpty(v.sessionID) && typeof v.on === "boolean";
     case "create":
-      return nonEmpty(v.directory) && v.directory.startsWith("/") && v.directory.length <= 4096 && (v.title === undefined || str2(v.title) && v.title.length <= 200) && (v.herdrWorkspace === undefined || nonEmpty(v.herdrWorkspace) && v.herdrWorkspace.length <= 100) && (v.launchID === undefined || deliverID(v.launchID)) && (v.agent === undefined || agentName(v.agent)) && (v.model === undefined || isModelSelection(v.model));
+      return nonEmpty(v.directory) && (v.directory.startsWith("/") || isWindowsAbsolutePath(v.directory)) && v.directory.length <= 4096 && (v.title === undefined || str2(v.title) && v.title.length <= 200) && (v.herdrWorkspace === undefined || nonEmpty(v.herdrWorkspace) && v.herdrWorkspace.length <= 100) && (v.launchID === undefined || deliverID(v.launchID)) && (v.agent === undefined || agentName(v.agent)) && (v.model === undefined || isModelSelection(v.model));
     case "sessionTokens":
       return Array.isArray(v.tokens) && v.tokens.length <= SESSION_TOKENS_MAX && v.tokens.every(isSessionToken) && (v.hubURL === undefined || isHubURL(v.hubURL));
     case "actTokens":
@@ -5474,18 +5503,22 @@ class OpenCodeWarmer {
   }
 }
 async function readServiceRegistration(file, options = {}) {
-  const uid = options.uid ?? (typeof process.getuid === "function" ? process.getuid() : undefined);
+  const win32 = isWin32(options);
+  const uid = win32 ? undefined : options.uid ?? (typeof process.getuid === "function" ? process.getuid() : undefined);
   let info;
   let fd;
   try {
     const before = lstatSync3(file);
     if (!before.isFile())
       return;
-    fd = openSync4(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
+    fd = win32 ? openSync4(file, "r") : openSync4(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
     const stat = fstatSync(fd);
     if (!stat.isFile() || stat.dev !== before.dev || stat.ino !== before.ino)
       return;
-    if ((stat.mode & 18) !== 0)
+    if (win32) {
+      if (!(options.acl ?? defaultWinAcl()).check(nativeWinPath(file)).ok)
+        return;
+    } else if ((stat.mode & 18) !== 0)
       return;
     if (uid !== undefined && stat.uid !== uid)
       return;
@@ -5596,7 +5629,23 @@ function nodeConfigPath(env = process.env, home = homedir2()) {
 var isObject3 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var whole = (v, min, max) => typeof v === "number" && Number.isInteger(v) && v >= min && v <= max;
 var show2 = (v) => JSON.stringify(v)?.slice(0, 80) ?? String(v);
-function normalizeNodeConfig(raw) {
+function configPathOf(raw, options) {
+  if ((options.platform ?? process.platform) !== "win32")
+    return isAbsolutePath2(raw) ? raw : undefined;
+  if (typeof raw !== "string")
+    return;
+  let native = raw;
+  if (/^~[\\/]/.test(raw)) {
+    const home = canonicalNativePath(options.home ?? homedir2());
+    if (!home || !isWindowsAbsolutePath(home))
+      return;
+    native = `${home}/${raw.slice(2)}`;
+  }
+  const canonical = canonicalNativePath(native);
+  return canonical && isWindowsAbsolutePath(canonical) ? canonical : undefined;
+}
+var isRoot = (p) => p === "/" || /^[A-Z]:\/$/.test(p);
+function normalizeNodeConfig(raw, options = {}) {
   const problems = [];
   let r = {};
   if (isObject3(raw))
@@ -5606,9 +5655,10 @@ function normalizeNodeConfig(raw) {
   const workspaceRoots = [];
   if (r.workspaceRoots !== undefined && !Array.isArray(r.workspaceRoots))
     problems.push("workspaceRoots must be a list of absolute paths");
-  for (const root of Array.isArray(r.workspaceRoots) ? r.workspaceRoots : []) {
-    if (!isAbsolutePath2(root) || root === "/") {
-      problems.push(`workspaceRoots: ${show2(root)} is not an absolute path (without . or .. segments, and not /)`);
+  for (const entry of Array.isArray(r.workspaceRoots) ? r.workspaceRoots : []) {
+    const root = configPathOf(entry, options);
+    if (root === undefined || isRoot(root)) {
+      problems.push(`workspaceRoots: ${show2(entry)} is not an absolute path (without . or .. segments, and not /)`);
       continue;
     }
     const clean = root.replace(/\/+$/, "");
@@ -5643,21 +5693,22 @@ function normalizeNodeConfig(raw) {
   }
   const openshell = r.openshell === undefined ? undefined : normalizeOpenShell(r.openshell, problems);
   const harnesses = r.harnesses === undefined ? undefined : normalizeHarnesses(r.harnesses, problems);
-  const opencode = r.opencode === undefined ? undefined : normalizeOpenCode(r.opencode, problems);
+  const opencode = r.opencode === undefined ? undefined : normalizeOpenCode(r.opencode, problems, options);
   return {
     config: { workspaceRoots, labels, slots, ...memoryMB !== undefined ? { memoryMB } : {}, ...openshell ? { openshell } : {}, ...harnesses ? { harnesses } : {}, ...opencode ? { opencode } : {} },
     problems
   };
 }
-function normalizeDirectories(raw, field, problems) {
+function normalizeDirectories(raw, field, problems, options) {
   if (!Array.isArray(raw)) {
     problems.push(`${field} must be a list of absolute paths`);
     return;
   }
   const out = [];
-  for (const dir of raw) {
-    if (!isAbsolutePath2(dir) || dir === "/") {
-      problems.push(`${field}: ${show2(dir)} is not an absolute path (without . or .. segments, and not /)`);
+  for (const entry of raw) {
+    const dir = configPathOf(entry, options);
+    if (dir === undefined || isRoot(dir)) {
+      problems.push(`${field}: ${show2(entry)} is not an absolute path (without . or .. segments, and not /)`);
       continue;
     }
     const clean = dir.replace(/\/+$/, "");
@@ -5688,12 +5739,12 @@ function loopbackOrigin(raw) {
     return;
   return url.origin;
 }
-function normalizeOpenCode(raw, problems) {
+function normalizeOpenCode(raw, problems, options) {
   if (!isObject3(raw)) {
     problems.push("opencode must be an object");
     return;
   }
-  const directories = raw.directories === undefined ? undefined : normalizeDirectories(raw.directories, "opencode.directories", problems);
+  const directories = raw.directories === undefined ? undefined : normalizeDirectories(raw.directories, "opencode.directories", problems, options);
   const servers = [];
   if (raw.servers !== undefined && !Array.isArray(raw.servers))
     problems.push("opencode.servers must be a list of {url, passwordFile, directories?}");
@@ -5705,12 +5756,13 @@ function normalizeOpenCode(raw, problems) {
     const url = loopbackOrigin(entry.url);
     if (!url)
       return void problems.push(`${field}.url must be an http(s) URL on 127.0.0.1, [::1] or localhost, without user info, path or query`);
-    if (!isAbsolutePath2(entry.passwordFile) || entry.passwordFile === "/")
+    const passwordFile = configPathOf(entry.passwordFile, options);
+    if (passwordFile === undefined || isRoot(passwordFile))
       return void problems.push(`${field}.passwordFile must be the absolute path of a private (chmod 600) file holding the server's password`);
     if (servers.some((s) => s.url === url))
       return void problems.push(`${field}: ${url} is listed twice; the first one is used`);
-    const dirs = entry.directories === undefined ? undefined : normalizeDirectories(entry.directories, `${field}.directories`, problems);
-    servers.push({ url, passwordFile: entry.passwordFile, ...dirs ? { directories: dirs } : {} });
+    const dirs = entry.directories === undefined ? undefined : normalizeDirectories(entry.directories, `${field}.directories`, problems, options);
+    servers.push({ url, passwordFile, ...dirs ? { directories: dirs } : {} });
   });
   if (servers.length > OPENCODE_SERVERS_MAX) {
     problems.push(`opencode.servers: at most ${OPENCODE_SERVERS_MAX} servers; the rest are ignored`);
@@ -5772,7 +5824,7 @@ function normalizeOpenShell(raw, problems) {
   problems.push(...profiles.problems);
   return { enabled, ...gateway ? { gateway } : {}, ...image ? { image } : {}, profiles };
 }
-function readNodeConfig(file) {
+function readNodeConfig(file, options = {}) {
   let text;
   try {
     text = readFileSync4(file, "utf8");
@@ -5782,7 +5834,7 @@ function readNodeConfig(file) {
     return { config: normalizeNodeConfig(undefined).config, problems: [`${file}: cannot read (${cause.message})`] };
   }
   try {
-    return normalizeNodeConfig(JSON.parse(text));
+    return normalizeNodeConfig(JSON.parse(text), options);
   } catch {
     return { config: normalizeNodeConfig(undefined).config, problems: [`${file}: not valid JSON`] };
   }
@@ -8951,7 +9003,7 @@ function grantText2(g) {
 var requestedText = (body) => `requested; waiting for the user (Decision ${body.decision.id})`;
 
 // packages/cli/src/node.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync7, readFileSync as readFileSync8, realpathSync as realpathSync3, rmSync as rmSync8, writeFileSync as writeFileSync4 } from "node:fs";
+import { appendFileSync, existsSync as existsSync5, mkdirSync as mkdirSync7, readFileSync as readFileSync8, realpathSync as realpathSync3, renameSync as renameSync5, rmSync as rmSync8, statSync as statSync4, writeFileSync as writeFileSync4 } from "node:fs";
 import path16 from "node:path";
 // packages/node/src/connection.ts
 var UNSUPPORTED_RETRY_MS = 30 * 60000;
@@ -9169,29 +9221,233 @@ class NodeConnection {
     } catch {}
   }
 }
-// packages/node/src/daemon.ts
-import { randomUUID } from "node:crypto";
-import { arch as osArch, platform as osPlatform } from "node:os";
-// packages/node/package.json
-var package_default2 = {
-  name: "@huynle/hub-node",
-  version: "0.9.0",
-  private: true,
-  description: "`hub node`: the per-machine daemon that prepares, collects and cleans up launch workspaces (internal; shipped inside @huynle/hub, not published on its own).",
-  license: "MIT",
-  type: "module",
-  exports: {
-    ".": "./src/index.ts",
-    "./package.json": "./package.json"
-  }
-};
-
-// packages/node/src/host.ts
-import { existsSync as existsSync3, lstatSync as lstatSync4, mkdirSync as mkdirSync6, readFileSync as readFileSync5, realpathSync as realpathSync2, rmSync as rmSync6, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import path11 from "node:path";
+// packages/node/src/daemon.ts
+import { randomUUID } from "node:crypto";
+import { arch as osArch, platform as osPlatform } from "node:os";
+// packages/node/package.json
+var package_default2 = {
+  name: "@huynle/hub-node",
+  version: "0.9.1",
+  private: true,
+  description: "`hub node`: the per-machine daemon that prepares, collects and cleans up launch workspaces (internal; shipped inside @huynle/hub, not published on its own).",
+  license: "MIT",
+  type: "module",
+  exports: {
+    ".": "./src/index.ts",
+    "./package.json": "./package.json"
+  }
+};
+
+// packages/node/src/host.ts
+import { existsSync as existsSync3, lstatSync as lstatSync4, mkdirSync as mkdirSync6, readFileSync as readFileSync5, realpathSync as realpathSync2, rmSync as rmSync6, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import path11 from "node:path";
+
+// packages/node/src/git.ts
+import { spawn } from "node:child_process";
+
+// packages/cli/src/bootstrap/adapters/process-tree.ts
+import { execFile, spawn as nodeSpawn } from "node:child_process";
+var TOOL_TIMEOUT_MS = 15000;
+var START_SLACK_MS = 2000;
+var FILETIME_EPOCH_MS = 11644473600000n;
+var defaultExec = (file, args) => new Promise((resolve) => {
+  execFile(file, [...args], { shell: false, windowsHide: true, timeout: TOOL_TIMEOUT_MS, encoding: "utf8", maxBuffer: 1 << 20 }, (error, stdout) => {
+    const code = error?.code;
+    resolve({ code: error ? typeof code === "number" ? code : null : 0, stdout: String(stdout ?? "") });
+  });
+});
+function systemRootOf(value) {
+  const v = value?.replace(/\\+$/, "");
+  return v && /^[A-Za-z]:\\[A-Za-z0-9 ._\\()-]*$/.test(v) ? v : "C:\\Windows";
+}
+function processTree(deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  if (platform === "win32") {
+    const exec = deps.exec ?? defaultExec;
+    const root = systemRootOf(deps.systemRoot ?? process.env.SystemRoot ?? process.env.SYSTEMROOT);
+    const taskkill = `${root}\\System32\\taskkill.exe`;
+    const powershell = `${root}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+    const killTree = async (pid) => {
+      if (!Number.isInteger(pid) || pid <= 0)
+        return;
+      try {
+        await exec(taskkill, ["/T", "/F", "/PID", String(pid)]);
+      } catch {}
+    };
+    return {
+      detached: false,
+      killTree,
+      async reap(pid, startedAt) {
+        if (!Number.isInteger(pid) || pid <= 0)
+          return;
+        const since = (BigInt(Math.max(0, Math.floor(startedAt) - START_SLACK_MS)) + FILETIME_EPOCH_MS) * 10000n;
+        const script = `$t=[DateTime]::FromFileTimeUtc(${since}); ` + `Get-CimInstance -ClassName Win32_Process -Filter 'ParentProcessId=${pid}' | ` + `Where-Object { $_.CreationDate.ToUniversalTime() -ge $t } | ForEach-Object { $_.ProcessId }`;
+        let stdout = "";
+        try {
+          stdout = (await exec(powershell, ["-NoProfile", "-NonInteractive", "-Command", script])).stdout;
+        } catch {
+          return;
+        }
+        for (const line of stdout.split(/\r?\n/)) {
+          const child = line.trim();
+          if (/^[1-9]\d*$/.test(child))
+            await killTree(Number(child));
+        }
+      }
+    };
+  }
+  const kill = deps.kill ?? ((pid, signal) => void process.kill(pid, signal));
+  const group = (pid) => {
+    try {
+      kill(-pid, "SIGKILL");
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  return {
+    detached: true,
+    async killTree(pid) {
+      if (!Number.isInteger(pid) || pid <= 0)
+        return;
+      if (group(pid))
+        return;
+      try {
+        kill(pid, "SIGKILL");
+      } catch {}
+    },
+    async reap(pid) {
+      if (Number.isInteger(pid) && pid > 0)
+        group(pid);
+    }
+  };
+}
+var DRAIN_GRACE_MS = 1000;
+function runBounded(request, options = {}) {
+  const tree = options.tree ?? processTree();
+  const spawn = options.spawn ?? nodeSpawn;
+  const now = options.now ?? Date.now;
+  const env = Object.fromEntries(Object.entries(request.env).filter((e) => typeof e[1] === "string"));
+  return new Promise((resolve) => {
+    let timedOut = false;
+    let aborted = false;
+    let overflowed = false;
+    let ended = false;
+    const out = [];
+    const err = [];
+    const size = { out: 0, err: 0 };
+    const result = (exitCode, spawnError) => ({
+      exitCode,
+      stdout: Buffer.concat(out).toString("utf8"),
+      stderr: Buffer.concat(err).toString("utf8"),
+      timedOut,
+      aborted,
+      overflowed,
+      ...spawnError ? { spawnError } : {}
+    });
+    if (request.signal?.aborted) {
+      aborted = true;
+      return resolve(result(null));
+    }
+    const startedAt = now();
+    let child;
+    try {
+      child = spawn(request.file, [...request.args], {
+        shell: false,
+        env,
+        stdio: ["ignore", "pipe", request.stderr ? "pipe" : "ignore"],
+        windowsHide: true,
+        detached: tree.detached
+      });
+    } catch (error) {
+      return resolve(result(null, error));
+    }
+    let settled = false;
+    let exited = false;
+    const pid = child.pid;
+    const end = () => {
+      if (ended || pid === undefined)
+        return;
+      ended = true;
+      tree.killTree(pid);
+    };
+    const timer = setTimeout(() => {
+      timedOut = true;
+      end();
+    }, request.timeoutMs);
+    const onAbort = () => {
+      aborted = true;
+      end();
+    };
+    request.signal?.addEventListener("abort", onAbort, { once: true });
+    const finish = (r) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      request.signal?.removeEventListener("abort", onAbort);
+      resolve(r);
+    };
+    const collect = (into, key) => (chunk) => {
+      const room = request.maxOutputBytes - size[key];
+      if (chunk.length > room) {
+        overflowed = true;
+        if (room > 0)
+          into.push(chunk.subarray(0, room));
+        size[key] = request.maxOutputBytes;
+        if ((request.overflow ?? "kill") === "kill")
+          end();
+        return;
+      }
+      into.push(chunk);
+      size[key] += chunk.length;
+    };
+    child.stdout?.on("data", collect(out, "out"));
+    child.stderr?.on("data", collect(err, "err"));
+    const streams = [child.stdout, child.stderr].filter((s) => Boolean(s));
+    const drained = () => new Promise((done) => {
+      let open = streams.filter((s) => !s.readableEnded && !s.destroyed).length;
+      if (open === 0)
+        return done();
+      const grace = setTimeout(() => {
+        for (const s of streams)
+          s.destroy();
+        done();
+      }, DRAIN_GRACE_MS);
+      for (const s of streams) {
+        if (s.readableEnded || s.destroyed)
+          continue;
+        const one = () => {
+          if (--open === 0) {
+            clearTimeout(grace);
+            done();
+          }
+        };
+        s.once("end", one);
+        s.once("close", () => s.readableEnded ? undefined : one());
+      }
+    });
+    child.on("error", (error) => {
+      if (!exited)
+        finish(result(null, error));
+    });
+    child.on("exit", (code) => {
+      if (exited)
+        return;
+      exited = true;
+      clearTimeout(timer);
+      const exitCode = typeof code === "number" && !ended ? code : null;
+      (async () => {
+        if (pid !== undefined)
+          await tree.reap(pid, startedAt);
+        await drained();
+        finish(result(exitCode));
+      })();
+    });
+  });
+}
 
 // packages/node/src/git.ts
-import { spawn } from "node:child_process";
 var ALLOWED_PROTOCOLS = "https:ssh";
 var GIT_TIMEOUT_MS = 120000;
 var MAX_BUFFER = 16 * 1024 * 1024;
@@ -9222,6 +9478,7 @@ function redact(text) {
 function runGit(args, options) {
   const argv = ["-c", "protocol.ext.allow=never", ...args];
   const what = `git ${args.find((a) => !a.startsWith("-")) ?? ""}`.trim();
+  const win32 = (options.platform ?? process.platform) === "win32";
   return new Promise((resolve, reject) => {
     if (options.signal?.aborted)
       return reject(new GitError(`${what} cancelled`));
@@ -9241,7 +9498,7 @@ function runGit(args, options) {
       cwd: options.cwd,
       env: gitEnv(options.baseEnv ?? process.env, options.env),
       stdio: ["ignore", "pipe", "pipe"],
-      detached: true,
+      detached: !win32,
       windowsHide: true
     });
     const out = [];
@@ -9265,6 +9522,13 @@ function runGit(args, options) {
     function stop(why) {
       if (settled)
         return;
+      if (win32) {
+        if (child.pid)
+          (options.tree ?? processTree({ platform: "win32" })).killTree(child.pid);
+        else
+          child.kill("SIGKILL");
+        return finish(new GitError(`${what} ${why}`));
+      }
       try {
         if (child.pid)
           process.kill(-child.pid, "SIGKILL");
@@ -9282,43 +9546,72 @@ function runGit(args, options) {
 
 // packages/node/src/host.ts
 var LAUNCH_MARKER = "hub-launch";
-function resolvePath(p) {
+var nativeOps = {
+  win32: process.platform === "win32",
+  path: path11,
+  realpath: (p) => realpathSync2(p),
+  isSymlink: (p) => {
+    try {
+      return lstatSync4(p).isSymbolicLink();
+    } catch {
+      return false;
+    }
+  }
+};
+function realOf(p, ops) {
+  const real = ops.realpath(p);
+  if (!ops.win32)
+    return real;
+  const canonical = canonicalNativePath(real);
+  if (canonical === undefined || !isWindowsAbsolutePath(canonical))
+    throw new RuntimeError(`${p} resolves to ${real}, which is not on a local drive`);
+  return canonical;
+}
+function resolvePath(p, ops = nativeOps) {
   const rest = [];
   let current = p;
   for (;; ) {
+    let real;
     try {
-      return path11.join(realpathSync2(current), ...rest.reverse());
+      real = realOf(current, ops);
     } catch (cause) {
+      if (cause instanceof RuntimeError)
+        throw cause;
       if (cause.code !== "ENOENT")
         throw new RuntimeError(`cannot resolve ${p}: ${cause.message}`);
-      let link = false;
-      try {
-        link = lstatSync4(current).isSymbolicLink();
-      } catch {}
-      if (link)
+      if (ops.isSymlink(current))
         throw new RuntimeError(`${p} goes through a dangling symlink`);
-      const parent = path11.dirname(current);
+      const parent = ops.path.dirname(current);
       if (parent === current)
         throw new RuntimeError(`cannot resolve ${p}`);
-      rest.push(path11.basename(current));
+      rest.push(ops.path.basename(current));
       current = parent;
+      continue;
     }
+    return ops.win32 ? path11.posix.join(real, ...rest.reverse()) : path11.join(real, ...rest.reverse());
   }
 }
-function resolveUnderRoots(p, roots) {
+function within3(real, root, ops) {
+  if (!ops.win32)
+    return real === root || real.startsWith(root.endsWith(path11.sep) ? root : root + path11.sep);
+  const r = real.toLowerCase();
+  const base = root.toLowerCase();
+  return r === base || r.startsWith(base.endsWith("/") ? base : `${base}/`);
+}
+function resolveUnderRoots(p, roots, ops = nativeOps) {
   if (roots.length === 0)
     throw new RuntimeError("this node has no workspaceRoots in node.json, so it prepares no workspaces");
   if (!isAbsolutePath2(p))
     throw new RuntimeError(`${p} is not an absolute path`);
-  const real = resolvePath(p);
+  const real = resolvePath(p, ops);
   for (const root of roots) {
     let realRoot;
     try {
-      realRoot = realpathSync2(root);
+      realRoot = realOf(root, ops);
     } catch {
       continue;
     }
-    if (real === realRoot || real.startsWith(realRoot.endsWith(path11.sep) ? realRoot : realRoot + path11.sep))
+    if (within3(real, realRoot, ops))
       return real;
   }
   throw new RuntimeError(`${p} is not under this node's workspace roots`);
@@ -9373,7 +9666,7 @@ class HostRuntime {
       const directory = resolveUnderRoots(existing, this.roots);
       return this.prepared(repo, directory, "worktree", branch, base, true, ctx);
     }
-    const directory = resolveUnderRoots(path11.join(repo, ".worktrees", ...branch.split("/")), this.roots);
+    const directory = resolveUnderRoots(path11.posix.join(repo, ".worktrees", ...branch.split("/")), this.roots);
     if (existsSync3(directory))
       throw new RuntimeError(`${directory} exists and is not the worktree of ${branch}`);
     if (base)
@@ -9405,7 +9698,7 @@ class HostRuntime {
     const target = resolveUnderRoots(input.workspace.repo, this.roots);
     if (existsSync3(target) || isLink3(target))
       throw new RuntimeError(`${target} exists; a clone needs a new directory`);
-    const parent = path11.dirname(target);
+    const parent = path11.posix.dirname(target);
     mkdirSync6(parent, { recursive: true });
     if (resolveUnderRoots(parent, this.roots) !== parent)
       throw new RuntimeError(`${parent} moved while preparing`);
@@ -9777,19 +10070,30 @@ import { accessSync, constants as constants2, readFileSync as readFileSync6, sta
 import { homedir as homedir3 } from "node:os";
 import path12 from "node:path";
 var KNOWN = ["opencode", "claude-code", "codex"];
-function executable(file) {
+function executable(file, win32 = false) {
   try {
     if (!statSync3(file).isFile())
       return false;
-    accessSync(file, constants2.X_OK);
+    if (!win32)
+      accessSync(file, constants2.X_OK);
     return true;
   } catch {
     return false;
   }
 }
-function findExecutable(name, env) {
+var WIN_RUNNABLE = [".exe", ".com"];
+function windowsNames(name, env) {
+  if (WIN_RUNNABLE.includes(path12.win32.extname(name).toLowerCase()))
+    return [name];
+  const listed = (env.PATHEXT ?? "").split(";").map((e) => e.trim().toLowerCase()).filter((e) => WIN_RUNNABLE.includes(e));
+  const order = listed.length ? [...new Set(listed)] : WIN_RUNNABLE;
+  return order.map((ext) => `${name}${ext}`);
+}
+function findExecutable(name, env, platform = process.platform) {
   if (!name)
     return;
+  if (platform === "win32")
+    return findWindowsExecutable(name, env);
   if (path12.isAbsolute(name))
     return executable(name) ? name : undefined;
   if (name.includes("/"))
@@ -9803,13 +10107,30 @@ function findExecutable(name, env) {
   }
   return;
 }
+function findWindowsExecutable(name, env) {
+  if (path12.isAbsolute(name) || path12.win32.isAbsolute(name))
+    return windowsNames(name, env).find((file) => executable(file, true));
+  if (/[\\/]/.test(name))
+    return;
+  for (const dir of (env.PATH ?? env.Path ?? "").split(";")) {
+    if (!dir || !(path12.isAbsolute(dir) || path12.win32.isAbsolute(dir)))
+      continue;
+    for (const file of windowsNames(name, env)) {
+      const full = path12.join(dir, file);
+      if (executable(full, true))
+        return full;
+    }
+  }
+  return;
+}
 function detectHarnesses(options = {}) {
   const env = options.env ?? process.env;
   const found = new Set(["opencode"]);
   const home = options.home ?? homedir3();
-  if (findExecutable(claudeBinary(env, home), env))
+  const platform = options.platform ?? process.platform;
+  if (findExecutable(claudeBinary(env, home), env, platform))
     found.add("claude-code");
-  if (findExecutable(codexBinary(env, home), env))
+  if (findExecutable(codexBinary(env, home, platform), env, platform))
     found.add("codex");
   for (const [name, on] of Object.entries(options.overrides ?? {})) {
     if (on)
@@ -9834,12 +10155,21 @@ function claudeBinary(env, home = homedir3()) {
   } catch {}
   return "claude";
 }
-function codexBinary(env, home = homedir3()) {
+function codexBinary(env, home = homedir3(), platform = process.platform) {
   if (env.HUB_CODEX_BIN)
     return env.HUB_CODEX_BIN;
   const data = env.XDG_DATA_HOME && path12.isAbsolute(env.XDG_DATA_HOME) ? env.XDG_DATA_HOME : path12.join(home, ".local", "share");
-  const current = path12.join(data, "hub", "harnesses", "codex", "current", "bin", "codex");
-  return executable(current) ? current : "codex";
+  const win32 = platform === "win32";
+  const current = path12.join(data, "hub", "harnesses", "codex", "current", "bin", win32 ? "codex.exe" : "codex");
+  return executable(current, win32) ? current : "codex";
+}
+function opencodeBinary(env, home = homedir3(), platform = process.platform) {
+  if (env.HUB_OPENCODE_BIN)
+    return env.HUB_OPENCODE_BIN;
+  const data = env.XDG_DATA_HOME && path12.isAbsolute(env.XDG_DATA_HOME) ? env.XDG_DATA_HOME : path12.join(home, ".local", "share");
+  const win32 = platform === "win32";
+  const current = path12.join(data, "hub", "harnesses", "opencode", "current", "bin", win32 ? "opencode.exe" : "opencode");
+  return executable(current, win32) ? current : "opencode";
 }
 // packages/node/src/run.ts
 import { homedir as homedir4 } from "node:os";
@@ -10259,6 +10589,91 @@ class OpenShellCli {
   }
 }
 
+// packages/node/src/opencode-service.ts
+import { spawn as spawn3 } from "node:child_process";
+var START_BACKOFF_MS = 30000;
+var START_BACKOFF_MAX_MS = 10 * 60000;
+var START_TIMEOUT_MS = 90000;
+var STDERR_MAX2 = 2000;
+function startRun(env = process.env, timeoutMs = START_TIMEOUT_MS) {
+  return (file, args) => new Promise((resolve) => {
+    const clean = Object.fromEntries(Object.entries(env).filter((e) => typeof e[1] === "string"));
+    let child;
+    try {
+      child = spawn3(file, [...args], { shell: false, windowsHide: true, env: clean, stdio: ["ignore", "ignore", "pipe"] });
+    } catch (cause) {
+      return resolve({ code: null, stderr: "", spawnError: cause.message });
+    }
+    let stderr = "";
+    let done = false;
+    const finish = (r) => {
+      if (done)
+        return;
+      done = true;
+      clearTimeout(timer);
+      child.stderr?.destroy();
+      resolve(r);
+    };
+    child.stderr?.on("data", (chunk) => {
+      if (stderr.length < STDERR_MAX2)
+        stderr += chunk.toString("utf8").slice(0, STDERR_MAX2 - stderr.length);
+    });
+    child.on("error", (cause) => finish({ code: null, stderr, spawnError: cause.message }));
+    child.on("exit", (code) => finish({ code, stderr }));
+    const timer = setTimeout(() => {
+      child.kill();
+      finish({ code: null, stderr, spawnError: `timed out after ${Math.round(timeoutMs / 1000)} s` });
+    }, timeoutMs);
+  });
+}
+var oneLine2 = (text) => text.replace(/[\p{Cc}\p{Cf}\u2028\u2029]+/gu, " ").replace(/\s+/g, " ").trim().slice(0, 300);
+
+class OpenCodeServiceStarter {
+  options;
+  nextAttempt = 0;
+  delay = START_BACKOFF_MS;
+  missingLogged = false;
+  constructor(options) {
+    this.options = options;
+  }
+  async start() {
+    const now = (this.options.now ?? Date.now)();
+    if (now < this.nextAttempt)
+      return false;
+    const binary = this.options.binary();
+    if (!binary) {
+      if (!this.missingLogged)
+        this.options.log("OpenCode is not installed (no opencode.exe found), so its background service cannot be started");
+      this.missingLogged = true;
+      return false;
+    }
+    this.missingLogged = false;
+    this.options.log("OpenCode's background service is not running; starting it (opencode service start)");
+    const r = await (this.options.run ?? startRun(this.options.env))(binary, ["service", "start"]);
+    if (r.code === 0) {
+      this.delay = START_BACKOFF_MS;
+      this.nextAttempt = 0;
+      this.options.log("started OpenCode's background service");
+      return true;
+    }
+    const why = r.spawnError ?? (oneLine2(r.stderr) || `exit ${r.code}`);
+    this.options.log(`could not start OpenCode's background service (${why}); retrying in ${Math.round(this.delay / 1000)} s`);
+    this.nextAttempt = (this.options.now ?? Date.now)() + this.delay;
+    this.delay = Math.min(this.delay * 2, START_BACKOFF_MAX_MS);
+    return false;
+  }
+}
+function serviceDiscovery(read, starter, platform = process.platform) {
+  if (platform !== "win32")
+    return read;
+  return async () => {
+    const endpoint = await read();
+    if (endpoint)
+      return endpoint;
+    return await starter.start() ? read() : undefined;
+  };
+}
+
 // packages/runtime-openshell/src/runtime.ts
 import { createHash as createHash2 } from "node:crypto";
 import { existsSync as existsSync4, mkdtempSync as mkdtempSync2, readFileSync as readFileSync7, rmSync as rmSync7, writeFileSync as writeFileSync3 } from "node:fs";
@@ -10267,7 +10682,7 @@ import path14 from "node:path";
 // packages/runtime-openshell/package.json
 var package_default3 = {
   name: "@huynle/hub-runtime-openshell",
-  version: "0.9.0",
+  version: "0.9.1",
   private: true,
   description: "The `openshell` runtime of `hub node`: launches in NVIDIA OpenShell sandboxes, driven through the openshell CLI (internal; shipped inside @huynle/hub, not published on its own).",
   license: "MIT",
@@ -10827,6 +11242,16 @@ async function sweepSandboxes(client, machineID) {
 
 // packages/node/src/run.ts
 var EXIT_CONFIG = 78;
+var IDLE_RECHECK_MS = 60000;
+var sleep5 = (ms, signal) => new Promise((resolve) => {
+  const timer = setTimeout(done, ms);
+  function done() {
+    clearTimeout(timer);
+    signal.removeEventListener("abort", done);
+    resolve();
+  }
+  signal.addEventListener("abort", done, { once: true });
+});
 var openCodeServiceFile = (env, home) => path15.join(env.XDG_STATE_HOME || path15.join(home, ".local", "state"), "opencode", "service.json");
 function startOpenCodeWarmers(config, service, log, signal) {
   const roots = () => config.workspaceRoots;
@@ -10862,6 +11287,7 @@ async function setupOpenShell(config, credentials, options, env, log) {
 async function runNode(options) {
   const env = options.env ?? process.env;
   const home = options.home ?? homedir4();
+  const platform = options.platform ?? process.platform;
   const log = options.log ?? ((line) => process.stderr.write(`[hub node] ${line}
 `));
   const credentials = readSpokeCredentials(env, home);
@@ -10870,12 +11296,23 @@ async function runNode(options) {
     return 1;
   }
   const file = nodeConfigPath(env, home);
-  const { config, problems } = readNodeConfig(file);
+  let { config, problems } = readNodeConfig(file, { platform, home });
   for (const problem of problems)
     log(`${file}: ${problem}`);
   if (config.workspaceRoots.length === 0) {
     log(`${file} lists no workspaceRoots, so this node can prepare no workspaces; add e.g. {"workspaceRoots": ["${home}/projects"]}`);
-    return EXIT_CONFIG;
+    if (platform !== "win32")
+      return EXIT_CONFIG;
+    log(`waiting: re-reading ${file} every ${Math.round((options.idleRecheckMs ?? IDLE_RECHECK_MS) / 1000)} s until it lists workspaceRoots`);
+    while (config.workspaceRoots.length === 0) {
+      await sleep5(options.idleRecheckMs ?? IDLE_RECHECK_MS, options.signal);
+      if (options.signal.aborted)
+        return 0;
+      ({ config, problems } = readNodeConfig(file, { platform, home }));
+    }
+    for (const problem of problems)
+      log(`${file}: ${problem}`);
+    log(`workspace roots now set in ${file}; starting`);
   }
   if (options.signal.aborted)
     return 0;
@@ -10900,8 +11337,16 @@ async function runNode(options) {
   });
   log(`hub node ${NODE_VERSION}: ${config.slots} slots, roots ${config.workspaceRoots.join(", ")}; host harnesses ${harnesses.join(", ") || "none"}`);
   daemon.start();
-  if (harnesses.includes("opencode"))
-    startOpenCodeWarmers(config, options.openCodeService ?? (() => readServiceRegistration(openCodeServiceFile(env, home))), log, options.signal);
+  if (harnesses.includes("opencode")) {
+    const read = options.openCodeService ?? (() => readServiceRegistration(openCodeServiceFile(env, home)));
+    const starter = new OpenCodeServiceStarter({
+      binary: options.openCodeBinary ?? (() => findExecutable(opencodeBinary(env, home, platform), env, platform)),
+      log,
+      env,
+      ...options.startOpenCode ? { run: options.startOpenCode } : {}
+    });
+    startOpenCodeWarmers(config, serviceDiscovery(read, starter, platform), log, options.signal);
+  }
   await new Promise((resolve) => {
     if (options.signal.aborted)
       return resolve();
@@ -11202,6 +11647,64 @@ NoNewPrivileges=true
 WantedBy=default.target
 `;
 
+// scripts/hub-node.task.xml
+var hub_node_task_default = `<?xml version="1.0" encoding="UTF-16"?>
+<!-- The hub node as a per-user logon task (Windows Task Scheduler). hubctl setup and \`hub node install\` render it
+     (no visible window: the hidden console host starts hubctl; native paths; Windows argv quoting) and write it as
+     UTF-16LE with a BOM, which schtasks /XML requires. -->
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Description>Hub node (prepares launch workspaces for the hub). Started at logon without a window; started again within a minute after it exits.</Description>
+  </RegistrationInfo>
+  <Triggers>
+    <LogonTrigger>
+      <Enabled>true</Enabled>
+      <UserId>__USER__</UserId>
+      <Repetition>
+        <Interval>PT1M</Interval>
+        <StopAtDurationEnd>false</StopAtDurationEnd>
+      </Repetition>
+    </LogonTrigger>
+  </Triggers>
+  <Principals>
+    <Principal id="Author">
+      <UserId>__USER__</UserId>
+      <LogonType>InteractiveToken</LogonType>
+      <RunLevel>LeastPrivilege</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <AllowHardTerminate>true</AllowHardTerminate>
+    <StartWhenAvailable>false</StartWhenAvailable>
+    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
+    <IdleSettings>
+      <StopOnIdleEnd>false</StopOnIdleEnd>
+      <RestartOnIdle>false</RestartOnIdle>
+    </IdleSettings>
+    <AllowStartOnDemand>true</AllowStartOnDemand>
+    <Enabled>true</Enabled>
+    <Hidden>false</Hidden>
+    <RunOnlyIfIdle>false</RunOnlyIfIdle>
+    <WakeToRun>false</WakeToRun>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <Priority>7</Priority>
+    <RestartOnFailure>
+      <Interval>PT1M</Interval>
+      <Count>999</Count>
+    </RestartOnFailure>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>%SystemRoot%\\System32\\conhost.exe</Command>
+      <Arguments>--headless __ARGV__</Arguments>
+    </Exec>
+  </Actions>
+</Task>
+`;
+
 // packages/cli/src/bootstrap/release/assets.ts
 var EMBEDDED_TEXT = Object.freeze({
   "service/launchd/node": io_github_huynle_hub_node_default,
@@ -11209,7 +11712,8 @@ var EMBEDDED_TEXT = Object.freeze({
   "service/launchd/claude-code": io_github_huynle_hub_claude_code_default,
   "service/systemd-user/claude-code": hub_claude_code_default,
   "service/launchd/codex-spoke": io_github_huynle_hub_codex_spoke_default,
-  "service/systemd-user/codex-spoke": hub_codex_spoke_default
+  "service/systemd-user/codex-spoke": hub_codex_spoke_default,
+  "service/task-scheduler/node": hub_node_task_default
 });
 
 // packages/cli/src/bootstrap/adapters/node-services/render.ts
@@ -11218,7 +11722,34 @@ var SERVICE_ENVIRONMENT = Object.freeze({
   "claude-code": ["HUB_SPOKE_CONFIG", "XDG_CONFIG_HOME", "HUB_STATE_DIR", "XDG_STATE_HOME", "HUB_CLAUDE_SOCKET", "HUB_CLAUDE_BIN"],
   "codex-spoke": ["HUB_SPOKE_CONFIG", "XDG_CONFIG_HOME", "HUB_STATE_DIR", "XDG_STATE_HOME", "CODEX_HOME", "HUB_CODEX_BIN", "HUB_CODEX_DAEMON_SOCKET"]
 });
-var UNIT_ROOT = Object.freeze({ launchd: "launch-agents", "systemd-user": "systemd-user" });
+var UNIT_ROOT = SERVICE_ROOT;
+var TASK_NAME = /^hub-(?:node|claude-code|codex-spoke|test-[a-z0-9-]{1,32})-[A-Za-z0-9._-]{1,64}$/;
+var TEST_PREFIX = /^hub-test-[a-z0-9-]{1,32}$/;
+var SID2 = /^S-1-[0-9]{1,12}(?:-[0-9]{1,10}){1,15}$/;
+function taskNameFor(service, user, env) {
+  const safe = user.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 64);
+  if (!safe)
+    throw new Error("the Windows user name is empty; set USERNAME");
+  const prefix = env.HUBCTL_TEST_TASK_PREFIX;
+  if (prefix !== undefined && !TEST_PREFIX.test(prefix))
+    throw new Error("HUBCTL_TEST_TASK_PREFIX must start with hub-test- (lower-case letters, digits and -)");
+  return `${prefix ?? `hub-${service}`}-${safe}`;
+}
+function quoteWindowsArg(word) {
+  if (word !== "" && !/[\s"]/.test(word))
+    return word;
+  let out = '"';
+  let slashes = 0;
+  for (const ch of word) {
+    if (ch === "\\")
+      slashes++;
+    else {
+      out += "\\".repeat(ch === '"' ? slashes * 2 + 1 : slashes) + ch;
+      slashes = 0;
+    }
+  }
+  return `${out}${"\\".repeat(slashes * 2)}"`;
+}
 var assetIDFor = (service, manager) => `service/${manager}/${service}`;
 function serviceName(service, manager) {
   const file = EMBEDDED_ASSETS[assetIDFor(service, manager)].installAs;
@@ -11278,6 +11809,40 @@ ${indent}<string>${xml(value)}</string>`).join("");
   return template.replace(/<!--[\s\S]*?-->/, () => `<!-- ${header2(asset, by)} -->`).replace(programArguments, (_all, open, _words, close) => `${open}${argv.map((w) => `
 ${indent}<string>${xml(w)}</string>`).join("")}${close}`).replaceAll("__HOME__", xml(home)).replace(/(<key>PATH<\/key>\s*<string>[^<]*<\/string>)/, (line) => `${line}${extra}`);
 }
+var xmlText = (text) => text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+function renderTask(c, input, asset, template) {
+  if (input.layout.kind !== "standalone")
+    c.add("/layout", "unsupported_platform", "a Windows logon task starts the standalone hubctl.exe only, not a script under a runtime");
+  if (Object.keys(input.environment ?? {}).length > 0)
+    c.add("/environment", "invalid_value", "a Task Scheduler task carries no environment of its own");
+  const task = input.task;
+  if (!task)
+    c.add("/task", "missing_field", "a Task Scheduler task needs its name and the user's SID");
+  else {
+    if (!TASK_NAME.test(task.name))
+      c.add("/task/name", "invalid_value", "expected a hub task name (hub-<service>-<user>)");
+    if (!SID2.test(task.userSid))
+      c.add("/task/userSid", "invalid_value", "expected the user's SID (S-1-…)");
+  }
+  if (!isAbsolutePath(input.home) || !isWindowsPath(input.home))
+    c.add("/home", "invalid_path", "a Windows logon task needs a Windows home directory (C:/…)");
+  if (!/<Arguments>--headless __ARGV__<\/Arguments>/.test(template))
+    c.add("/asset", "inconsistent", `${asset} does not start hubctl under the hidden console host`);
+  if (c.issues.length > 0)
+    return;
+  const argv = serviceArgv(input.layout, input.service);
+  const words = argv.map((w, i) => i === 0 ? toNativePath(w, "win32") : w);
+  if (words.some((w) => w.includes('"')))
+    c.add("/layout", "invalid_path", "the program path may not contain a double quote");
+  return template.replace(/<!--[\s\S]*?-->/, () => `<!-- ${header2(asset, input.writtenBy)} -->`).replaceAll("__USER__", () => task.userSid).replace("__ARGV__", () => xmlText(words.map(quoteWindowsArg).join(" ")));
+}
+var utf16le = (text) => {
+  const body = Buffer.from(text, "utf16le");
+  const bytes = new Uint8Array(body.length + 2);
+  bytes.set([255, 254]);
+  bytes.set(body, 2);
+  return bytes;
+};
 function renderServiceUnit(input) {
   const c = new Checker;
   const asset = assetIDFor(input.service, input.manager);
@@ -11287,22 +11852,44 @@ function renderServiceUnit(input) {
     c.add("/service", "invalid_value", `no embedded template for ${input.service} under ${input.manager}`);
     return c.result(undefined);
   }
+  if (input.manager === "task-scheduler") {
+    const text = renderTask(c, input, asset, template);
+    if (text === undefined || c.issues.length > 0)
+      return c.result(undefined);
+    if (PLACEHOLDER.test(text))
+      c.add("/asset", "inconsistent", `${asset} has a placeholder this hubctl does not fill`);
+    if (c.issues.length > 0)
+      return c.result(undefined);
+    const bytes = utf16le(text);
+    return c.result({
+      asset,
+      service: input.service,
+      manager: input.manager,
+      path: { root: UNIT_ROOT[input.manager], rel: entry.installAs },
+      name: input.task.name,
+      argv: serviceArgv(input.layout, input.service),
+      text,
+      bytes,
+      sha256: `sha256:${sha256Hex(bytes)}`
+    });
+  }
+  const manager = input.manager;
   let argv = [];
   try {
     argv = serviceArgv(input.layout, input.service);
   } catch (error) {
     c.add("/layout", "invalid_path", error.message);
   }
-  const homeOK = isAbsolutePath(input.home) && input.home !== "/" && (input.manager !== "systemd-user" || SYSTEMD_HOME.test(input.home));
+  const homeOK = isAbsolutePath(input.home) && input.home !== "/" && (manager !== "systemd-user" || SYSTEMD_HOME.test(input.home));
   if (!homeOK)
     c.add("/home", "invalid_path", "the service's home must be an absolute, normalized directory other than /");
   const env = checkEnvironment(c, input.service, input.environment ?? {});
   if (c.issues.length > 0)
     return c.result(undefined);
   const command = SERVICE_COMMANDS[input.service];
-  const raw = input.manager === "systemd-user" ? renderSystemd(c, asset, template, argv, command, input.home, env, input.writtenBy) : renderLaunchd(c, asset, template, argv, command, input.home, env, input.writtenBy);
+  const raw = manager === "systemd-user" ? renderSystemd(c, asset, template, argv, command, input.home, env, input.writtenBy) : renderLaunchd(c, asset, template, argv, command, input.home, env, input.writtenBy);
   const asBun = input.layout.kind === "script";
-  const text = asBun ? raw : raw.replace(BUN_BE_BUN[input.manager], "");
+  const text = asBun ? raw : raw.replace(BUN_BE_BUN[manager], "");
   if (!asBun && text.includes("BUN_BE_BUN"))
     c.add("/asset", "inconsistent", `${asset} sets BUN_BE_BUN, which a standalone hubctl must not get`);
   if (PLACEHOLDER.test(text))
@@ -11317,7 +11904,7 @@ function renderServiceUnit(input) {
     service: input.service,
     manager: input.manager,
     path: { root: UNIT_ROOT[input.manager], rel: entry.installAs },
-    name: serviceName(input.service, input.manager),
+    name: serviceName(input.service, manager),
     argv,
     text,
     bytes,
@@ -11325,6 +11912,39 @@ function renderServiceUnit(input) {
   });
 }
 
+// packages/cli/src/bootstrap/discovery/util.ts
+function normalizeAbs(value) {
+  if (typeof value !== "string")
+    return;
+  let p = value;
+  if (/^[A-Za-z]:[\\/]/.test(p))
+    p = p[0].toUpperCase() + p.slice(1).replace(/\\/g, "/");
+  else if (!p.startsWith("/") || p.startsWith("//"))
+    return;
+  p = p.replace(/\/{2,}/g, "/");
+  if (p.endsWith("/") && p !== "/" && !/^[A-Z]:\/$/.test(p))
+    p = p.slice(0, -1);
+  return isAbsolutePath(p) ? p : undefined;
+}
+function canonicalWinLink(text) {
+  const stripped = text.replace(/^(\\\\\?\\|\\\?\?\\)/, "");
+  return normalizeAbs(stripped) ?? text;
+}
+var probePath = (platform, text) => text !== undefined && platform === "win32" ? canonicalWinLink(text) : text;
+var join = (dir, rel) => dir.endsWith("/") ? `${dir}${rel}` : `${dir}/${rel}`;
+var decode = (bytes) => bytes ? new TextDecoder("utf-8", { fatal: false }).decode(bytes) : "";
+var oneLine3 = (v, max = 64) => v && v.length <= max && !/[\u0000-\u001f\u007f]/.test(v) ? v : undefined;
+var hostAbs = (platform, value) => {
+  const p = normalizeAbs(value);
+  return p && (platform !== "win32" || isWindowsPath(p)) ? p : undefined;
+};
+var underDir = (p, dir) => {
+  const prefix = dir.endsWith("/") ? dir : `${dir}/`;
+  return isWindowsPath(p) ? p.toLowerCase().startsWith(prefix.toLowerCase()) : p.startsWith(prefix);
+};
+var WINDOWS_COMMAND_EXTENSIONS = [".com", ".exe", ".bat", ".cmd"];
+var isWindowsExecutable = (path) => WINDOWS_COMMAND_EXTENSIONS.some((e) => path.toLowerCase().endsWith(e));
+
 // packages/cli/src/node.ts
 var NODE_LABEL = "io.github.huynle.hub-node";
 var NODE_UNIT = "hub-node.service";
@@ -11399,13 +12019,58 @@ function systemd(spec, io, extra) {
     check: [`systemctl --user status ${unit}`, `journalctl --user -u ${unit} -f`]
   };
 }
+function taskScheduler(spec, io, extra) {
+  if (spec.service !== "node")
+    throw new CliError(EXIT.unavailable, `${spec.command} install does not support Windows yet: hubctl installs no user service for it there`, spec.elsewhere);
+  const home = normalizeAbs(io.home);
+  if (!home)
+    throw new CliError(EXIT.usage, `cannot write the ${spec.command} task: the home directory ${io.home} is not a drive path`);
+  const state = normalizeAbs(resolveHubStateDir(io.env, io.home).dir);
+  if (!state)
+    throw new CliError(EXIT.usage, `cannot write the ${spec.command} task: the hub state directory is not a drive path`);
+  const executable = normalizeAbs(io.program.execPath);
+  const found = programLayout(io.program);
+  const layout = found.kind === "standalone" && executable ? { kind: "standalone", executable } : found;
+  const { environment, skipped } = carried(spec, io, extra);
+  let name;
+  try {
+    name = taskNameFor(spec.service, io.env.USERNAME ?? "", io.env);
+  } catch (error) {
+    throw new CliError(EXIT.usage, `cannot write the ${spec.command} task: ${error.message}`);
+  }
+  const r = renderServiceUnit({ service: spec.service, manager: "task-scheduler", layout, home, writtenBy: spec.command, task: { name, userSid: (io.userSid ?? (() => defaultWinAcl().sid()))() } });
+  if (!r.ok)
+    throw new CliError(EXIT.usage, `cannot write the ${spec.command} task: ${r.issues.map((i) => `${i.path ? `${i.path}: ` : ""}${i.message}`).join("; ")}`);
+  const file = toNativePath(`${state}/tasks/${r.value.path.rel}`, "win32");
+  const stopNode = `Get-CimInstance Win32_Process -Filter "Name='hubctl.exe'" | Where-Object CommandLine -like '* node run' | Invoke-CimMethod -MethodName Terminate   # PowerShell: /End stops only the hidden console host`;
+  return {
+    kind: "task-scheduler",
+    file,
+    content: r.value.text,
+    bytes: r.value.bytes,
+    skipped: [...Object.keys(environment), ...skipped].sort(),
+    dirs: [],
+    load: [`schtasks /Create /TN ${name} /XML "${file}" /F`, `schtasks /Run /TN ${name}`],
+    unload: [`schtasks /End /TN ${name}`, stopNode, `schtasks /Delete /TN ${name} /F`],
+    check: [`schtasks /Query /TN ${name} /V /FO LIST`]
+  };
+}
 function serviceFor(spec, io, extra) {
   if (io.platform === "darwin")
     return launchd(spec, io, extra);
   if (io.platform === "linux")
     return systemd(spec, io, extra);
+  if (io.platform === "win32")
+    return taskScheduler(spec, io, extra);
   throw new CliError(EXIT.unavailable, `${spec.command} install supports macOS (launchd) and Linux (systemd), not ${io.platform}`, spec.elsewhere);
 }
+var readBytes = (file) => {
+  try {
+    return readFileSync8(file);
+  } catch {
+    return;
+  }
+};
 var readText = (file) => {
   try {
     return readFileSync8(file, "utf8");
@@ -11432,21 +12097,22 @@ function installNode(io, options) {
 }
 function installService(spec, io, options, given, extra) {
   const service = serviceFor(spec, io, extra);
-  const warnings = [...given, ...service.skipped.map((key) => `${key} is not an absolute path, so the service does not carry it`)];
+  const why = service.kind === "task-scheduler" ? "is set in this shell, but a logon task has no environment of its own, so the node does not see it" : "is not an absolute path, so the service does not carry it";
+  const warnings = [...given, ...service.skipped.map((key) => `${key} ${why}`)];
   const load = commands(`Load it ${NOT_RUN}:`, service.load);
   if (options.dryRun)
     return { stdout: `would write ${service.file}:
 
 ${service.content}
 ${load}`, warnings };
-  const current = readText(service.file);
+  const current = service.bytes ? readBytes(service.file) : readText(service.file);
   for (const dir of service.dirs)
     mkdirSync7(dir, { recursive: true });
-  if (current === service.content)
+  if (service.bytes ? current !== undefined && Buffer.from(service.bytes).equals(current) : current === service.content)
     return { stdout: `${service.file} is up to date
 ${load}`, warnings };
   mkdirSync7(path16.dirname(service.file), { recursive: true });
-  writeFileSync4(service.file, service.content, { mode: 420 });
+  writeFileSync4(service.file, service.bytes ?? service.content, { mode: 420 });
   return { stdout: `${current === undefined ? "wrote" : "updated"} ${service.file}
 ${load}`, warnings };
 }
@@ -11468,6 +12134,10 @@ ${stop}`, warnings: [] };
 function serviceState(spec, io, extra) {
   try {
     const s = serviceFor(spec, io, extra);
+    if (s.bytes) {
+      const bytes = readBytes(s.file);
+      return { kind: s.kind, file: s.file, installed: bytes !== undefined, current: bytes !== undefined && Buffer.from(s.bytes).equals(bytes), check: s.check };
+    }
     const text = readText(s.file);
     return { kind: s.kind, file: s.file, installed: text !== undefined, current: text === s.content, check: s.check };
   } catch {
@@ -11508,9 +12178,28 @@ function nodeStatusText(status) {
   return lines.join(`
 `);
 }
+var NODE_LOG_MAX_BYTES = 1024 * 1024;
+function nodeLogger(o) {
+  const file = path16.join(o.stateDir, "node.log");
+  return (line) => {
+    o.stderr(`[hub node] ${line}
+`);
+    if (o.platform !== "win32")
+      return;
+    try {
+      mkdirSync7(o.stateDir, { recursive: true });
+      try {
+        if (statSync4(file).size > NODE_LOG_MAX_BYTES)
+          renameSync5(file, `${file}.1`);
+      } catch {}
+      appendFileSync(file, `${(o.now ?? (() => new Date))().toISOString()} ${line}
+`);
+    } catch {}
+  };
+}
 function runNodeCommand(io) {
-  return runNode({ env: io.env, home: io.home, signal: io.signal ?? new AbortController().signal, log: (line) => io.stderr(`[hub node] ${line}
-`) });
+  const log = nodeLogger({ platform: io.platform ?? process.platform, stateDir: resolveHubStateDir(io.env, io.home).dir, stderr: (s) => io.stderr(s) });
+  return runNode({ env: io.env, home: io.home, signal: io.signal ?? new AbortController().signal, log });
 }
 
 // packages/cli/src/openshell.ts
@@ -12745,8 +13434,8 @@ async function runMcpPipe(options) {
 }
 
 // packages/claude-code/src/launcher.ts
-import { spawn as spawn3 } from "node:child_process";
-import { realpathSync as realpathSync4, statSync as statSync4 } from "node:fs";
+import { spawn as spawn4 } from "node:child_process";
+import { realpathSync as realpathSync4, statSync as statSync5 } from "node:fs";
 import path19 from "node:path";
 var INTERRUPTED = "Interrupted from the hub";
 var CONTROL_WAIT_MS = 5000;
@@ -12755,7 +13444,7 @@ var KILL_GRACE_MS = 1000;
 var LINE_MAX = 16 * 1024 * 1024;
 var STDERR_KEEP = 2000;
 var record2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : {};
-var sleep5 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var sleep6 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var AGENT2 = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
 var MODEL = /^[A-Za-z0-9][A-Za-z0-9._:@/\[\]-]{0,299}$/;
 var PROVIDERS = new Set(["anthropic", "claude-code"]);
@@ -12769,7 +13458,7 @@ function launchDirectory(directory, roots) {
   } catch {
     throw new Error(`${directory} does not exist`);
   }
-  if (!statSync4(real).isDirectory())
+  if (!statSync5(real).isDirectory())
     throw new Error(`${directory} is not a directory`);
   for (const root of roots) {
     let base;
@@ -12843,7 +13532,7 @@ class ClaudeLauncher {
     delete env.BUN_BE_BUN;
     let child;
     try {
-      child = spawn3(this.#options.bin, launchArgs(input), { cwd: input.directory, env, stdio: ["pipe", "pipe", "pipe"] });
+      child = spawn4(this.#options.bin, launchArgs(input), { cwd: input.directory, env, stdio: ["pipe", "pipe", "pipe"] });
     } catch (cause) {
       throw new Error(`cannot run ${this.#options.bin}: ${cause.message}`);
     }
@@ -12931,7 +13620,7 @@ class ClaudeLauncher {
     const answered = new Promise((resolve) => proc.controls.set(id, resolve));
     proc.child.stdin.write(`${JSON.stringify({ type: "control_request", request_id: id, request })}
 `);
-    const response = await Promise.race([answered, sleep5(waitMs).then(() => {
+    const response = await Promise.race([answered, sleep6(waitMs).then(() => {
       return;
     })]);
     proc.controls.delete(id);
@@ -12942,10 +13631,10 @@ class ClaudeLauncher {
     for (const proc of procs)
       proc.child.stdin.end();
     await Promise.all(procs.map(async (proc) => {
-      if (await Promise.race([proc.exited.then(() => true), sleep5(STOP_GRACE_MS).then(() => false)]))
+      if (await Promise.race([proc.exited.then(() => true), sleep6(STOP_GRACE_MS).then(() => false)]))
         return;
       proc.child.kill("SIGTERM");
-      if (await Promise.race([proc.exited.then(() => true), sleep5(KILL_GRACE_MS).then(() => false)]))
+      if (await Promise.race([proc.exited.then(() => true), sleep6(KILL_GRACE_MS).then(() => false)]))
         return;
       proc.child.kill("SIGKILL");
       await proc.exited;
@@ -13944,14 +14633,14 @@ async function startDaemon(options) {
 }
 
 // packages/claude-code/src/wrapper.ts
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 import { randomBytes as randomBytes9 } from "node:crypto";
 import { closeSync as closeSync5, openSync as openSync5 } from "node:fs";
 import path23 from "node:path";
 // packages/claude-code/package.json
 var package_default4 = {
   name: "@huynle/hub-claude-code",
-  version: "0.9.0",
+  version: "0.9.1",
   private: true,
   description: "The Claude Code hooks spoke: per-user daemon, hook bridge, plugin dir, `hub claude` wrapper and daemon-backed MCP server (internal; shipped inside @huynle/hub, not published on its own).",
   license: "MIT",
@@ -13964,7 +14653,7 @@ var package_default4 = {
 
 // packages/claude-code/src/plugin.ts
 import { createHash as createHash5 } from "node:crypto";
-import { existsSync as existsSync7, mkdirSync as mkdirSync9, renameSync as renameSync5, rmSync as rmSync9, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync9, renameSync as renameSync6, rmSync as rmSync9, writeFileSync as writeFileSync6 } from "node:fs";
 import path22 from "node:path";
 var HOOK_EVENTS = [
   "SessionStart",
@@ -14022,7 +14711,7 @@ function writePlugin(base, options) {
     writeFileSync6(path22.join(tmp, file), content, { mode: 384 });
   }
   try {
-    renameSync5(tmp, dir);
+    renameSync6(tmp, dir);
   } catch (cause) {
     rmSync9(tmp, { recursive: true, force: true });
     if (!existsSync7(dir))
@@ -14048,7 +14737,7 @@ function spawnDaemon(io) {
   ensurePrivateDir(dir);
   const log = openSync5(path23.join(dir, "daemon.log"), "a", 384);
   try {
-    const child = spawn4(io.program.execPath, [io.program.entry, "claude-code", "daemon"], { detached: true, stdio: ["ignore", log, log], env: { ...io.env, BUN_BE_BUN: "1" } });
+    const child = spawn5(io.program.execPath, [io.program.entry, "claude-code", "daemon"], { detached: true, windowsHide: true, stdio: ["ignore", log, log], env: { ...io.env, BUN_BE_BUN: "1" } });
     child.on("error", () => {});
     child.unref();
   } finally {
@@ -14087,7 +14776,7 @@ async function prepare(io, socket) {
 }
 function spawnClaude(bin, args, env, stderr) {
   return new Promise((resolve) => {
-    const child = spawn4(bin, args, { stdio: "inherit", env });
+    const child = spawn5(bin, args, { stdio: "inherit", windowsHide: true, env });
     const ignore = () => {};
     const forward = () => child.kill("SIGTERM");
     process.on("SIGINT", ignore);
@@ -14240,7 +14929,7 @@ import path26 from "node:path";
 // packages/preset/package.json
 var package_default5 = {
   name: "@huynle/hub-preset",
-  version: "0.9.0",
+  version: "0.9.1",
   private: true,
   description: "The preset spoke: drives a harness without a spoke of its own through a terminal pane (tmux), described by a data-only preset; official presets in presets/ (internal; shipped inside @huynle/hub, not published on its own).",
   license: "MIT",
@@ -14516,12 +15205,12 @@ class PresetSpoke {
 }
 
 // packages/preset/src/tmux.ts
-import { execFile } from "node:child_process";
+import { execFile as execFile2 } from "node:child_process";
 import { randomBytes as randomBytes10 } from "node:crypto";
 var TMUX_TIMEOUT_MS = 5000;
 function tmuxRunner(bin = "tmux", env = process.env, timeoutMs = TMUX_TIMEOUT_MS) {
   return (args) => new Promise((resolve) => {
-    execFile(bin, args, { env, timeout: timeoutMs, encoding: "utf8", maxBuffer: 4 * 1024 * 1024 }, (error, stdout, stderr) => {
+    execFile2(bin, args, { env, timeout: timeoutMs, encoding: "utf8", maxBuffer: 4 * 1024 * 1024 }, (error, stdout, stderr) => {
       const exit = error?.code;
       const code = !error ? 0 : typeof exit === "number" ? exit : 1;
       resolve({ code, stdout: stdout ?? "", stderr: stderr || (error ? error.message : "") });
@@ -14765,7 +15454,7 @@ import { openSync as openSync6, closeSync as closeSync6, readFileSync as readFil
 // packages/codex/package.json
 var package_default6 = {
   name: "@huynle/hub-codex",
-  version: "0.9.0",
+  version: "0.9.1",
   private: true,
   description: "The Codex app-server spoke: attaches to Codex's app-server (its own over stdio, and the shared daemon's socket when present), and the `hub codex` wrapper (internal; shipped inside @huynle/hub, not published on its own).",
   license: "MIT",
@@ -14965,7 +15654,7 @@ async function openAppServer(channel, options) {
 
 // packages/codex/src/profile.ts
 import { randomBytes as randomBytes11 } from "node:crypto";
-import { existsSync as existsSync8, mkdirSync as mkdirSync11, readdirSync as readdirSync2, renameSync as renameSync6, rmSync as rmSync10, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync11, readdirSync as readdirSync2, renameSync as renameSync7, rmSync as rmSync10, writeFileSync as writeFileSync7 } from "node:fs";
 import path28 from "node:path";
 var CODEX_PROFILE_CAPABILITIES = Object.freeze({
   instructions: true,
@@ -15059,7 +15748,7 @@ class CodexProfiles {
             mkdirSync11(path28.join(temp, "skills", skill.name), { recursive: true, mode: 448 });
             writeFileSync7(path28.join(temp, "skills", skill.name, "SKILL.md"), skillFile(skill), { mode: 384 });
           }
-          renameSync6(temp, versionDir);
+          renameSync7(temp, versionDir);
         } catch (cause) {
           rmSync10(temp, { recursive: true, force: true });
           throw cause;
@@ -15093,7 +15782,7 @@ class CodexProfiles {
 }
 
 // packages/codex/src/sessions.ts
-import { statSync as statSync5 } from "node:fs";
+import { statSync as statSync6 } from "node:fs";
 import path29 from "node:path";
 import { randomBytes as randomBytes13 } from "node:crypto";
 
@@ -15123,7 +15812,7 @@ var textInput = (text) => ({ type: "text", text, text_elements: [] });
 function gitRoot2(cwd) {
   for (let dir = path29.resolve(cwd);; dir = path29.dirname(dir)) {
     try {
-      statSync5(path29.join(dir, ".git"));
+      statSync6(path29.join(dir, ".git"));
       return dir;
     } catch {}
     if (path29.dirname(dir) === dir)
@@ -15391,7 +16080,7 @@ class CodexSessions {
       throw new Error(`The directory must be an absolute path (got ${JSON.stringify(req.directory)})`);
     let isDir = false;
     try {
-      isDir = statSync5(req.directory).isDirectory();
+      isDir = statSync6(req.directory).isDirectory();
     } catch {}
     if (!isDir)
       throw new Error(`${req.directory} does not exist or is not a directory`);
@@ -15574,7 +16263,7 @@ function input(text, images) {
 }
 
 // packages/codex/src/stdio.ts
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 var STDIO_MAX_LINE = 16 * 1024 * 1024;
 var KILL_GRACE_MS2 = 2000;
 var LOG_LINE_MAX = 2000;
@@ -15590,7 +16279,7 @@ function spawnStdioChannel(options) {
       cb(reason);
   };
   const env = Object.fromEntries(Object.entries(options.env).filter(([, v]) => v !== undefined));
-  const child = spawn5(options.command, [...options.args], { cwd: options.cwd, env, stdio: ["pipe", "pipe", "pipe"] });
+  const child = spawn6(options.command, [...options.args], { cwd: options.cwd, env, stdio: ["pipe", "pipe", "pipe"] });
   let exitDone;
   const exited = new Promise((resolve) => exitDone = resolve);
   child.on("error", (error) => {
@@ -16251,7 +16940,7 @@ function spokeServiceStatusText(name, status) {
 }
 
 // packages/codex/src/wrapper.ts
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 import { closeSync as closeSync7, openSync as openSync7 } from "node:fs";
 import path32 from "node:path";
 var SERVICE_START_MS = 8000;
@@ -16261,7 +16950,7 @@ function spawnService(io) {
   ensurePrivateDir2(dir);
   const log = openSync7(path32.join(dir, "spoke.log"), "a", 384);
   try {
-    const child = spawn6(io.program.execPath, [io.program.entry, "codex-spoke", "serve"], { detached: true, stdio: ["ignore", log, log], env: { ...io.env, BUN_BE_BUN: "1" } });
+    const child = spawn7(io.program.execPath, [io.program.entry, "codex-spoke", "serve"], { detached: true, windowsHide: true, stdio: ["ignore", log, log], env: { ...io.env, BUN_BE_BUN: "1" } });
     child.on("error", () => {});
     child.unref();
   } finally {
@@ -16290,7 +16979,7 @@ async function ensureService(io) {
 var SIGNALS2 = { SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGKILL: 9, SIGTERM: 15 };
 function spawnCodex(bin, args, env, stderr) {
   return new Promise((resolve) => {
-    const child = spawn6(bin, args, { stdio: "inherit", env });
+    const child = spawn7(bin, args, { stdio: "inherit", windowsHide: true, env });
     const ignore = () => {};
     const forward = () => child.kill("SIGTERM");
     process.on("SIGINT", ignore);
@@ -16324,7 +17013,7 @@ async function runCodex(args, given) {
 }
 
 // packages/cli/src/setup/commands.ts
-import { existsSync as existsSync9, readFileSync as readFileSync13, renameSync as renameSync8, writeFileSync as writeFileSync8 } from "node:fs";
+import { existsSync as existsSync9, readFileSync as readFileSync13, renameSync as renameSync9, writeFileSync as writeFileSync8 } from "node:fs";
 import { hostname as hostname4 } from "node:os";
 import path35 from "node:path";
 
@@ -18243,50 +18932,15 @@ function renderYAML(vars) {
     "# the profile and the pins must stay exactly what was previewed and signed.",
     ...VAR_ORDER.map((key) => `${key}: ${canonicalJSON(vars[key])}`)
   ];
-  return `${lines.join(`
-`)}
-`;
-}
-
-// packages/cli/src/bootstrap/discovery/node-probe.ts
-import childProcess from "node:child_process";
-import fs from "node:fs";
-import os from "node:os";
-
-// packages/cli/src/bootstrap/discovery/util.ts
-function normalizeAbs(value) {
-  if (typeof value !== "string")
-    return;
-  let p = value;
-  if (/^[A-Za-z]:[\\/]/.test(p))
-    p = p[0].toUpperCase() + p.slice(1).replace(/\\/g, "/");
-  else if (!p.startsWith("/") || p.startsWith("//"))
-    return;
-  p = p.replace(/\/{2,}/g, "/");
-  if (p.endsWith("/") && p !== "/" && !/^[A-Z]:\/$/.test(p))
-    p = p.slice(0, -1);
-  return isAbsolutePath(p) ? p : undefined;
-}
-function canonicalWinLink(text) {
-  const stripped = text.replace(/^(\\\\\?\\|\\\?\?\\)/, "");
-  return normalizeAbs(stripped) ?? text;
+  return `${lines.join(`
+`)}
+`;
 }
-var probePath = (platform, text) => text !== undefined && platform === "win32" ? canonicalWinLink(text) : text;
-var join = (dir, rel) => dir.endsWith("/") ? `${dir}${rel}` : `${dir}/${rel}`;
-var decode = (bytes) => bytes ? new TextDecoder("utf-8", { fatal: false }).decode(bytes) : "";
-var oneLine2 = (v, max = 64) => v && v.length <= max && !/[\u0000-\u001f\u007f]/.test(v) ? v : undefined;
-var hostAbs = (platform, value) => {
-  const p = normalizeAbs(value);
-  return p && (platform !== "win32" || isWindowsPath(p)) ? p : undefined;
-};
-var underDir = (p, dir) => {
-  const prefix = dir.endsWith("/") ? dir : `${dir}/`;
-  return isWindowsPath(p) ? p.toLowerCase().startsWith(prefix.toLowerCase()) : p.startsWith(prefix);
-};
-var WINDOWS_COMMAND_EXTENSIONS = [".com", ".exe", ".bat", ".cmd"];
-var isWindowsExecutable = (path) => WINDOWS_COMMAND_EXTENSIONS.some((e) => path.toLowerCase().endsWith(e));
 
 // packages/cli/src/bootstrap/discovery/node-probe.ts
+import childProcess from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
 var MAX_READ_BYTES = 16 * 1024 * 1024;
 var kindOf = (st) => st.isSymbolicLink() ? "symlink" : st.isDirectory() ? "directory" : st.isFile() ? "file" : "other";
 function attempt(f) {
@@ -18385,6 +19039,10 @@ function createNodeProbe(options = {}) {
 }
 // packages/cli/src/bootstrap/profiles/desired.ts
 var NO_SERVICES_ON_TARGET = "needs user services, which hubctl does not install on Windows yet";
+var NO_SERVICE_ON_TARGET = "needs a user service hubctl does not install on Windows yet";
+function servicesWithoutTemplate(profile, manager, at = "/profile/services") {
+  return profile.services.flatMap((service, i) => EMBEDDED_ASSETS[`service/${manager}/${service}`] ? [] : [{ path: `${at}/${i}`, code: "unsupported_platform", message: `${service} ${NO_SERVICE_ON_TARGET}` }]);
+}
 
 // packages/cli/src/bootstrap/preview/plan.ts
 var PHASE = {
@@ -18432,6 +19090,11 @@ function planSetup(input) {
     return failed(issuesAt("/snapshot/host/target", target.ok ? fail("", "unsupported_platform", "unsupported host") : target));
   if (profile.services.length > 0 && target.value.serviceManager === "none")
     return fail("/profile/services", "unsupported_platform", `${profile.id} ${NO_SERVICES_ON_TARGET}`);
+  if (target.value.serviceManager !== "none") {
+    const missing = servicesWithoutTemplate(profile, target.value.serviceManager);
+    if (missing.length > 0)
+      return failed(missing);
+  }
   if (profile.services.length > 0 && snapshot.managers.service === "none")
     return fail("/profile/services", "no_service_manager", `the ${profile.id} profile installs services, but this host has no user service manager (launchd or systemd --user)`);
   const planInput = { snapshot, profile };
@@ -18729,6 +19392,8 @@ function discoverRoots(probe) {
     paths["launch-agents"] = join(home, "Library/LaunchAgents");
   if (probe.platform === "linux")
     paths["systemd-user"] = join(config, "systemd/user");
+  if (windows)
+    paths["task-defs"] = join(paths.state, "hub/tasks");
   return ROOT_IDS.flatMap((id) => paths[id] ? [{ id, path: paths[id] }] : []);
 }
 function hubStateRoot(probe, home) {
@@ -18780,17 +19445,17 @@ function discoverLibc(probe) {
 function discoverOS(probe) {
   if (probe.platform === "darwin") {
     const plist = decode(probe.readFile("/System/Library/CoreServices/SystemVersion.plist", 64 * 1024));
-    const value = (key) => oneLine2(new RegExp(`<key>${key}</key>\\s*<string>([^<]*)</string>`).exec(plist)?.[1]);
+    const value = (key) => oneLine3(new RegExp(`<key>${key}</key>\\s*<string>([^<]*)</string>`).exec(plist)?.[1]);
     return { name: value("ProductName") ?? "macOS", version: value("ProductVersion") ?? "unknown" };
   }
   if (probe.platform === "linux") {
     const text = decode(probe.readFile("/etc/os-release", 64 * 1024) ?? probe.readFile("/usr/lib/os-release", 64 * 1024));
-    const value = (key) => oneLine2(new RegExp(`^${key}=(.*)$`, "m").exec(text)?.[1]?.trim().replace(/^(["'])(.*)\1$/, "$2"));
+    const value = (key) => oneLine3(new RegExp(`^${key}=(.*)$`, "m").exec(text)?.[1]?.trim().replace(/^(["'])(.*)\1$/, "$2"));
     return { name: value("NAME") ?? "Linux", version: value("VERSION_ID") ?? "unknown" };
   }
   if (probe.platform === "win32")
-    return { name: oneLine2(probe.osInfo?.name) ?? "Windows", version: oneLine2(probe.osInfo?.version) ?? "unknown" };
-  return { name: oneLine2(probe.platform, 32) ?? "unknown", version: "unknown" };
+    return { name: oneLine3(probe.osInfo?.name) ?? "Windows", version: oneLine3(probe.osInfo?.version) ?? "unknown" };
+  return { name: oneLine3(probe.platform, 32) ?? "unknown", version: "unknown" };
 }
 function discoverContainer(probe) {
   if (probe.platform !== "linux")
@@ -18840,10 +19505,13 @@ function configCandidates(platform, roots, context = "host") {
       add("launch-agents", asset.installAs, "hub", "plist");
     if (platform === "linux" && asset.manager === "systemd-user")
       add("systemd-user", asset.installAs, "hub", "unit");
+    if (platform === "win32" && asset.manager === "task-scheduler")
+      add("task-defs", asset.installAs, "hub", "xml");
   }
   return list.filter((c) => c !== undefined);
 }
 var HARNESS_BIN_DIR = { opencode: "/bin", "claude-code": "", codex: "/bin" };
+var systemRootOf2 = (probe) => hostAbs("win32", probe.env.SystemRoot ?? probe.env.SYSTEMROOT) ?? "C:/Windows";
 function discover(probe, options) {
   let roots = discoverRoots(probe);
   if (!roots)
@@ -18865,6 +19533,8 @@ function discover(probe, options) {
     service = "launchd";
   if (probe.platform === "linux" && probe.lstat("/run/systemd/system") === "directory" && which(probe, [...dirs, "/usr/bin", "/bin"], "systemctl"))
     service = "systemd-user";
+  if (probe.platform === "win32" && probe.executable(join(systemRootOf2(probe), "System32/schtasks.exe")))
+    service = "task-scheduler";
   const shims = [];
   const harnesses = HARNESS_ORDER.map((id) => {
     const name = HARNESS_BINARIES[id];
@@ -19262,7 +19932,7 @@ function installedHarnesses(history) {
 }
 function installedServiceUnits(history, manager) {
   const byFile = new Map(Object.values(EMBEDDED_ASSETS).filter((a) => a.manager === manager).map((a) => [a.installAs, a.service]));
-  const root = manager === "launchd" ? "launch-agents" : "systemd-user";
+  const root = SERVICE_ROOT[manager];
   const units = {};
   for (const tx of history) {
     if (tx.outcome !== "committed")
@@ -19383,7 +20053,7 @@ import {
   readFileSync as readFileSync12,
   readlinkSync as readlinkSync2,
   readSync as readSync2,
-  renameSync as renameSync7,
+  renameSync as renameSync8,
   rmdirSync,
   symlinkSync as symlinkSync2,
   unlinkSync as unlinkSync2,
@@ -19494,7 +20164,7 @@ var posixFs = {
       abort: () => finish(false)
     };
   },
-  rename: (from, to) => renameSync7(from, to),
+  rename: (from, to) => renameSync8(from, to),
   link: (from, to) => linkSync(from, to),
   unlink: (path) => unlinkSync2(path),
   mkdir: (path, mode) => mkdirSync12(path, { mode }),
@@ -20585,208 +21255,6 @@ import { closeSync as closeSync9, mkdtempSync as mkdtempSync3, openSync as openS
 import { tmpdir as tmpdir3 } from "node:os";
 import { join as join2 } from "node:path";
 
-// packages/cli/src/bootstrap/adapters/process-tree.ts
-import { execFile as execFile2, spawn as nodeSpawn } from "node:child_process";
-var TOOL_TIMEOUT_MS = 15000;
-var START_SLACK_MS = 2000;
-var FILETIME_EPOCH_MS = 11644473600000n;
-var defaultExec = (file, args) => new Promise((resolve) => {
-  execFile2(file, [...args], { shell: false, windowsHide: true, timeout: TOOL_TIMEOUT_MS, encoding: "utf8", maxBuffer: 1 << 20 }, (error, stdout) => {
-    const code = error?.code;
-    resolve({ code: error ? typeof code === "number" ? code : null : 0, stdout: String(stdout ?? "") });
-  });
-});
-function systemRootOf(value) {
-  const v = value?.replace(/\\+$/, "");
-  return v && /^[A-Za-z]:\\[A-Za-z0-9 ._\\()-]*$/.test(v) ? v : "C:\\Windows";
-}
-function processTree(deps = {}) {
-  const platform = deps.platform ?? process.platform;
-  if (platform === "win32") {
-    const exec = deps.exec ?? defaultExec;
-    const root = systemRootOf(deps.systemRoot ?? process.env.SystemRoot ?? process.env.SYSTEMROOT);
-    const taskkill = `${root}\\System32\\taskkill.exe`;
-    const powershell = `${root}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
-    const killTree = async (pid) => {
-      if (!Number.isInteger(pid) || pid <= 0)
-        return;
-      try {
-        await exec(taskkill, ["/T", "/F", "/PID", String(pid)]);
-      } catch {}
-    };
-    return {
-      detached: false,
-      killTree,
-      async reap(pid, startedAt) {
-        if (!Number.isInteger(pid) || pid <= 0)
-          return;
-        const since = (BigInt(Math.max(0, Math.floor(startedAt) - START_SLACK_MS)) + FILETIME_EPOCH_MS) * 10000n;
-        const script = `$t=[DateTime]::FromFileTimeUtc(${since}); ` + `Get-CimInstance -ClassName Win32_Process -Filter 'ParentProcessId=${pid}' | ` + `Where-Object { $_.CreationDate.ToUniversalTime() -ge $t } | ForEach-Object { $_.ProcessId }`;
-        let stdout = "";
-        try {
-          stdout = (await exec(powershell, ["-NoProfile", "-NonInteractive", "-Command", script])).stdout;
-        } catch {
-          return;
-        }
-        for (const line of stdout.split(/\r?\n/)) {
-          const child = line.trim();
-          if (/^[1-9]\d*$/.test(child))
-            await killTree(Number(child));
-        }
-      }
-    };
-  }
-  const kill = deps.kill ?? ((pid, signal) => void process.kill(pid, signal));
-  const group = (pid) => {
-    try {
-      kill(-pid, "SIGKILL");
-      return true;
-    } catch {
-      return false;
-    }
-  };
-  return {
-    detached: true,
-    async killTree(pid) {
-      if (!Number.isInteger(pid) || pid <= 0)
-        return;
-      if (group(pid))
-        return;
-      try {
-        kill(pid, "SIGKILL");
-      } catch {}
-    },
-    async reap(pid) {
-      if (Number.isInteger(pid) && pid > 0)
-        group(pid);
-    }
-  };
-}
-var DRAIN_GRACE_MS = 1000;
-function runBounded(request, options = {}) {
-  const tree = options.tree ?? processTree();
-  const spawn = options.spawn ?? nodeSpawn;
-  const now = options.now ?? Date.now;
-  const env = Object.fromEntries(Object.entries(request.env).filter((e) => typeof e[1] === "string"));
-  return new Promise((resolve) => {
-    let timedOut = false;
-    let aborted = false;
-    let overflowed = false;
-    let ended = false;
-    const out = [];
-    const err = [];
-    const size = { out: 0, err: 0 };
-    const result = (exitCode, spawnError) => ({
-      exitCode,
-      stdout: Buffer.concat(out).toString("utf8"),
-      stderr: Buffer.concat(err).toString("utf8"),
-      timedOut,
-      aborted,
-      overflowed,
-      ...spawnError ? { spawnError } : {}
-    });
-    if (request.signal?.aborted) {
-      aborted = true;
-      return resolve(result(null));
-    }
-    const startedAt = now();
-    let child;
-    try {
-      child = spawn(request.file, [...request.args], {
-        shell: false,
-        env,
-        stdio: ["ignore", "pipe", request.stderr ? "pipe" : "ignore"],
-        windowsHide: true,
-        detached: tree.detached
-      });
-    } catch (error) {
-      return resolve(result(null, error));
-    }
-    let settled = false;
-    let exited = false;
-    const pid = child.pid;
-    const end = () => {
-      if (ended || pid === undefined)
-        return;
-      ended = true;
-      tree.killTree(pid);
-    };
-    const timer = setTimeout(() => {
-      timedOut = true;
-      end();
-    }, request.timeoutMs);
-    const onAbort = () => {
-      aborted = true;
-      end();
-    };
-    request.signal?.addEventListener("abort", onAbort, { once: true });
-    const finish = (r) => {
-      if (settled)
-        return;
-      settled = true;
-      clearTimeout(timer);
-      request.signal?.removeEventListener("abort", onAbort);
-      resolve(r);
-    };
-    const collect = (into, key) => (chunk) => {
-      const room = request.maxOutputBytes - size[key];
-      if (chunk.length > room) {
-        overflowed = true;
-        if (room > 0)
-          into.push(chunk.subarray(0, room));
-        size[key] = request.maxOutputBytes;
-        if ((request.overflow ?? "kill") === "kill")
-          end();
-        return;
-      }
-      into.push(chunk);
-      size[key] += chunk.length;
-    };
-    child.stdout?.on("data", collect(out, "out"));
-    child.stderr?.on("data", collect(err, "err"));
-    const streams = [child.stdout, child.stderr].filter((s) => Boolean(s));
-    const drained = () => new Promise((done) => {
-      let open = streams.filter((s) => !s.readableEnded && !s.destroyed).length;
-      if (open === 0)
-        return done();
-      const grace = setTimeout(() => {
-        for (const s of streams)
-          s.destroy();
-        done();
-      }, DRAIN_GRACE_MS);
-      for (const s of streams) {
-        if (s.readableEnded || s.destroyed)
-          continue;
-        const one = () => {
-          if (--open === 0) {
-            clearTimeout(grace);
-            done();
-          }
-        };
-        s.once("end", one);
-        s.once("close", () => s.readableEnded ? undefined : one());
-      }
-    });
-    child.on("error", (error) => {
-      if (!exited)
-        finish(result(null, error));
-    });
-    child.on("exit", (code) => {
-      if (exited)
-        return;
-      exited = true;
-      clearTimeout(timer);
-      const exitCode = typeof code === "number" && !ended ? code : null;
-      (async () => {
-        if (pid !== undefined)
-          await tree.reap(pid, startedAt);
-        await drained();
-        finish(result(exitCode));
-      })();
-    });
-  });
-}
-
 // packages/cli/src/bootstrap/adapters/claude/ports.ts
 class DownloadTooLarge extends Error {
   constructor(url, maxBytes) {
@@ -21512,7 +21980,7 @@ var OIDC_ISSUER_V2 = "1.3.6.1.4.1.57264.1.8";
 var OIDC_ISSUER_V1 = "1.3.6.1.4.1.57264.1.1";
 var isObj5 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var b64 = (s) => typeof s === "string" && /^[A-Za-z0-9+/]*={0,2}$/.test(s) ? Buffer.from(s, "base64") : undefined;
-var within3 = (t, v) => t >= v.start && (v.end === undefined || t <= v.end);
+var within4 = (t, v) => t >= v.start && (v.end === undefined || t <= v.end);
 function tlv(buf, at) {
   const tag = buf[at];
   let len = buf[at + 1];
@@ -21647,7 +22115,7 @@ function verifySigstoreBundle(bundle, artifact, options) {
     const t = b.payload.integratedTime * 1000;
     if (t < Date.parse(leaf.validFrom) || t > Date.parse(leaf.validTo))
       return failed2("the entry was logged outside the certificate's validity");
-    if (!within3(t, authority.validFor))
+    if (!within4(t, authority.validFor))
       return failed2("the entry was logged outside the CA's validity");
     const sans = (leaf.subjectAltName ?? "").split(/,\s*/);
     if (!sans.includes(`URI:${identity.san}`))
@@ -21667,7 +22135,7 @@ function verifySigstoreBundle(bundle, artifact, options) {
     const log = trust.logs.find((l) => l.logID === b.payload.logID.toLowerCase());
     if (!log)
       return unavailable("the entry is in a transparency log this hubctl does not trust");
-    if (!within3(t, log.validFor))
+    if (!within4(t, log.validFor))
       return failed2("the entry was logged outside the log key's validity");
     if (!verifySET(log, b))
       return failed2("the transparency log's signed entry timestamp does not verify");
@@ -21804,13 +22272,50 @@ var labelOfTarget = (word) => {
   const at = word?.lastIndexOf("/") ?? -1;
   return at > 0 && DOMAIN.test(word.slice(0, at)) ? word.slice(at + 1) : undefined;
 };
+var TASK_FILES = new Set(Object.values(EMBEDDED_ASSETS).flatMap((a) => a.manager === "task-scheduler" ? [a.installAs] : []));
+var TASK_FILE = /^[A-Z]:\\(?:[^\\/:*?"<>|]+\\)*([^\\/:*?"<>|]+)$/;
+function taskQueryWords(name) {
+  if (!TASK_NAME.test(name))
+    throw new Error(`not a hub task name: ${JSON.stringify(name)}`);
+  const script = "$ErrorActionPreference='Stop';$s=New-Object -ComObject Schedule.Service;$s.Connect();" + `$t=$s.GetFolder('\\').GetTask('${name}');` + "'state='+[int]$t.State;'enabled='+$t.Enabled;'result='+$t.LastTaskResult;" + "foreach($r in $t.GetInstances(0)){'pid='+$r.EnginePID}";
+  return ["-NoProfile", "-NonInteractive", "-Command", script];
+}
+function checkWindowsCall(program, words) {
+  if (program === "taskkill")
+    return words.length === 4 && words[0] === "/T" && words[1] === "/F" && words[2] === "/PID" && /^[1-9][0-9]{0,9}$/.test(words[3]);
+  if (program === "powershell") {
+    const name = /GetTask\('([^']*)'\)/.exec(words[words.length - 1] ?? "")?.[1];
+    if (!name || !TASK_NAME.test(name))
+      return false;
+    const expected = taskQueryWords(name);
+    return words.length === expected.length && words.every((w, i) => w === expected[i]);
+  }
+  const [verb, tn, name] = words;
+  if (tn !== "/TN" || !TASK_NAME.test(name ?? ""))
+    return false;
+  if (verb === "/Run" || verb === "/End")
+    return words.length === 3;
+  if (verb === "/Delete")
+    return words.length === 4 && words[3] === "/F";
+  if (verb === "/Query")
+    return words.length === 4 && words[3] === "/XML";
+  if (verb === "/Create")
+    return words.length === 6 && words[3] === "/XML" && words[5] === "/F" && TASK_FILES.has(TASK_FILE.exec(words[4])?.[1] ?? "");
+  return false;
+}
+var WINDOWS_PROGRAMS = new Set(["schtasks", "powershell", "taskkill"]);
 function checkManagerCall(call) {
-  if (!isRecord2(call) || !Array.isArray(call.words) || call.words.length > 4)
+  if (!isRecord2(call) || !Array.isArray(call.words))
+    return false;
+  const windows = typeof call.program === "string" && WINDOWS_PROGRAMS.has(call.program);
+  if (call.words.length > (windows ? 6 : 4))
     return false;
   const w = call.words;
   if (!w.every((x) => typeof x === "string" && x.length > 0 && x.length <= 4096 && !CONTROL5.test(x)))
     return false;
   const words = w;
+  if (windows)
+    return checkWindowsCall(call.program, words);
   if (call.program === "systemctl") {
     if (words[0] !== "--user")
       return false;
@@ -21844,6 +22349,24 @@ function unitPathResolver(roots, context) {
     return where.ok ? where.value : undefined;
   };
 }
+var taskFields = (output) => showFields(output.replaceAll("\r", ""));
+var taskPids = (output) => output.replaceAll("\r", "").split(`
+`).flatMap((line) => /^pid=([1-9][0-9]{0,9})$/.exec(line.trim()) ? [Number(line.trim().slice(4))] : []);
+function taskSchedulerHealth(output) {
+  const fields = taskFields(output);
+  const state = /^[0-4]$/.test(fields.state ?? "") ? Number(fields.state) : undefined;
+  const result = /^-?[0-9]{1,10}$/.test(fields.result ?? "") ? Number(fields.result) >>> 0 : undefined;
+  const pid = taskPids(output)[0];
+  if (state === 4)
+    return { state: "running", restarts: 0, detail: pid ? `running, pid ${pid}` : "running" };
+  if (state === 2)
+    return { state: "starting", restarts: 0, detail: "queued" };
+  if (state === 1)
+    return { state: "stopped", restarts: 0, detail: "disabled" };
+  if (state === 3)
+    return { state: result === 267011 ? "starting" : "stopped", restarts: 0, detail: `ready, last result 0x${(result ?? 0).toString(16)}` };
+  return { state: "stopped", restarts: 0, detail: "unknown" };
+}
 var ok4 = txOk(undefined);
 function showFields(output) {
   const fields = {};
@@ -22005,20 +22528,84 @@ function createServiceControl(options) {
       return await call("launchctl", "print", `${domain}/${label}`) === 0 ? txFail("internal", `${label} is still loaded after launchctl bootout`) : ok4;
     }
   };
-  const deactivate = (service, manager) => guarded(() => manager === "launchd" ? launchd.deactivate(service) : systemd.restore(service, { loaded: false, enabled: false }));
+  const taskOf = (service) => {
+    const name = options.taskName?.(service);
+    return name && TASK_NAME.test(name) ? name : undefined;
+  };
+  const noTask = (service) => txFail("invalid", `this hubctl has no Task Scheduler task name for the ${service} service`);
+  const tasks = {
+    async query(name) {
+      const r = await options.run(checked("powershell", ...taskQueryWords(name)));
+      return r.exitCode === 0 ? r.output ?? "" : undefined;
+    },
+    async endTrees(name) {
+      for (const pid of taskPids(await tasks.query(name) ?? ""))
+        await call("taskkill", "/T", "/F", "/PID", String(pid));
+    },
+    async state(service) {
+      const name = taskOf(service);
+      if (!name)
+        return noTask(service);
+      const r = await options.run(checked("schtasks", "/Query", "/TN", name, "/XML"));
+      if (r.exitCode !== 0)
+        return txOk({ loaded: false, enabled: false });
+      const enabled = /<Settings>[\s\S]*?<Enabled>(true|false)<\/Enabled>/.exec(r.output ?? "")?.[1] !== "false";
+      return txOk({ loaded: true, enabled });
+    },
+    async activate(service) {
+      const name = taskOf(service);
+      if (!name)
+        return noTask(service);
+      const file = options.unitPath(service, "task-scheduler");
+      if (!file)
+        return txFail("invalid", `this host has no task-defs directory for ${name}`);
+      await tasks.endTrees(name);
+      const created = await call("schtasks", "/Create", "/TN", name, "/XML", toNativePath(file, "win32"), "/F");
+      if (created !== 0)
+        return txFail("internal", `schtasks /Create of ${name} failed (exit ${created})`);
+      const run = await call("schtasks", "/Run", "/TN", name);
+      if (run !== 0)
+        return txFail("internal", `schtasks /Run of ${name} failed (exit ${run})`);
+      return settle(() => tasks.health(service), name, `schtasks /Query /TN ${name} /V /FO LIST and the Task Scheduler history`);
+    },
+    async health(service) {
+      const name = taskOf(service);
+      if (!name)
+        return noTask(service);
+      const output = await tasks.query(name);
+      return txOk(output === undefined ? { state: "stopped", restarts: 0, detail: "not registered" } : taskSchedulerHealth(output));
+    },
+    async deactivate(service) {
+      const name = taskOf(service);
+      if (!name)
+        return noTask(service);
+      await tasks.endTrees(name);
+      await call("schtasks", "/End", "/TN", name);
+      await call("schtasks", "/Delete", "/TN", name, "/F");
+      return await call("schtasks", "/Query", "/TN", name, "/XML") === 0 ? txFail("internal", `${name} is still registered after schtasks /Delete`) : ok4;
+    }
+  };
+  const by = (manager, calls) => guarded(() => {
+    const f = Object.hasOwn(calls, manager) ? calls[manager] : undefined;
+    if (!f)
+      throw new Error(`unknown service manager ${String(manager)}`);
+    return f();
+  });
+  const deactivate = (service, manager) => by(manager, { launchd: () => launchd.deactivate(service), "systemd-user": () => systemd.restore(service, { loaded: false, enabled: false }), "task-scheduler": () => tasks.deactivate(service) });
   return {
-    state: (service, manager) => guarded(() => manager === "launchd" ? launchd.state(service) : systemd.state(service)),
-    activate: (service, manager) => guarded(() => manager === "launchd" ? launchd.activate(service) : systemd.activate(service)),
+    state: (service, manager) => by(manager, { launchd: () => launchd.state(service), "systemd-user": () => systemd.state(service), "task-scheduler": () => tasks.state(service) }),
+    activate: (service, manager) => by(manager, { launchd: () => launchd.activate(service), "systemd-user": () => systemd.activate(service), "task-scheduler": () => tasks.activate(service) }),
     deactivate,
-    restore: (service, manager, prior) => prior.loaded ? guarded(async () => manager === "launchd" ? ok4 : systemd.restore(service, prior)) : deactivate(service, manager),
-    health: (service, manager) => guarded(() => manager === "launchd" ? launchd.health(service) : systemd.health(service))
+    restore: (service, manager, prior) => prior.loaded ? by(manager, { launchd: async () => ok4, "systemd-user": () => systemd.restore(service, prior), "task-scheduler": async () => ok4 }) : deactivate(service, manager),
+    health: (service, manager) => by(manager, { launchd: () => launchd.health(service), "systemd-user": () => systemd.health(service), "task-scheduler": () => tasks.health(service) })
   };
 }
 var MAX_OUTPUT2 = 64 * 1024;
-var capturesOutput = (call) => call.program === "systemctl" ? call.words[1] === "show" : call.words[0] === "print";
+var capturesOutput = (call) => call.program === "systemctl" ? call.words[1] === "show" : call.program === "launchctl" ? call.words[0] === "print" : call.program === "powershell" || call.program === "schtasks" && call.words[0] === "/Query";
 var BUS_ENV = ["XDG_RUNTIME_DIR", "DBUS_SESSION_BUS_ADDRESS"];
+var WINDOWS_ENV = ["SystemRoot", "windir", "SystemDrive", "TEMP", "TMP", "USERPROFILE", "LOCALAPPDATA", "APPDATA", "USERNAME", "USERDOMAIN"];
 var defaultSpawn = (file, words, options) => new Promise((resolve) => {
-  const child = nodeSpawn2(file, [...words], { shell: false, env: { ...options.env }, stdio: ["ignore", options.capture ? "pipe" : "ignore", "ignore"], timeout: options.timeoutMs, killSignal: "SIGKILL" });
+  const child = nodeSpawn2(file, [...words], { shell: false, windowsHide: true, env: { ...options.env }, stdio: ["ignore", options.capture ? "pipe" : "ignore", "ignore"], timeout: options.timeoutMs, killSignal: "SIGKILL" });
   let output = "";
   child.stdout?.setEncoding("utf8");
   child.stdout?.on("data", (chunk) => {
@@ -22030,13 +22617,16 @@ var defaultSpawn = (file, words, options) => new Promise((resolve) => {
   child.on("close", (code, signal) => done(code ?? (signal ? 128 : 1)));
 });
 function spawnManagerRunner(options) {
-  for (const program of ["systemctl", "launchctl"]) {
+  const given = Object.keys(options.programs);
+  const windows = given.some((p) => WINDOWS_PROGRAMS.has(p));
+  for (const program of windows ? given : ["systemctl", "launchctl"]) {
     const file = options.programs[program];
-    if (!isAbsolutePath(file) || path34.basename(file) !== program)
+    const base = file === undefined ? "" : path34.basename(file);
+    if (!isAbsolutePath(file) || base !== program && base.toLowerCase() !== `${program}.exe`)
       throw new Error(`${program} must be given as an absolute path to ${program}`);
   }
   const env = {};
-  for (const key of BUS_ENV)
+  for (const key of windows ? WINDOWS_ENV : BUS_ENV)
     if (options.env?.[key])
       env[key] = options.env[key];
   const spawn = options.spawn ?? defaultSpawn;
@@ -22045,7 +22635,10 @@ function spawnManagerRunner(options) {
     if (!checkManagerCall(call))
       throw new Error(`refused a service manager call outside the fixed set (${String(call.program)})`);
     const capture = capturesOutput(call);
-    const r = await spawn(options.programs[call.program], [...call.words], { shell: false, env, timeoutMs, ...capture ? { capture: true } : {} });
+    const file = options.programs[call.program];
+    if (!file)
+      throw new Error(`this host's service manager does not use ${call.program}`);
+    const r = await spawn(file, [...call.words], { shell: false, env, timeoutMs, ...capture ? { capture: true } : {} });
     if (typeof r === "number")
       return { exitCode: r };
     return capture ? { exitCode: r.exitCode, output: r.output.slice(0, MAX_OUTPUT2) } : { exitCode: r.exitCode };
@@ -22224,8 +22817,12 @@ function launchSessionExecutor(probe) {
 var DEFAULT_SLOTS2 = 4;
 var BOOTSTRAP_SLOTS_MAX = 64;
 var RESERVED_LABELS = ["os", "arch"];
-var inside = (path, dir) => path === dir || path.startsWith(dir === "/" ? "/" : `${dir}/`);
-var parentOf3 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
+var folded = (p) => isWindowsPath(p) ? p.toLowerCase() : p;
+var inside = (path, dir) => {
+  const [p, d] = [folded(path), folded(dir)];
+  return p === d || p.startsWith(d.endsWith("/") ? d : `${d}/`);
+};
+var parentOf3 = (path) => folded(path.slice(0, path.lastIndexOf("/")) || "/");
 function otherViews(roots, context) {
   return roots.flatMap((r) => r.containerPath !== undefined && r.containerPath !== r.path ? [context === "container" ? r.path : r.containerPath] : []);
 }
@@ -22348,6 +22945,7 @@ function serviceContextOf(input) {
 // packages/cli/src/bootstrap/adapters/node-services/plan.ts
 var NODE_CONFIG_REF = { root: "config", rel: "hub/node.json" };
 var CONFIG_DIR = { root: "config", rel: "hub" };
+var UNIT_KIND = { launchd: "launchd agent", "systemd-user": "systemd --user unit", "task-scheduler": "logon task" };
 var LABEL3 = { node: "hub node", "claude-code": "Claude Code spoke", "codex-spoke": "Codex spoke" };
 var SERVICE_HARNESS = Object.fromEntries(Object.entries(HARNESS_SERVICE).map(([h, s]) => [s, h]));
 var BIN_SETTING = { "claude-code": "HUB_CLAUDE_BIN", codex: "HUB_CODEX_BIN" };
@@ -22424,9 +23022,19 @@ function planNodeServices(input, options) {
     }
   }
   const units = [];
+  const uncarried = new Set;
   for (const service of profile.services) {
-    const environment = environmentFor(service, servedBy(service, profile.harnesses), ctx, options.environment);
-    const unit = renderServiceUnit({ service, manager: ctx.manager, layout: options.layout, home: ctx.home, environment });
+    let environment = environmentFor(service, servedBy(service, profile.harnesses), ctx, options.environment);
+    if (ctx.manager === "task-scheduler") {
+      for (const key of Object.keys(environment))
+        uncarried.add(key);
+      environment = {};
+      if (!options.task) {
+        issues.push({ path: `/services/${service}/task`, code: "missing_field", message: "a Windows logon task needs its name and your SID; hubctl could not find them (USERNAME, whoami)" });
+        continue;
+      }
+    }
+    const unit = renderServiceUnit({ service, manager: ctx.manager, layout: options.layout, home: ctx.home, environment, ...ctx.manager === "task-scheduler" ? { task: options.task } : {} });
     if (!unit.ok) {
       issues.push(...prefixed(`/services/${service}`, unit));
       continue;
@@ -22436,7 +23044,7 @@ function planNodeServices(input, options) {
       id: `install-${service}-service`,
       kind: "install-service",
       escalation: "user",
-      summary: `Write the ${LABEL3[service]} ${ctx.manager === "launchd" ? "launchd agent" : "systemd --user unit"} (${unit.value.name})`,
+      summary: `Write the ${LABEL3[service]} ${UNIT_KIND[ctx.manager]} (${unit.value.name})`,
       service,
       manager: ctx.manager,
       path: unit.value.path,
@@ -22468,7 +23076,7 @@ function planNodeServices(input, options) {
   }
   if (issues.length > 0)
     return failed3(issues);
-  return { ok: true, value: { actions, units, ...settings ? { settings } : {}, context: ctx, notes: notesFor(options, ctx) } };
+  return { ok: true, value: { actions, units, ...settings ? { settings } : {}, context: ctx, notes: notesFor(options, ctx, [...uncarried].sort()) } };
 }
 function checkLaunch(input, options, ctx, settings) {
   const launch = options.launch;
@@ -22486,11 +23094,15 @@ function checkLaunch(input, options, ctx, settings) {
     return [{ path: "/launch/workspace", code: "invalid_path", message: `${where.value} is outside the node's workspace roots` }];
   return [];
 }
-function notesFor(options, ctx) {
+function notesFor(options, ctx, uncarried) {
   const notes = [];
   if (!options.activate)
     notes.push("The services are installed but not loaded: pass --confirm-activation to load them (hubctl never loads a service without it).");
-  if (ctx.manager === "systemd-user")
+  if (ctx.manager === "task-scheduler") {
+    notes.push("The hub node runs as a logon task for you (no window, no administrator rights, no stored password): Windows starts it at each logon and again within a minute after it exits; it runs while you are logged in.");
+    if (uncarried.length > 0)
+      notes.push(`The logon task does not see ${uncarried.join(", ")} from this shell (a task has no environment of its own); set them as user environment variables if the node needs them.`);
+  } else if (ctx.manager === "systemd-user")
     notes.push(options.linger ? "To keep the services running while you are logged out, run `loginctl enable-linger` yourself; hubctl does not change login settings." : "systemd --user services stop when you log out; keeping them running (linger) is opt-in.");
   else
     notes.push("launchd user agents run while you are logged in.");
@@ -22796,7 +23408,6 @@ function createOpencodeHarness(options) {
 }
 
 // packages/cli/src/bootstrap/profiles/upgrade.ts
-var UNIT_ROOT2 = { launchd: "launch-agents", "systemd-user": "systemd-user" };
 function removeServiceActions(service, facts) {
   const actions = [
     { id: `deactivate-${service}`, kind: "deactivate-service", escalation: "user", summary: `Unload the hub ${service} service (profile downgrade)`, service, manager: facts.manager }
@@ -22811,7 +23422,7 @@ function removeServiceActions(service, facts) {
       summary: `Remove the hub ${service} ${facts.manager} unit (profile downgrade)`,
       service,
       manager: facts.manager,
-      path: { root: UNIT_ROOT2[facts.manager], rel: asset.installAs },
+      path: { root: SERVICE_ROOT[facts.manager], rel: asset.installAs },
       sha256
     });
   return actions;
@@ -24014,6 +24625,10 @@ function codexSpokeStatus(options) {
 }
 
 // packages/cli/src/setup/runtime.ts
+function windowsServicePrograms(systemRoot) {
+  const dir = `${systemRoot.replace(/\/+$/, "")}/System32`;
+  return { schtasks: `${dir}/schtasks.exe`, powershell: `${dir}/WindowsPowerShell/v1.0/powershell.exe`, taskkill: `${dir}/taskkill.exe` };
+}
 function readinessGate(consent, harness) {
   return { requireReady: consent.requireReady === true || (consent.strict ?? []).includes(harness), ...consent.onReadiness ? { onReadiness: consent.onReadiness } : {} };
 }
@@ -24182,7 +24797,8 @@ function createSetupRuntime(deps) {
           ...choices.node ? { node: choices.node } : {},
           ...choices.activate ? { activate: true } : {},
           environment: deps.env,
-          ...choices.launch ? { launch: choices.launch } : {}
+          ...choices.launch ? { launch: choices.launch } : {},
+          ...input.snapshot.managers.service === "task-scheduler" && input.profile.services.length > 0 ? { task: taskIdentity() } : {}
         });
         if (!planned.ok)
           return planned;
@@ -24203,15 +24819,28 @@ function createSetupRuntime(deps) {
     ];
     return { sources: { adapters: registry, contributors, ...choices.enrollment ? { enrollment: choices.enrollment } : {} }, node: () => nodePlan, history: records };
   }
+  function taskIdentity() {
+    return { name: taskNameFor("node", deps.env.USERNAME ?? "", deps.env), userSid: (ports.userSid ?? (() => defaultWinAcl().sid()))() };
+  }
   function control(snap) {
     if (snap.managers.service === "none")
       return;
+    const tasks = snap.managers.service === "task-scheduler";
     let run = ports.serviceRunner;
     if (!run) {
-      const systemctl = which(deps.probe, [...pathDirs(deps.probe), "/usr/bin", "/bin"], "systemctl") ?? "/usr/bin/systemctl";
-      run = spawnManagerRunner({ programs: { launchctl: "/bin/launchctl", systemctl }, env: deps.env });
+      if (tasks)
+        run = spawnManagerRunner({ programs: windowsServicePrograms(systemRootOf2(deps.probe)), env: deps.env });
+      else {
+        const systemctl = which(deps.probe, [...pathDirs(deps.probe), "/usr/bin", "/bin"], "systemctl") ?? "/usr/bin/systemctl";
+        run = spawnManagerRunner({ programs: { launchctl: "/bin/launchctl", systemctl }, env: deps.env });
+      }
     }
-    return createServiceControl({ run, uid: ports.uid ?? deps.probe.uid, unitPath: unitPathResolver(snap.roots, executionContextOf(snap)) });
+    return createServiceControl({
+      run,
+      uid: ports.uid ?? deps.probe.uid,
+      unitPath: unitPathResolver(snap.roots, executionContextOf(snap)),
+      ...tasks ? { taskName: (service) => taskNameFor(service, deps.env.USERNAME ?? "", deps.env) } : {}
+    });
   }
   function hubctlSource() {
     const manifest = deps.manifest;
@@ -24506,14 +25135,14 @@ class BootstrapStateStore {
 }
 
 // packages/cli/src/setup/self-aside.ts
-import { spawn as spawn7 } from "node:child_process";
-import { readdirSync as readdirSync4, statSync as statSync6, unlinkSync as unlinkSync3 } from "node:fs";
+import { spawn as spawn8 } from "node:child_process";
+import { readdirSync as readdirSync4, statSync as statSync7, unlinkSync as unlinkSync3 } from "node:fs";
 var nodeSelfAsideIo = (env = process.env) => ({
   platform: process.platform,
   systemRoot: env.SystemRoot ?? env.SYSTEMROOT ?? "C:\\Windows",
   stat: (path) => {
     try {
-      return { ino: statSync6(path, { bigint: true }).ino };
+      return { ino: statSync7(path, { bigint: true }).ino };
     } catch {
       return;
     }
@@ -24521,7 +25150,7 @@ var nodeSelfAsideIo = (env = process.env) => ({
   readdir: (path) => readdirSync4(path),
   unlink: (path) => unlinkSync3(path),
   spawnDetached: (file, line, cwd) => {
-    const child = spawn7(file, [line], { cwd, detached: true, stdio: "ignore", windowsHide: true, windowsVerbatimArguments: true });
+    const child = spawn8(file, [line], { cwd, detached: true, stdio: "ignore", windowsHide: true, windowsVerbatimArguments: true });
     child.on("error", () => {});
     child.unref();
   }
@@ -24774,20 +25403,38 @@ function refFor(abs, snapshot) {
   for (const id of ["home"]) {
     const root = snapshot.roots.find((r) => r.id === id);
     const base = root ? rootPathIn(root, ctx) : undefined;
-    if (base && abs.startsWith(`${base}/`))
-      return { root: id, rel: abs.slice(base.length + 1) };
+    if (base && underDir(abs, base))
+      return { root: id, rel: abs.slice(base.length + (base.endsWith("/") ? 0 : 1)) };
   }
   return;
 }
+function workspaceRootOf(raw, where) {
+  if (where.platform !== "win32")
+    return path35.resolve(where.cwd, raw);
+  if (/^[\\/]{2}/.test(raw))
+    return;
+  const home = normalizeAbs(where.home);
+  const tilde = /^~(?:[\\/](.*))?$/.exec(raw);
+  if (tilde)
+    return home ? normalizeAbs(path35.win32.join(home, tilde[1] ?? "")) : undefined;
+  const resolved = path35.win32.resolve(path35.win32.normalize(where.cwd), raw);
+  return /^[\\/]{2}/.test(resolved) ? undefined : normalizeAbs(resolved);
+}
 function choicesOf(io, flags, profile, snapshot) {
   const enrollment = str(flags, "enrollment");
   if (enrollment !== undefined && !ENROLLMENT_MODES.includes(enrollment))
     throw new Refusal("usage", `--enrollment is ${ENROLLMENT_MODES.join(" or ")}`);
-  let roots = flags["workspace-root"]?.map((r) => path35.resolve(io.cwd ?? process.cwd(), r));
+  const where = { platform: snapshot.host.platform, cwd: io.cwd ?? process.cwd(), home: io.home };
+  let roots = flags["workspace-root"]?.map((r) => {
+    const root = workspaceRootOf(r, where);
+    if (root === undefined)
+      throw new Refusal("usage", `--workspace-root ${r} is not a local absolute path (a drive path such as C:\\Users\\you\\projects, or ~/projects)`);
+    return root;
+  });
   if (!roots?.length && profile.services.includes("node")) {
     const existing = readNodeConfig(nodeConfigPath(io.env, io.home)).config.workspaceRoots;
     if (existing.length > 0)
-      roots = [...existing];
+      roots = where.platform === "win32" ? existing.map((r) => workspaceRootOf(r, where) ?? r) : [...existing];
   }
   const launchHarness = str(flags, "verify-launch");
   let launch;
@@ -24907,7 +25554,7 @@ async function preview3(io, flags, json) {
     else {
       const tmp = `${file}.${process.pid}.tmp`;
       writeFileSync8(tmp, text, { mode: 384 });
-      renameSync8(tmp, file);
+      renameSync9(tmp, file);
     }
   }
   const warnings = previewWarnings(snapshot, r.value.plan, bundle.node()?.notes ?? [], io.env);