@zixt/host 0.0.11 → 0.0.12

package/dist/index.js

@@ -31,7 +31,7 @@ import { homedir } from "node:os";
 // package.json
 var package_default = {
   name: "@zixt/host",
-  version: "0.0.11",
+  version: "0.0.12",
   type: "module",
   exports: {
     ".": "./src/client.ts",
@@ -15047,6 +15047,15 @@ var TaskRunnerSelection = external_exports.object({
   model: runnerModel,
   effort: TaskRunnerEffort.optional()
 }).strict();
+var RunnerRuntimeBase = {
+  type: RunnerType,
+  /** Resolved model id as the CLI reports it (`gpt-5.6-sol`, `claude-opus-5`). */
+  model: external_exports.string().min(1).max(120).refine(isSafeSingleLineDisplayText, "model must be a single display line").nullable(),
+  /** Resolved reasoning effort; the CLI's own default when nothing was set. */
+  effort: external_exports.string().min(1).max(40).refine(isSafeSingleLineDisplayText, "effort must be a single display line").nullable()
+};
+var TaskRunnerRuntimeObservation = external_exports.object(RunnerRuntimeBase).strict();
+var TaskRunnerRuntime = external_exports.object({ ...RunnerRuntimeBase, observedAt: IsoDate2 }).strict();
 var RunnerConfig = external_exports.discriminatedUnion("type", [
   external_exports.object({
     type: external_exports.literal("claude-code"),
@@ -15840,6 +15849,12 @@ var Task = external_exports.object({
   requestedHostId: HostId.nullable().default(null),
   /** TS-16: per-Task runner/model/effort selection; null runs the teammate's configuration. */
   runner: TaskRunnerSelection.nullable().default(null),
+  /**
+   * TS-16: what the runner CLI actually used on its newest attempt, as the
+   * CLI itself reported it. Null until a run starts (or when the Machine
+   * could not read the CLI's record), and replaced on every new attempt.
+   */
+  runnerRuntime: TaskRunnerRuntime.nullable().default(null),
   disposition: TaskDisposition.nullable(),
   /** Follow-ups accepted but not yet folded into a run; the thread renders
    * exactly this many trailing prompts as queued rather than answered. */
@@ -18320,6 +18335,12 @@ var TaskWorkingContextReport = external_exports.object({
   epoch: external_exports.number().int().min(1),
   context: TaskWorkingContextObservation
 });
+var TaskRunnerRuntimeReport = external_exports.object({
+  type: external_exports.literal("task.runner_runtime"),
+  taskId: TaskId,
+  epoch: external_exports.number().int().min(1),
+  runtime: TaskRunnerRuntimeObservation
+});
 var TaskTitle = external_exports.object({
   type: external_exports.literal("task.title"),
   taskId: TaskId,
@@ -18401,6 +18422,7 @@ var AgentOpRequest = external_exports.object({
 var UpMessage = external_exports.discriminatedUnion("type", [
   TaskEvent,
   TaskWorkingContextReport,
+  TaskRunnerRuntimeReport,
   TaskTitle,
   TaskResult,
   HostReport,
@@ -18440,7 +18462,9 @@ var HelloAckFrame = external_exports.object({
   features: external_exports.object({
     browserSessions: external_exports.literal(true).optional(),
     /** Host may send task.working_context only after this advertisement. */
-    taskWorkingContext: external_exports.literal(true).optional()
+    taskWorkingContext: external_exports.literal(true).optional(),
+    /** Host may send task.runner_runtime only after this advertisement. */
+    taskRunnerRuntime: external_exports.literal(true).optional()
   }).optional(),
   /**
    * Workspace paths configured for this organization's teammates. The Machine
@@ -19382,6 +19406,7 @@ var HostClient = class _HostClient {
   /** True only after the connected cloud's helloAck advertised the feature. */
   browserFeatureActive = false;
   workingContextFeatureActive = false;
+  runnerRuntimeFeatureActive = false;
   /** TCP open is not protocol authority; only the current helloAck opens upstream delivery. */
   protocolReady = false;
   /** Workspace paths this organization configured, as of the last hello/update. */
@@ -19419,6 +19444,7 @@ var HostClient = class _HostClient {
     this.protocolReady = false;
     this.browserFeatureActive = false;
     this.workingContextFeatureActive = false;
+    this.runnerRuntimeFeatureActive = false;
     this.opts.browser?.attach(null);
     await Promise.allSettled([
       this.unwindAllRuns("host client stopped", "client_shutdown"),
@@ -19678,6 +19704,7 @@ var HostClient = class _HostClient {
     if (this.ws !== void 0) return;
     this.browserFeatureActive = false;
     this.workingContextFeatureActive = false;
+    this.runnerRuntimeFeatureActive = false;
     this.opts.browser?.attach(null);
     void this.opts.browser?.closeAll("machine_offline");
     if (code === CLOSE_CODES.revoked) {
@@ -19706,13 +19733,13 @@ var HostClient = class _HostClient {
     );
     if (this.stopped) return;
     if (!this.stopped && this.opts.reconnect !== false) {
-      const delay2 = reconnectBackoffDelay(this.reconnectFailures, this.opts.backoffMs);
+      const delay4 = reconnectBackoffDelay(this.reconnectFailures, this.opts.backoffMs);
       this.reconnectFailures++;
       if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
       this.reconnectTimer = setTimeout(() => {
         this.reconnectTimer = void 0;
         this.connect();
-      }, delay2);
+      }, delay4);
     } else {
       this.stopped = true;
     }
@@ -19743,7 +19770,7 @@ var HostClient = class _HostClient {
     this.send(frame);
   }
   replaceablePendingUp(message) {
-    return message.type === "host.report" || message.type === "task.working_context" || message.type === "task.title" || message.type === "task.event" && message.event.ephemeral === true;
+    return message.type === "host.report" || message.type === "task.working_context" || message.type === "task.runner_runtime" || message.type === "task.title" || message.type === "task.event" && message.event.ephemeral === true;
   }
   supersedesPendingUp(candidate, incoming) {
     if (candidate.type !== incoming.type) return false;
@@ -19754,7 +19781,7 @@ var HostClient = class _HostClient {
     if (incoming.type === "agent.op") {
       return candidate.type === "agent.op" && candidate.taskId === incoming.taskId && candidate.epoch === incoming.epoch && candidate.requestId === incoming.requestId;
     }
-    if (incoming.type === "task.working_context" || incoming.type === "task.title") {
+    if (incoming.type === "task.working_context" || incoming.type === "task.runner_runtime" || incoming.type === "task.title") {
       return candidate.type === incoming.type && candidate.taskId === incoming.taskId && candidate.epoch === incoming.epoch;
     }
     return false;
@@ -19914,6 +19941,7 @@ var HostClient = class _HostClient {
         this.configuredWorkspaces = frame.workspaces ?? [];
         this.browserFeatureActive = frame.features?.browserSessions === true;
         this.workingContextFeatureActive = frame.features?.taskWorkingContext === true;
+        this.runnerRuntimeFeatureActive = frame.features?.taskRunnerRuntime === true;
         if (this.browserFeatureActive && this.opts.browser) {
           this.opts.browser.attach({
             state: (state, openRequestId) => this.sendBrowserFrame({
@@ -20397,6 +20425,21 @@ var HostClient = class _HostClient {
         throw new Error("Working-context evidence could not be delivered before execution.");
       }
     };
+    const emitRunnerRuntime = (runtime) => {
+      if (!this.runnerRuntimeFeatureActive) return;
+      const parsed = TaskRunnerRuntimeObservation.safeParse({
+        type: runtime.type,
+        model: runtime.model === null ? null : safe(runtime.model, 120),
+        effort: runtime.effort === null ? null : safe(runtime.effort, 40)
+      });
+      if (!parsed.success) return;
+      this.sendUp({
+        type: "task.runner_runtime",
+        taskId: assign.taskId,
+        epoch: assign.epoch,
+        runtime: parsed.data
+      });
+    };
     const secrets = () => {
       if (authorityController.signal.aborted) return Promise.resolve({});
       const entry = this.secretGrants.get(cancelKey) ?? { resolvers: [] };
@@ -20723,6 +20766,7 @@ var HostClient = class _HostClient {
         spec: assign.spec,
         event: emitEvent,
         workingContext: emitWorkingContext,
+        runnerRuntime: emitRunnerRuntime,
         siblingTasks: () => [...this.liveTasks.values()].filter((live) => live.agentId === assign.agentId && live.taskId !== assign.taskId).map(({ taskId, title }) => ({ taskId, title })),
         fetchAttachment: (attachmentId) => this.fetchAttachment(attachmentId, authorityController.signal),
         secrets,
@@ -24403,7 +24447,7 @@ var BrowserManager = class {
     session.pendingFrame = frame;
     if (session.frameTimer) return;
     const elapsed = Date.now() - session.lastFrameSentAt;
-    const delay2 = Math.max(0, this.frameMinIntervalMs - elapsed);
+    const delay4 = Math.max(0, this.frameMinIntervalMs - elapsed);
     session.frameTimer = setTimeout(() => {
       session.frameTimer = null;
       const pending = session.pendingFrame;
@@ -24418,7 +24462,7 @@ var BrowserManager = class {
         width: pending.width,
         height: pending.height
       });
-    }, delay2);
+    }, delay4);
     session.frameTimer.unref?.();
   }
   markActivity(agentId) {
@@ -33376,7 +33420,10 @@ function createCliRunner(adapter, opts = {}) {
         // The trusted workspace facts describe where Zixt put provider clones,
         // which is always the Zixt-owned root — never a configured workspace.
         taskRoot,
-        cwd
+        cwd,
+        command: resolvedCommand,
+        commandPrefixArgs: prefixArgs,
+        env
       });
       const runEnv = prepared.env ? { ...env, ...prepared.env } : env;
       let attachmentSection = "";
@@ -34064,6 +34111,171 @@ function runCliProcess(options) {
 
 // src/runners/claude-code.ts
 import { randomUUID as randomUUID11 } from "node:crypto";
+
+// src/runners/runtime-observation.ts
+import { open as open5, readdir as readdir4, realpath as realpath8 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import { join as join15 } from "node:path";
+var READ_WINDOW_BYTES = 1024 * 1024;
+var CATALOG_TIMEOUT_MS = 15e3;
+var CATALOG_OUTPUT_LIMIT_BYTES = 4 * 1024 * 1024;
+function homeFrom(env) {
+  return env["HOME"] || env["USERPROFILE"] || homedir5();
+}
+async function readHead(path) {
+  let handle;
+  try {
+    handle = await open5(path, "r");
+    const buffer = Buffer.alloc(READ_WINDOW_BYTES);
+    const { bytesRead } = await handle.read(buffer, 0, READ_WINDOW_BYTES, 0);
+    return buffer.subarray(0, bytesRead).toString("utf8");
+  } catch {
+    return "";
+  } finally {
+    await handle?.close().catch(() => {
+    });
+  }
+}
+async function readTail(path) {
+  let handle;
+  try {
+    handle = await open5(path, "r");
+    const { size } = await handle.stat();
+    const start = Math.max(0, size - READ_WINDOW_BYTES);
+    const length = Math.min(size, READ_WINDOW_BYTES);
+    const buffer = Buffer.alloc(length);
+    const { bytesRead } = await handle.read(buffer, 0, length, start);
+    const text = buffer.subarray(0, bytesRead).toString("utf8");
+    return start === 0 ? text : text.slice(text.indexOf("\n") + 1);
+  } catch {
+    return "";
+  } finally {
+    await handle?.close().catch(() => {
+    });
+  }
+}
+function parseLines(text) {
+  const records = [];
+  for (const line of text.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      const value = JSON.parse(line);
+      if (value && typeof value === "object") records.push(value);
+    } catch {
+    }
+  }
+  return records;
+}
+function displayValue(value, maxLength) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.length > maxLength || /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u.test(trimmed)) {
+    return null;
+  }
+  return trimmed;
+}
+function claudeTranscriptPath(input) {
+  const configDir = input.env["CLAUDE_CONFIG_DIR"] || join15(homeFrom(input.env), ".claude");
+  const slug = input.resolvedCwd.replace(/[^a-zA-Z0-9]/g, "-");
+  return join15(configDir, "projects", slug, `${input.sessionId}.jsonl`);
+}
+async function readClaudeSessionEffort(input) {
+  const resolvedCwd = await realpath8(input.cwd).catch(() => input.cwd);
+  const path = claudeTranscriptPath({ env: input.env, resolvedCwd, sessionId: input.sessionId });
+  const records = parseLines(await readTail(path));
+  for (let index = records.length - 1; index >= 0; index -= 1) {
+    const record2 = records[index];
+    if (record2["type"] !== "assistant") continue;
+    const effort = displayValue(record2["effort"], 40);
+    if (effort) return effort;
+  }
+  return null;
+}
+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));
+}
+async function findCodexRolloutPath(input) {
+  const codexHome = input.env["CODEX_HOME"] || join15(homeFrom(input.env), ".codex");
+  const sessions = join15(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);
+      }
+    }
+  }
+  return null;
+}
+async function readCodexSessionRuntime(input) {
+  const path = await findCodexRolloutPath(input);
+  if (!path) return null;
+  const contexts = parseLines(await readHead(path)).filter(
+    (record2) => record2["type"] === "turn_context"
+  );
+  const payload = contexts.at(-1)?.["payload"];
+  if (!payload || typeof payload !== "object") return null;
+  const context = payload;
+  const settings = context["collaboration_mode"]?.["settings"];
+  return {
+    model: displayValue(context["model"] ?? settings?.["model"], 120),
+    effort: displayValue(context["effort"] ?? settings?.["reasoning_effort"], 40)
+  };
+}
+var codexCatalogCache = /* @__PURE__ */ new Map();
+async function loadCodexModelCatalog(command, prefixArgs, env) {
+  const output = await new Promise((resolve13) => {
+    const child = spawnCli(command, [...prefixArgs, "debug", "models"], {
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true,
+      env
+    });
+    let text = "";
+    child.stdout?.on("data", (chunk) => {
+      if (text.length < CATALOG_OUTPUT_LIMIT_BYTES) text += chunk.toString("utf8");
+    });
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve13(value);
+    };
+    const timer = setTimeout(() => {
+      child.kill();
+      finish("");
+    }, CATALOG_TIMEOUT_MS);
+    timer.unref?.();
+    child.on("error", () => finish(""));
+    child.on("close", () => finish(text));
+  });
+  const defaults = /* @__PURE__ */ new Map();
+  try {
+    const catalog2 = JSON.parse(output);
+    for (const model of catalog2.models ?? []) {
+      const slug = displayValue(model["slug"], 120);
+      const effort = displayValue(model["default_reasoning_level"], 40);
+      if (slug && effort) defaults.set(slug, effort);
+    }
+  } catch {
+  }
+  return defaults;
+}
+async function codexModelDefaultEffort(input) {
+  const prefixArgs = input.commandPrefixArgs ?? [];
+  const cacheKey = [input.command, ...prefixArgs].join(" ");
+  let catalog2 = codexCatalogCache.get(cacheKey);
+  if (!catalog2) {
+    catalog2 = loadCodexModelCatalog(input.command, prefixArgs, input.env);
+    codexCatalogCache.set(cacheKey, catalog2);
+  }
+  return (await catalog2).get(input.model) ?? null;
+}
+
+// src/runners/claude-code.ts
 var CLAUDE_SESSION_CRON_TOOLS = ["CronCreate", "CronList", "CronDelete"];
 var CLAUDE_REINVOCATION_TOOLS = ["Monitor", "ScheduleWakeup"];
 var SESSION_CONFLICT = /session/i;
@@ -34088,13 +34300,14 @@ var claudeCodeAdapter = {
       input.cwd
     );
     const sessionId = input.task.spec.sessionKey ?? randomUUID11();
+    const observeRuntime = createRuntimeReporter(input, sessionId);
     return {
       argsFor: (mode) => [
         ...baseArgs,
         ...mode === "resume" ? ["--resume", sessionId] : ["--session-id", sessionId]
       ],
       prompt: buildRunnerPrompt(input.task),
-      createParser: createStreamParser,
+      createParser: (onStream) => createStreamParser(onStream, { onSessionModel: observeRuntime }),
       // Self-heal both directions: a crashed first run leaves a transcript
       // (new → conflict), a lost workspace breaks resume (resume → not
       // found). One flip covers both.
@@ -34105,6 +34318,36 @@ var claudeCodeAdapter = {
 function createClaudeCodeRunner(opts = {}) {
   return createCliRunner(claudeCodeAdapter, opts);
 }
+function createRuntimeReporter(input, sessionId) {
+  const { task, runner, env, cwd } = input;
+  const chosenEffort = runner.effort ?? null;
+  let reported = false;
+  return (model) => {
+    if (reported) return;
+    reported = true;
+    task.runnerRuntime?.({ type: "claude-code", model, effort: chosenEffort });
+    if (chosenEffort) return;
+    void (async () => {
+      for (let attempt = 0; attempt < EFFORT_READ_ATTEMPTS; attempt += 1) {
+        await delay2(EFFORT_READ_INTERVAL_MS);
+        if (task.cancelledNow()) return;
+        const effort = await readClaudeSessionEffort({ env, cwd, sessionId }).catch(() => null);
+        if (effort) {
+          task.runnerRuntime?.({ type: "claude-code", model, effort });
+          return;
+        }
+      }
+    })();
+  };
+}
+var EFFORT_READ_ATTEMPTS = 5;
+var EFFORT_READ_INTERVAL_MS = 3e3;
+function delay2(ms) {
+  return new Promise((resolve13) => {
+    const timer = setTimeout(resolve13, ms);
+    timer.unref?.();
+  });
+}
 async function buildArgs(task, runner, artifacts, mcp, preparedWorkspace, taskRoot, workspacePath = taskRoot ?? "") {
   const args = [
     // Hermetic, non-interactive run — no local slash commands or global state.
@@ -34150,7 +34393,7 @@ async function buildArgs(task, runner, artifacts, mcp, preparedWorkspace, taskRo
   );
   return args;
 }
-function createStreamParser(onStream) {
+function createStreamParser(onStream, hooks = {}) {
   let buffer = "";
   let responseText = "";
   let inputTokens = 0;
@@ -34175,7 +34418,9 @@ function createStreamParser(onStream) {
       return void 0;
     }
     const type = json2["type"];
-    if (type === "assistant") {
+    if (type === "system" && json2["subtype"] === "init") {
+      if (typeof json2["model"] === "string" && json2["model"]) hooks.onSessionModel?.(json2["model"]);
+    } else if (type === "assistant") {
       const message = json2["message"];
       applyUsage(message?.["usage"]);
       const content = message?.["content"] ?? [];
@@ -34290,16 +34535,16 @@ function improveErrorMessage(error52) {
 
 // src/runners/codex.ts
 import { mkdir as mkdir11, readFile as readFile7, writeFile as writeFile6 } from "node:fs/promises";
-import { homedir as homedir5 } from "node:os";
-import { join as join15 } from "node:path";
+import { homedir as homedir6 } from "node:os";
+import { join as join16 } 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 join15(homedir5(), ".zixt", "codex-threads");
+  return join16(homedir6(), ".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 join15(root, agentId, `${sessionKey}.json`);
+  return join16(root, agentId, `${sessionKey}.json`);
 }
 async function readThreadId(path) {
   try {
@@ -34389,9 +34634,12 @@ ${buildRunnerPrompt(task)}` : buildRunnerPrompt(task);
       const recordedThreadId = indexPath ? await readThreadId(indexPath) : null;
       const rememberThread = (threadId) => {
         if (!indexPath) return;
-        void mkdir11(join15(threadIndexRoot, task.agentId), { recursive: true }).then(() => writeFile6(indexPath, JSON.stringify({ threadId }), "utf8")).catch(() => {
+        void mkdir11(join16(threadIndexRoot, task.agentId), { recursive: true }).then(() => writeFile6(indexPath, JSON.stringify({ threadId }), "utf8")).catch(() => {
         });
       };
+      const observeRuntime = (threadId) => {
+        void reportCodexRuntime({ input, threadId });
+      };
       return {
         argsFor: (mode) => {
           if (mode === "resume") {
@@ -34401,7 +34649,12 @@ ${buildRunnerPrompt(task)}` : buildRunnerPrompt(task);
         },
         prompt,
         env,
-        createParser: (onStream) => createCodexStreamParser(onStream, { onThreadStarted: rememberThread }),
+        createParser: (onStream) => createCodexStreamParser(onStream, {
+          onThreadStarted: (threadId) => {
+            rememberThread(threadId);
+            observeRuntime(threadId);
+          }
+        }),
         // Only one flip is meaningful: a resume whose rollout vanished starts
         // over. Codex assigns new-session ids itself, so a new session can
         // never collide the way a pre-specified id can.
@@ -34410,6 +34663,30 @@ ${buildRunnerPrompt(task)}` : buildRunnerPrompt(task);
     }
   };
 }
+var RUNTIME_READ_ATTEMPTS = 5;
+var RUNTIME_READ_INTERVAL_MS = 2e3;
+function delay3(ms) {
+  return new Promise((resolve13) => {
+    const timer = setTimeout(resolve13, ms);
+    timer.unref?.();
+  });
+}
+async function reportCodexRuntime(args) {
+  const { task, runner, env, command, commandPrefixArgs } = args.input;
+  for (let attempt = 0; attempt < RUNTIME_READ_ATTEMPTS; attempt += 1) {
+    if (task.cancelledNow()) return;
+    const observed = await readCodexSessionRuntime({ env, threadId: args.threadId }).catch(
+      () => null
+    );
+    const model = observed?.model ?? runner.model ?? null;
+    if (model) {
+      const effort = observed?.effort ?? runner.effort ?? (command ? await codexModelDefaultEffort({ command, commandPrefixArgs, env, model }) : null);
+      task.runnerRuntime?.({ type: "codex", model, effort });
+      return;
+    }
+    await delay3(RUNTIME_READ_INTERVAL_MS);
+  }
+}
 function createCodexRunner(opts = {}) {
   const adapter = createCodexAdapter(opts.threadIndexRoot ?? defaultCodexThreadIndexRoot());
   return createCliRunner(adapter, opts);
@@ -34559,7 +34836,7 @@ function improveCodexErrorMessage(error52) {
 
 // src/runners/git-preflight.ts
 import { spawn as spawn9 } from "node:child_process";
-import { realpath as realpath8 } from "node:fs/promises";
+import { realpath as realpath9 } from "node:fs/promises";
 import { isAbsolute as isAbsolute13, resolve as resolve7 } from "node:path";
 var OUTPUT_LIMIT = 8192;
 var DEFAULT_TIMEOUT_MS4 = 1e4;
@@ -34579,7 +34856,7 @@ async function preflightGit(options = {}) {
   if (configured !== void 0 && !isAbsolute13(configured)) {
     return unavailable("configured git command must be an absolute file", checkedAt);
   }
-  const trustedCwd = await realpath8(resolve7(options.trustedCwd ?? process.cwd())).catch(() => null);
+  const trustedCwd = await realpath9(resolve7(options.trustedCwd ?? process.cwd())).catch(() => null);
   if (!trustedCwd)
     return unavailable("Host-owned git preflight directory is unavailable", checkedAt);
   const executablePath = await resolveTrustedCliCommand(configured ?? "git", {
@@ -34831,9 +35108,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 open5, rename as rename5, rm as rm7 } from "node:fs/promises";
-import { homedir as homedir6, userInfo } from "node:os";
-import { basename as basename3, dirname as dirname7, join as join16, relative as relative8, resolve as resolve8, sep as sep4 } from "node:path";
+import { access as access4, chmod as chmod7, mkdir as mkdir12, open as open6, rename as rename5, rm as rm7 } from "node:fs/promises";
+import { homedir as homedir7, userInfo } from "node:os";
+import { basename as basename3, dirname as dirname7, join as join17, relative as relative8, resolve as resolve8, sep as sep4 } from "node:path";
 var SERVICE_NAME = "zixt-host.service";
 var SYSTEM_SERVICE_COMMAND_TIMEOUT_MS = 7e4;
 var SERVICE_STABILITY_DELAY_MS = 2e3;
@@ -34921,7 +35198,7 @@ function systemdDirectiveValue(value) {
   return systemdQuotedValue(value, false);
 }
 async function defaultSyncDirectory(path) {
-  const directory = await open5(path, "r");
+  const directory = await open6(path, "r");
   try {
     await directory.sync();
   } finally {
@@ -34938,14 +35215,14 @@ async function ensureDirectory(path, mode, syncDirectory7) {
   const descendants = relative8(first, target);
   for (const part of descendants ? descendants.split(sep4) : []) {
     await syncDirectory7(current);
-    current = join16(current, part);
+    current = join17(current, part);
   }
 }
 async function replacePrivateFile(path, contents, mode, syncDirectory7) {
   const parent = dirname7(path);
   await ensureDirectory(parent, 448, syncDirectory7);
-  const temporary = join16(parent, `.${basename3(path)}.${process.pid}.${crypto.randomUUID()}.tmp`);
-  const handle = await open5(temporary, "wx", mode);
+  const temporary = join17(parent, `.${basename3(path)}.${process.pid}.${crypto.randomUUID()}.tmp`);
+  const handle = await open6(temporary, "wx", mode);
   try {
     await handle.writeFile(contents, "utf8");
     await handle.sync();
@@ -34988,7 +35265,7 @@ async function installLinuxService(options) {
     throw new Error("Linux automatic startup is available only on Linux.");
   }
   const env = options.env ?? process.env;
-  const home = options.home ?? homedir6();
+  const home = options.home ?? homedir7();
   const username = oneLine(options.username ?? userInfo().username, "user name");
   const token2 = oneLine(options.token, "pairing code");
   const path = oneLine(
@@ -34996,11 +35273,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") : join16(home, ".config");
-  const configRoot = options.serviceConfigRoot ?? join16(xdgConfigHome, "zixt");
-  const unitRoot = options.userUnitRoot ?? join16(xdgConfigHome, "systemd", "user");
-  const environmentPath = join16(configRoot, "host.env");
-  const unitPath = join16(unitRoot, SERVICE_NAME);
+  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 installVersion = options.installVersion ?? installRelease;
   const activateVersion = options.activateVersion ?? (options.installVersion ? async (entry) => entry : activateInstalledRelease);
   const resolveCommand = options.resolveCommand ?? defaultResolveCommand;
@@ -35119,9 +35396,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 open6, rename as rename6, rm as rm8 } from "node:fs/promises";
-import { homedir as homedir7, userInfo as userInfo2 } from "node:os";
-import { basename as basename4, dirname as dirname8, join as join17, relative as relative9, resolve as resolve9, sep as sep5 } from "node:path";
+import { access as access5, chmod as chmod8, mkdir as mkdir13, open as open7, rename as rename6, rm as rm8 } from "node:fs/promises";
+import { homedir as homedir8, userInfo as userInfo2 } from "node:os";
+import { basename as basename4, dirname as dirname8, join as join18, relative as relative9, resolve as resolve9, sep as sep5 } from "node:path";
 var LAUNCH_AGENT_LABEL = "ai.zixt.host";
 var SERVICE_STABILITY_DELAY_MS2 = 2e3;
 var COMMAND_TIMEOUT_MS2 = 7e4;
@@ -35137,7 +35414,7 @@ function shellValue(value) {
   return `'${oneLine2(value, "service setting").replaceAll("'", `'"'"'`)}'`;
 }
 async function syncDirectory4(path) {
-  const directory = await open6(path, "r");
+  const directory = await open7(path, "r");
   try {
     await directory.sync();
   } finally {
@@ -35153,14 +35430,14 @@ async function ensureDirectory2(path, sync) {
   let current = first;
   for (const part of relative9(first, target).split(sep5).filter(Boolean)) {
     await sync(current);
-    current = join17(current, part);
+    current = join18(current, part);
   }
 }
 async function replacePrivateFile2(path, contents, mode, sync) {
   const parent = dirname8(path);
   await ensureDirectory2(parent, sync);
-  const temporary = join17(parent, `.${basename4(path)}.${process.pid}.${crypto.randomUUID()}.tmp`);
-  const handle = await open6(temporary, "wx", mode);
+  const temporary = join18(parent, `.${basename4(path)}.${process.pid}.${crypto.randomUUID()}.tmp`);
+  const handle = await open7(temporary, "wx", mode);
   try {
     await handle.writeFile(contents, "utf8");
     await handle.sync();
@@ -35247,7 +35524,7 @@ async function installMacosService(options) {
     throw new Error("macOS automatic startup is available only on macOS.");
   }
   const env = options.env ?? process.env;
-  const home = options.home ?? homedir7();
+  const home = options.home ?? homedir8();
   const uid = options.uid ?? userInfo2().uid;
   if (!Number.isSafeInteger(uid) || uid < 0) throw new Error("macOS user id is invalid.");
   const token2 = oneLine2(options.token, "pairing code");
@@ -35256,20 +35533,20 @@ async function installMacosService(options) {
     options.path ?? env.PATH ?? "/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin",
     "command search path"
   );
-  const configRoot = options.configRoot ?? join17(home, "Library", "Application Support", "Zixt");
-  const launchAgentsRoot = options.launchAgentsRoot ?? join17(home, "Library", "LaunchAgents");
-  const logRoot = options.logRoot ?? join17(home, "Library", "Logs", "Zixt");
-  const configPath = join17(configRoot, "host.env");
-  const launcherPath = join17(configRoot, "host-launcher.sh");
-  const plistPath = join17(launchAgentsRoot, `${LAUNCH_AGENT_LABEL}.plist`);
-  const stdoutPath = join17(logRoot, "host.log");
-  const stderrPath = join17(logRoot, "host-error.log");
+  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 installVersion = options.installVersion ?? installRelease;
   const activateVersion = options.activateVersion ?? (options.installVersion ? async (entry) => entry : (entry) => activateInstalledRelease(entry));
   const resolveCommand = options.resolveCommand ?? (async () => defaultResolveCommand2());
   const run3 = options.runCommand ?? ((command, args) => defaultRunCommand2(command, args, env));
   const sync = options.syncDirectory ?? syncDirectory4;
-  const delay2 = options.delay ?? ((ms) => new Promise((done) => setTimeout(done, ms)));
+  const delay4 = options.delay ?? ((ms) => new Promise((done) => setTimeout(done, ms)));
   const launchctl = await resolveCommand("launchctl");
   if (!launchctl) throw new Error("macOS launchctl could not be found.");
   const releaseEntry = await installVersion(options.hostVersion);
@@ -35331,7 +35608,7 @@ async function installMacosService(options) {
     return status;
   };
   const first = await observe();
-  await delay2(options.serviceStabilityDelayMs ?? SERVICE_STABILITY_DELAY_MS2);
+  await delay4(options.serviceStabilityDelayMs ?? SERVICE_STABILITY_DELAY_MS2);
   const second = await observe();
   if (first.pid !== second.pid || first.runs !== second.runs) {
     throw new Error("Zixt started but restarted during its readiness check.");
@@ -35350,9 +35627,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 open7, readFile as readFile8, rename as rename7, rm as rm9 } from "node:fs/promises";
-import { homedir as homedir8 } from "node:os";
-import { basename as basename5, dirname as dirname9, isAbsolute as isAbsolute14, join as join18, relative as relative10, resolve as resolve10, sep as sep6 } from "node:path";
+import { access as access6, mkdir as mkdir14, open as open8, readFile as readFile8, rename as rename7, rm as rm9 } from "node:fs/promises";
+import { homedir as homedir9 } from "node:os";
+import { basename as basename5, dirname as dirname9, isAbsolute as isAbsolute14, join as join19, relative as relative10, resolve as resolve10, sep as sep6 } from "node:path";
 var TASK_NAME = "Zixt Host";
 var COMMAND_TIMEOUT_MS3 = 7e4;
 var SERVICE_STABILITY_DELAY_MS3 = 2e3;
@@ -35370,7 +35647,7 @@ function psLiteral(value) {
 }
 async function syncDirectory5(path) {
   if (process.platform === "win32") return;
-  const directory = await open7(path, "r");
+  const directory = await open8(path, "r");
   try {
     await directory.sync();
   } finally {
@@ -35386,14 +35663,14 @@ async function ensureDirectory3(path, sync) {
   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 replacePrivateFile3(path, contents, sync) {
   const parent = dirname9(path);
   await ensureDirectory3(parent, sync);
-  const temporary = join18(parent, `.${basename5(path)}.${process.pid}.${crypto.randomUUID()}.tmp`);
-  const handle = await open7(temporary, "wx", 384);
+  const temporary = join19(parent, `.${basename5(path)}.${process.pid}.${crypto.randomUUID()}.tmp`);
+  const handle = await open8(temporary, "wx", 384);
   try {
     await handle.writeFile(contents, "utf8");
     await handle.sync();
@@ -35447,7 +35724,7 @@ async function runChild(command, args, env, input) {
 async function defaultResolveCommand3(name, env) {
   const root = env.SYSTEMROOT ?? env.WINDIR;
   if (!root || !isAbsolute14(root)) return null;
-  const candidate = name === "powershell" ? join18(root, "System32", "WindowsPowerShell", "v1.0", "powershell.exe") : join18(root, "System32", `${name}.exe`);
+  const candidate = name === "powershell" ? join19(root, "System32", "WindowsPowerShell", "v1.0", "powershell.exe") : join19(root, "System32", `${name}.exe`);
   return access6(candidate, constants4.X_OK).then(
     () => candidate,
     () => null
@@ -35576,7 +35853,7 @@ async function installWindowsService(options) {
     throw new Error("Windows automatic startup is available only on Windows.");
   }
   const env = options.env ?? process.env;
-  const home = options.home ?? homedir8();
+  const home = options.home ?? homedir9();
   const localAppData = options.localAppData ?? env.LOCALAPPDATA;
   if (!localAppData || !isAbsolute14(localAppData)) {
     throw new Error("Windows local application data path is unavailable.");
@@ -35584,17 +35861,17 @@ 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 ?? join18(localAppData, "Zixt", "Host");
-  const configPath = join18(configRoot, "host.json");
-  const launcherPath = join18(configRoot, "host-launcher.ps1");
-  const taskXmlPath = join18(configRoot, "host-task.xml");
-  const statusPath = join18(configRoot, "host-status.json");
+  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 installVersion = options.installVersion ?? installRelease;
   const activateVersion = options.activateVersion ?? (options.installVersion ? async (entry) => entry : (entry) => activateInstalledRelease(entry));
   const resolveCommand = options.resolveCommand ?? ((name) => defaultResolveCommand3(name, env));
   const run3 = options.runCommand ?? ((command, args) => runChild(command, args, env));
   const sync = options.syncDirectory ?? syncDirectory5;
-  const delay2 = options.delay ?? ((ms) => new Promise((done) => setTimeout(done, ms)));
+  const delay4 = options.delay ?? ((ms) => new Promise((done) => setTimeout(done, ms)));
   const observe = options.observeStatus ?? defaultObserveStatus;
   const [powershell, schtasks, icacls] = await Promise.all([
     resolveCommand("powershell"),
@@ -35657,10 +35934,10 @@ async function installWindowsService(options) {
   do {
     first = await observe(statusPath, generation);
     if (first) break;
-    await delay2(50);
+    await delay4(50);
   } while (Date.now() < deadline);
   if (!first) throw new Error("Zixt started but did not reach a running process state.");
-  await delay2(options.serviceStabilityDelayMs ?? SERVICE_STABILITY_DELAY_MS3);
+  await delay4(options.serviceStabilityDelayMs ?? SERVICE_STABILITY_DELAY_MS3);
   const second = await observe(statusPath, generation);
   if (!second || first.pid !== second.pid) {
     throw new Error("Zixt started but restarted during its readiness check.");
@@ -35689,27 +35966,27 @@ async function installSystemService(options) {
 }
 
 // src/terminal-outcomes.ts
-import { chmod as chmod9, lstat as lstat10, mkdir as mkdir15, open as open8, readdir as readdir4, readFile as readFile9, rename as rename8, rm as rm10 } from "node:fs/promises";
-import { homedir as homedir9 } from "node:os";
-import { dirname as dirname10, join as join19, relative as relative11, resolve as resolve11, sep as sep7 } from "node:path";
+import { chmod as chmod9, lstat as lstat10, mkdir as mkdir15, open as open9, readdir as readdir5, readFile as readFile9, rename as rename8, rm as rm10 } from "node:fs/promises";
+import { homedir as homedir10 } from "node:os";
+import { dirname as dirname10, join as join20, relative as relative11, resolve as resolve11, sep as sep7 } 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 join19(homedir9(), ".zixt", "terminal-outcomes");
+  return join20(homedir10(), ".zixt", "terminal-outcomes");
 }
 function hostOutcomeRoot(root, hostId) {
   if (!HOST_DIRECTORY.test(hostId)) throw new Error("terminal outcome Host identity is malformed");
-  return join19(root, hostId);
+  return join20(root, hostId);
 }
 function outcomePath(root, hostId, taskId, epoch) {
-  return join19(hostOutcomeRoot(root, hostId), `${taskId}.${epoch}.json`);
+  return join20(hostOutcomeRoot(root, hostId), `${taskId}.${epoch}.json`);
 }
 async function syncDirectory6(root) {
   if (process.platform === "win32") return;
-  const handle = await open8(root, "r");
+  const handle = await open9(root, "r");
   try {
     await handle.sync();
   } finally {
@@ -35725,7 +36002,7 @@ async function requirePrivateRoot(root, sync = syncDirectory6) {
     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);
     }
   }
   const stat3 = await lstat10(root);
@@ -35765,13 +36042,13 @@ async function recordTerminalOutcome(hostId, input, root = defaultTerminalOutcom
   } catch (error52) {
     if (error52.code !== "ENOENT") throw error52;
   }
-  const temporary = join19(
+  const temporary = join20(
     scopedRoot,
     `.${outcome.taskId}.${outcome.epoch}.${process.pid}.${Date.now()}.${outcome.resultId}.tmp`
   );
   let handle;
   try {
-    handle = await open8(temporary, "wx", FILE_MODE4);
+    handle = await open9(temporary, "wx", FILE_MODE4);
     await handle.writeFile(JSON.stringify(outcome), "utf8");
     await handle.sync();
     await handle.close();
@@ -35798,7 +36075,7 @@ async function readTerminalOutcomesStrict(root = defaultTerminalOutcomeRoot()) {
     throw new Error("terminal outcome journal root is not a trusted directory");
   }
   await chmod9(root, DIRECTORY_MODE5);
-  const hostEntries = await readdir4(root, { withFileTypes: true });
+  const hostEntries = await readdir5(root, { withFileTypes: true });
   const outcomes = [];
   const resultIds = /* @__PURE__ */ new Set();
   for (const hostEntry of hostEntries) {
@@ -35811,14 +36088,14 @@ async function readTerminalOutcomesStrict(root = defaultTerminalOutcomeRoot()) {
       throw new Error("terminal outcome Host scope is not a trusted directory");
     }
     await chmod9(scopedRoot, DIRECTORY_MODE5);
-    const entries = await readdir4(scopedRoot, { withFileTypes: true });
+    const entries = await readdir5(scopedRoot, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.name.endsWith(".json")) continue;
       const match = OUTCOME_FILE.exec(entry.name);
       if (!match || !entry.isFile() || entry.isSymbolicLink()) {
         throw new Error("committed terminal outcome is not a trusted regular file");
       }
-      const path = join19(scopedRoot, entry.name);
+      const path = join20(scopedRoot, entry.name);
       const stat3 = await lstat10(path);
       if (!stat3.isFile() || stat3.isSymbolicLink() || stat3.size > MAX_OUTCOME_BYTES) {
         throw new Error("committed terminal outcome is not a trusted regular file");
@@ -35971,7 +36248,7 @@ function createHostLogger(options = {}) {
 }
 
 // src/demo-state.ts
-import { isAbsolute as isAbsolute15, join as join20, parse as parse3, resolve as resolve12 } from "node:path";
+import { isAbsolute as isAbsolute15, join as join21, parse as parse3, resolve as resolve12 } 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;
@@ -35981,12 +36258,12 @@ function resolveDemoHostStatePaths(env = process.env) {
     throw new Error(`${DEMO_STATE_ROOT_ENV} must be a dedicated absolute directory`);
   }
   return {
-    runRegistryRoot: join20(root, "run-registry"),
-    terminalOutcomeRoot: join20(root, "terminal-outcomes"),
-    runArtifactRoot: join20(root, "run-artifacts"),
-    browserProfileRoot: join20(root, "browser-profiles"),
-    runnerWorkspaceRoot: join20(root, "workspaces"),
-    codexThreadIndexRoot: join20(root, "codex-threads")
+    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")
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zixt/host",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "type": "module",
   "exports": {
     ".": "./src/client.ts",