@zixt/host 0.0.75 → 0.0.76

package/dist/index.js

@@ -16,22 +16,22 @@ import { fstatSync } from "node:fs";
 import {
   access as access2,
   lstat as lstat5,
-  mkdir as mkdir4,
+  mkdir as mkdir5,
   open as open4,
   readFile as readFile6,
   readlink,
   readdir as readdir3,
   rename as rename3,
-  rm as rm4,
+  rm as rm5,
   symlink
 } from "node:fs/promises";
-import { basename as basename3, dirname as dirname4, isAbsolute as isAbsolute8, join as join7, relative as relative4, resolve as resolve5, sep as sep4 } from "node:path";
+import { basename as basename4, dirname as dirname5, isAbsolute as isAbsolute8, join as join8, relative as relative4, resolve as resolve5, sep as sep4 } from "node:path";
 import { homedir as homedir2 } from "node:os";
 
 // package.json
 var package_default = {
   name: "@zixt/host",
-  version: "0.0.75",
+  version: "0.0.76",
   type: "module",
   exports: {
     ".": "./src/client.ts",
@@ -24037,22 +24037,107 @@ function createReleaseStateStore(root) {
   };
 }
 
+// src/launcher-claim.ts
+import { createHash as createHash2 } from "node:crypto";
+import { mkdir as mkdir3, rm as rm3 } from "node:fs/promises";
+import { createConnection, createServer } from "node:net";
+import { basename as basename3, dirname as dirname3, join as join6 } from "node:path";
+var PEER_PROBE_TIMEOUT_MS = 2e3;
+function machineLauncherClaimAddress(ownershipRoot, platform = process.platform) {
+  if (platform !== "win32") {
+    return join6(dirname3(ownershipRoot), `.${basename3(ownershipRoot)}-claim.sock`);
+  }
+  const digest = createHash2("sha256").update(ownershipRoot.toLowerCase()).digest("hex").slice(0, 32);
+  return `\\\\.\\pipe\\zixt-host-launcher-${digest}`;
+}
+function describe4(error52) {
+  const code = error52?.code;
+  if (typeof code === "string" && code.length > 0) return code;
+  return error52 instanceof Error ? error52.message : "unknown error";
+}
+function peerAnswers(address) {
+  return new Promise((resolve17) => {
+    const socket = createConnection(address);
+    let settled = false;
+    const finish = (answered) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      resolve17(answered);
+    };
+    socket.setTimeout(PEER_PROBE_TIMEOUT_MS, () => finish(true));
+    socket.once("connect", () => finish(true));
+    socket.once("error", () => finish(false));
+  });
+}
+function listen(address) {
+  return new Promise((resolve17) => {
+    const server = createServer((socket) => socket.destroy());
+    const fail = (error52) => {
+      server.close();
+      resolve17({ error: error52 });
+    };
+    server.once("error", fail);
+    server.listen(address, () => {
+      server.off("error", fail);
+      server.on("error", () => {
+      });
+      server.unref();
+      resolve17({ server });
+    });
+  });
+}
+async function claimMachineLauncher(ownershipRoot, platform = process.platform) {
+  const address = machineLauncherClaimAddress(ownershipRoot, platform);
+  if (platform !== "win32") {
+    try {
+      await mkdir3(dirname3(address), { recursive: true, mode: 448 });
+    } catch (error52) {
+      return { kind: "unavailable", reason: describe4(error52) };
+    }
+  }
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const outcome = await listen(address);
+    if ("server" in outcome) {
+      const { server } = outcome;
+      return {
+        kind: "held",
+        release: async () => {
+          await new Promise((resolve17) => server.close(() => resolve17()));
+          if (platform !== "win32") await rm3(address, { force: true }).catch(() => {
+          });
+        }
+      };
+    }
+    if (outcome.error.code !== "EADDRINUSE") {
+      return { kind: "unavailable", reason: describe4(outcome.error) };
+    }
+    if (platform === "win32" || await peerAnswers(address)) return { kind: "busy" };
+    try {
+      await rm3(address, { force: true });
+    } catch (error52) {
+      return { kind: "unavailable", reason: describe4(error52) };
+    }
+  }
+  return { kind: "busy" };
+}
+
 // src/runners/run-artifacts.ts
 import { spawn as spawn4 } from "node:child_process";
 import {
   chmod as chmod2,
   lstat as lstat4,
-  mkdir as mkdir3,
+  mkdir as mkdir4,
   open as open3,
   readdir as readdir2,
   readFile as readFile5,
   realpath as realpath3,
   rename as rename2,
-  rm as rm3,
+  rm as rm4,
   writeFile
 } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname as dirname3, isAbsolute as isAbsolute7, join as join6, relative as relative3, resolve as resolve4, sep as sep3, win32 as win322 } from "node:path";
+import { dirname as dirname4, isAbsolute as isAbsolute7, join as join7, relative as relative3, resolve as resolve4, sep as sep3, win32 as win322 } from "node:path";
 
 // src/windows-job.ts
 import { spawn as spawn3 } from "node:child_process";
@@ -24791,7 +24876,7 @@ foreach ($path in $paths) {
 }
 `;
 function defaultRunArtifactRoot() {
-  return join6(homedir(), ".zixt", "run-artifacts");
+  return join7(homedir(), ".zixt", "run-artifacts");
 }
 function requireSafeSegment(value, field) {
   if (!SAFE_SEGMENT.test(value)) {
@@ -24847,7 +24932,7 @@ async function prepareRoot(root) {
     await lstat4(absolute);
   } catch (error52) {
     if (!isMissing(error52)) throw error52;
-    await mkdir3(absolute, { recursive: true, mode: DIRECTORY_MODE });
+    await mkdir4(absolute, { recursive: true, mode: DIRECTORY_MODE });
   }
   const real = await requireRealDirectory(absolute, "run artifact root");
   if (realProfile) assertWindowsProfileBoundary(realProfile, real);
@@ -24855,14 +24940,14 @@ async function prepareRoot(root) {
   return real;
 }
 async function prepareAgentRoot(root, agentId) {
-  const path = join6(root, agentId);
+  const path = join7(root, agentId);
   assertBelow(root, path);
   try {
     await lstat4(path);
   } catch (error52) {
     if (!isMissing(error52)) throw error52;
     try {
-      await mkdir3(path, { mode: DIRECTORY_MODE });
+      await mkdir4(path, { mode: DIRECTORY_MODE });
     } catch (mkdirError) {
       if (mkdirError.code !== "EEXIST") throw mkdirError;
     }
@@ -24878,7 +24963,7 @@ async function lockDownWindowsDirectories(paths) {
   if (!windowsRoot || !win322.isAbsolute(windowsRoot)) {
     throw new Error("private Windows run-artifact ACL authority is unavailable");
   }
-  const powershell = join6(windowsRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+  const powershell = join7(windowsRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
   const encoded = Buffer.from(WINDOWS_PRIVATE_DACL_SCRIPT, "utf16le").toString("base64");
   await new Promise((resolvePromise, reject3) => {
     const helper = spawn4(
@@ -24920,9 +25005,9 @@ async function lockDownWindowsDirectories(paths) {
   });
 }
 async function createPrivateDirectory(parent, name) {
-  const path = join6(parent, name);
+  const path = join7(parent, name);
   assertBelow(parent, path);
-  await mkdir3(path, { mode: DIRECTORY_MODE });
+  await mkdir4(path, { mode: DIRECTORY_MODE });
   await chmod2(path, DIRECTORY_MODE);
   const real = await realpath3(path);
   assertBelow(parent, real);
@@ -24949,24 +25034,24 @@ async function createRunArtifacts(input) {
   requireSafeSegment(input.agentId, "agentId");
   requireSafeSegment(input.runToken, "runToken");
   const root = await prepareRoot(input.root);
-  const removeTree = input.removeTree ?? ((path) => rm3(path, { recursive: true, force: true }));
+  const removeTree = input.removeTree ?? ((path) => rm4(path, { recursive: true, force: true }));
   const cleanupRetryDelayMs = input.cleanupRetryDelayMs ?? CLEANUP_RETRY_DELAY_MS;
   const agentRoot = await prepareAgentRoot(root, input.agentId);
   await lockDownWindowsDirectories([root, agentRoot]);
-  const runRoot = join6(agentRoot, input.runToken);
+  const runRoot = join7(agentRoot, input.runToken);
   assertBelow(agentRoot, runRoot);
   try {
-    await mkdir3(runRoot, { mode: DIRECTORY_MODE });
+    await mkdir4(runRoot, { mode: DIRECTORY_MODE });
     await chmod2(runRoot, DIRECTORY_MODE);
     const realRunRoot = await realpath3(runRoot);
     assertBelow(agentRoot, realRunRoot);
     const emptyGithubConfigDirectory = await createPrivateDirectory(realRunRoot, "gh-config");
     const emptyGitHooksDirectory = await createPrivateDirectory(realRunRoot, "git-hooks");
     const gitBridgesDirectory = await createPrivateDirectory(realRunRoot, "git-bridges");
-    const denySshScript = join6(realRunRoot, "deny-ssh.cjs");
-    const runnerWrapperScript = join6(realRunRoot, "runner-wrapper.cjs");
-    const systemPromptPath = join6(realRunRoot, "system-prompt.txt");
-    const mcpConfigPath = join6(realRunRoot, "mcp.json");
+    const denySshScript = join7(realRunRoot, "deny-ssh.cjs");
+    const runnerWrapperScript = join7(realRunRoot, "runner-wrapper.cjs");
+    const systemPromptPath = join7(realRunRoot, "system-prompt.txt");
+    const mcpConfigPath = join7(realRunRoot, "mcp.json");
     await writePrivateFile(denySshScript, "process.exitCode = 127;");
     await writePrivateFile(runnerWrapperScript, RUNNER_GUARDIAN);
     return {
@@ -25030,20 +25115,20 @@ async function sweepOrphanedRunArtifacts(root) {
   let removed = 0;
   for (const agent of agents) {
     if (!SAFE_SEGMENT.test(agent.name) || !agent.isDirectory() || agent.isSymbolicLink()) continue;
-    const agentPath = join6(realRoot, agent.name);
+    const agentPath = join7(realRoot, agent.name);
     const runs = await readdir2(agentPath, { withFileTypes: true });
     for (const run3 of runs) {
       if (!SAFE_SEGMENT.test(run3.name) || !run3.isDirectory() || run3.isSymbolicLink()) continue;
-      const runPath = join6(agentPath, run3.name);
+      const runPath = join7(agentPath, run3.name);
       assertBelow(agentPath, runPath);
-      await rm3(runPath, { recursive: true, force: true });
+      await rm4(runPath, { recursive: true, force: true });
       removed++;
     }
   }
   return removed;
 }
 function defaultRunRegistryRoot() {
-  return join6(homedir(), ".zixt", "run-registry");
+  return join7(homedir(), ".zixt", "run-registry");
 }
 async function terminateRecordedRunProcesses(registryRoot = defaultRunRegistryRoot(), terminate = terminateRecordedProcessTree) {
   const entries = await readRecordedRunAssignmentEntriesStrict(registryRoot);
@@ -25069,23 +25154,23 @@ async function syncRunRegistryDirectory(path) {
   }
 }
 async function ensureDurableRunRegistryRoot(registryRoot, syncDirectory7) {
-  const firstCreated = await mkdir3(registryRoot, { recursive: true, mode: DIRECTORY_MODE });
+  const firstCreated = await mkdir4(registryRoot, { recursive: true, mode: DIRECTORY_MODE });
   if (firstCreated && process.platform !== "win32") {
     const first = resolve4(firstCreated);
     const target = resolve4(registryRoot);
-    await syncDirectory7(dirname3(first));
+    await syncDirectory7(dirname4(first));
     let current = first;
     for (const part of relative3(first, target).split(sep3).filter(Boolean)) {
       await syncDirectory7(current);
-      current = join6(current, part);
+      current = join7(current, part);
     }
   }
   await chmod2(registryRoot, DIRECTORY_MODE);
 }
 async function recordRunAssignment(runToken, record2, registryRoot = defaultRunRegistryRoot(), options = {}) {
   if (!SAFE_SEGMENT.test(runToken)) return false;
-  const destination = join6(registryRoot, `${runToken}.json`);
-  const temporary = join6(registryRoot, `.${runToken}.${process.pid}.${Date.now()}.tmp`);
+  const destination = join7(registryRoot, `${runToken}.json`);
+  const temporary = join7(registryRoot, `.${runToken}.${process.pid}.${Date.now()}.tmp`);
   let handle;
   try {
     const syncDirectory7 = options.syncDirectory ?? syncRunRegistryDirectory;
@@ -25105,7 +25190,7 @@ async function recordRunAssignment(runToken, record2, registryRoot = defaultRunR
   } finally {
     await handle?.close().catch(() => {
     });
-    await rm3(temporary, { force: true }).catch(() => {
+    await rm4(temporary, { force: true }).catch(() => {
     });
   }
 }
@@ -25117,7 +25202,7 @@ async function forgetRunAssignment(runToken, registryRoot = defaultRunRegistryRo
   if (retainingAssignments) return;
   if (!SAFE_SEGMENT.test(runToken)) return;
   try {
-    await rm3(join6(registryRoot, `${runToken}.json`), { force: true });
+    await rm4(join7(registryRoot, `${runToken}.json`), { force: true });
   } catch {
   }
 }
@@ -25162,7 +25247,7 @@ async function readRecordedRunAssignmentEntries(registryRoot = defaultRunRegistr
     if (!SAFE_SEGMENT.test(runToken)) continue;
     let text;
     try {
-      text = await readFile5(join6(registryRoot, entry.name), "utf8");
+      text = await readFile5(join7(registryRoot, entry.name), "utf8");
     } catch {
       continue;
     }
@@ -25198,7 +25283,7 @@ async function readRecordedRunAssignmentEntriesStrict(registryRoot = defaultRunR
     }
     let text;
     try {
-      text = await readFile5(join6(registryRoot, entry.name), "utf8");
+      text = await readFile5(join7(registryRoot, entry.name), "utf8");
     } catch {
       throw new Error("committed run registry witness could not be read");
     }
@@ -25215,13 +25300,13 @@ async function forgetAcknowledgedRunAssignments(assignments, registryRoot = defa
   );
   const entries = await readRecordedRunAssignmentEntries(registryRoot);
   await Promise.all(
-    entries.filter(({ record: record2 }) => acknowledged.has(`${record2.taskId}:${record2.epoch}`)).map(({ runToken }) => rm3(join6(registryRoot, `${runToken}.json`), { force: true }))
+    entries.filter(({ record: record2 }) => acknowledged.has(`${record2.taskId}:${record2.epoch}`)).map(({ runToken }) => rm4(join7(registryRoot, `${runToken}.json`), { force: true }))
   );
 }
 async function forgetSupersededRunAssignments(taskId, epoch, registryRoot = defaultRunRegistryRoot()) {
   const entries = await readRecordedRunAssignmentEntries(registryRoot);
   await Promise.all(
-    entries.filter(({ record: record2 }) => record2.taskId === taskId && record2.epoch < epoch).map(({ runToken }) => rm3(join6(registryRoot, `${runToken}.json`), { force: true }))
+    entries.filter(({ record: record2 }) => record2.taskId === taskId && record2.epoch < epoch).map(({ runToken }) => rm4(join7(registryRoot, `${runToken}.json`), { force: true }))
   );
 }
 
@@ -25263,7 +25348,7 @@ function signalWorkerGroup(child, signal) {
   }
 }
 function versionsRoot() {
-  return process.env.ZIXT_HOST_VERSIONS_DIR ?? join7(homedir2(), ".zixt", "host-versions");
+  return process.env.ZIXT_HOST_VERSIONS_DIR ?? join8(homedir2(), ".zixt", "host-versions");
 }
 function npmCommand(platform = process.platform) {
   return platform === "win32" ? "npm.cmd" : "npm";
@@ -25272,13 +25357,13 @@ function windowsInstallerCommandLine(command, args) {
   return [command, ...args].map(quoteForCmd).join(" ");
 }
 function installedReleaseEntry(version2, root = versionsRoot()) {
-  return join7(root, version2, "node_modules", PACKAGE_NAME, "dist", "index.js");
+  return join8(root, version2, "node_modules", PACKAGE_NAME, "dist", "index.js");
 }
 function releaseEntryAtPrefix(prefix) {
-  return join7(prefix, "node_modules", PACKAGE_NAME, "dist", "index.js");
+  return join8(prefix, "node_modules", PACKAGE_NAME, "dist", "index.js");
 }
 function releaseManifestAtPrefix(prefix) {
-  return join7(prefix, "node_modules", PACKAGE_NAME, "package.json");
+  return join8(prefix, "node_modules", PACKAGE_NAME, "package.json");
 }
 async function validReleaseAtPrefix(prefix, version2) {
   try {
@@ -25313,10 +25398,10 @@ function installedReleaseVersion(entry, root = versionsRoot()) {
   return resolve5(entry) === resolve5(installedReleaseEntry(version2, root)) ? version2 : null;
 }
 function currentReleaseEntry(root = versionsRoot(), platform = process.platform) {
-  return join7(root, platform === "win32" ? "current-launcher.cjs" : CURRENT_RELEASE_ENTRY);
+  return join8(root, platform === "win32" ? "current-launcher.cjs" : CURRENT_RELEASE_ENTRY);
 }
 function windowsReleasePointer(root = versionsRoot()) {
-  return join7(root, WINDOWS_RELEASE_POINTER);
+  return join8(root, WINDOWS_RELEASE_POINTER);
 }
 var WINDOWS_STABLE_LAUNCHER = `${WINDOWS_LAUNCHER_MARKER}
 'use strict';
@@ -25351,9 +25436,9 @@ child.once('error', () => process.exit(1));
 child.once('exit', (code) => process.exit(code == null ? 1 : code));
 `;
 async function replaceDurableFile(path, contents, sync = syncDirectory3) {
-  const parent = dirname4(path);
-  await mkdir4(parent, { recursive: true, mode: 448 });
-  const temporary = join7(parent, `.${CURRENT_RELEASE_ENTRY}.${process.pid}.${crypto.randomUUID()}`);
+  const parent = dirname5(path);
+  await mkdir5(parent, { recursive: true, mode: 448 });
+  const temporary = join8(parent, `.${CURRENT_RELEASE_ENTRY}.${process.pid}.${crypto.randomUUID()}`);
   const handle = await open4(temporary, "wx", 384);
   try {
     await handle.writeFile(contents, "utf8");
@@ -25363,7 +25448,7 @@ async function replaceDurableFile(path, contents, sync = syncDirectory3) {
     await sync(parent);
   } catch (error52) {
     await handle.close().catch(() => void 0);
-    await rm4(temporary, { force: true }).catch(() => void 0);
+    await rm5(temporary, { force: true }).catch(() => void 0);
     throw error52;
   }
 }
@@ -25373,7 +25458,7 @@ async function activateInstalledRelease(entry, root = versionsRoot(), platform =
   }
   await access2(entry);
   if (platform === "win32") {
-    await mkdir4(root, { recursive: true, mode: 448 });
+    await mkdir5(root, { recursive: true, mode: 448 });
     const launcher = currentReleaseEntry(root, platform);
     const existingLauncher = await lstat5(launcher).catch((error52) => {
       if (error52.code === "ENOENT") return null;
@@ -25422,7 +25507,7 @@ async function activateInstalledRelease(entry, root = versionsRoot(), platform =
     return launcher;
   }
   if (platform !== "linux" && platform !== "darwin") return entry;
-  await mkdir4(root, { recursive: true, mode: 448 });
+  await mkdir5(root, { recursive: true, mode: 448 });
   const current = currentReleaseEntry(root, platform);
   const existing = await lstat5(current).catch((error52) => {
     if (error52.code === "ENOENT") return null;
@@ -25431,13 +25516,13 @@ async function activateInstalledRelease(entry, root = versionsRoot(), platform =
   if (existing && !existing.isSymbolicLink()) {
     throw new Error("the Zixt Host current-release entry is not a symbolic link");
   }
-  const temporary = join7(root, `.${CURRENT_RELEASE_ENTRY}.${process.pid}.${crypto.randomUUID()}`);
+  const temporary = join8(root, `.${CURRENT_RELEASE_ENTRY}.${process.pid}.${crypto.randomUUID()}`);
   try {
     await symlink(entry, temporary, "file");
     await rename3(temporary, current);
     await sync(root);
   } catch (error52) {
-    await rm4(temporary, { force: true }).catch(() => void 0);
+    await rm5(temporary, { force: true }).catch(() => void 0);
     throw error52;
   }
   return current;
@@ -25458,7 +25543,7 @@ async function activatedReleaseVersion(root = versionsRoot(), platform = process
   try {
     const current = currentReleaseEntry(root, platform);
     const target = await readlink(current);
-    return installedReleaseVersion(resolve5(dirname4(current), target), root);
+    return installedReleaseVersion(resolve5(dirname5(current), target), root);
   } catch {
     return null;
   }
@@ -25562,13 +25647,13 @@ async function installRelease(version2, options = {}) {
   const platform = options.platform ?? process.platform;
   const installerCommand = options.installerCommand ?? npmCommand(platform);
   const root = options.root ?? versionsRoot();
-  const prefix = join7(root, version2);
+  const prefix = join8(root, version2);
   const entry = installedReleaseEntry(version2, root);
   if (await validReleaseAtPrefix(prefix, version2)) return entry;
   if (options.signal?.aborted) return null;
-  await mkdir4(root, { recursive: true, mode: 448 });
-  const staging = join7(root, `.install-${version2}-${process.pid}-${crypto.randomUUID()}`);
-  const quarantine = join7(root, `.invalid-${version2}-${process.pid}-${crypto.randomUUID()}`);
+  await mkdir5(root, { recursive: true, mode: 448 });
+  const staging = join8(root, `.install-${version2}-${process.pid}-${crypto.randomUUID()}`);
+  const quarantine = join8(root, `.invalid-${version2}-${process.pid}-${crypto.randomUUID()}`);
   const usesWindowsInstallerGuardian = platform === "win32" && options.spawnInstaller === void 0;
   const installerGateNonce = usesWindowsInstallerGuardian ? crypto.randomUUID() : null;
   const installerArguments = (installPrefix, installVersion) => [
@@ -25600,7 +25685,7 @@ async function installRelease(version2, options = {}) {
   try {
     child = spawnInstaller(staging, version2);
   } catch {
-    await rm4(staging, { recursive: true, force: true }).catch(() => void 0);
+    await rm5(staging, { recursive: true, force: true }).catch(() => void 0);
     return null;
   }
   let resolveChildExited;
@@ -25750,8 +25835,8 @@ async function installRelease(version2, options = {}) {
     await syncDirectory3(root);
     return await validReleaseAtPrefix(prefix, version2) ? entry : null;
   } finally {
-    await rm4(staging, { recursive: true, force: true }).catch(() => void 0);
-    await rm4(quarantine, { recursive: true, force: true }).catch(() => void 0);
+    await rm5(staging, { recursive: true, force: true }).catch(() => void 0);
+    await rm5(quarantine, { recursive: true, force: true }).catch(() => void 0);
   }
 }
 async function pruneInstalledVersions(keep, root = versionsRoot()) {
@@ -25766,10 +25851,10 @@ async function pruneInstalledVersions(keep, root = versionsRoot()) {
   const removed = [];
   for (const name of entries) {
     if (protectedDirs.has(name) || !VERSION_DIR.test(name)) continue;
-    const dir = join7(root, name);
+    const dir = join8(root, name);
     if (running && running.startsWith(`${dir}${sep4}`)) continue;
     try {
-      await rm4(dir, { recursive: true, force: true });
+      await rm5(dir, { recursive: true, force: true });
       removed.push(name);
     } catch {
     }
@@ -25780,7 +25865,7 @@ function durableState(phase, candidateVersion, fallbackVersion) {
   return { schema: 1, phase, candidateVersion, fallbackVersion };
 }
 async function validInstalledRelease(version2, root = versionsRoot()) {
-  return validReleaseAtPrefix(join7(root, version2), version2);
+  return validReleaseAtPrefix(join8(root, version2), version2);
 }
 async function recoverDurableReleaseState(store, runningVersion, activeBootVersion, activate, log2) {
   const state = await store.load();
@@ -25899,7 +25984,7 @@ function defaultSpawn(command, argv, supervisorVersion, watchdog, compatibilityO
     stdio: watchdog ? ["pipe", "inherit", "inherit", "ipc"] : ["pipe", "inherit", "inherit"],
     env,
     ...containmentGateNonce ? {
-      cwd: ownership?.ownershipFile ? dirname4(ownership.ownershipFile) : dirname4(entry)
+      cwd: ownership?.ownershipFile ? dirname5(ownership.ownershipFile) : dirname5(entry)
     } : {},
     // The launch nonce is not a user-facing CLI argument. Keeping it as
     // argv[0] gives the stable launcher an exact cross-platform process
@@ -25996,10 +26081,10 @@ async function launchHostSupervisor(options = {}) {
     delete env[WORKER_WATCHDOG_FILE_ENV];
     delete env[WORKER_OWNERSHIP_FILE_ENV];
     delete env[SUPERVISOR_OWNERSHIP_FILE_ENV];
-    const generationNonce = ownershipDirectory ? basename3(ownershipDirectory) : null;
+    const generationNonce = ownershipDirectory ? basename4(ownershipDirectory) : null;
     if (ownershipDirectory && generationNonce) {
       env[LAUNCHER_OWNERSHIP_DIR_ENV] = ownershipDirectory;
-      env[SUPERVISOR_OWNERSHIP_FILE_ENV] = join7(ownershipDirectory, `${generationNonce}.json`);
+      env[SUPERVISOR_OWNERSHIP_FILE_ENV] = join8(ownershipDirectory, `${generationNonce}.json`);
     } else {
       delete env[LAUNCHER_OWNERSHIP_DIR_ENV];
     }
@@ -26010,7 +26095,7 @@ async function launchHostSupervisor(options = {}) {
     const child2 = spawn5(process.execPath, [supervisorEntry, ...argv], {
       stdio: ["pipe", "inherit", "inherit"],
       env,
-      ...containmentGateNonce ? { cwd: ownershipDirectory ?? dirname4(supervisorEntry) } : {},
+      ...containmentGateNonce ? { cwd: ownershipDirectory ?? dirname5(supervisorEntry) } : {},
       detached: platform !== "win32",
       // The new launcher can discover the durable PID record and still has
       // to bind it to this exact process before signalling a recycled PID.
@@ -26022,8 +26107,8 @@ async function launchHostSupervisor(options = {}) {
   });
   const customDelay = options.delay;
   const ownsWorkerBoundary = options.spawnSupervisor === void 0 || options.ownershipRoot !== void 0;
-  const ownershipRoot = options.ownershipRoot ?? join7(versionsRoot(), "launcher-ownership");
-  const runRegistryRoot2 = options.runRegistryRoot ?? (options.ownershipRoot ? join7(dirname4(options.ownershipRoot), "run-registry") : defaultRunRegistryRoot());
+  const ownershipRoot = options.ownershipRoot ?? join8(versionsRoot(), "launcher-ownership");
+  const runRegistryRoot2 = options.runRegistryRoot ?? (options.ownershipRoot ? join8(dirname5(options.ownershipRoot), "run-registry") : defaultRunRegistryRoot());
   const terminateRecordedOwnership = options.terminateRecordedOwnership ?? terminateRecordedProcessTree;
   const createSupervisorContainment = options.createSupervisorContainment ?? (platform === "win32" && options.spawnSupervisor === void 0 ? async (target, identityNonce, signal) => {
     if (!target.pid) throw new Error("supervisor process id is unavailable");
@@ -26078,7 +26163,7 @@ async function launchHostSupervisor(options = {}) {
     return false;
   };
   const cleanupOwnershipGeneration = async (directory) => {
-    const generationNonce = basename3(directory);
+    const generationNonce = basename4(directory);
     const firstRecords = await readWorkerOwnershipRecords(directory);
     const supervisorRecord = firstRecords.find((record2) => record2.nonce === generationNonce);
     if (firstRecords.length > 0 && !supervisorRecord) {
@@ -26169,7 +26254,23 @@ async function launchHostSupervisor(options = {}) {
     }
     return false;
   };
+  let releaseMachineClaim = null;
   try {
+    if (ownsWorkerBoundary) {
+      const claim = await claimMachineLauncher(ownershipRoot);
+      if (claim.kind === "busy") {
+        log2(
+          "Zixt Host: another Zixt Host is already running on this Machine, so this one is stopping instead of taking that Host and its Tasks down. Stop the running Host first if you meant to replace it."
+        );
+        return DO_NOT_RESTART_EXIT_CODE;
+      }
+      if (claim.kind === "held") releaseMachineClaim = claim.release;
+      else {
+        log2(
+          `Zixt Host launcher: this Machine cannot be claimed for a single Host (${claim.reason}); continuing without that protection`
+        );
+      }
+    }
     if (!await recoverPriorOwnership()) return 1;
     for (; ; ) {
       if (stopping) return 0;
@@ -26201,7 +26302,7 @@ async function launchHostSupervisor(options = {}) {
       let supervisorContainment = null;
       try {
         if (containmentGateNonce) {
-          const supervisorIdentity = ownershipDirectory ? basename3(ownershipDirectory) : null;
+          const supervisorIdentity = ownershipDirectory ? basename4(ownershipDirectory) : null;
           if (!supervisorIdentity) {
             throw new Error("supervisor containment identity is unavailable");
           }
@@ -26276,6 +26377,7 @@ async function launchHostSupervisor(options = {}) {
       process.stdin.off("data", onStdinData);
       process.stdin.pause();
     }
+    if (releaseMachineClaim) await releaseMachineClaim();
   }
 }
 async function superviseHost(options = {}) {
@@ -26292,8 +26394,8 @@ async function superviseHost(options = {}) {
   const inheritedOwnershipDirectory = process.env[LAUNCHER_OWNERSHIP_DIR_ENV];
   const launcherOwnershipDirectory = productionLifecycle && typeof inheritedOwnershipDirectory === "string" && isAbsolute8(inheritedOwnershipDirectory) ? inheritedOwnershipDirectory : null;
   if (productionLifecycle && isSupervisorRole() && launcherOwnershipDirectory) {
-    const generationNonce = basename3(launcherOwnershipDirectory);
-    const expectedOwnershipFile = join7(launcherOwnershipDirectory, `${generationNonce}.json`);
+    const generationNonce = basename4(launcherOwnershipDirectory);
+    const expectedOwnershipFile = join8(launcherOwnershipDirectory, `${generationNonce}.json`);
     const configuredOwnershipFile = process.env[SUPERVISOR_OWNERSHIP_FILE_ENV];
     if (process.argv0 !== generationNonce || configuredOwnershipFile !== expectedOwnershipFile || !recordWorkerOwnership(expectedOwnershipFile, generationNonce)) {
       log2("Zixt Host: supervisor ownership could not be committed; refusing to start a worker");
@@ -26821,7 +26923,7 @@ import { homedir as homedir12, hostname as hostname3 } from "node:os";
 import { existsSync } from "node:fs";
 import { statfs } from "node:fs/promises";
 import { cpus, freemem, homedir as homedir3, totalmem } from "node:os";
-import { dirname as dirname5, resolve as resolve6 } from "node:path";
+import { dirname as dirname6, resolve as resolve6 } from "node:path";
 async function machineHardware(workRoot = homedir3()) {
   return {
     // A container or cgroup can hide processors from this count; it is what
@@ -26850,7 +26952,7 @@ function nearestExistingPath(start) {
   let candidate = resolve6(start);
   for (let depth = 0; depth < 16; depth++) {
     if (existsSync(candidate)) return candidate;
-    const parent = dirname5(candidate);
+    const parent = dirname6(candidate);
     if (parent === candidate) return null;
     candidate = parent;
   }
@@ -27044,17 +27146,17 @@ function createDemoBrowserAdapterFactory() {
 }
 
 // src/browser/manager.ts
-import { lstat as lstat6, mkdir as mkdir5, open as open5, opendir, readFile as readFile7, rename as rename4, rm as rm5 } from "node:fs/promises";
+import { lstat as lstat6, mkdir as mkdir6, open as open5, opendir, readFile as readFile7, rename as rename4, rm as rm6 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import { dirname as dirname6, join as join8, resolve as resolve7 } from "node:path";
+import { dirname as dirname7, join as join9, resolve as resolve7 } from "node:path";
 var SAFE_SEGMENT2 = /^[A-Za-z0-9_-]{1,200}$/;
 var FRAME_MIN_INTERVAL_MS = 100;
 var IDLE_TIMEOUT_MS = 15 * 6e4;
 var BrowserManager = class {
   constructor(opts) {
     this.opts = opts;
-    this.profileRoot = opts.profileRoot ?? join8(homedir4(), ".zixt", "browser-profiles");
-    this.profileStateRoot = join8(this.profileRoot, ".profile-state");
+    this.profileRoot = opts.profileRoot ?? join9(homedir4(), ".zixt", "browser-profiles");
+    this.profileStateRoot = join9(this.profileRoot, ".profile-state");
     this.viewport = opts.viewport ?? BROWSER_DEFAULT_VIEWPORT;
     this.idleTimeoutMs = opts.idleTimeoutMs ?? IDLE_TIMEOUT_MS;
     this.frameMinIntervalMs = opts.frameMinIntervalMs ?? FRAME_MIN_INTERVAL_MS;
@@ -27146,13 +27248,13 @@ var BrowserManager = class {
   exactChild(root, child) {
     const canonicalRoot = resolve7(root);
     const target = resolve7(canonicalRoot, child);
-    if (dirname6(target) !== canonicalRoot) {
+    if (dirname7(target) !== canonicalRoot) {
       throw new Error("browser profile path escaped its owned root");
     }
     return target;
   }
   async ensureOwnedDirectory(path) {
-    await mkdir5(path, { recursive: true, mode: 448 });
+    await mkdir6(path, { recursive: true, mode: 448 });
     const stat3 = await lstat6(path);
     if (!stat3.isDirectory() || stat3.isSymbolicLink()) {
       throw new Error("browser profile root must be an owned directory, not a symbolic link");
@@ -27218,7 +27320,7 @@ var BrowserManager = class {
       await this.syncDirectory(this.profileStateRoot);
       await this.syncDirectory(this.profileRoot);
     } catch (error52) {
-      await rm5(temporary, { force: true }).catch(() => {
+      await rm6(temporary, { force: true }).catch(() => {
       });
       throw error52;
     }
@@ -27294,7 +27396,7 @@ var BrowserManager = class {
       } catch (error52) {
         if (error52.code !== "ENOENT") throw error52;
       }
-      await mkdir5(profileDir, { recursive: true, mode: 448 });
+      await mkdir6(profileDir, { recursive: true, mode: 448 });
       const adapter = await this.opts.factory.open({
         agentId,
         profileDir,
@@ -27373,7 +27475,7 @@ var BrowserManager = class {
         purgeId
       });
       await this.closeLocked(agentId, "stopped");
-      await rm5(this.profilePath(agentId), { recursive: true, force: true, maxRetries: 3 });
+      await rm6(this.profilePath(agentId), { recursive: true, force: true, maxRetries: 3 });
       await this.syncDirectory(this.profileRoot);
     });
   }
@@ -28064,9 +28166,9 @@ function createPlaywrightBrowserAdapterFactory(dependencies = {}) {
 // src/runners/cli-runner.ts
 import { spawn as spawn8 } from "node:child_process";
 import { randomUUID as randomUUID10 } from "node:crypto";
-import { lstat as lstat11, mkdir as mkdir10, realpath as realpath8 } from "node:fs/promises";
+import { lstat as lstat11, mkdir as mkdir11, realpath as realpath8 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
-import { dirname as dirname8, isAbsolute as isAbsolute14, join as join14, resolve as resolve10 } from "node:path";
+import { dirname as dirname9, isAbsolute as isAbsolute14, join as join15, resolve as resolve10 } from "node:path";
 
 // src/tool-packs/browser/authentication-wall.ts
 var AUTH_PATH_SEGMENT = /(?:^|\/)(?:log[-_]?in|sign[-_]?in|sso|saml|auth|authorize|authenticate|oauth2?|session\/new|checkpoint)(?:\/|$)/i;
@@ -28353,7 +28455,7 @@ function createBrowserToolPack(deps) {
 }
 
 // src/tool-packs/provider-intents.ts
-import { createHash as createHash2, randomUUID as randomUUID3 } from "node:crypto";
+import { createHash as createHash3, randomUUID as randomUUID3 } from "node:crypto";
 
 // src/tool-packs/github/rest-transport.ts
 var MAX_RESPONSE_BYTES = 2 * 1024 * 1024;
@@ -28599,7 +28701,7 @@ function canonicalJson(value) {
   return `{${Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, child]) => `${JSON.stringify(key)}:${canonicalJson(child)}`).join(",")}}`;
 }
 function payloadFingerprint(value) {
-  return createHash2("sha256").update(canonicalJson(value)).digest("hex");
+  return createHash3("sha256").update(canonicalJson(value)).digest("hex");
 }
 function claimResult(result) {
   if (!result.ok || !result.result || typeof result.result !== "object") return null;
@@ -30791,14 +30893,14 @@ function createGithubPushOrchestrator(input) {
 // src/tool-packs/github/git-bridge.ts
 import { spawn as spawn6 } from "node:child_process";
 import { randomUUID as randomUUID7 } from "node:crypto";
-import { chmod as chmod4, lstat as lstat8, mkdir as mkdir6, realpath as realpath5, rm as rm6 } from "node:fs/promises";
-import { dirname as dirname7, isAbsolute as isAbsolute10, join as join10, relative as relative6 } from "node:path";
+import { chmod as chmod4, lstat as lstat8, mkdir as mkdir7, realpath as realpath5, rm as rm7 } from "node:fs/promises";
+import { dirname as dirname8, isAbsolute as isAbsolute10, join as join11, relative as relative6 } from "node:path";
 
 // src/tool-packs/github/git-credential-broker.ts
-import { createServer } from "node:http";
+import { createServer as createServer2 } from "node:http";
 import { randomBytes, randomUUID as randomUUID6, timingSafeEqual } from "node:crypto";
 import { chmod as chmod3, lstat as lstat7, realpath as realpath4, writeFile as writeFile2 } from "node:fs/promises";
-import { isAbsolute as isAbsolute9, join as join9, relative as relative5 } from "node:path";
+import { isAbsolute as isAbsolute9, join as join10, relative as relative5 } from "node:path";
 var MAX_REQUEST_BYTES = 16 * 1024;
 var FILE_MODE2 = 384;
 var HELPER_SOURCE = String.raw`'use strict';
@@ -30927,14 +31029,14 @@ async function createGithubGitCredentialBroker(input) {
     throw new Error("Git credential broker requires a private real run directory");
   }
   const runRoot = await realpath4(input.runArtifactsRoot);
-  const helperPath = join9(runRoot, `git-credential-${randomUUID6()}.cjs`);
+  const helperPath = join10(runRoot, `git-credential-${randomUUID6()}.cjs`);
   assertChildPath(runRoot, helperPath);
   await writeFile2(helperPath, HELPER_SOURCE, { flag: "wx", mode: FILE_MODE2 });
   await chmod3(helperPath, FILE_MODE2);
   const capability2 = randomBytes(32).toString("base64url");
   const expectedPath = `${input.repositoryFullName}.git`;
   let closed = false;
-  const server = createServer(async (request, response) => {
+  const server = createServer2(async (request, response) => {
     try {
       if (closed || input.authoritySignal.aborted || input.expiresAt !== null && input.expiresAt.getTime() <= Date.now()) {
         reject(response, 410);
@@ -31043,7 +31145,7 @@ async function requireRealDirectory2(path, label) {
 async function validateTokenlessPaths(command) {
   if (command.kind === "clone-from-bridge") {
     if (!isAbsolute10(command.destination)) throw new GithubGitProcessError("invalid_input");
-    const parent = await requireRealDirectory2(dirname7(command.destination), "clone parent");
+    const parent = await requireRealDirectory2(dirname8(command.destination), "clone parent");
     assertBelow2(parent, command.destination, "clone destination");
     const destination = await lstat8(command.destination).catch((error52) => {
       if (error52.code === "ENOENT") return null;
@@ -31331,9 +31433,9 @@ function createGithubGitBridge(input) {
     async createPrivateBridge() {
       if (closed) throw new GithubGitProcessError("cancelled");
       const current = await roots();
-      const path = join10(current.bridges, `${randomUUID7()}.git`);
+      const path = join11(current.bridges, `${randomUUID7()}.git`);
       assertBelow2(current.bridges, path, "git bridge");
-      await mkdir6(path, { mode: DIRECTORY_MODE2 });
+      await mkdir7(path, { mode: DIRECTORY_MODE2 });
       await chmod4(path, DIRECTORY_MODE2);
       try {
         await runGit(
@@ -31349,16 +31451,16 @@ function createGithubGitBridge(input) {
         );
         const real = await requireRealDirectory2(path, "git bridge");
         assertBelow2(current.bridges, real, "git bridge");
-        const hooks = join10(real, "hooks");
-        await rm6(hooks, { recursive: true, force: true });
-        await mkdir6(hooks, { mode: DIRECTORY_MODE2 });
+        const hooks = join11(real, "hooks");
+        await rm7(hooks, { recursive: true, force: true });
+        await mkdir7(hooks, { mode: DIRECTORY_MODE2 });
         await chmod4(hooks, DIRECTORY_MODE2);
-        const config2 = join10(real, "config");
+        const config2 = join11(real, "config");
         await chmod4(config2, 384);
         active.add(real);
         return real;
       } catch (error52) {
-        await rm6(path, { recursive: true, force: true }).catch(() => {
+        await rm7(path, { recursive: true, force: true }).catch(() => {
         });
         throw error52;
       }
@@ -31452,7 +31554,7 @@ function createGithubGitBridge(input) {
     },
     async destroyPrivateBridge(path) {
       const bridge = await requireBridge(path);
-      await rm6(bridge, { recursive: true, force: true });
+      await rm7(bridge, { recursive: true, force: true });
       active.delete(bridge);
       credentialed2.delete(bridge);
     },
@@ -31460,7 +31562,7 @@ function createGithubGitBridge(input) {
       if (closed) return;
       closed = true;
       const paths = [...active];
-      await Promise.all(paths.map((path) => rm6(path, { recursive: true, force: true })));
+      await Promise.all(paths.map((path) => rm7(path, { recursive: true, force: true })));
       active.clear();
       credentialed2.clear();
     }
@@ -31801,8 +31903,8 @@ function createRepositoryTools(runtime) {
 
 // src/tool-packs/github/workspace.ts
 import { randomUUID as randomUUID8 } from "node:crypto";
-import { chmod as chmod5, lstat as lstat9, mkdir as mkdir7, readFile as readFile8, realpath as realpath6, rename as rename5, rm as rm7, writeFile as writeFile3 } from "node:fs/promises";
-import { isAbsolute as isAbsolute11, join as join11, relative as relative7, resolve as resolve8 } from "node:path";
+import { chmod as chmod5, lstat as lstat9, mkdir as mkdir8, readFile as readFile8, realpath as realpath6, rename as rename5, rm as rm8, writeFile as writeFile3 } from "node:fs/promises";
+import { isAbsolute as isAbsolute11, join as join12, relative as relative7, resolve as resolve8 } from "node:path";
 var SAFE_LOCAL_ID = /^[A-Za-z0-9_-]{1,200}$/;
 var FULL_NAME2 = /^[A-Za-z0-9_.-]{1,100}\/[A-Za-z0-9_.-]{1,100}$/;
 var DIRECTORY_MODE3 = 448;
@@ -31839,10 +31941,10 @@ async function requireRealDirectory3(path, label) {
   return real;
 }
 async function createOrRequirePrivateDirectory(parent, name, label) {
-  const path = join11(parent, name);
+  const path = join12(parent, name);
   assertBelow3(parent, path, label);
   try {
-    await mkdir7(path, { mode: DIRECTORY_MODE3 });
+    await mkdir8(path, { mode: DIRECTORY_MODE3 });
   } catch (error52) {
     if (error52.code !== "EEXIST") throw error52;
   }
@@ -31922,8 +32024,8 @@ async function createGithubWorkspaceService(input) {
     if (expectedFullName !== void 0 && repository.fullName !== expectedFullName) {
       throw new Error("GitHub repository name does not match this task grant");
     }
-    const destination = join11(repositoriesRoot, parsed.data);
-    const metadataPath = join11(metadataRoot, `${parsed.data}.json`);
+    const destination = join12(repositoriesRoot, parsed.data);
+    const metadataPath = join12(metadataRoot, `${parsed.data}.json`);
     if (!await pathExists(destination) || !await pathExists(metadataPath)) {
       throw new Error("GitHub repository workspace has not been prepared");
     }
@@ -31940,14 +32042,14 @@ async function createGithubWorkspaceService(input) {
     return real;
   };
   const cloneRepository = async (clone2) => {
-    const destination = join11(repositoriesRoot, clone2.repositoryId);
-    const metadataPath = join11(metadataRoot, `${clone2.repositoryId}.json`);
+    const destination = join12(repositoriesRoot, clone2.repositoryId);
+    const metadataPath = join12(metadataRoot, `${clone2.repositoryId}.json`);
     assertBelow3(repositoriesRoot, destination, "repository path");
     assertBelow3(metadataRoot, metadataPath, "repository metadata");
     if (await pathExists(destination) || await pathExists(metadataPath)) {
       throw new Error("GitHub repository workspace already exists or is inconsistent");
     }
-    const temporary = join11(repositoriesRoot, `.clone-${randomUUID8()}`);
+    const temporary = join12(repositoriesRoot, `.clone-${randomUUID8()}`);
     assertBelow3(repositoriesRoot, temporary, "temporary clone");
     try {
       await input.git.clone({
@@ -31972,7 +32074,7 @@ async function createGithubWorkspaceService(input) {
         path: destination,
         ...clone2.createIntentId === void 0 ? {} : { createIntentId: clone2.createIntentId }
       };
-      const metadataTemporary = join11(metadataRoot, `.${clone2.repositoryId}-${randomUUID8()}.tmp`);
+      const metadataTemporary = join12(metadataRoot, `.${clone2.repositoryId}-${randomUUID8()}.tmp`);
       assertBelow3(metadataRoot, metadataTemporary, "temporary repository metadata");
       await writeFile3(metadataTemporary, `${JSON.stringify(metadata)}
 `, {
@@ -31985,11 +32087,11 @@ async function createGithubWorkspaceService(input) {
         try {
           await rename5(metadataTemporary, metadataPath);
         } catch (error52) {
-          await rm7(destination, { recursive: true, force: true });
+          await rm8(destination, { recursive: true, force: true });
           throw error52;
         }
       } finally {
-        await rm7(metadataTemporary, { force: true }).catch(() => {
+        await rm8(metadataTemporary, { force: true }).catch(() => {
         });
       }
       const path = await requireRealDirectory3(destination, "GitHub repository");
@@ -32001,14 +32103,14 @@ async function createGithubWorkspaceService(input) {
         headSha
       };
     } finally {
-      await rm7(temporary, { recursive: true, force: true }).catch(() => {
+      await rm8(temporary, { recursive: true, force: true }).catch(() => {
       });
     }
   };
   const prepareRepository = async (authority) => {
     const { repository } = authority;
-    const destination = join11(repositoriesRoot, repository.repositoryId);
-    const metadataPath = join11(metadataRoot, `${repository.repositoryId}.json`);
+    const destination = join12(repositoriesRoot, repository.repositoryId);
+    const metadataPath = join12(metadataRoot, `${repository.repositoryId}.json`);
     assertBelow3(repositoriesRoot, destination, "repository path");
     assertBelow3(metadataRoot, metadataPath, "repository metadata");
     return withWorkspaceLock(destination, async () => {
@@ -32173,7 +32275,7 @@ async function createGithubWorkspaceService(input) {
         throw new Error("GitHub created repository is outside this installation");
       }
       parseGitRef(cloneInput.repository.defaultBranch, "default branch");
-      return withWorkspaceLock(join11(repositoriesRoot, repositoryId2), async () => {
+      return withWorkspaceLock(join12(repositoriesRoot, repositoryId2), async () => {
         const prepared = await cloneRepository({
           repositoryId: repositoryId2,
           fullName: cloneInput.repository.fullName,
@@ -32580,7 +32682,7 @@ function createGithubToolPackFactory(options = {}) {
 var githubToolPackFactory = createGithubToolPackFactory();
 
 // src/runners/linear-api.ts
-import { createHash as createHash3, randomUUID as randomUUID9 } from "node:crypto";
+import { createHash as createHash4, randomUUID as randomUUID9 } from "node:crypto";
 var MAX_RESPONSE_BYTES2 = 2 * 1024 * 1024;
 var MAX_RESULT_STRING = 1e5;
 var MAX_RESULT_ARRAY = 100;
@@ -33151,7 +33253,7 @@ function operationFor(name, args, appUserId, heldBy) {
   }
 }
 function fingerprint(value) {
-  return createHash3("sha256").update(canonicalLinearMutationPayload(value)).digest("hex");
+  return createHash4("sha256").update(canonicalLinearMutationPayload(value)).digest("hex");
 }
 function providerIntentFor(mutation, payloadFingerprint2) {
   const common = {
@@ -33714,8 +33816,8 @@ function createDefaultToolPackRegistry() {
 }
 
 // src/runners/attachments.ts
-import { mkdir as mkdir8, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join12 } from "node:path";
+import { mkdir as mkdir9, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join13 } from "node:path";
 var WINDOWS_RESERVED = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\..*)?$/i;
 function sanitizeAttachmentFileName(name) {
   const base = name.split(/[/\\]/).pop() ?? "";
@@ -33744,9 +33846,9 @@ async function materializeAttachments(task, taskRoot) {
         `attached file "${attachment.name}" arrived incomplete (${bytes.byteLength} of ${attachment.size} bytes)`
       );
     }
-    const directory = join12(taskRoot, ".zixt-attachments", task.taskId, attachment.id);
-    await mkdir8(directory, { recursive: true });
-    const path = join12(directory, sanitizeAttachmentFileName(attachment.name));
+    const directory = join13(taskRoot, ".zixt-attachments", task.taskId, attachment.id);
+    await mkdir9(directory, { recursive: true });
+    const path = join13(directory, sanitizeAttachmentFileName(attachment.name));
     await writeFile4(path, bytes);
     materialized.push({
       path,
@@ -33774,7 +33876,7 @@ function renderAttachmentSection(files) {
 }
 
 // src/runners/ask-user-server.ts
-import { createServer as createServer2 } from "node:http";
+import { createServer as createServer3 } from "node:http";
 
 // src/runners/ask-user-secrets.ts
 var SECRET_NOUN_SOURCE = "(?:passwords?|passphrases?|api[ -]?keys?|access tokens?|auth tokens?|api tokens?|bearer tokens?|refresh tokens?|tokens?|secret keys?|client secrets?|private keys?|one[- ]time (?:code|password)s?|otps?|2fa codes?|mfa codes?|verification codes?|security codes?|session cookies?)";
@@ -34444,7 +34546,7 @@ function createAskUserServer() {
   let listening;
   function ensureListening() {
     listening ??= new Promise((resolve17, reject3) => {
-      server = createServer2((req, res) => {
+      server = createServer3((req, res) => {
         res.on("error", () => {
         });
         handle(req, res).catch(() => {
@@ -34851,9 +34953,9 @@ function buildRunnerEnv(input) {
 // src/runners/github-shell-auth.ts
 import { execFile } from "node:child_process";
 import { randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
-import { chmod as chmod6, lstat as lstat10, mkdir as mkdir9, realpath as realpath7, writeFile as writeFile5 } from "node:fs/promises";
-import { createServer as createServer3 } from "node:http";
-import { isAbsolute as isAbsolute13, join as join13, relative as relative8 } from "node:path";
+import { chmod as chmod6, lstat as lstat10, mkdir as mkdir10, realpath as realpath7, writeFile as writeFile5 } from "node:fs/promises";
+import { createServer as createServer4 } from "node:http";
+import { isAbsolute as isAbsolute13, join as join14, relative as relative8 } from "node:path";
 var MAX_REQUEST_BYTES2 = 16 * 1024;
 var DIRECTORY_MODE4 = 448;
 var PRIVATE_FILE_MODE = 384;
@@ -35241,7 +35343,7 @@ async function prepareHelpers(input) {
     throw new Error("GitHub shell authentication requires a private real run directory");
   }
   const runRoot = await realpath7(input.runRoot);
-  const helperPath = join13(runRoot, "github-shell-git-credential.cjs");
+  const helperPath = join14(runRoot, "github-shell-git-credential.cjs");
   assertChildPath2(runRoot, helperPath);
   await writePrivate(helperPath, GIT_HELPER_SOURCE);
   if (!input.ghExecutablePath) {
@@ -35252,14 +35354,14 @@ async function prepareHelpers(input) {
       wrapperSourcePath: null
     };
   }
-  const shellToolsDirectory = join13(runRoot, "shell-tools");
+  const shellToolsDirectory = join14(runRoot, "shell-tools");
   assertChildPath2(runRoot, shellToolsDirectory);
-  await mkdir9(shellToolsDirectory, { mode: DIRECTORY_MODE4 });
+  await mkdir10(shellToolsDirectory, { mode: DIRECTORY_MODE4 });
   await chmod6(shellToolsDirectory, DIRECTORY_MODE4);
-  const wrapperSourcePath = join13(runRoot, "github-shell-gh-wrapper.cjs");
+  const wrapperSourcePath = join14(runRoot, "github-shell-gh-wrapper.cjs");
   assertChildPath2(runRoot, wrapperSourcePath);
   await writePrivate(wrapperSourcePath, GH_WRAPPER_SOURCE);
-  const wrapperPath = join13(shellToolsDirectory, process.platform === "win32" ? "gh.cmd" : "gh");
+  const wrapperPath = join14(shellToolsDirectory, process.platform === "win32" ? "gh.cmd" : "gh");
   assertChildPath2(runRoot, wrapperPath);
   const launcher = process.platform === "win32" ? `@"${process.execPath.replaceAll('"', '""')}" "${wrapperSourcePath.replaceAll('"', '""')}" %*\r
 ` : `#!/bin/sh
@@ -35379,7 +35481,7 @@ async function createGithubShellAuth(input) {
   });
   const capability2 = randomBytes2(32).toString("base64url");
   let closed = false;
-  const server = createServer3(async (request, response) => {
+  const server = createServer4(async (request, response) => {
     try {
       if (closed || input.authoritySignal.aborted) {
         reject2(response, 410);
@@ -36053,7 +36155,7 @@ async function settlesWithin(promise2, timeoutMs) {
   }
 }
 function defaultRunnerWorkspaceRoot() {
-  return join14(homedir5(), ".zixt", "workspaces");
+  return join15(homedir5(), ".zixt", "workspaces");
 }
 function defaultRunnerArtifactRoot() {
   return defaultRunArtifactRoot();
@@ -36102,7 +36204,7 @@ function createCliRunner(adapter, opts = {}) {
   const prefixArgs = opts.commandPrefixArgs ?? [];
   const maxWallTimeMs = opts.maxWallTimeMs;
   const workspaceRoot = opts.workspaceRoot ?? defaultRunnerWorkspaceRoot();
-  const artifactRoot = opts.artifactRoot ?? (opts.workspaceRoot === void 0 ? defaultRunnerArtifactRoot() : join14(dirname8(workspaceRoot), "run-artifacts"));
+  const artifactRoot = opts.artifactRoot ?? (opts.workspaceRoot === void 0 ? defaultRunnerArtifactRoot() : join15(dirname9(workspaceRoot), "run-artifacts"));
   const runRegistryRoot2 = opts.runRegistryRoot ?? defaultRunRegistryRoot();
   const createArtifacts = opts.createArtifacts ?? createRunArtifacts;
   const toolPackRegistry2 = opts.toolPackRegistry ?? createDefaultToolPackRegistry();
@@ -36120,7 +36222,7 @@ function createCliRunner(adapter, opts = {}) {
   };
   const askUserServer = createAskUserServer();
   const windowsRoot = process.env.SystemRoot ?? process.env.WINDIR;
-  const windowsComspecCandidate = process.platform === "win32" && windowsRoot ? join14(windowsRoot, "System32", "cmd.exe") : void 0;
+  const windowsComspecCandidate = process.platform === "win32" && windowsRoot ? join15(windowsRoot, "System32", "cmd.exe") : void 0;
   let safetyFailure;
   return async (task) => {
     if (safetyFailure) {
@@ -36160,8 +36262,8 @@ function createCliRunner(adapter, opts = {}) {
         usage: { inputTokens: 0, outputTokens: 0 }
       };
     }
-    const taskRoot = join14(workspaceRoot, task.agentId);
-    await mkdir10(taskRoot, { recursive: true });
+    const taskRoot = join15(workspaceRoot, task.agentId);
+    await mkdir11(taskRoot, { recursive: true });
     if (task.cancelledNow()) return cancelledBeforeRun();
     const configuredWorkspace = task.spec.workspace;
     let cwd = taskRoot;
@@ -36469,7 +36571,7 @@ ${attachmentSection}` : prompt;
         for (const path of paths) {
           if (!path || path.length > 4096) continue;
           const absolutePath = isAbsolute14(path) ? path : resolve10(cwd, path);
-          const directory = dirname8(absolutePath);
+          const directory = dirname9(absolutePath);
           observedWorkingDirectories.delete(directory);
           observedWorkingDirectories.add(directory);
           while (observedWorkingDirectories.size > 19) {
@@ -36915,7 +37017,7 @@ function runCliProcess(options) {
         // The idle pre-assignment guardian must never load from or depend
         // on an untrusted Task checkout. Only the post-gate target enters
         // the requested working directory from its private release frame.
-        cwd: dirname8(options.guardian.scriptPath),
+        cwd: dirname9(options.guardian.scriptPath),
         env: runnerGuardianEnv(process.env, containmentGateNonce),
         stdio: ["pipe", "pipe", "pipe"],
         windowsHide: true,
@@ -37197,7 +37299,7 @@ import { randomUUID as randomUUID11 } from "node:crypto";
 // src/runners/runtime-observation.ts
 import { open as open6, readdir as readdir4, realpath as realpath9 } from "node:fs/promises";
 import { homedir as homedir6 } from "node:os";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 var READ_WINDOW_BYTES = 1024 * 1024;
 var CATALOG_TIMEOUT_MS = 15e3;
 var CATALOG_OUTPUT_LIMIT_BYTES = 4 * 1024 * 1024;
@@ -37257,9 +37359,9 @@ function displayValue(value, maxLength) {
   return trimmed;
 }
 function claudeTranscriptPath(input) {
-  const configDir = input.env["CLAUDE_CONFIG_DIR"] || join15(homeFrom(input.env), ".claude");
+  const configDir = input.env["CLAUDE_CONFIG_DIR"] || join16(homeFrom(input.env), ".claude");
   const slug = input.resolvedCwd.replace(/[^a-zA-Z0-9]/g, "-");
-  return join15(configDir, "projects", slug, `${input.sessionId}.jsonl`);
+  return join16(configDir, "projects", slug, `${input.sessionId}.jsonl`);
 }
 async function readClaudeSessionEffort(input) {
   const resolvedCwd = await realpath9(input.cwd).catch(() => input.cwd);
@@ -37275,18 +37377,18 @@ async function readClaudeSessionEffort(input) {
 }
 async function newestDirectories(root, limit) {
   const entries = await readdir4(root, { withFileTypes: true }).catch(() => []);
-  return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort((left, right) => right.localeCompare(left)).slice(0, limit).map((name) => join15(root, name));
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort((left, right) => right.localeCompare(left)).slice(0, limit).map((name) => join16(root, name));
 }
 async function findCodexRolloutPath(input) {
-  const codexHome = input.env["CODEX_HOME"] || join15(homeFrom(input.env), ".codex");
-  const sessions = join15(codexHome, "sessions");
+  const codexHome = input.env["CODEX_HOME"] || join16(homeFrom(input.env), ".codex");
+  const sessions = join16(codexHome, "sessions");
   const suffix = `-${input.threadId}.jsonl`;
   for (const year of await newestDirectories(sessions, 2)) {
     for (const month of await newestDirectories(year, 2)) {
       for (const day of await newestDirectories(month, 3)) {
         const files = await readdir4(day).catch(() => []);
         const match = files.find((name) => name.endsWith(suffix));
-        if (match) return join15(day, match);
+        if (match) return join16(day, match);
       }
     }
   }
@@ -37670,18 +37772,18 @@ function improveErrorMessage(error52) {
 }
 
 // src/runners/codex.ts
-import { mkdir as mkdir11, readFile as readFile9, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdir as mkdir12, readFile as readFile9, writeFile as writeFile6 } from "node:fs/promises";
 import { randomUUID as randomUUID12 } from "node:crypto";
 import { homedir as homedir7 } from "node:os";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 var CODEX_NOT_FOUND_MESSAGE = "The `codex` CLI was not found on this Machine. Install it (npm install -g @openai/codex) and sign in with `codex login`, or switch the agent to API-key auth.";
 function defaultCodexThreadIndexRoot() {
-  return join16(homedir7(), ".zixt", "codex-threads");
+  return join17(homedir7(), ".zixt", "codex-threads");
 }
 var SAFE_SEGMENT3 = /^[A-Za-z0-9_-]{1,200}$/;
 function threadIndexPath(root, agentId, sessionKey) {
   if (!SAFE_SEGMENT3.test(agentId) || !SAFE_SEGMENT3.test(sessionKey)) return null;
-  return join16(root, agentId, `${sessionKey}.json`);
+  return join17(root, agentId, `${sessionKey}.json`);
 }
 async function readThreadId(path) {
   try {
@@ -37776,7 +37878,7 @@ ${value}` : value;
       const recordedThreadId = indexPath ? await readThreadId(indexPath) : null;
       const rememberThread = (threadId) => {
         if (!indexPath) return;
-        void mkdir11(join16(threadIndexRoot, task.agentId), { recursive: true }).then(() => writeFile6(indexPath, JSON.stringify({ threadId }), "utf8")).catch(() => {
+        void mkdir12(join17(threadIndexRoot, task.agentId), { recursive: true }).then(() => writeFile6(indexPath, JSON.stringify({ threadId }), "utf8")).catch(() => {
         });
       };
       const observeRuntime = (threadId) => {
@@ -38512,9 +38614,9 @@ function run2(command, args) {
 // src/linux-service.ts
 import { spawn as spawn10 } from "node:child_process";
 import { constants as constants2 } from "node:fs";
-import { access as access4, chmod as chmod7, mkdir as mkdir12, open as open7, rename as rename6, rm as rm8 } from "node:fs/promises";
+import { access as access4, chmod as chmod7, mkdir as mkdir13, open as open7, rename as rename6, rm as rm9 } from "node:fs/promises";
 import { homedir as homedir8, userInfo } from "node:os";
-import { basename as basename4, dirname as dirname9, join as join17, relative as relative9, resolve as resolve12, sep as sep5 } from "node:path";
+import { basename as basename5, dirname as dirname10, join as join18, relative as relative9, resolve as resolve12, sep as sep5 } from "node:path";
 var SERVICE_NAME = "zixt-host.service";
 var SYSTEM_SERVICE_COMMAND_TIMEOUT_MS = 7e4;
 var SERVICE_STABILITY_DELAY_MS = 2e3;
@@ -38615,22 +38717,22 @@ async function defaultSyncDirectory(path) {
   }
 }
 async function ensureDirectory(path, mode, syncDirectory7) {
-  const firstCreated = await mkdir12(path, { recursive: true, mode });
+  const firstCreated = await mkdir13(path, { recursive: true, mode });
   if (!firstCreated) return;
   const first = resolve12(firstCreated);
   const target = resolve12(path);
-  await syncDirectory7(dirname9(first));
+  await syncDirectory7(dirname10(first));
   let current = first;
   const descendants = relative9(first, target);
   for (const part of descendants ? descendants.split(sep5) : []) {
     await syncDirectory7(current);
-    current = join17(current, part);
+    current = join18(current, part);
   }
 }
 async function replacePrivateFile(path, contents, mode, syncDirectory7) {
-  const parent = dirname9(path);
+  const parent = dirname10(path);
   await ensureDirectory(parent, 448, syncDirectory7);
-  const temporary = join17(parent, `.${basename4(path)}.${process.pid}.${crypto.randomUUID()}.tmp`);
+  const temporary = join18(parent, `.${basename5(path)}.${process.pid}.${crypto.randomUUID()}.tmp`);
   const handle = await open7(temporary, "wx", mode);
   try {
     await handle.writeFile(contents, "utf8");
@@ -38641,7 +38743,7 @@ async function replacePrivateFile(path, contents, mode, syncDirectory7) {
     await syncDirectory7(parent);
   } catch (error52) {
     await handle.close().catch(() => void 0);
-    await rm8(temporary, { force: true }).catch(() => void 0);
+    await rm9(temporary, { force: true }).catch(() => void 0);
     throw error52;
   }
 }
@@ -38682,11 +38784,11 @@ async function installLinuxService(options) {
     "command search path"
   );
   const cloudUrl = options.cloudUrl ? oneLine(options.cloudUrl, "Zixt Cloud address") : void 0;
-  const xdgConfigHome = env.XDG_CONFIG_HOME ? oneLine(env.XDG_CONFIG_HOME, "Linux configuration path") : join17(home, ".config");
-  const configRoot = options.serviceConfigRoot ?? join17(xdgConfigHome, "zixt");
-  const unitRoot = options.userUnitRoot ?? join17(xdgConfigHome, "systemd", "user");
-  const environmentPath = join17(configRoot, "host.env");
-  const unitPath = join17(unitRoot, SERVICE_NAME);
+  const xdgConfigHome = env.XDG_CONFIG_HOME ? oneLine(env.XDG_CONFIG_HOME, "Linux configuration path") : join18(home, ".config");
+  const configRoot = options.serviceConfigRoot ?? join18(xdgConfigHome, "zixt");
+  const unitRoot = options.userUnitRoot ?? join18(xdgConfigHome, "systemd", "user");
+  const environmentPath = join18(configRoot, "host.env");
+  const unitPath = join18(unitRoot, SERVICE_NAME);
   const installVersion = options.installVersion ?? installRelease;
   const activateVersion = options.activateVersion ?? (options.installVersion ? async (entry) => entry : activateInstalledRelease);
   const resolveCommand = options.resolveCommand ?? defaultResolveCommand;
@@ -38805,9 +38907,9 @@ async function installLinuxService(options) {
 // src/macos-service.ts
 import { spawn as spawn11 } from "node:child_process";
 import { constants as constants3 } from "node:fs";
-import { access as access5, chmod as chmod8, mkdir as mkdir13, open as open8, rename as rename7, rm as rm9 } from "node:fs/promises";
+import { access as access5, chmod as chmod8, mkdir as mkdir14, open as open8, rename as rename7, rm as rm10 } from "node:fs/promises";
 import { homedir as homedir9, userInfo as userInfo2 } from "node:os";
-import { basename as basename5, dirname as dirname10, join as join18, relative as relative10, resolve as resolve13, sep as sep6 } from "node:path";
+import { basename as basename6, dirname as dirname11, join as join19, relative as relative10, resolve as resolve13, sep as sep6 } from "node:path";
 var LAUNCH_AGENT_LABEL = "ai.zixt.host";
 var SERVICE_STABILITY_DELAY_MS2 = 2e3;
 var COMMAND_TIMEOUT_MS2 = 7e4;
@@ -38831,21 +38933,21 @@ async function syncDirectory4(path) {
   }
 }
 async function ensureDirectory2(path, sync) {
-  const firstCreated = await mkdir13(path, { recursive: true, mode: 448 });
+  const firstCreated = await mkdir14(path, { recursive: true, mode: 448 });
   if (!firstCreated) return;
   const first = resolve13(firstCreated);
   const target = resolve13(path);
-  await sync(dirname10(first));
+  await sync(dirname11(first));
   let current = first;
   for (const part of relative10(first, target).split(sep6).filter(Boolean)) {
     await sync(current);
-    current = join18(current, part);
+    current = join19(current, part);
   }
 }
 async function replacePrivateFile2(path, contents, mode, sync) {
-  const parent = dirname10(path);
+  const parent = dirname11(path);
   await ensureDirectory2(parent, sync);
-  const temporary = join18(parent, `.${basename5(path)}.${process.pid}.${crypto.randomUUID()}.tmp`);
+  const temporary = join19(parent, `.${basename6(path)}.${process.pid}.${crypto.randomUUID()}.tmp`);
   const handle = await open8(temporary, "wx", mode);
   try {
     await handle.writeFile(contents, "utf8");
@@ -38856,7 +38958,7 @@ async function replacePrivateFile2(path, contents, mode, sync) {
     await sync(parent);
   } catch (error52) {
     await handle.close().catch(() => void 0);
-    await rm9(temporary, { force: true }).catch(() => void 0);
+    await rm10(temporary, { force: true }).catch(() => void 0);
     throw error52;
   }
 }
@@ -38942,14 +39044,14 @@ async function installMacosService(options) {
     options.path ?? env.PATH ?? "/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin",
     "command search path"
   );
-  const configRoot = options.configRoot ?? join18(home, "Library", "Application Support", "Zixt");
-  const launchAgentsRoot = options.launchAgentsRoot ?? join18(home, "Library", "LaunchAgents");
-  const logRoot = options.logRoot ?? join18(home, "Library", "Logs", "Zixt");
-  const configPath = join18(configRoot, "host.env");
-  const launcherPath = join18(configRoot, "host-launcher.sh");
-  const plistPath = join18(launchAgentsRoot, `${LAUNCH_AGENT_LABEL}.plist`);
-  const stdoutPath = join18(logRoot, "host.log");
-  const stderrPath = join18(logRoot, "host-error.log");
+  const configRoot = options.configRoot ?? join19(home, "Library", "Application Support", "Zixt");
+  const launchAgentsRoot = options.launchAgentsRoot ?? join19(home, "Library", "LaunchAgents");
+  const logRoot = options.logRoot ?? join19(home, "Library", "Logs", "Zixt");
+  const configPath = join19(configRoot, "host.env");
+  const launcherPath = join19(configRoot, "host-launcher.sh");
+  const plistPath = join19(launchAgentsRoot, `${LAUNCH_AGENT_LABEL}.plist`);
+  const stdoutPath = join19(logRoot, "host.log");
+  const stderrPath = join19(logRoot, "host-error.log");
   const installVersion = options.installVersion ?? installRelease;
   const activateVersion = options.activateVersion ?? (options.installVersion ? async (entry) => entry : (entry) => activateInstalledRelease(entry));
   const resolveCommand = options.resolveCommand ?? (async () => defaultResolveCommand2());
@@ -39036,9 +39138,9 @@ async function installMacosService(options) {
 // src/windows-service.ts
 import { spawn as spawn12 } from "node:child_process";
 import { constants as constants4 } from "node:fs";
-import { access as access6, mkdir as mkdir14, open as open9, readFile as readFile10, rename as rename8, rm as rm10 } from "node:fs/promises";
+import { access as access6, mkdir as mkdir15, open as open9, readFile as readFile10, rename as rename8, rm as rm11 } from "node:fs/promises";
 import { homedir as homedir10 } from "node:os";
-import { basename as basename6, dirname as dirname11, isAbsolute as isAbsolute16, join as join19, relative as relative11, resolve as resolve14, sep as sep7 } from "node:path";
+import { basename as basename7, dirname as dirname12, isAbsolute as isAbsolute16, join as join20, relative as relative11, resolve as resolve14, sep as sep7 } from "node:path";
 var TASK_NAME = "Zixt Host";
 var COMMAND_TIMEOUT_MS3 = 7e4;
 var SERVICE_STABILITY_DELAY_MS3 = 2e3;
@@ -39064,21 +39166,21 @@ async function syncDirectory5(path) {
   }
 }
 async function ensureDirectory3(path, sync) {
-  const firstCreated = await mkdir14(path, { recursive: true, mode: 448 });
+  const firstCreated = await mkdir15(path, { recursive: true, mode: 448 });
   if (!firstCreated) return;
   const first = resolve14(firstCreated);
   const target = resolve14(path);
-  await sync(dirname11(first));
+  await sync(dirname12(first));
   let current = first;
   for (const part of relative11(first, target).split(sep7).filter(Boolean)) {
     await sync(current);
-    current = join19(current, part);
+    current = join20(current, part);
   }
 }
 async function replacePrivateFile3(path, contents, sync) {
-  const parent = dirname11(path);
+  const parent = dirname12(path);
   await ensureDirectory3(parent, sync);
-  const temporary = join19(parent, `.${basename6(path)}.${process.pid}.${crypto.randomUUID()}.tmp`);
+  const temporary = join20(parent, `.${basename7(path)}.${process.pid}.${crypto.randomUUID()}.tmp`);
   const handle = await open9(temporary, "wx", 384);
   try {
     await handle.writeFile(contents, "utf8");
@@ -39088,7 +39190,7 @@ async function replacePrivateFile3(path, contents, sync) {
     await sync(parent);
   } catch (error52) {
     await handle.close().catch(() => void 0);
-    await rm10(temporary, { force: true }).catch(() => void 0);
+    await rm11(temporary, { force: true }).catch(() => void 0);
     throw error52;
   }
 }
@@ -39133,7 +39235,7 @@ async function runChild(command, args, env, input) {
 async function defaultResolveCommand3(name, env) {
   const root = env.SYSTEMROOT ?? env.WINDIR;
   if (!root || !isAbsolute16(root)) return null;
-  const candidate = name === "powershell" ? join19(root, "System32", "WindowsPowerShell", "v1.0", "powershell.exe") : join19(root, "System32", `${name}.exe`);
+  const candidate = name === "powershell" ? join20(root, "System32", "WindowsPowerShell", "v1.0", "powershell.exe") : join20(root, "System32", `${name}.exe`);
   return access6(candidate, constants4.X_OK).then(
     () => candidate,
     () => null
@@ -39270,11 +39372,11 @@ async function installWindowsService(options) {
   const token2 = oneLine3(options.token, "pairing code");
   const cloudUrl = options.cloudUrl ? oneLine3(options.cloudUrl, "Zixt Cloud address") : void 0;
   const path = oneLine3(options.path ?? env.PATH ?? "", "command search path");
-  const configRoot = options.configRoot ?? join19(localAppData, "Zixt", "Host");
-  const configPath = join19(configRoot, "host.json");
-  const launcherPath = join19(configRoot, "host-launcher.ps1");
-  const taskXmlPath = join19(configRoot, "host-task.xml");
-  const statusPath = join19(configRoot, "host-status.json");
+  const configRoot = options.configRoot ?? join20(localAppData, "Zixt", "Host");
+  const configPath = join20(configRoot, "host.json");
+  const launcherPath = join20(configRoot, "host-launcher.ps1");
+  const taskXmlPath = join20(configRoot, "host-task.xml");
+  const statusPath = join20(configRoot, "host-status.json");
   const installVersion = options.installVersion ?? installRelease;
   const activateVersion = options.activateVersion ?? (options.installVersion ? async (entry) => entry : (entry) => activateInstalledRelease(entry));
   const resolveCommand = options.resolveCommand ?? ((name) => defaultResolveCommand3(name, env));
@@ -39323,7 +39425,7 @@ async function installWindowsService(options) {
   );
   await replacePrivateFile3(launcherPath, launcherSource2(configPath, statusPath), sync);
   await replacePrivateFile3(taskXmlPath, taskXml({ sid, powershell, launcherPath, home }), sync);
-  await rm10(statusPath, { force: true });
+  await rm11(statusPath, { force: true });
   const acl = await run3(icacls, [
     configRoot,
     "/inheritance:r",
@@ -39375,23 +39477,23 @@ async function installSystemService(options) {
 }
 
 // src/terminal-outcomes.ts
-import { chmod as chmod9, lstat as lstat12, mkdir as mkdir15, open as open10, readdir as readdir5, readFile as readFile11, rename as rename9, rm as rm11 } from "node:fs/promises";
+import { chmod as chmod9, lstat as lstat12, mkdir as mkdir16, open as open10, readdir as readdir5, readFile as readFile11, rename as rename9, rm as rm12 } from "node:fs/promises";
 import { homedir as homedir11 } from "node:os";
-import { dirname as dirname12, join as join20, relative as relative12, resolve as resolve15, sep as sep8 } from "node:path";
+import { dirname as dirname13, join as join21, relative as relative12, resolve as resolve15, sep as sep8 } from "node:path";
 var DIRECTORY_MODE5 = 448;
 var FILE_MODE4 = 384;
 var MAX_OUTCOME_BYTES = 4 * 1024 * 1024;
 var HOST_DIRECTORY = /^hst_[0-9a-f]{32}$/;
 var OUTCOME_FILE = /^(tsk_[0-9a-f]{32})\.([1-9][0-9]*)\.json$/;
 function defaultTerminalOutcomeRoot() {
-  return join20(homedir11(), ".zixt", "terminal-outcomes");
+  return join21(homedir11(), ".zixt", "terminal-outcomes");
 }
 function hostOutcomeRoot(root, hostId) {
   if (!HOST_DIRECTORY.test(hostId)) throw new Error("terminal outcome Host identity is malformed");
-  return join20(root, hostId);
+  return join21(root, hostId);
 }
 function outcomePath(root, hostId, taskId, epoch) {
-  return join20(hostOutcomeRoot(root, hostId), `${taskId}.${epoch}.json`);
+  return join21(hostOutcomeRoot(root, hostId), `${taskId}.${epoch}.json`);
 }
 async function syncDirectory6(root) {
   if (process.platform === "win32") return;
@@ -39403,15 +39505,15 @@ async function syncDirectory6(root) {
   }
 }
 async function requirePrivateRoot(root, sync = syncDirectory6) {
-  const firstCreated = await mkdir15(root, { recursive: true, mode: DIRECTORY_MODE5 });
+  const firstCreated = await mkdir16(root, { recursive: true, mode: DIRECTORY_MODE5 });
   if (firstCreated) {
     const first = resolve15(firstCreated);
     const target = resolve15(root);
-    await sync(dirname12(first));
+    await sync(dirname13(first));
     let current = first;
     for (const part of relative12(first, target).split(sep8).filter(Boolean)) {
       await sync(current);
-      current = join20(current, part);
+      current = join21(current, part);
     }
   }
   const stat3 = await lstat12(root);
@@ -39451,7 +39553,7 @@ async function recordTerminalOutcome(hostId, input, root = defaultTerminalOutcom
   } catch (error52) {
     if (error52.code !== "ENOENT") throw error52;
   }
-  const temporary = join20(
+  const temporary = join21(
     scopedRoot,
     `.${outcome.taskId}.${outcome.epoch}.${process.pid}.${Date.now()}.${outcome.resultId}.tmp`
   );
@@ -39468,7 +39570,7 @@ async function recordTerminalOutcome(hostId, input, root = defaultTerminalOutcom
   } finally {
     await handle?.close().catch(() => {
     });
-    await rm11(temporary, { force: true }).catch(() => {
+    await rm12(temporary, { force: true }).catch(() => {
     });
   }
 }
@@ -39504,7 +39606,7 @@ async function readTerminalOutcomesStrict(root = defaultTerminalOutcomeRoot()) {
       if (!match || !entry.isFile() || entry.isSymbolicLink()) {
         throw new Error("committed terminal outcome is not a trusted regular file");
       }
-      const path = join20(scopedRoot, entry.name);
+      const path = join21(scopedRoot, entry.name);
       const stat3 = await lstat12(path);
       if (!stat3.isFile() || stat3.isSymbolicLink() || stat3.size > MAX_OUTCOME_BYTES) {
         throw new Error("committed terminal outcome is not a trusted regular file");
@@ -39537,7 +39639,7 @@ async function forgetAcknowledgedTerminalOutcomes(refs, root = defaultTerminalOu
     if (acknowledged.get(`${hostId}:${outcome.taskId}:${outcome.epoch}`) !== outcome.resultId) {
       continue;
     }
-    await rm11(outcomePath(root, hostId, outcome.taskId, outcome.epoch), { force: true });
+    await rm12(outcomePath(root, hostId, outcome.taskId, outcome.epoch), { force: true });
     changedHostRoots.add(hostOutcomeRoot(root, hostId));
   }
   for (const scopedRoot of changedHostRoots) await syncDirectory6(scopedRoot);
@@ -39549,7 +39651,7 @@ async function forgetSupersededTerminalOutcomes(hostId, taskId, epoch, root = de
     if (scoped.hostId !== hostId) continue;
     const { outcome } = scoped;
     if (outcome.taskId !== taskId || outcome.epoch >= epoch) continue;
-    await rm11(outcomePath(root, hostId, outcome.taskId, outcome.epoch), { force: true });
+    await rm12(outcomePath(root, hostId, outcome.taskId, outcome.epoch), { force: true });
     removed = true;
   }
   if (removed) await syncDirectory6(hostOutcomeRoot(root, hostId));
@@ -39657,7 +39759,7 @@ function createHostLogger(options = {}) {
 }
 
 // src/demo-state.ts
-import { isAbsolute as isAbsolute17, join as join21, parse as parse3, resolve as resolve16 } from "node:path";
+import { isAbsolute as isAbsolute17, join as join22, parse as parse3, resolve as resolve16 } from "node:path";
 var DEMO_STATE_ROOT_ENV = "ZIXT_DEMO_STATE_ROOT";
 function resolveDemoHostStatePaths(env = process.env) {
   const configured = env.ZIXT_RUNNER === "demo" ? env[DEMO_STATE_ROOT_ENV] : void 0;
@@ -39667,12 +39769,12 @@ function resolveDemoHostStatePaths(env = process.env) {
     throw new Error(`${DEMO_STATE_ROOT_ENV} must be a dedicated absolute directory`);
   }
   return {
-    runRegistryRoot: join21(root, "run-registry"),
-    terminalOutcomeRoot: join21(root, "terminal-outcomes"),
-    runArtifactRoot: join21(root, "run-artifacts"),
-    browserProfileRoot: join21(root, "browser-profiles"),
-    runnerWorkspaceRoot: join21(root, "workspaces"),
-    codexThreadIndexRoot: join21(root, "codex-threads")
+    runRegistryRoot: join22(root, "run-registry"),
+    terminalOutcomeRoot: join22(root, "terminal-outcomes"),
+    runArtifactRoot: join22(root, "run-artifacts"),
+    browserProfileRoot: join22(root, "browser-profiles"),
+    runnerWorkspaceRoot: join22(root, "workspaces"),
+    codexThreadIndexRoot: join22(root, "codex-threads")
   };
 }