@amistio/cli 0.1.36 → 0.1.37

package/dist/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { createHash as createHash8, randomUUID } from "node:crypto";
-import { writeFile as writeFile10 } from "node:fs/promises";
+import { createHash as createHash9, randomUUID as randomUUID2 } from "node:crypto";
+import { writeFile as writeFile11 } from "node:fs/promises";
 import os8 from "node:os";
-import path16 from "node:path";
+import path17 from "node:path";
 import { Command } from "commander";
 
 // ../shared/src/schemas.ts
@@ -484,6 +484,33 @@ var runnerProviderConfigSchema = z.object({
   models: z.record(runnerProviderModelIdSchema, runnerProviderModelSchema).default({})
 }).strict();
 var runnerProviderCatalogSchema = z.record(runnerProviderIdSchema, runnerProviderConfigSchema);
+var runnerProviderClientIdSchema = z.string().trim().min(1).max(120);
+var runnerProviderRouteTypeSchema = z.enum(["directProvider", "agentClient", "localRuntime"]);
+var runnerProviderAuthStateSchema = z.enum(["notConfigured", "pendingUserAction", "authenticated", "expired", "revoked", "mismatch", "unavailable", "unsupported", "unknown"]);
+var runnerProviderAuthStatusSchema = z.object({
+  providerId: runnerProviderIdSchema,
+  providerClientId: runnerProviderClientIdSchema,
+  routeType: runnerProviderRouteTypeSchema,
+  status: runnerProviderAuthStateSchema,
+  authMethodLabel: z.string().trim().min(1).max(120).optional(),
+  accountHost: z.string().trim().min(1).max(200).optional(),
+  accountLogin: z.string().trim().min(1).max(120).optional(),
+  accountFingerprint: z.string().trim().min(1).max(160).optional(),
+  modelCount: z.number().int().nonnegative().optional(),
+  checkedAt: isoDateTimeSchema,
+  expiresAt: isoDateTimeSchema.optional(),
+  message: z.string().max(400).optional(),
+  errorCode: z.string().trim().min(1).max(80).optional()
+}).strict();
+var runnerProviderAuthLinkRequestSchema = z.object({
+  providerId: runnerProviderIdSchema,
+  providerClientId: runnerProviderClientIdSchema,
+  routeType: runnerProviderRouteTypeSchema,
+  requestedAccountHost: z.string().trim().min(1).max(200).optional(),
+  requestedAccountLogin: z.string().trim().min(1).max(120).optional(),
+  requestedAccountFingerprint: z.string().trim().min(1).max(160).optional(),
+  intentExpiresAt: isoDateTimeSchema.optional()
+}).strict();
 var runnerToolModelPreferenceSchema = z.object({
   tool: runnerToolSelectionSchema.optional(),
   invocationChannel: runnerInvocationChannelSchema.optional(),
@@ -855,6 +882,7 @@ var runnerHeartbeatItemSchema = baseItemSchema.extend({
   autoSyncPushedCount: z.number().int().nonnegative().optional(),
   autoSyncSkippedCount: z.number().int().nonnegative().optional(),
   autoSyncConflictCount: z.number().int().nonnegative().optional(),
+  providerAuthStatuses: z.array(runnerProviderAuthStatusSchema).max(20).optional(),
   lastSeenAt: isoDateTimeSchema
 });
 var runnerSettingsItemSchema = baseItemSchema.extend({
@@ -918,7 +946,7 @@ var runnerCredentialItemSchema = baseItemSchema.extend({
   lastUsedAt: isoDateTimeSchema.optional(),
   status: z.enum(["active", "revoked"]).default("active")
 });
-var runnerCommandKindSchema = z.enum(["update", "restart", "remove", "implementationHandoffRecovery"]);
+var runnerCommandKindSchema = z.enum(["update", "restart", "remove", "implementationHandoffRecovery", "providerAuthLinkRequested"]);
 var runnerCommandStatusSchema = z.enum(["pending", "acknowledged", "running", "completed", "failed", "expired", "cancelled"]);
 var runnerCommandItemSchema = baseItemSchema.extend({
   type: z.literal("runnerCommand"),
@@ -930,6 +958,8 @@ var runnerCommandItemSchema = baseItemSchema.extend({
   repositoryLinkId: z.string().min(1),
   workItemId: z.string().min(1).optional(),
   handoffRecoveryAction: implementationHandoffRecoveryActionSchema.optional(),
+  providerAuthLinkRequest: runnerProviderAuthLinkRequestSchema.optional(),
+  providerAuthStatus: runnerProviderAuthStatusSchema.optional(),
   executionBranch: z.string().min(1).optional(),
   executionWorktreeKey: z.string().min(1).optional(),
   requestedByUserId: z.string().min(1),
@@ -3112,8 +3142,8 @@ var toolSessionMutationSchema = z3.object({
 });
 function resolveApiUrl(apiUrl, urlPath) {
   const base = apiUrl.endsWith("/") ? apiUrl.slice(0, -1) : apiUrl;
-  const path17 = urlPath.startsWith("/") ? urlPath : `/${urlPath}`;
-  return new URL(`${base}${path17}`);
+  const path18 = urlPath.startsWith("/") ? urlPath : `/${urlPath}`;
+  return new URL(`${base}${path18}`);
 }
 
 // src/orchestrator.ts
@@ -3522,13 +3552,887 @@ function truncateLocalError(error) {
 }
 
 // src/local-tool-runner.ts
-import { spawn } from "node:child_process";
-import { mkdtemp, readFile as readFile4, rm as rm2, writeFile as writeFile5 } from "node:fs/promises";
+import { mkdtemp, readFile as readFile5, rm as rm2, writeFile as writeFile6 } from "node:fs/promises";
 import os3 from "node:os";
+import path7 from "node:path";
+
+// src/bounded-tool-adapter.ts
+import { constants } from "node:fs";
+import { access, mkdir as mkdir6, readdir as readdir3, readFile as readFile4, stat as stat3, writeFile as writeFile5 } from "node:fs/promises";
 import path6 from "node:path";
+
+// src/host-execution.ts
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+var hostExecutionProtocolVersion = "amistio.hostExecution.v1";
+var nativeHostHelperEnvironmentAllowlist = [
+  "PATH",
+  "Path",
+  "HOME",
+  "USERPROFILE",
+  "TMPDIR",
+  "TEMP",
+  "TMP",
+  "LANG",
+  "LC_ALL",
+  "CI",
+  "NODE_ENV",
+  "SystemRoot",
+  "WINDIR",
+  "ComSpec",
+  "PATHEXT"
+];
+var defaultNativeHostOutputBudgetBytes = 64 * 1024;
+var nodeHostExecutionCapabilities = {
+  protocolVersion: hostExecutionProtocolVersion,
+  implementation: "node",
+  processGroups: process.platform === "win32" ? { supported: false, reason: "Windows process-group cleanup needs a native helper or platform-specific implementation." } : { supported: true },
+  signalEscalation: { supported: true },
+  streamCapture: { supported: true },
+  pty: { supported: false, reason: "PTY bridging is reserved for a future native helper." },
+  sandbox: { supported: false, reason: "Sandboxed command execution is reserved for a future native helper." },
+  outputEncoding: "utf8"
+};
+var defaultHostExecution = {
+  capabilities: nodeHostExecutionCapabilities,
+  executeCommand: executeNodeCommand,
+  commandExists
+};
+var runtimeHostExecutionCacheKey;
+var runtimeHostExecutionPortPromise;
+function getRuntimeHostExecutionPort(env = process.env) {
+  const helperConfig = nativeHostHelperConfigFromEnvironment(env);
+  const cacheKey = helperConfig?.command ?? "";
+  if (!runtimeHostExecutionPortPromise || runtimeHostExecutionCacheKey !== cacheKey) {
+    runtimeHostExecutionCacheKey = cacheKey;
+    runtimeHostExecutionPortPromise = createHostExecutionPort(helperConfig ? { nativeHelper: helperConfig } : {});
+  }
+  return runtimeHostExecutionPortPromise;
+}
+async function createHostExecutionPort(options = {}) {
+  const fallback = options.fallback ?? defaultHostExecution;
+  const helperConfig = options.nativeHelper ?? nativeHostHelperConfigFromEnvironment();
+  if (!helperConfig) {
+    return fallback;
+  }
+  const discovery = await discoverNativeHostHelper(helperConfig);
+  return createCompositeHostExecutionPort(fallback, discovery);
+}
+function nativeHostHelperConfigFromEnvironment(env = process.env) {
+  const command = env.AMISTIO_HOST_HELPER_PATH?.trim();
+  if (!command) {
+    return void 0;
+  }
+  return { command };
+}
+async function discoverNativeHostHelper(config) {
+  const normalizedConfig = normalizeNativeHostHelperConfig(config);
+  const result = await executeHelperProcess(normalizedConfig, "--amistio-host-helper-handshake", void 0, normalizedConfig.handshakeTimeoutMs);
+  if (result.status === "spawnFailed") {
+    return { ok: false, failure: { code: "helper_unavailable", message: result.error?.message ?? "Native host helper is unavailable.", stdout: result.stdout, stderr: result.stderr } };
+  }
+  if (result.status === "timedOut") {
+    return { ok: false, failure: { code: "helper_unavailable", message: result.error?.message ?? "Native host helper handshake timed out.", stdout: result.stdout, stderr: result.stderr } };
+  }
+  if (result.exitCode !== 0) {
+    return { ok: false, failure: { code: "helper_failed", message: `Native host helper handshake exited with code ${result.exitCode}.`, stdout: result.stdout, stderr: result.stderr } };
+  }
+  const parsed = parseJson(result.stdout);
+  if (!isNativeHostHelperHandshake(parsed)) {
+    return { ok: false, failure: { code: "protocol_mismatch", message: "Native host helper handshake did not match the Amistio host execution protocol.", stdout: result.stdout, stderr: result.stderr } };
+  }
+  return { ok: true, helper: { config: normalizedConfig, handshake: parsed } };
+}
+function createNativeHostCommandRequestEnvelope(request, requestId = randomUUID()) {
+  const env = filterNativeHostHelperEnvironment(request.env ?? process.env);
+  const sandbox = request.sandbox ?? "none";
+  return {
+    protocolVersion: hostExecutionProtocolVersion,
+    requestId,
+    command: request.command,
+    args: [...request.args],
+    cwd: request.cwd,
+    shell: request.shell ?? false,
+    timeoutMs: request.timeoutMs ?? 0,
+    stdin: request.stdin ? "provided" : "none",
+    env,
+    envAllowlist: Object.keys(env).sort(),
+    streamOutput: request.streamOutput ?? false,
+    requirePty: request.requirePty ?? false,
+    sandbox,
+    sandboxPolicy: nativeHostSandboxPolicy(request.cwd, sandbox),
+    outputBudgetBytes: positiveInteger(request.outputBudgetBytes) ?? defaultNativeHostOutputBudgetBytes
+  };
+}
+function createCompositeHostExecutionPort(fallback, discovery) {
+  return {
+    capabilities: discovery.ok ? discovery.helper.handshake.capabilities : fallback.capabilities,
+    async executeCommand(request) {
+      if (!discovery.ok) {
+        if (request.requireNativeHelper) {
+          return helperDiscoveryFailureResult(discovery.failure);
+        }
+        return fallback.executeCommand(request);
+      }
+      const helper = discovery.helper;
+      const capabilityFailure = helperCapabilityFailure(request, helper.handshake.capabilities);
+      if (capabilityFailure) {
+        return capabilityFailure;
+      }
+      if (!canDelegateToNativeHelper(request)) {
+        if (request.requireNativeHelper) {
+          return unsupportedResult("helper_failed", "Native host helper delegation is unavailable for requests with stdin payloads.");
+        }
+        return fallback.executeCommand(request);
+      }
+      return executeNativeHelperCommand(helper, request);
+    },
+    commandExists: fallback.commandExists
+  };
+}
+function helperCapabilityFailure(request, capabilities) {
+  if (request.requirePty && !capabilities.pty.supported) {
+    return unsupportedResult("pty_unsupported", capabilities.pty.reason ?? "PTY command execution is not supported by the native host helper.");
+  }
+  if (request.sandbox && request.sandbox !== "none" && !capabilities.sandbox.supported) {
+    return unsupportedResult("sandbox_unsupported", capabilities.sandbox.reason ?? `${request.sandbox} sandbox execution is not supported by the native host helper.`);
+  }
+  return void 0;
+}
+function canDelegateToNativeHelper(request) {
+  return !request.stdin && !request.shell;
+}
+async function executeNativeHelperCommand(helper, request) {
+  const requestId = randomUUID();
+  const envelope = createNativeHostCommandRequestEnvelope(request, requestId);
+  const result = await executeHelperProcess(helper.config, "--amistio-host-helper-execute", JSON.stringify(envelope), request.timeoutMs ?? helper.config.executeTimeoutMs);
+  if (result.status === "spawnFailed") {
+    return { status: "helperUnavailable", exitCode: 1, stdout: result.stdout, stderr: result.stderr, error: { code: "helper_unavailable", message: result.error?.message ?? "Native host helper is unavailable." } };
+  }
+  if (result.status === "timedOut") {
+    return result;
+  }
+  if (result.exitCode !== 0) {
+    return { status: "failed", exitCode: result.exitCode, stdout: result.stdout, stderr: result.stderr, error: { code: "helper_failed", message: `Native host helper exited with code ${result.exitCode}.` } };
+  }
+  const parsed = parseJson(result.stdout);
+  if (!isNativeHostCommandResultEnvelope(parsed) || parsed.requestId !== requestId) {
+    return { status: "protocolMismatch", exitCode: 1, stdout: result.stdout, stderr: result.stderr, error: { code: "protocol_mismatch", message: "Native host helper command result did not match the Amistio host execution protocol." } };
+  }
+  return normalizeHostCommandResult(request, {
+    status: parsed.status,
+    exitCode: parsed.exitCode,
+    stdout: parsed.stdout,
+    stderr: parsed.stderr,
+    ...parsed.error ? { error: parsed.error } : {}
+  });
+}
+async function executeNodeCommand(request) {
+  if (request.requirePty) {
+    return unsupportedResult("pty_unsupported", "PTY command execution is not supported by the default Node host execution port.");
+  }
+  if (request.sandbox && request.sandbox !== "none") {
+    return unsupportedResult("sandbox_unsupported", `${request.sandbox} sandbox execution is not supported by the default Node host execution port.`);
+  }
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(request.command, [...request.args], {
+        cwd: request.cwd,
+        env: request.env ?? process.env,
+        detached: process.platform !== "win32",
+        shell: request.shell ?? false,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch (error) {
+      resolve(spawnFailedResult(error));
+      return;
+    }
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let forceKillTimer;
+    let timedOutError;
+    const timeout = request.timeoutMs && request.timeoutMs > 0 ? setTimeout(() => {
+      if (settled) return;
+      const message = request.timeoutMessage ?? `Command timed out after ${request.timeoutMs}ms: ${request.command}`;
+      stderr += `${message}
+`;
+      timedOutError = { code: "timeout", message };
+      killProcessTree(child, "SIGTERM");
+      forceKillTimer = setTimeout(() => killProcessTree(child, "SIGKILL"), request.killGraceMs ?? 5e3);
+      forceKillTimer.unref?.();
+    }, request.timeoutMs) : void 0;
+    timeout?.unref?.();
+    const resolveOnce = (result) => {
+      if (settled) return;
+      settled = true;
+      if (timeout) clearTimeout(timeout);
+      if (forceKillTimer) clearTimeout(forceKillTimer);
+      resolve(result);
+    };
+    child.on("error", (error) => {
+      if (timedOutError) return;
+      resolveOnce(spawnFailedResult(error, stdout, stderr));
+    });
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+      if (request.streamOutput) process.stdout.write(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+      if (request.streamOutput) process.stderr.write(chunk);
+    });
+    child.stdin.on("error", () => void 0);
+    if (request.stdin) {
+      child.stdin.write(request.stdin);
+    }
+    child.stdin.end();
+    child.on("close", (exitCode) => {
+      if (forceKillTimer) clearTimeout(forceKillTimer);
+      if (timedOutError) {
+        resolveOnce({ status: "timedOut", exitCode: 1, stdout, stderr, error: timedOutError });
+        return;
+      }
+      resolveOnce({ status: "completed", exitCode: exitCode ?? 1, stdout, stderr });
+    });
+  });
+}
+function unsupportedResult(code, message) {
+  return { status: "unsupported", exitCode: 1, stdout: "", stderr: "", error: { code, message } };
+}
+function helperDiscoveryFailureResult(failure) {
+  const status = failure.code === "protocol_mismatch" ? "protocolMismatch" : failure.code === "helper_unavailable" ? "helperUnavailable" : "failed";
+  return { status, exitCode: 1, stdout: failure.stdout ?? "", stderr: failure.stderr ?? "", error: { code: failure.code, message: failure.message } };
+}
+function spawnFailedResult(error, stdout = "", stderr = "") {
+  return { status: "spawnFailed", exitCode: 1, stdout, stderr, error: { code: "spawn_failed", message: errorMessage(error) } };
+}
+function killProcessTree(child, signal) {
+  if (child.pid && process.platform !== "win32") {
+    try {
+      process.kill(-child.pid, signal);
+      return;
+    } catch {
+    }
+  }
+  child.kill(signal);
+}
+async function commandExists(command) {
+  const lookupCommand = process.platform === "win32" ? "where" : "which";
+  return new Promise((resolve) => {
+    const lookup = spawn(lookupCommand, [command], { stdio: "ignore" });
+    lookup.on("error", () => resolve(false));
+    lookup.on("close", (exitCode) => resolve(exitCode === 0));
+  });
+}
+function normalizeNativeHostHelperConfig(config) {
+  return {
+    command: config.command,
+    args: config.args ? [...config.args] : [],
+    cwd: config.cwd ?? process.cwd(),
+    env: filterNativeHostHelperEnvironment(config.env ?? process.env),
+    handshakeTimeoutMs: positiveInteger(config.handshakeTimeoutMs) ?? 2e3,
+    executeTimeoutMs: positiveInteger(config.executeTimeoutMs) ?? 3e4
+  };
+}
+function executeHelperProcess(config, mode, stdin, timeoutMs) {
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(config.command, [...config.args, mode], {
+        cwd: config.cwd,
+        env: config.env,
+        shell: false,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch (error) {
+      resolve(spawnFailedResult(error));
+      return;
+    }
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const timeout = timeoutMs > 0 ? setTimeout(() => {
+      if (settled) return;
+      const message = `Native host helper timed out after ${timeoutMs}ms.`;
+      stderr += `${message}
+`;
+      child.kill("SIGKILL");
+      settled = true;
+      resolve({ status: "timedOut", exitCode: 1, stdout, stderr, error: { code: "timeout", message } });
+    }, timeoutMs) : void 0;
+    timeout?.unref?.();
+    const resolveOnce = (result) => {
+      if (settled) return;
+      settled = true;
+      if (timeout) clearTimeout(timeout);
+      resolve(result);
+    };
+    child.on("error", (error) => resolveOnce(spawnFailedResult(error, stdout, stderr)));
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.stdin.on("error", () => void 0);
+    if (stdin) {
+      child.stdin.write(stdin);
+    }
+    child.stdin.end();
+    child.on("close", (exitCode) => {
+      resolveOnce({ status: "completed", exitCode: exitCode ?? 1, stdout, stderr });
+    });
+  });
+}
+function filterNativeHostHelperEnvironment(env) {
+  const allowedNames = new Set(nativeHostHelperEnvironmentAllowlist);
+  const filtered = {};
+  for (const [name, value] of Object.entries(env)) {
+    if (!value || !allowedNames.has(name) || isSensitiveEnvironmentName(name)) {
+      continue;
+    }
+    filtered[name] = value;
+  }
+  return filtered;
+}
+function nativeHostSandboxPolicy(cwd, mode) {
+  return {
+    mode,
+    cwd,
+    filesystem: mode === "filesystemReadOnly" ? "readOnly" : "default",
+    network: mode === "networkDisabled" ? "disabled" : "default",
+    envPolicy: "allowlist-only"
+  };
+}
+function normalizeHostCommandResult(request, result) {
+  const outputBudgetBytes = positiveInteger(request.outputBudgetBytes) ?? defaultNativeHostOutputBudgetBytes;
+  const normalize = request.requirePty ? normalizePtyTranscript : (value) => value;
+  return {
+    ...result,
+    stdout: capUtf8Text(normalize(result.stdout), outputBudgetBytes),
+    stderr: capUtf8Text(normalize(result.stderr), outputBudgetBytes)
+  };
+}
+function normalizePtyTranscript(value) {
+  return value.replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, "").replace(/\u001b\][^\u0007]*(?:\u0007|\u001b\\)/g, "").replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "");
+}
+function capUtf8Text(value, budgetBytes) {
+  if (Buffer.byteLength(value, "utf8") <= budgetBytes) {
+    return value;
+  }
+  let capped = Buffer.from(value, "utf8").subarray(0, budgetBytes).toString("utf8");
+  while (Buffer.byteLength(capped, "utf8") > budgetBytes && capped.length > 0) {
+    capped = capped.slice(0, -1);
+  }
+  return capped;
+}
+function isSensitiveEnvironmentName(name) {
+  return /(?:TOKEN|SECRET|PASSWORD|PASS|KEY|CREDENTIAL|AUTH|OAUTH|COOKIE|SESSION|PRIVATE|CERT|SSH)/i.test(name);
+}
+function isNativeHostHelperHandshake(value) {
+  if (!isRecord(value) || value.protocolVersion !== hostExecutionProtocolVersion) return false;
+  if (!isHostExecutionCapabilities(value.capabilities)) return false;
+  if (!isRecord(value.secretBoundary)) return false;
+  return value.secretBoundary.credentialPolicy === "never-send-credentials" && value.secretBoundary.environmentPolicy === "allowlist-only" && Array.isArray(value.secretBoundary.forbiddenInputs) && value.secretBoundary.forbiddenInputs.length > 0 && value.secretBoundary.forbiddenInputs.every((item) => typeof item === "string" && item.trim().length > 0);
+}
+function isHostExecutionCapabilities(value) {
+  if (!isRecord(value)) return false;
+  return value.protocolVersion === hostExecutionProtocolVersion && (value.implementation === "node" || value.implementation === "nativeHelper") && isCapabilitySupport(value.processGroups) && isCapabilitySupport(value.signalEscalation) && isCapabilitySupport(value.streamCapture) && isCapabilitySupport(value.pty) && isCapabilitySupport(value.sandbox) && value.outputEncoding === "utf8";
+}
+function isCapabilitySupport(value) {
+  return isRecord(value) && typeof value.supported === "boolean" && (value.reason === void 0 || typeof value.reason === "string");
+}
+function isNativeHostCommandResultEnvelope(value) {
+  if (!isRecord(value) || value.protocolVersion !== hostExecutionProtocolVersion) return false;
+  return typeof value.requestId === "string" && isHostCommandStatus(value.status) && typeof value.exitCode === "number" && typeof value.stdout === "string" && typeof value.stderr === "string" && (value.error === void 0 || isHostCommandError(value.error));
+}
+function isHostCommandStatus(value) {
+  return value === "completed" || value === "timedOut" || value === "spawnFailed" || value === "permissionDenied" || value === "helperUnavailable" || value === "protocolMismatch" || value === "killed" || value === "unsupported" || value === "failed";
+}
+function isHostCommandError(value) {
+  return isRecord(value) && isHostCommandErrorCode(value.code) && typeof value.message === "string";
+}
+function isHostCommandErrorCode(value) {
+  return value === "timeout" || value === "spawn_failed" || value === "permission_denied" || value === "helper_unavailable" || value === "protocol_mismatch" || value === "helper_failed" || value === "killed" || value === "pty_unsupported" || value === "sandbox_unsupported";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+function positiveInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/bounded-tool-adapter.ts
+var boundedToolAdapterCatalog = [
+  { id: "filesystem.readFile", kind: "filesystem", displayName: "Read scoped file", implemented: true, mutating: false, concurrency: "parallelSafe", serializedResourceKinds: ["executionRoot"] },
+  { id: "filesystem.listFiles", kind: "filesystem", displayName: "List scoped files", implemented: true, mutating: false, concurrency: "parallelSafe", serializedResourceKinds: ["executionRoot"] },
+  { id: "filesystem.searchText", kind: "filesystem", displayName: "Search scoped text", implemented: true, mutating: false, concurrency: "parallelSafe", serializedResourceKinds: ["executionRoot"] },
+  { id: "filesystem.writeFile", kind: "filesystem", displayName: "Write scoped file", implemented: true, mutating: true, concurrency: "serialized", serializedResourceKinds: ["executionRoot"] },
+  { id: "shell.curatedCommand", kind: "shell", displayName: "Run runner-owned command preset", implemented: true, mutating: false, concurrency: "serialized", serializedResourceKinds: ["executionRoot", "process"] },
+  { id: "git.status", kind: "git", displayName: "Read Git status", implemented: true, mutating: false, concurrency: "parallelSafe", serializedResourceKinds: ["gitIndex"] },
+  { id: "git.diffNameOnly", kind: "git", displayName: "Read changed Git paths", implemented: true, mutating: false, concurrency: "parallelSafe", serializedResourceKinds: ["gitIndex"] },
+  { id: "packageManager.detect", kind: "packageManager", displayName: "Detect package manager", implemented: true, mutating: false, concurrency: "parallelSafe", serializedResourceKinds: ["packageManagerCache"] },
+  { id: "testRunner.profile", kind: "testRunner", displayName: "Run known verification profile", implemented: true, mutating: false, concurrency: "serialized", serializedResourceKinds: ["testRunner", "packageManagerCache"] },
+  { id: "browser.check", kind: "browser", displayName: "Run local browser smoke check", implemented: true, mutating: false, concurrency: "serialized", serializedResourceKinds: ["browserProfile"] },
+  { id: "modelClient.direct", kind: "modelClient", displayName: "Invoke direct model client", implemented: true, mutating: false, concurrency: "serialized", serializedResourceKinds: ["modelProvider"] },
+  { id: "agentClient.compatibilityBridge", kind: "agentClient", displayName: "Invoke optional local AI client", implemented: true, mutating: true, concurrency: "serialized", serializedResourceKinds: ["agentSession", "providerAuth", "executionRoot"] }
+];
+var testRunnerProfileIds = ["verify", "test", "typecheck", "lint", "build"];
+var packageLockfiles = {
+  pnpm: ["pnpm-lock.yaml"],
+  npm: ["package-lock.json"],
+  yarn: ["yarn.lock"],
+  bun: ["bun.lockb", "bun.lock"]
+};
+var ignoredTraversalDirectories = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", ".next", ".turbo", "coverage", ".cache"]);
+var defaultFilesystemListLimit = 200;
+var defaultFilesystemSearchLimit = 80;
+var filesystemSearchMaxFileBytes = 256e3;
+var defaultCuratedShellCommands = {
+  "git.status.short": {
+    command: "git",
+    args: ["status", "--short"],
+    displayName: "git status --short",
+    mutationPolicy: "readOnly"
+  },
+  "git.diff.nameOnly": {
+    command: "git",
+    args: ["diff", "--name-only"],
+    displayName: "git diff --name-only",
+    mutationPolicy: "readOnly"
+  },
+  "package.detect": {
+    command: process.execPath,
+    args: ["-e", "const fs=require('fs');const files=['pnpm-lock.yaml','package-lock.json','yarn.lock','bun.lockb'];console.log(files.filter((file)=>fs.existsSync(file)).join('\\n'));"],
+    displayName: "detect package manager lockfiles",
+    mutationPolicy: "readOnly"
+  }
+};
+function createBoundedToolAdapterPolicy(options) {
+  const executionRoot = path6.resolve(options.executionRoot);
+  return {
+    executionRoot,
+    mutationPolicy: options.mutationPolicy,
+    timeoutMs: positiveInteger2(options.timeoutMs) ?? 3e4,
+    outputBudgetBytes: positiveInteger2(options.outputBudgetBytes) ?? 64e3,
+    allowedWorkKinds: options.allowedWorkKinds ?? ["assistantQuestion", "projectContextRefresh", "implementationVerification", "testQualityScan", "implementationTestGate", "implementation"],
+    redaction: { localPaths: true, secretAssignments: true },
+    concurrency: {
+      mode: options.concurrencyMode ?? "serialized",
+      resourceKey: options.resourceKey ?? executionRoot
+    }
+  };
+}
+async function runFilesystemReadTool(options) {
+  const resolved = resolveRelativePath(options.policy, options.relativePath);
+  if (!resolved.ok) {
+    return failedResult("filesystem.readFile", resolved.error, options.policy);
+  }
+  try {
+    const content = await readFile4(resolved.path, "utf8");
+    return completedResult("filesystem.readFile", content, "", options.policy);
+  } catch (error) {
+    return failedResult("filesystem.readFile", { code: "execution_failed", message: `File read failed: ${errorMessage2(error)}` }, options.policy);
+  }
+}
+async function runFilesystemWriteTool(options) {
+  const mutation = ensureMutationAllowed(options.policy, "mutating");
+  if (mutation) {
+    return failedResult("filesystem.writeFile", mutation, options.policy);
+  }
+  const resolved = resolveRelativePath(options.policy, options.relativePath);
+  if (!resolved.ok) {
+    return failedResult("filesystem.writeFile", resolved.error, options.policy);
+  }
+  try {
+    await mkdir6(path6.dirname(resolved.path), { recursive: true });
+    await writeFile5(resolved.path, options.content, "utf8");
+    const summary = { relativePath: normalizeRelativePath(options.relativePath), bytes: Buffer.byteLength(options.content, "utf8") };
+    return completedResult("filesystem.writeFile", JSON.stringify(summary, null, 2), "", options.policy);
+  } catch (error) {
+    return failedResult("filesystem.writeFile", { code: "execution_failed", message: `File write failed: ${errorMessage2(error)}` }, options.policy);
+  }
+}
+async function runFilesystemListTool(options) {
+  const relativeDirectory = normalizeRelativePath(options.relativeDirectory ?? ".");
+  const resolved = resolveRelativePath(options.policy, relativeDirectory);
+  if (!resolved.ok) {
+    return failedResult("filesystem.listFiles", resolved.error, options.policy);
+  }
+  try {
+    const maxFiles = positiveInteger2(options.maxFiles) ?? defaultFilesystemListLimit;
+    const files = await listFiles(options.policy.executionRoot, resolved.path, maxFiles);
+    const summary = { relativeDirectory, files: files.items, truncated: files.truncated };
+    return completedResult("filesystem.listFiles", JSON.stringify(summary, null, 2), "", options.policy);
+  } catch (error) {
+    return failedResult("filesystem.listFiles", { code: "execution_failed", message: `File list failed: ${errorMessage2(error)}` }, options.policy);
+  }
+}
+async function runFilesystemSearchTool(options) {
+  const query = options.query.trim();
+  if (!query) {
+    return failedResult("filesystem.searchText", { code: "command_not_allowed", message: "Search query must not be empty." }, options.policy);
+  }
+  const relativeDirectory = normalizeRelativePath(options.relativeDirectory ?? ".");
+  const resolved = resolveRelativePath(options.policy, relativeDirectory);
+  if (!resolved.ok) {
+    return failedResult("filesystem.searchText", resolved.error, options.policy);
+  }
+  try {
+    const maxMatches = positiveInteger2(options.maxMatches) ?? defaultFilesystemSearchLimit;
+    const matches = await searchText(options.policy, resolved.path, query, maxMatches);
+    const summary = { query, matches: matches.items, truncated: matches.truncated };
+    return completedResult("filesystem.searchText", JSON.stringify(summary, null, 2), "", options.policy);
+  } catch (error) {
+    return failedResult("filesystem.searchText", { code: "execution_failed", message: `Text search failed: ${errorMessage2(error)}` }, options.policy);
+  }
+}
+async function runGitStatusTool(options) {
+  return executeCuratedCommand(defaultCuratedShellCommands["git.status.short"], options.policy, "git.status");
+}
+async function runGitDiffNameOnlyTool(options) {
+  return executeCuratedCommand(defaultCuratedShellCommands["git.diff.nameOnly"], options.policy, "git.diffNameOnly");
+}
+async function runPackageManagerDetectTool(options) {
+  try {
+    const detection = await detectPackageManager(options.policy.executionRoot);
+    return completedResult("packageManager.detect", JSON.stringify(detection, null, 2), "", options.policy);
+  } catch (error) {
+    return failedResult("packageManager.detect", { code: "execution_failed", message: `Package manager detection failed: ${errorMessage2(error)}` }, options.policy);
+  }
+}
+async function runTestRunnerProfileTool(options) {
+  const profileId = options.profileId ?? "test";
+  if (!testRunnerProfileIds.includes(profileId)) {
+    return failedResult("testRunner.profile", { code: "command_not_allowed", message: "Verification profile is not allowed by this runner policy." }, options.policy);
+  }
+  let detection;
+  try {
+    detection = await detectPackageManager(options.policy.executionRoot);
+  } catch (error) {
+    return failedResult("testRunner.profile", { code: "execution_failed", message: `Verification profile discovery failed: ${errorMessage2(error)}` }, options.policy);
+  }
+  if (!detection.profiles.includes(profileId)) {
+    return failedResult("testRunner.profile", { code: "command_not_allowed", message: `Verification profile is not defined in local package scripts: ${profileId}.` }, options.policy);
+  }
+  const command = options.commandCatalog?.[profileId] ?? testRunnerProfileCommand(options.packageManager ?? detection.packageManager ?? "npm", profileId);
+  return executeCuratedCommand(command, options.policy, "testRunner.profile");
+}
+async function runBrowserCheckTool(options) {
+  const target = parseBrowserCheckTarget(options.url, options.allowedHosts);
+  if (!target.ok) {
+    return failedResult("browser.check", target.error, options.policy);
+  }
+  const abortController = new AbortController();
+  const timeout = setTimeout(() => abortController.abort(), options.policy.timeoutMs);
+  timeout.unref?.();
+  try {
+    const response = await (options.fetchImpl ?? fetch)(target.url, { method: "GET", redirect: "manual", signal: abortController.signal });
+    const body = await response.text();
+    const summary = {
+      url: target.url.toString(),
+      status: response.status,
+      ok: response.ok,
+      ...response.headers.get("content-type") ? { contentType: response.headers.get("content-type") } : {},
+      ...extractHtmlTitle(body) ? { title: extractHtmlTitle(body) } : {},
+      bytes: Buffer.byteLength(body, "utf8")
+    };
+    const stdout = JSON.stringify(summary, null, 2);
+    if (response.ok) {
+      return completedResult("browser.check", stdout, "", options.policy);
+    }
+    return failedResult("browser.check", { code: "execution_failed", message: `Browser check failed with HTTP ${response.status}.` }, options.policy, stdout);
+  } catch (error) {
+    if (abortController.signal.aborted) {
+      return failedResult("browser.check", { code: "timeout", message: `Browser check timed out after ${formatTimeoutDuration(options.policy.timeoutMs)}.` }, options.policy);
+    }
+    return failedResult("browser.check", { code: "execution_failed", message: `Browser check failed: ${errorMessage2(error)}` }, options.policy);
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function executeCuratedCommand(command, policy, adapterId) {
+  const hostExecution = await getRuntimeHostExecutionPort();
+  const result = await hostExecution.executeCommand({
+    command: command.command,
+    args: command.args,
+    cwd: policy.executionRoot,
+    env: process.env,
+    shell: false,
+    timeoutMs: policy.timeoutMs,
+    timeoutMessage: `Tool adapter timed out after ${formatTimeoutDuration(policy.timeoutMs)}: ${command.displayName}`
+  });
+  if (result.status === "timedOut") {
+    return failedResult(adapterId, { code: "timeout", message: result.error?.message ?? `Tool adapter timed out after ${formatTimeoutDuration(policy.timeoutMs)}: ${command.displayName}` }, policy, result.stdout, result.stderr);
+  }
+  if (result.status === "spawnFailed" || result.status === "unsupported") {
+    return failedResult(adapterId, { code: "execution_failed", message: result.error?.message ?? `Command execution failed: ${command.displayName}` }, policy, result.stdout, result.stderr);
+  }
+  if (result.exitCode === 0) {
+    return completedResult(adapterId, result.stdout, result.stderr, policy);
+  }
+  return failedResult(adapterId, { code: "execution_failed", message: `${command.displayName} exited with code ${result.exitCode}.` }, policy, result.stdout, result.stderr);
+}
+async function detectPackageManager(executionRoot) {
+  const packageJson = await readPackageJson(executionRoot);
+  const lockfiles = await detectPackageLockfiles(executionRoot);
+  const scripts = Object.keys(packageJson?.scripts ?? {}).sort();
+  const packageManager = packageManagerFromPackageManagerField(packageJson?.packageManager) ?? packageManagerFromLockfiles(lockfiles);
+  const profiles = testRunnerProfileIds.filter((profileId) => scripts.includes(profileId));
+  return {
+    ...packageManager ? { packageManager } : {},
+    lockfiles,
+    scripts,
+    profiles
+  };
+}
+async function listFiles(executionRoot, directoryPath, maxFiles) {
+  const items = [];
+  let truncated = false;
+  const visit = async (currentDirectory) => {
+    if (truncated) return;
+    const entries = await readdir3(currentDirectory, { withFileTypes: true });
+    for (const entry of entries.sort((first, second) => first.name.localeCompare(second.name))) {
+      if (truncated) return;
+      if (entry.name.startsWith(".") && ignoredTraversalDirectories.has(entry.name)) continue;
+      if (ignoredTraversalDirectories.has(entry.name)) continue;
+      const absolutePath = path6.join(currentDirectory, entry.name);
+      if (entry.isDirectory()) {
+        await visit(absolutePath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      items.push(normalizeRelativePath(path6.relative(executionRoot, absolutePath)));
+      if (items.length >= maxFiles) {
+        truncated = true;
+        return;
+      }
+    }
+  };
+  await visit(directoryPath);
+  return { items, truncated };
+}
+async function searchText(policy, directoryPath, query, maxMatches) {
+  const listed = await listFiles(policy.executionRoot, directoryPath, Math.max(maxMatches * 20, maxMatches));
+  const lowerQuery = query.toLowerCase();
+  const matches = [];
+  let truncated = listed.truncated;
+  for (const relativePath of listed.items) {
+    if (matches.length >= maxMatches) {
+      truncated = true;
+      break;
+    }
+    const absolutePath = path6.join(policy.executionRoot, relativePath);
+    const stats = await stat3(absolutePath);
+    if (!stats.isFile() || stats.size > filesystemSearchMaxFileBytes) continue;
+    const content = await readFile4(absolutePath, "utf8").catch(() => void 0);
+    if (content === void 0 || content.includes("\0")) continue;
+    const lines = content.split(/\r?\n/);
+    for (const [lineIndex, line] of lines.entries()) {
+      if (!line.toLowerCase().includes(lowerQuery)) continue;
+      matches.push({ relativePath, line: lineIndex + 1, text: line.slice(0, 500) });
+      if (matches.length >= maxMatches) {
+        truncated = true;
+        break;
+      }
+    }
+  }
+  return { items: matches, truncated };
+}
+async function readPackageJson(executionRoot) {
+  const packageJsonPath = path6.join(executionRoot, "package.json");
+  if (!await fileExists(packageJsonPath)) {
+    return void 0;
+  }
+  const parsed = JSON.parse(await readFile4(packageJsonPath, "utf8"));
+  if (!isRecord2(parsed)) {
+    return void 0;
+  }
+  const scripts = isRecord2(parsed.scripts) ? Object.fromEntries(Object.entries(parsed.scripts).filter((entry) => typeof entry[1] === "string")) : void 0;
+  return {
+    ...typeof parsed.packageManager === "string" ? { packageManager: parsed.packageManager } : {},
+    ...scripts ? { scripts } : {}
+  };
+}
+async function detectPackageLockfiles(executionRoot) {
+  const lockfileCandidates = Object.values(packageLockfiles).flat();
+  const presentLockfiles = [];
+  for (const lockfile of lockfileCandidates) {
+    if (await fileExists(path6.join(executionRoot, lockfile))) {
+      presentLockfiles.push(lockfile);
+    }
+  }
+  return presentLockfiles;
+}
+function packageManagerFromPackageManagerField(value) {
+  const packageManagerName = value?.split("@")[0]?.trim();
+  return isPackageManagerName(packageManagerName) ? packageManagerName : void 0;
+}
+function packageManagerFromLockfiles(lockfiles) {
+  for (const packageManager of ["pnpm", "npm", "yarn", "bun"]) {
+    if (packageLockfiles[packageManager].some((lockfile) => lockfiles.includes(lockfile))) {
+      return packageManager;
+    }
+  }
+  return void 0;
+}
+function testRunnerProfileCommand(packageManager, profileId) {
+  if (packageManager === "pnpm") {
+    return { command: "corepack", args: ["pnpm", "--config.verify-deps-before-run=false", "run", profileId], displayName: `pnpm run ${profileId}`, mutationPolicy: "readOnly" };
+  }
+  if (packageManager === "yarn") {
+    return { command: "corepack", args: ["yarn", "run", profileId], displayName: `yarn run ${profileId}`, mutationPolicy: "readOnly" };
+  }
+  if (packageManager === "bun") {
+    return { command: "bun", args: ["run", profileId], displayName: `bun run ${profileId}`, mutationPolicy: "readOnly" };
+  }
+  return { command: "npm", args: ["run", profileId], displayName: `npm run ${profileId}`, mutationPolicy: "readOnly" };
+}
+function parseBrowserCheckTarget(value, allowedHosts) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return { ok: false, error: { code: "command_not_allowed", message: "Browser check target URL is invalid." } };
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    return { ok: false, error: { code: "command_not_allowed", message: "Browser check target must use http or https." } };
+  }
+  if (url.username || url.password) {
+    return { ok: false, error: { code: "command_not_allowed", message: "Browser check target must not include credentials." } };
+  }
+  const allowedHostSet = new Set((allowedHosts ?? []).map((host2) => host2.toLowerCase()));
+  const hostname = url.hostname.toLowerCase();
+  const host = url.host.toLowerCase();
+  if (!isLoopbackHost(hostname) && !allowedHostSet.has(hostname) && !allowedHostSet.has(host)) {
+    return { ok: false, error: { code: "command_not_allowed", message: "Browser check target must be loopback or explicitly allowed by the runner policy." } };
+  }
+  return { ok: true, url };
+}
+function isLoopbackHost(hostname) {
+  return hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "127.0.0.1" || hostname.startsWith("127.") || hostname === "::1" || hostname === "[::1]" || hostname === "0.0.0.0";
+}
+function extractHtmlTitle(body) {
+  const match = /<title[^>]*>([^<]*)<\/title>/i.exec(body);
+  const title = match?.[1]?.replace(/\s+/g, " ").trim();
+  return title || void 0;
+}
+async function fileExists(filePath) {
+  try {
+    await access(filePath, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isPackageManagerName(value) {
+  return value === "pnpm" || value === "npm" || value === "yarn" || value === "bun";
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveRelativePath(policy, relativePath) {
+  if (path6.isAbsolute(relativePath)) {
+    return { ok: false, error: { code: "out_of_root", message: "Tool adapter rejected absolute local path input." } };
+  }
+  const resolved = path6.resolve(policy.executionRoot, relativePath);
+  if (!isInsideRoot(policy.executionRoot, resolved)) {
+    return { ok: false, error: { code: "out_of_root", message: "Tool adapter path is outside the execution root." } };
+  }
+  return { ok: true, path: resolved };
+}
+function normalizeRelativePath(relativePath) {
+  const normalized = relativePath.replaceAll("\\", "/").replace(/^\.\//, "");
+  return normalized || ".";
+}
+function ensureMutationAllowed(policy, requiredPolicy) {
+  if (requiredPolicy === "mutating" && policy.mutationPolicy !== "mutating") {
+    return { code: "mutation_denied", message: "Tool adapter mutation is not allowed by the current harness policy." };
+  }
+  return void 0;
+}
+function completedResult(adapterId, stdout, stderr, policy) {
+  const output = normalizeOutput(stdout, stderr, policy);
+  return { adapterId, status: "completed", exitCode: 0, stdout: output.stdout, stderr: output.stderr, truncated: output.truncated };
+}
+function failedResult(adapterId, error, policy, stdout = "", stderr = "") {
+  const output = normalizeOutput(stdout, stderr, policy);
+  return { adapterId, status: "failed", exitCode: 1, stdout: output.stdout, stderr: output.stderr, truncated: output.truncated, error };
+}
+function normalizeOutput(stdout, stderr, policy) {
+  const redactedStdout = redactToolAdapterText(stdout, policy);
+  const redactedStderr = redactToolAdapterText(stderr, policy);
+  const stdoutBudget = Math.floor(policy.outputBudgetBytes / 2);
+  const stderrBudget = policy.outputBudgetBytes - stdoutBudget;
+  const normalizedStdout = truncateToBudget(redactedStdout, stdoutBudget);
+  const normalizedStderr = truncateToBudget(redactedStderr, stderrBudget);
+  return {
+    stdout: normalizedStdout.value,
+    stderr: normalizedStderr.value,
+    truncated: normalizedStdout.truncated || normalizedStderr.truncated
+  };
+}
+function redactToolAdapterText(value, policy) {
+  let result = value;
+  if (policy.redaction.localPaths) {
+    result = result.replaceAll(policy.executionRoot, "<execution-root>");
+  }
+  if (policy.redaction.secretAssignments) {
+    result = result.replace(/\b([A-Z0-9_]*(?:TOKEN|SECRET|PASSWORD|API_KEY|ACCESS_KEY)[A-Z0-9_]*)=([^\s"'`]+)/gi, "$1=<redacted>");
+  }
+  return result;
+}
+function truncateToBudget(value, budgetBytes) {
+  if (budgetBytes <= 0) {
+    return { value: "", truncated: Boolean(value) };
+  }
+  const bytes = Buffer.byteLength(value, "utf8");
+  if (bytes <= budgetBytes) {
+    return { value, truncated: false };
+  }
+  const suffix = "\n[truncated by Amistio tool adapter output budget]";
+  const contentBudget = Math.max(0, budgetBytes - Buffer.byteLength(suffix, "utf8"));
+  return { value: `${Buffer.from(value, "utf8").subarray(0, contentBudget).toString("utf8")}${suffix}`, truncated: true };
+}
+function isInsideRoot(root, candidatePath) {
+  const relative = path6.relative(root, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path6.isAbsolute(relative);
+}
+function positiveInteger2(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
+}
+function errorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function formatTimeoutDuration(timeoutMs) {
+  if (timeoutMs < 1e3) {
+    return `${timeoutMs}ms`;
+  }
+  const seconds = timeoutMs / 1e3;
+  return Number.isInteger(seconds) ? `${seconds}s` : `${seconds.toFixed(1)}s`;
+}
+
+// src/local-tool-runner.ts
 var localToolNames = runnerToolNames;
 var allReasoningEfforts = ["auto", "low", "medium", "high", "xhigh"];
 var highReasoningEfforts = ["auto", "high", "xhigh"];
+var localToolOutputBudgetBytes = 32 * 1024;
 var builtInProviderCatalogs = {
   opencode: {
     anthropic: {
@@ -3714,7 +4618,7 @@ async function detectLocalTools() {
   return Promise.all(
     localToolAdapters.map(async (adapter) => {
       const sdkAvailable = await isSdkAvailable(adapter);
-      const commandAvailable = adapter.executable ? await commandExists(adapter.executable) : false;
+      const commandAvailable = adapter.executable ? await commandExists2(adapter.executable) : false;
       const providerCatalog = await detectRunnerProviderCatalog(adapter);
       return {
         name: adapter.name,
@@ -3732,9 +4636,9 @@ async function detectLocalTools() {
   );
 }
 async function runLocalTool(options) {
-  const promptTempDir = await mkdtemp(path6.join(os3.tmpdir(), "amistio-prompt-"));
-  const promptFilePath = path6.join(promptTempDir, "prompt.md");
-  await writeFile5(promptFilePath, options.prompt, "utf8");
+  const promptTempDir = await mkdtemp(path7.join(os3.tmpdir(), "amistio-prompt-"));
+  const promptFilePath = path7.join(promptTempDir, "prompt.md");
+  await writeFile6(promptFilePath, options.prompt, "utf8");
   const modelConfig = normalizeModelOptions(options);
   try {
     const runnerOptions = {
@@ -3749,14 +4653,14 @@ async function runLocalTool(options) {
       runnerOptions.toolCommand = options.toolCommand;
     }
     const runner2 = await createToolRunner(runnerOptions);
-    const result = await executeToolRunner(runner2, {
+    const result = normalizeToolExecutionResult(await executeToolRunner(runner2, {
       rootDir: options.rootDir,
       prompt: options.prompt,
       promptFilePath,
       streamOutput: Boolean(options.streamOutput),
       ...modelConfig,
       ...options.session ? { session: options.session } : {}
-    }, options.timeoutMs);
+    }, options.timeoutMs), options.rootDir);
     return {
       toolName: runner2.toolName,
       displayCommand: runner2.kind === "sdk" ? runner2.displayCommand : runner2.invocation.displayCommand,
@@ -3770,7 +4674,7 @@ async function runLocalTool(options) {
   }
 }
 async function createToolRunPreview(options) {
-  const promptFilePath = path6.join(os3.tmpdir(), "amistio-generated-prompt.md");
+  const promptFilePath = path7.join(os3.tmpdir(), "amistio-generated-prompt.md");
   const modelConfig = normalizeModelOptions(options);
   const runnerOptions = {
     rootDir: options.rootDir,
@@ -3831,7 +4735,7 @@ async function createToolRunner(options) {
   if (requiresModelSelection && !options.model) {
     throw new Error("Provider-backed model configuration requires --model or --provider with --model-id.");
   }
-  const adapter = tool === "auto" ? await selectFirstAvailableAdapter(requiresModelSelection, options.invocationChannel) : await selectRequestedAdapter(tool, options.invocationChannel);
+  const adapter = tool === "auto" ? await selectFirstAvailableAdapter(options, options.invocationChannel) : await selectRequestedAdapter(tool, options.invocationChannel, options);
   if (requiresModelSelection && !adapter.supportsModelSelection) {
     throw new Error(`Model selection is not supported by ${adapter.name}. Remove model configuration or choose a model-aware adapter.`);
   }
@@ -3844,7 +4748,7 @@ async function createToolRunner(options) {
       allowCommandFallback: options.invocationChannel === "auto"
     };
   }
-  if (options.invocationChannel !== "sdk" && adapter.buildInvocation && adapter.executable && await commandExists(adapter.executable)) {
+  if (options.invocationChannel !== "sdk" && adapter.buildInvocation && adapter.executable && await commandExists2(adapter.executable)) {
     return {
       toolName: adapter.name,
       kind: "command",
@@ -3866,10 +4770,10 @@ async function executeToolRunner(runner2, input, timeoutMs) {
   try {
     return await withTimeout(runner2.adapter.runWithSdk(input), timeoutMs, runner2.displayCommand);
   } catch (error) {
-    if (runner2.allowCommandFallback && runner2.adapter.buildInvocation && runner2.adapter.executable && await commandExists(runner2.adapter.executable)) {
+    if (runner2.allowCommandFallback && runner2.adapter.buildInvocation && runner2.adapter.executable && await commandExists2(runner2.adapter.executable)) {
       const fallback = runner2.adapter.buildInvocation(input);
       const result = await executeToolInvocation(fallback, input.rootDir, input.streamOutput, timeoutMs);
-      const sdkFailure = `SDK execution for ${runner2.adapter.name} failed, fell back to ${fallback.displayCommand}: ${errorMessage(error)}`;
+      const sdkFailure = `SDK execution for ${runner2.adapter.name} failed, fell back to ${fallback.displayCommand}: ${errorMessage3(error)}`;
       return {
         ...result,
         stderr: result.stderr ? `${sdkFailure}
@@ -3885,31 +4789,48 @@ function normalizeToolRequest(value) {
   }
   throw new Error(`Unsupported local tool: ${value}. Supported tools: auto, none, ${localToolNames.join(", ")}.`);
 }
-async function selectFirstAvailableAdapter(requiresModelSelection = false, invocationChannel = "auto") {
+async function selectFirstAvailableAdapter(modelOptions, invocationChannel = "auto") {
+  const requiresModelSelection = hasModelSelection(modelOptions);
+  let modelSelectionFailure;
   for (const adapter of localToolAdapters) {
     if (requiresModelSelection && !adapter.supportsModelSelection) {
       continue;
     }
+    const validationError = requiresModelSelection ? modelSelectionValidationError(adapter, modelOptions) : void 0;
+    if (validationError) {
+      modelSelectionFailure ??= validationError;
+      continue;
+    }
     const sdkAvailable = await isSdkAvailable(adapter);
-    const commandAvailable = adapter.executable ? await commandExists(adapter.executable) : false;
+    const commandAvailable = adapter.executable ? await commandExists2(adapter.executable) : false;
     if (supportsRequestedInvocationChannel({ sdkAvailable, commandAvailable }, invocationChannel)) {
       return adapter;
     }
   }
   if (invocationChannel !== "auto") {
+    if (modelSelectionFailure) {
+      throw new Error(`No installed local AI tool supports the selected provider/model for ${invocationChannel} invocation. ${modelSelectionFailure}`);
+    }
     throw new Error(`No installed local AI tool supports ${invocationChannel} invocation${requiresModelSelection ? " with model selection" : ""}. Select Auto or install a compatible tool.`);
   }
+  if (modelSelectionFailure) {
+    throw new Error(`No installed local AI tool supports the selected provider/model. ${modelSelectionFailure}`);
+  }
   throw new Error(
     requiresModelSelection ? "No installed local AI tool supports model selection. Remove --model or choose a model-aware adapter." : `No supported local AI tool was found. Install one of ${localToolNames.join(", ")} or pass --tool-command "your-tool --prompt-file {promptFile}".`
   );
 }
-async function selectRequestedAdapter(tool, invocationChannel = "auto") {
+async function selectRequestedAdapter(tool, invocationChannel = "auto", modelOptions) {
   const adapter = localToolAdapters.find((candidate) => candidate.name === tool);
   if (!adapter) {
     throw new Error(`Unsupported local tool: ${tool}.`);
   }
+  if (modelOptions) {
+    const validationError = modelSelectionValidationError(adapter, modelOptions);
+    if (validationError) throw new Error(validationError);
+  }
   const sdkAvailable = await isSdkAvailable(adapter);
-  const commandAvailable = adapter.executable ? await commandExists(adapter.executable) : false;
+  const commandAvailable = adapter.executable ? await commandExists2(adapter.executable) : false;
   if (!supportsRequestedInvocationChannel({ sdkAvailable, commandAvailable }, invocationChannel)) {
     if (invocationChannel === "sdk") {
       throw new Error(`The ${tool} SDK was not found. Select Auto or Command invocation, install it, or pass --tool-command locally.`);
@@ -3925,18 +4846,78 @@ async function selectRequestedAdapter(tool, invocationChannel = "auto") {
   if (invocationChannel !== "sdk" && commandAvailable) {
     return adapter;
   }
-  throw new Error(`The ${tool} SDK or executable was not found. Install it or pass --tool-command.`);
+  throw new Error(`The ${tool} SDK or executable was not found. Install it or pass --tool-command.`);
+}
+function supportsRequestedInvocationChannel(capability, invocationChannel) {
+  if (invocationChannel === "auto") return capability.sdkAvailable || capability.commandAvailable;
+  if (invocationChannel === "sdk") return capability.sdkAvailable;
+  return capability.commandAvailable;
+}
+function hasModelSelection(options) {
+  return Boolean(options.model || options.providerId || options.modelId || options.modelVariant || options.reasoningEffort && options.reasoningEffort !== "auto");
+}
+function modelSelectionValidationError(adapter, options) {
+  if (!hasModelSelection(options)) return void 0;
+  if (!adapter.supportsModelSelection) {
+    return `Model selection is not supported by ${adapter.name}. Remove model configuration or choose a model-aware adapter.`;
+  }
+  if (!adapter.providerCatalog) return void 0;
+  const selection = resolveModelSelectionParts(options);
+  if (!selection.providerId && !selection.modelId) return void 0;
+  if (selection.providerId) {
+    const provider = adapter.providerCatalog[selection.providerId];
+    if (!provider) return `Provider ${selection.providerId} is not available on ${adapter.name}.`;
+    if (!selection.modelId) return void 0;
+    const model = provider.models[selection.modelId];
+    if (!model) return `Model ${selection.modelId} is not available for provider ${selection.providerId} on ${adapter.name}.`;
+    return modelCapabilityValidationError(adapter, selection.providerId, model, options);
+  }
+  if (selection.modelId) {
+    const match = findCatalogModel(adapter.providerCatalog, selection.modelId);
+    if (!match) return `Model ${selection.modelId} is not available on ${adapter.name}.`;
+    return modelCapabilityValidationError(adapter, match.providerId, match.model, options);
+  }
+  return void 0;
+}
+function resolveModelSelectionParts(options) {
+  const providerId = options.providerId?.trim();
+  const modelId = options.modelId?.trim();
+  if (providerId || modelId) {
+    return {
+      ...providerId ? { providerId } : {},
+      ...modelId ? { modelId } : {}
+    };
+  }
+  const model = options.model?.trim();
+  if (!model) return {};
+  const separatorIndex = model.indexOf("/");
+  if (separatorIndex > 0 && separatorIndex < model.length - 1) {
+    return { providerId: model.slice(0, separatorIndex), modelId: model.slice(separatorIndex + 1) };
+  }
+  return { modelId: model };
 }
-function supportsRequestedInvocationChannel(capability, invocationChannel) {
-  if (invocationChannel === "auto") return capability.sdkAvailable || capability.commandAvailable;
-  if (invocationChannel === "sdk") return capability.sdkAvailable;
-  return capability.commandAvailable;
+function findCatalogModel(catalog, modelId) {
+  for (const [providerId, provider] of Object.entries(catalog)) {
+    const model = provider.models[modelId];
+    if (model) return { providerId, model };
+  }
+  return void 0;
+}
+function modelCapabilityValidationError(adapter, providerId, model, options) {
+  const modelId = options.modelId ?? model.id;
+  if (options.modelVariant && model.variants && !model.variants[options.modelVariant]) {
+    return `Model variant ${options.modelVariant} is not available for ${providerId}/${modelId} on ${adapter.name}.`;
+  }
+  if (options.reasoningEffort && options.reasoningEffort !== "auto" && model.supportedReasoningEfforts?.length && !model.supportedReasoningEfforts.includes(options.reasoningEffort)) {
+    return `${options.reasoningEffort} reasoning effort is not available for ${providerId}/${modelId} on ${adapter.name}.`;
+  }
+  return void 0;
 }
 async function isSdkAvailable(adapter) {
   if (!adapter.sdkPackageName || !adapter.runWithSdk) {
     return false;
   }
-  if (adapter.sdkRequiresExecutable && adapter.executable && !await commandExists(adapter.executable)) {
+  if (adapter.sdkRequiresExecutable && adapter.executable && !await commandExists2(adapter.executable)) {
     return false;
   }
   return packageAvailable(adapter.sdkPackageName);
@@ -3949,13 +4930,9 @@ async function packageAvailable(packageName) {
     return false;
   }
 }
-async function commandExists(command) {
-  const lookupCommand = process.platform === "win32" ? "where" : "which";
-  return new Promise((resolve) => {
-    const lookup = spawn(lookupCommand, [command], { stdio: "ignore" });
-    lookup.on("error", () => resolve(false));
-    lookup.on("close", (exitCode) => resolve(exitCode === 0));
-  });
+async function commandExists2(command) {
+  const hostExecution = await getRuntimeHostExecutionPort();
+  return hostExecution.commandExists(command);
 }
 async function detectRunnerProviderCatalog(adapter) {
   const localOpencodeConfigCatalog = adapter.name === "opencode" ? await loadLocalOpencodeProviderConfigCatalog() : void 0;
@@ -3963,16 +4940,16 @@ async function detectRunnerProviderCatalog(adapter) {
 }
 function localOpencodeProviderConfigPaths() {
   return [
-    path6.join(os3.homedir(), ".config", "opencode", "opencode.json"),
-    path6.join(os3.homedir(), ".config", "opencode", "config.json"),
-    path6.join(process.cwd(), "opencode.json")
+    path7.join(os3.homedir(), ".config", "opencode", "opencode.json"),
+    path7.join(os3.homedir(), ".config", "opencode", "config.json"),
+    path7.join(process.cwd(), "opencode.json")
   ];
 }
 async function loadLocalOpencodeProviderConfigCatalog(configPaths = localOpencodeProviderConfigPaths()) {
   for (const configPath of configPaths) {
     try {
-      const parsed = JSON.parse(await readFile4(configPath, "utf8"));
-      const providerValue = isRecord(parsed) ? parsed.provider : void 0;
+      const parsed = JSON.parse(await readFile5(configPath, "utf8"));
+      const providerValue = isRecord3(parsed) ? parsed.provider : void 0;
       const catalog = sanitizeProviderCatalog(providerValue);
       if (catalog) return catalog;
     } catch {
@@ -3985,8 +4962,8 @@ function mergeProviderCatalogs(...catalogs) {
   for (const catalog of catalogs) {
     if (!catalog) continue;
     for (const [providerId, provider] of Object.entries(catalog)) {
-      const existing = isRecord(merged[providerId]) ? merged[providerId] : void 0;
-      const existingModels = existing && isRecord(existing.models) ? existing.models : {};
+      const existing = isRecord3(merged[providerId]) ? merged[providerId] : void 0;
+      const existingModels = existing && isRecord3(existing.models) ? existing.models : {};
       merged[providerId] = {
         ...existing,
         ...provider,
@@ -3999,7 +4976,7 @@ function mergeProviderCatalogs(...catalogs) {
   return parsed.success && Object.keys(parsed.data).length ? parsed.data : void 0;
 }
 function sanitizeProviderCatalog(value) {
-  if (!isRecord(value)) return void 0;
+  if (!isRecord3(value)) return void 0;
   const catalog = {};
   for (const [providerId, providerValue] of Object.entries(value)) {
     const provider = sanitizeProviderConfig(providerId, providerValue);
@@ -4009,7 +4986,7 @@ function sanitizeProviderCatalog(value) {
   return parsed.success && Object.keys(parsed.data).length ? parsed.data : void 0;
 }
 function sanitizeProviderConfig(providerId, value) {
-  if (!isRecord(value)) return void 0;
+  if (!isRecord3(value)) return void 0;
   const models = sanitizeProviderModels(value.models);
   if (!Object.keys(models).length) return void 0;
   return {
@@ -4020,7 +4997,7 @@ function sanitizeProviderConfig(providerId, value) {
   };
 }
 function sanitizeProviderModels(value) {
-  if (!isRecord(value)) return {};
+  if (!isRecord3(value)) return {};
   const models = {};
   for (const [modelId, modelValue] of Object.entries(value)) {
     const model = sanitizeProviderModel(modelId, modelValue);
@@ -4029,7 +5006,7 @@ function sanitizeProviderModels(value) {
   return models;
 }
 function sanitizeProviderModel(modelId, value) {
-  if (!isRecord(value)) return void 0;
+  if (!isRecord3(value)) return void 0;
   const reasoning = booleanValue(value.reasoning);
   const releaseDate = stringValue(value.release_date) ?? stringValue(value.releaseDate);
   const toolCall = booleanValue(value.tool_call) ?? booleanValue(value.toolCall);
@@ -4055,7 +5032,7 @@ function sanitizeProviderModel(modelId, value) {
   return model;
 }
 function sanitizeLimit(value) {
-  if (!isRecord(value)) return void 0;
+  if (!isRecord3(value)) return void 0;
   const limit = {
     ...numberValue(value.context) !== void 0 ? { context: numberValue(value.context) } : {},
     ...numberValue(value.input) !== void 0 ? { input: numberValue(value.input) } : {},
@@ -4064,7 +5041,7 @@ function sanitizeLimit(value) {
   return Object.keys(limit).length ? limit : void 0;
 }
 function sanitizeModalities(value) {
-  if (!isRecord(value)) return void 0;
+  if (!isRecord3(value)) return void 0;
   const modalities = {
     ...stringArrayValue(value.input) ? { input: stringArrayValue(value.input) } : {},
     ...stringArrayValue(value.output) ? { output: stringArrayValue(value.output) } : {}
@@ -4072,10 +5049,10 @@ function sanitizeModalities(value) {
   return Object.keys(modalities).length ? modalities : void 0;
 }
 function sanitizeVariants(value) {
-  if (!isRecord(value)) return void 0;
+  if (!isRecord3(value)) return void 0;
   const variants = {};
   for (const [variantId, variantValue] of Object.entries(value)) {
-    variants[variantId] = isRecord(variantValue) && booleanValue(variantValue.disabled) !== void 0 ? { disabled: booleanValue(variantValue.disabled) } : {};
+    variants[variantId] = isRecord3(variantValue) && booleanValue(variantValue.disabled) !== void 0 ? { disabled: booleanValue(variantValue.disabled) } : {};
   }
   return Object.keys(variants).length ? variants : void 0;
 }
@@ -4085,7 +5062,7 @@ function sanitizeReasoningEfforts(value) {
   const efforts = values.filter((candidate) => allReasoningEfforts.includes(candidate));
   return efforts.length ? efforts : void 0;
 }
-function isRecord(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stringValue(value) {
@@ -4101,66 +5078,38 @@ function stringArrayValue(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : void 0;
 }
 async function executeToolInvocation(invocation, rootDir, streamOutput, timeoutMs) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(invocation.command, invocation.args, {
-      cwd: rootDir,
-      env: process.env,
-      shell: invocation.shell ?? false,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    let settled = false;
-    let forceKillTimer;
-    const timeout = timeoutMs && timeoutMs > 0 ? setTimeout(() => {
-      if (settled) return;
-      stderr += `${toolTimeoutMessage(invocation.displayCommand, timeoutMs)}
-`;
-      child.kill("SIGTERM");
-      forceKillTimer = setTimeout(() => child.kill("SIGKILL"), 5e3);
-      forceKillTimer.unref?.();
-      rejectOnce(new Error(toolTimeoutMessage(invocation.displayCommand, timeoutMs)));
-    }, timeoutMs) : void 0;
-    timeout?.unref?.();
-    const resolveOnce = (value) => {
-      if (settled) return;
-      settled = true;
-      if (timeout) clearTimeout(timeout);
-      if (forceKillTimer) clearTimeout(forceKillTimer);
-      resolve(value);
-    };
-    const rejectOnce = (error) => {
-      if (settled) return;
-      settled = true;
-      if (timeout) clearTimeout(timeout);
-      if (forceKillTimer) clearTimeout(forceKillTimer);
-      reject(error);
-    };
-    child.on("error", rejectOnce);
-    child.stdout.setEncoding("utf8");
-    child.stderr.setEncoding("utf8");
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk;
-      if (streamOutput) {
-        process.stdout.write(chunk);
-      }
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk;
-      if (streamOutput) {
-        process.stderr.write(chunk);
-      }
-    });
-    child.stdin.on("error", () => void 0);
-    if (invocation.stdin) {
-      child.stdin.write(invocation.stdin);
-    }
-    child.stdin.end();
-    child.on("close", (exitCode) => {
-      if (forceKillTimer) clearTimeout(forceKillTimer);
-      resolveOnce({ exitCode: exitCode ?? 1, stdout, stderr });
-    });
+  const hostExecution = await getRuntimeHostExecutionPort();
+  const result = await hostExecution.executeCommand({
+    command: invocation.command,
+    args: invocation.args,
+    cwd: rootDir,
+    env: process.env,
+    shell: invocation.shell ?? false,
+    ...invocation.stdin ? { stdin: invocation.stdin } : {},
+    ...timeoutMs ? { timeoutMs, timeoutMessage: toolTimeoutMessage(invocation.displayCommand, timeoutMs) } : {},
+    streamOutput
   });
+  if (result.status === "timedOut" || result.status === "spawnFailed" || result.status === "unsupported") {
+    throw new Error(result.error?.message ?? `Command execution failed: ${invocation.displayCommand}`);
+  }
+  return { exitCode: result.exitCode, stdout: result.stdout, stderr: result.stderr };
+}
+function normalizeToolExecutionResult(result, rootDir) {
+  return {
+    ...result,
+    stdout: normalizeLocalToolOutput(result.stdout, rootDir),
+    stderr: normalizeLocalToolOutput(result.stderr, rootDir)
+  };
+}
+function normalizeLocalToolOutput(value, rootDir) {
+  const redacted = redactToolAdapterText(value, { executionRoot: rootDir, redaction: { localPaths: true, secretAssignments: true } });
+  return truncateLocalToolOutput(redacted, localToolOutputBudgetBytes);
+}
+function truncateLocalToolOutput(value, budgetBytes) {
+  if (Buffer.byteLength(value, "utf8") <= budgetBytes) return value;
+  const suffix = "\n[truncated by Amistio local tool output budget]";
+  const contentBudget = Math.max(0, budgetBytes - Buffer.byteLength(suffix, "utf8"));
+  return `${Buffer.from(value, "utf8").subarray(0, contentBudget).toString("utf8")}${suffix}`;
 }
 async function withTimeout(promise, timeoutMs, displayCommand) {
   if (!timeoutMs || timeoutMs <= 0) {
@@ -4182,9 +5131,9 @@ async function withTimeout(promise, timeoutMs, displayCommand) {
   });
 }
 function toolTimeoutMessage(displayCommand, timeoutMs) {
-  return `Local tool timed out after ${formatTimeoutDuration(timeoutMs)}: ${displayCommand}`;
+  return `Local tool timed out after ${formatTimeoutDuration2(timeoutMs)}: ${displayCommand}`;
 }
-function formatTimeoutDuration(timeoutMs) {
+function formatTimeoutDuration2(timeoutMs) {
   if (timeoutMs < 1e3) {
     return `${timeoutMs}ms`;
   }
@@ -4246,7 +5195,7 @@ async function runClaudeSdk(input) {
       }
     }
   })) {
-    if (isRecord(message) && message.type === "result") {
+    if (isRecord3(message) && message.type === "result") {
       if (message.subtype === "success" && typeof message.result === "string") {
         stdout += message.result;
         if (input.streamOutput) {
@@ -4332,9 +5281,9 @@ function extractTextParts(parts) {
   if (!Array.isArray(parts)) {
     return "";
   }
-  return parts.filter(isRecord).map((part) => part.type === "text" && typeof part.text === "string" ? part.text : "").filter(Boolean).join("\n");
+  return parts.filter(isRecord3).map((part) => part.type === "text" && typeof part.text === "string" ? part.text : "").filter(Boolean).join("\n");
 }
-function errorMessage(error) {
+function errorMessage3(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function shellQuote(value) {
@@ -4345,14 +5294,14 @@ function shellQuote(value) {
 import { spawn as spawn2 } from "node:child_process";
 import { createHash as createHash3 } from "node:crypto";
 import { openSync } from "node:fs";
-import { mkdir as mkdir6, readdir as readdir3, readFile as readFile5, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdir as mkdir7, readdir as readdir4, readFile as readFile6, writeFile as writeFile7 } from "node:fs/promises";
 import os4 from "node:os";
-import path7 from "node:path";
+import path8 from "node:path";
 function currentRunnerMode() {
   return process.env.AMISTIO_RUNNER_MODE === "background" ? "background" : "foreground";
 }
 function defaultRunnerMetadataDir() {
-  return path7.join(os4.homedir(), ".config", "amistio", "runners");
+  return path8.join(os4.homedir(), ".config", "amistio", "runners");
 }
 function updatedCliRunnerLaunchOptions() {
   return { executablePath: "amistio", directExecutable: true };
@@ -4369,8 +5318,8 @@ async function startRunnerDaemon(input) {
   if (existing?.status === "running" && isProcessRunning(existing.pid)) {
     throw new Error(`Background runner ${existing.runnerId} is already running with PID ${existing.pid}.`);
   }
-  await mkdir6(metadataDir, { recursive: true });
-  const logPath = path7.join(metadataDir, `${runnerDaemonKey(input)}.log`);
+  await mkdir7(metadataDir, { recursive: true });
+  const logPath = path8.join(metadataDir, `${runnerDaemonKey(input)}.log`);
   const logFd = openSync(logPath, "a");
   const launch = resolveRunnerDaemonLaunch({
     args: input.args,
@@ -4397,7 +5346,7 @@ async function startRunnerDaemon(input) {
     projectId: input.projectId,
     repositoryLinkId: input.repositoryLinkId,
     runnerId: input.runnerId,
-    rootDir: path7.resolve(input.rootDir),
+    rootDir: path8.resolve(input.rootDir),
     apiUrl: input.apiUrl,
     pid: child.pid,
     status: "running",
@@ -4411,8 +5360,8 @@ async function startRunnerDaemon(input) {
 }
 async function restartRunnerDaemonProcess(metadata, args, input = {}) {
   const metadataDir = input.metadataDir ?? defaultRunnerMetadataDir();
-  await mkdir6(metadataDir, { recursive: true });
-  const logPath = metadata.logPath ?? path7.join(metadataDir, `${runnerDaemonKey(metadata)}.log`);
+  await mkdir7(metadataDir, { recursive: true });
+  const logPath = metadata.logPath ?? path8.join(metadataDir, `${runnerDaemonKey(metadata)}.log`);
   const logFd = openSync(logPath, "a");
   const launch = resolveRunnerDaemonLaunch({
     args,
@@ -4449,12 +5398,12 @@ async function restartRunnerDaemonProcess(metadata, args, input = {}) {
 async function listRunnerDaemonMetadata(input, metadataDir = defaultRunnerMetadataDir()) {
   let entries;
   try {
-    entries = await readdir3(metadataDir);
+    entries = await readdir4(metadataDir);
   } catch {
     return [];
   }
   const records = await Promise.all(
-    entries.filter((entry) => entry.endsWith(".json")).map(async (entry) => readRunnerDaemonMetadataFile(path7.join(metadataDir, entry)))
+    entries.filter((entry) => entry.endsWith(".json")).map(async (entry) => readRunnerDaemonMetadataFile(path8.join(metadataDir, entry)))
   );
   return records.filter((record) => Boolean(record)).filter((record) => record.accountId === input.accountId && record.projectId === input.projectId && record.repositoryLinkId === input.repositoryLinkId).filter((record) => !input.runnerId || record.runnerId === input.runnerId).sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt));
 }
@@ -4462,8 +5411,8 @@ async function readRunnerDaemonMetadata(input, metadataDir = defaultRunnerMetada
   return readRunnerDaemonMetadataFile(runnerDaemonMetadataPath(input, metadataDir));
 }
 async function writeRunnerDaemonMetadata(metadata, metadataDir = defaultRunnerMetadataDir()) {
-  await mkdir6(metadataDir, { recursive: true });
-  await writeFile6(runnerDaemonMetadataPath(metadata, metadataDir), JSON.stringify(metadata, null, 2), { encoding: "utf8", mode: 384 });
+  await mkdir7(metadataDir, { recursive: true });
+  await writeFile7(runnerDaemonMetadataPath(metadata, metadataDir), JSON.stringify(metadata, null, 2), { encoding: "utf8", mode: 384 });
 }
 async function markRunnerDaemonStopped(metadata, metadataDir = defaultRunnerMetadataDir()) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -4525,14 +5474,14 @@ function runnerDaemonUptime(metadata, now = Date.now()) {
   return `${seconds}s`;
 }
 function runnerDaemonMetadataPath(input, metadataDir) {
-  return path7.join(metadataDir, `${runnerDaemonKey(input)}.json`);
+  return path8.join(metadataDir, `${runnerDaemonKey(input)}.json`);
 }
 function runnerDaemonKey(input) {
   return createHash3("sha256").update(`${input.accountId}:${input.projectId}:${input.repositoryLinkId}:${input.runnerId}`).digest("hex");
 }
 async function readRunnerDaemonMetadataFile(filePath) {
   try {
-    const parsed = JSON.parse(await readFile5(filePath, "utf8"));
+    const parsed = JSON.parse(await readFile6(filePath, "utf8"));
     if (parsed.schemaVersion !== 1 || !parsed.runnerId || !parsed.projectId || !parsed.repositoryLinkId) {
       return void 0;
     }
@@ -4545,9 +5494,9 @@ async function readRunnerDaemonMetadataFile(filePath) {
 // src/runner-service.ts
 import { spawn as spawn3 } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
-import { mkdir as mkdir7, readFile as readFile6, rm as rm3, writeFile as writeFile7 } from "node:fs/promises";
+import { mkdir as mkdir8, readFile as readFile7, rm as rm3, writeFile as writeFile8 } from "node:fs/promises";
 import os5 from "node:os";
-import path8 from "node:path";
+import path9 from "node:path";
 function detectRunnerServicePlatform(platform = process.platform) {
   if (platform === "darwin") return "launchd";
   if (platform === "linux") return "systemd";
@@ -4563,14 +5512,14 @@ function createRunnerServiceDescriptor(input) {
   const serviceFilePath = runnerServiceFilePath(platform, serviceName, homeDir);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const command = [input.executablePath ?? process.execPath, input.scriptPath ?? process.argv[1], ...input.args];
-  const logPath = path8.join(input.metadataDir ?? defaultRunnerMetadataDir(), `${runnerServiceKey(input)}.service.log`);
+  const logPath = path9.join(input.metadataDir ?? defaultRunnerMetadataDir(), `${runnerServiceKey(input)}.service.log`);
   const metadata = {
     schemaVersion: 1,
     accountId: input.accountId,
     projectId: input.projectId,
     repositoryLinkId: input.repositoryLinkId,
     runnerId: input.runnerId,
-    rootDir: path8.resolve(input.rootDir),
+    rootDir: path9.resolve(input.rootDir),
     apiUrl: input.apiUrl,
     serviceName,
     serviceFilePath,
@@ -4587,9 +5536,9 @@ function createRunnerServiceDescriptor(input) {
 }
 async function installRunnerService(input, options = {}) {
   const descriptor = createRunnerServiceDescriptor(input);
-  await mkdir7(path8.dirname(descriptor.metadata.serviceFilePath), { recursive: true });
-  await mkdir7(input.metadataDir ?? defaultRunnerMetadataDir(), { recursive: true });
-  await writeFile7(descriptor.metadata.serviceFilePath, descriptor.content, { encoding: "utf8", mode: 384 });
+  await mkdir8(path9.dirname(descriptor.metadata.serviceFilePath), { recursive: true });
+  await mkdir8(input.metadataDir ?? defaultRunnerMetadataDir(), { recursive: true });
+  await writeFile8(descriptor.metadata.serviceFilePath, descriptor.content, { encoding: "utf8", mode: 384 });
   await writeRunnerServiceMetadata(descriptor.metadata, input.metadataDir);
   if (options.activate !== false) {
     const activation = await activateRunnerService(descriptor.metadata);
@@ -4611,7 +5560,7 @@ async function removeRunnerService(input) {
 }
 async function readRunnerServiceMetadata(input, metadataDir = defaultRunnerMetadataDir()) {
   try {
-    const parsed = JSON.parse(await readFile6(runnerServiceMetadataPath(input, metadataDir), "utf8"));
+    const parsed = JSON.parse(await readFile7(runnerServiceMetadataPath(input, metadataDir), "utf8"));
     if (parsed.schemaVersion !== 1 || !parsed.serviceName || !parsed.serviceFilePath) {
       return void 0;
     }
@@ -4621,8 +5570,8 @@ async function readRunnerServiceMetadata(input, metadataDir = defaultRunnerMetad
   }
 }
 async function writeRunnerServiceMetadata(metadata, metadataDir = defaultRunnerMetadataDir()) {
-  await mkdir7(metadataDir, { recursive: true });
-  await writeFile7(runnerServiceMetadataPath(metadata, metadataDir), JSON.stringify(metadata, null, 2), { encoding: "utf8", mode: 384 });
+  await mkdir8(metadataDir, { recursive: true });
+  await writeFile8(runnerServiceMetadataPath(metadata, metadataDir), JSON.stringify(metadata, null, 2), { encoding: "utf8", mode: 384 });
 }
 async function runnerServiceRuntimeStatus(metadata) {
   if (metadata.platform === "launchd") {
@@ -4705,12 +5654,12 @@ WantedBy=default.target
 }
 function runnerServiceFilePath(platform, serviceName, homeDir) {
   if (platform === "launchd") {
-    return path8.join(homeDir, "Library", "LaunchAgents", `${serviceName}.plist`);
+    return path9.join(homeDir, "Library", "LaunchAgents", `${serviceName}.plist`);
   }
-  return path8.join(homeDir, ".config", "systemd", "user", `${serviceName}.service`);
+  return path9.join(homeDir, ".config", "systemd", "user", `${serviceName}.service`);
 }
 function runnerServiceMetadataPath(input, metadataDir) {
-  return path8.join(metadataDir, `${runnerServiceKey(input)}.service.json`);
+  return path9.join(metadataDir, `${runnerServiceKey(input)}.service.json`);
 }
 function runnerServiceName(input) {
   return `com.amistio.runner.${runnerServiceKey(input).slice(0, 20)}`;
@@ -4769,7 +5718,7 @@ function completedToolSessionClosedReason(session) {
   return "Completed one-shot tool run; this session is not reusable.";
 }
 function staleToolSessionClosedReason(session, now = /* @__PURE__ */ new Date()) {
-  if (session.status !== "open") {
+  if (session.status !== "open" && session.status !== "active") {
     return void 0;
   }
   const lastActivityMs = Date.parse(session.lastActivityAt);
@@ -5045,8 +5994,8 @@ function createSmokeSession({ now, status, lastActivityAt }) {
 // src/sync.ts
 import { execFile as execFile3 } from "node:child_process";
 import { createHash as createHash5 } from "node:crypto";
-import { mkdir as mkdir8, readdir as readdir4, readFile as readFile7, stat as stat3, writeFile as writeFile8 } from "node:fs/promises";
-import path9 from "node:path";
+import { mkdir as mkdir9, readdir as readdir5, readFile as readFile8, stat as stat4, writeFile as writeFile9 } from "node:fs/promises";
+import path10 from "node:path";
 import { promisify as promisify3 } from "node:util";
 var execFileAsync3 = promisify3(execFile3);
 var legacySyncRoots = ["architecture", "context", "decisions", "features", "memory", "plans", "prompts", "workflows"];
@@ -5142,7 +6091,7 @@ async function readLocalSyncedDocuments(rootDir) {
   const documentFiles = await findBrainDocumentFiles(rootDir);
   const documents = [];
   for (const fullPath of documentFiles) {
-    const raw = await readFile7(fullPath, "utf8");
+    const raw = await readFile8(fullPath, "utf8");
     const repoPath = toRepoPath(rootDir, fullPath);
     const parsed = parseSyncedDocument(raw, repoPath);
     if (!parsed) {
@@ -5192,8 +6141,8 @@ async function materializeBrainDocuments(rootDir, documents, options = {}) {
       result.skipped.push(document.repoPath);
       continue;
     }
-    await mkdir8(path9.dirname(fullPath), { recursive: true });
-    await writeFile8(fullPath, createSyncedDocumentContent(document), "utf8");
+    await mkdir9(path10.dirname(fullPath), { recursive: true });
+    await writeFile9(fullPath, createSyncedDocumentContent(document), "utf8");
     result.written.push(document.repoPath);
   }
   return result;
@@ -5322,7 +6271,7 @@ function parseSyncedHtml(content) {
 }
 async function readExistingSyncedDocument(fullPath) {
   try {
-    const raw = await readFile7(fullPath, "utf8");
+    const raw = await readFile8(fullPath, "utf8");
     const parsed = parseSyncedDocument(raw, fullPath);
     if (!parsed) {
       return { exists: true };
@@ -5347,7 +6296,7 @@ async function readExistingSyncedDocument(fullPath) {
 async function findBrainDocumentFiles(rootDir) {
   const files = [];
   for (const syncRoot of [...syncRoots, htmlSyncRoot]) {
-    const fullRoot = path9.join(rootDir, syncRoot);
+    const fullRoot = path10.join(rootDir, syncRoot);
     if (!await exists2(fullRoot)) {
       continue;
     }
@@ -5356,8 +6305,8 @@ async function findBrainDocumentFiles(rootDir) {
   return files;
 }
 async function walkBrainDocumentFiles(directory, files) {
-  for (const entry of await readdir4(directory, { withFileTypes: true })) {
-    const fullPath = path9.join(directory, entry.name);
+  for (const entry of await readdir5(directory, { withFileTypes: true })) {
+    const fullPath = path10.join(directory, entry.name);
     if (entry.isDirectory()) {
       await walkBrainDocumentFiles(fullPath, files);
     } else if (entry.isFile() && /\.(md|mdx|html?)$/i.test(entry.name)) {
@@ -5366,23 +6315,23 @@ async function walkBrainDocumentFiles(directory, files) {
   }
 }
 function safeRepoPath(rootDir, repoPath) {
-  if (path9.isAbsolute(repoPath)) {
+  if (path10.isAbsolute(repoPath)) {
     throw new Error(`Refusing to use absolute repo path: ${repoPath}`);
   }
-  const normalized = path9.normalize(repoPath);
-  if (normalized === ".." || normalized.startsWith(`..${path9.sep}`)) {
+  const normalized = path10.normalize(repoPath);
+  if (normalized === ".." || normalized.startsWith(`..${path10.sep}`)) {
     throw new Error(`Refusing to use path outside the repository: ${repoPath}`);
   }
-  const root = path9.resolve(rootDir);
-  const fullPath = path9.resolve(root, normalized);
-  if (!fullPath.startsWith(`${root}${path9.sep}`)) {
+  const root = path10.resolve(rootDir);
+  const fullPath = path10.resolve(root, normalized);
+  if (!fullPath.startsWith(`${root}${path10.sep}`)) {
     throw new Error(`Refusing to use path outside the repository: ${repoPath}`);
   }
   return fullPath;
 }
 function isControlPlanePath(repoPath) {
-  const normalized = path9.normalize(repoPath);
-  return syncRoots.some((syncRoot) => normalized === syncRoot || normalized.startsWith(`${syncRoot}${path9.sep}`)) || normalized === htmlSyncRoot || normalized.startsWith(`${htmlSyncRoot}${path9.sep}`);
+  const normalized = path10.normalize(repoPath);
+  return syncRoots.some((syncRoot) => normalized === syncRoot || normalized.startsWith(`${syncRoot}${path10.sep}`)) || normalized === htmlSyncRoot || normalized.startsWith(`${htmlSyncRoot}${path10.sep}`);
 }
 function canonicalControlPlaneRepoPath(repoPath) {
   const normalized = repoPath.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
@@ -5393,16 +6342,16 @@ function canonicalControlPlaneRepoPath(repoPath) {
   return normalized;
 }
 function toRepoPath(rootDir, fullPath) {
-  return path9.relative(rootDir, fullPath).split(path9.sep).join("/");
+  return path10.relative(rootDir, fullPath).split(path10.sep).join("/");
 }
 function inferTitle(content, repoPath) {
   const heading = content.split("\n").find((line) => line.startsWith("# "))?.replace(/^#\s+/, "").trim();
   if (heading) return heading;
   const htmlHeading = content.match(/<h1\b[^>]*>([\s\S]*?)<\/h1>/i)?.[1]?.replace(/<[^>]+>/g, "").trim();
-  return htmlHeading || path9.basename(repoPath, path9.extname(repoPath));
+  return htmlHeading || path10.basename(repoPath, path10.extname(repoPath));
 }
 async function collectExternalBrainDocumentsForPush(rootDir, metadata, existingDocuments, options) {
-  const root = path9.resolve(rootDir);
+  const root = path10.resolve(rootDir);
   const maxBytes = (options.maxFileKb ?? defaultAutoSyncMaxFileKb) * 1024;
   const syncedAt = options.syncedAt ?? (/* @__PURE__ */ new Date()).toISOString();
   const existingById = new Map(existingDocuments.map((document) => [document.documentId, document]));
@@ -5418,7 +6367,7 @@ async function collectExternalBrainDocumentsForPush(rootDir, metadata, existingD
       continue;
     }
     const fullPath = safeRepoPath(root, normalizedRepoPath);
-    const fileStat = await stat3(fullPath).catch(() => void 0);
+    const fileStat = await stat4(fullPath).catch(() => void 0);
     if (!fileStat?.isFile()) {
       skipped.push({ repoPath: normalizedRepoPath, reason: "unreadable" });
       continue;
@@ -5427,7 +6376,7 @@ async function collectExternalBrainDocumentsForPush(rootDir, metadata, existingD
       skipped.push({ repoPath: normalizedRepoPath, reason: "tooLarge" });
       continue;
     }
-    const content = await readFile7(fullPath, "utf8").catch(() => void 0);
+    const content = await readFile8(fullPath, "utf8").catch(() => void 0);
     if (content === void 0) {
       skipped.push({ repoPath: normalizedRepoPath, reason: "unreadable" });
       continue;
@@ -5492,7 +6441,7 @@ async function listAutoSyncCandidatePaths(rootDir) {
   }
   const files = [];
   for (const syncRoot of [...syncRoots, htmlSyncRoot, ...legacySyncRoots]) {
-    const fullRoot = path9.join(rootDir, syncRoot);
+    const fullRoot = path10.join(rootDir, syncRoot);
     if (await exists2(fullRoot)) {
       await walkAutoSyncFiles(rootDir, fullRoot, files);
     }
@@ -5500,9 +6449,9 @@ async function listAutoSyncCandidatePaths(rootDir) {
   return uniqueSortedRepoPaths(files);
 }
 async function walkAutoSyncFiles(rootDir, directory, files) {
-  for (const entry of await readdir4(directory, { withFileTypes: true }).catch(() => [])) {
-    const fullPath = path9.join(directory, entry.name);
-    const repoPath = normalizeRepoPath3(path9.relative(rootDir, fullPath));
+  for (const entry of await readdir5(directory, { withFileTypes: true }).catch(() => [])) {
+    const fullPath = path10.join(directory, entry.name);
+    const repoPath = normalizeRepoPath3(path10.relative(rootDir, fullPath));
     if (entry.isDirectory()) {
       if (!autoSyncExcludedDirectoryNames.has(entry.name)) {
         await walkAutoSyncFiles(rootDir, fullPath, files);
@@ -5556,7 +6505,7 @@ function parseFrontmatterFromSyncedDocument(frontmatter) {
 }
 async function exists2(filePath) {
   try {
-    await stat3(filePath);
+    await stat4(filePath);
     return true;
   } catch {
     return false;
@@ -5564,9 +6513,9 @@ async function exists2(filePath) {
 }
 
 // src/tool-session-store.ts
-import { mkdir as mkdir9, readFile as readFile8, writeFile as writeFile9 } from "node:fs/promises";
+import { mkdir as mkdir10, readFile as readFile9, writeFile as writeFile10 } from "node:fs/promises";
 import os6 from "node:os";
-import path10 from "node:path";
+import path11 from "node:path";
 var LocalToolSessionStore = class {
   constructor(filePath = defaultSessionStorePath()) {
     this.filePath = filePath;
@@ -5580,12 +6529,12 @@ var LocalToolSessionStore = class {
   async setProviderSessionId(toolSessionId, toolName, providerSessionId) {
     const data = await this.read();
     data[toolSessionId] = { toolName, providerSessionId, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-    await mkdir9(path10.dirname(this.filePath), { recursive: true });
-    await writeFile9(this.filePath, JSON.stringify(data, null, 2), "utf8");
+    await mkdir10(path11.dirname(this.filePath), { recursive: true });
+    await writeFile10(this.filePath, JSON.stringify(data, null, 2), "utf8");
   }
   async read() {
     try {
-      return JSON.parse(await readFile8(this.filePath, "utf8"));
+      return JSON.parse(await readFile9(this.filePath, "utf8"));
     } catch {
       return {};
     }
@@ -5593,16 +6542,16 @@ var LocalToolSessionStore = class {
 };
 function defaultSessionStorePath() {
   if (process.platform === "darwin") {
-    return path10.join(os6.homedir(), "Library", "Application Support", "Amistio", "tool-sessions.json");
+    return path11.join(os6.homedir(), "Library", "Application Support", "Amistio", "tool-sessions.json");
   }
   if (process.platform === "win32") {
-    return path10.join(process.env.APPDATA ?? os6.homedir(), "Amistio", "tool-sessions.json");
+    return path11.join(process.env.APPDATA ?? os6.homedir(), "Amistio", "tool-sessions.json");
   }
-  return path10.join(process.env.XDG_STATE_HOME ?? path10.join(os6.homedir(), ".local", "state"), "amistio", "tool-sessions.json");
+  return path11.join(process.env.XDG_STATE_HOME ?? path11.join(os6.homedir(), ".local", "state"), "amistio", "tool-sessions.json");
 }
 
 // src/work-runner.ts
-import path11 from "node:path";
+import path12 from "node:path";
 var generationResultStart = "AMISTIO_BRAIN_GENERATION_RESULT_START";
 var generationResultEnd = "AMISTIO_BRAIN_GENERATION_RESULT_END";
 var assistantAnswerStart = "AMISTIO_ASSISTANT_ANSWER_START";
@@ -7085,15 +8034,15 @@ function normalizeProjectContextRepoPath(value, options) {
   if (!trimmed || /^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(trimmed) || /^file:/i.test(trimmed) || /^[A-Za-z]:($|[^\\/])/.test(trimmed)) {
     throwUnsafeProjectContextPath();
   }
-  const absolute = trimmed.startsWith("/") || trimmed.startsWith("\\\\") || path11.isAbsolute(trimmed) || path11.win32.isAbsolute(trimmed);
+  const absolute = trimmed.startsWith("/") || trimmed.startsWith("\\\\") || path12.isAbsolute(trimmed) || path12.win32.isAbsolute(trimmed);
   if (!absolute) {
     return normalizeRelativeProjectContextPath(trimmed);
   }
   if (!options.repositoryRoot) {
     throwUnsafeProjectContextPath();
   }
-  const useWindowsPathRules = path11.win32.isAbsolute(trimmed) && !trimmed.startsWith("/");
-  const relativePath = useWindowsPathRules ? path11.win32.relative(path11.win32.resolve(options.repositoryRoot), path11.win32.resolve(trimmed)) : path11.relative(path11.resolve(options.repositoryRoot), path11.resolve(trimmed));
+  const useWindowsPathRules = path12.win32.isAbsolute(trimmed) && !trimmed.startsWith("/");
+  const relativePath = useWindowsPathRules ? path12.win32.relative(path12.win32.resolve(options.repositoryRoot), path12.win32.resolve(trimmed)) : path12.relative(path12.resolve(options.repositoryRoot), path12.resolve(trimmed));
   return normalizeRelativeProjectContextPath(relativePath);
 }
 function normalizeRelativeProjectContextPath(value) {
@@ -7298,8 +8247,8 @@ function roundNumber(value, digits) {
 // src/importer.ts
 import { execFile as execFile4 } from "node:child_process";
 import { createHash as createHash7 } from "node:crypto";
-import { readdir as readdir5, readFile as readFile9, stat as stat4 } from "node:fs/promises";
-import path12 from "node:path";
+import { readdir as readdir6, readFile as readFile10, stat as stat5 } from "node:fs/promises";
+import path13 from "node:path";
 import { promisify as promisify4 } from "node:util";
 var execFileAsync4 = promisify4(execFile4);
 var defaultMaxFileKb = 256;
@@ -7320,12 +8269,12 @@ var documentFolderByType = {
   workflow: "docs/workflows"
 };
 async function inspectLocalRepository(rootDir, defaultBranch) {
-  const requestedRoot = path12.resolve(rootDir);
+  const requestedRoot = path13.resolve(rootDir);
   const root = await runGit2(["-C", requestedRoot, "rev-parse", "--show-toplevel"]).catch(() => requestedRoot);
   const detectedBranch = await runGit2(["-C", root, "symbolic-ref", "--quiet", "--short", "HEAD"]).catch(() => defaultBranch);
   const originUrl = await runGit2(["-C", root, "remote", "get-url", "origin"]).catch(() => void 0);
   const parsedCloneUrl = originUrl ? parseOptionalOriginCloneUrl(originUrl) : void 0;
-  const repoName = (parsedCloneUrl?.repoName ?? path12.basename(root)) || "repository";
+  const repoName = (parsedCloneUrl?.repoName ?? path13.basename(root)) || "repository";
   const fingerprintSeed = parsedCloneUrl ? `origin:${parsedCloneUrl.normalizedKey}` : `repo:${repoName}:${detectedBranch || defaultBranch}`;
   return {
     rootDir: root,
@@ -7337,7 +8286,7 @@ async function inspectLocalRepository(rootDir, defaultBranch) {
   };
 }
 async function scanLegacyDocuments(options) {
-  const rootDir = path12.resolve(options.rootDir);
+  const rootDir = path13.resolve(options.rootDir);
   const maxBytes = (options.maxFileKb ?? defaultMaxFileKb) * 1024;
   const skipped = [];
   const candidates = [];
@@ -7357,8 +8306,8 @@ async function scanLegacyDocuments(options) {
       skipped.push({ repoPath, reason: "excluded" });
       continue;
     }
-    const fullPath = path12.join(rootDir, ...repoPath.split("/"));
-    const fileStat = await stat4(fullPath).catch(() => void 0);
+    const fullPath = path13.join(rootDir, ...repoPath.split("/"));
+    const fileStat = await stat5(fullPath).catch(() => void 0);
     if (!fileStat?.isFile()) {
       skipped.push({ repoPath, reason: "unreadable" });
       continue;
@@ -7367,7 +8316,7 @@ async function scanLegacyDocuments(options) {
       skipped.push({ repoPath, reason: "tooLarge" });
       continue;
     }
-    const content = await readFile9(fullPath, "utf8").catch(() => void 0);
+    const content = await readFile10(fullPath, "utf8").catch(() => void 0);
     if (content === void 0) {
       skipped.push({ repoPath, reason: "unreadable" });
       continue;
@@ -7457,10 +8406,10 @@ async function listRepositoryPaths(rootDir) {
   return files;
 }
 async function walkRepository(rootDir, directory, files) {
-  const entries = await readdir5(directory, { withFileTypes: true }).catch(() => []);
+  const entries = await readdir6(directory, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
-    const fullPath = path12.join(directory, entry.name);
-    const repoPath = normalizeRepoPath4(path12.relative(rootDir, fullPath));
+    const fullPath = path13.join(directory, entry.name);
+    const repoPath = normalizeRepoPath4(path13.relative(rootDir, fullPath));
     if (entry.isDirectory()) {
       if (!excludedDirectoryNames.has(entry.name)) {
         await walkRepository(rootDir, fullPath, files);
@@ -7528,9 +8477,9 @@ function uniqueDestinationPath(basePath, sourcePath, usedPaths) {
     usedPaths.add(basePath);
     return basePath;
   }
-  const extension = path12.posix.extname(basePath) || ".md";
-  const directory = path12.posix.dirname(basePath);
-  const basename = path12.posix.basename(basePath, extension);
+  const extension = path13.posix.extname(basePath) || ".md";
+  const directory = path13.posix.dirname(basePath);
+  const basename = path13.posix.basename(basePath, extension);
   const uniquePath = `${directory}/${basename}-${hashText(sourcePath, 8)}${extension}`;
   usedPaths.add(uniquePath);
   return uniquePath;
@@ -7603,7 +8552,7 @@ function inferTitle2(content, repoPath) {
   if (heading) return heading;
   const htmlHeading = body.match(/<h1\b[^>]*>([\s\S]*?)<\/h1>/i)?.[1]?.replace(/<[^>]+>/g, "").trim();
   if (htmlHeading) return htmlHeading;
-  const basename = path12.posix.basename(repoPath, path12.posix.extname(repoPath)).replace(/[-_]+/g, " ").trim();
+  const basename = path13.posix.basename(repoPath, path13.posix.extname(repoPath)).replace(/[-_]+/g, " ").trim();
   return titleCase(basename || "Imported Document");
 }
 function stripFrontmatter(content) {
@@ -7637,7 +8586,7 @@ async function runGit2(args) {
 
 // src/runner-actions.ts
 import { spawn as spawn4 } from "node:child_process";
-import path13 from "node:path";
+import path14 from "node:path";
 function buildBackgroundRunnerArgs(options) {
   const args = [
     "run",
@@ -7647,7 +8596,7 @@ function buildBackgroundRunnerArgs(options) {
     "--runner-id",
     options.runnerId,
     "--root",
-    path13.resolve(options.root),
+    path14.resolve(options.root),
     "--session",
     options.session,
     "--interval-seconds",
@@ -7765,8 +8714,8 @@ function truncateProcessOutput(value) {
 
 // src/git-worktree.ts
 import { execFile as execFile5 } from "node:child_process";
-import { copyFile, lstat, mkdir as mkdir10, readdir as readdir6, stat as stat5 } from "node:fs/promises";
-import path14 from "node:path";
+import { copyFile, lstat, mkdir as mkdir11, readdir as readdir7, stat as stat6 } from "node:fs/promises";
+import path15 from "node:path";
 import { promisify as promisify5 } from "node:util";
 var execFileAsync5 = promisify5(execFile5);
 var exactLocalEnvironmentFiles = /* @__PURE__ */ new Set([".env", ".env.local", ".env.development", ".env.development.local", ".env.test", ".env.test.local", ".env.production", ".env.production.local"]);
@@ -7787,7 +8736,7 @@ function resolveWorktreeIdentity(workItem) {
 async function prepareGitWorktreeIsolation(rootDir, workItem) {
   const identity = resolveWorktreeIdentity(workItem);
   const repoRoot = await gitOutput(rootDir, ["rev-parse", "--show-toplevel"]).catch((error) => {
-    throw new Error(`Git worktree isolation requires a paired Git checkout: ${errorMessage2(error)}`);
+    throw new Error(`Git worktree isolation requires a paired Git checkout: ${errorMessage4(error)}`);
   });
   const currentHead = await gitOutput(repoRoot, ["rev-parse", "HEAD"]);
   await assertBaseRevision(repoRoot, workItem.baseRevision, currentHead);
@@ -7798,11 +8747,11 @@ async function prepareGitWorktreeIsolation(rootDir, workItem) {
     const preparedLocalEnvironmentFileCount2 = await prepareLocalWorktreeEnvironment(repoRoot, worktreePath);
     return { ...identity, baseRevision, worktreePath, ...preparedLocalEnvironmentFileCount2 ? { preparedLocalEnvironmentFileCount: preparedLocalEnvironmentFileCount2 } : {} };
   }
-  await mkdir10(path14.dirname(worktreePath), { recursive: true });
+  await mkdir11(path15.dirname(worktreePath), { recursive: true });
   const branchExists = await gitCommandSucceeds(repoRoot, ["show-ref", "--verify", "--quiet", `refs/heads/${identity.branch}`]);
   const worktreeArgs = branchExists ? ["worktree", "add", worktreePath, identity.branch] : ["worktree", "add", "-b", identity.branch, worktreePath, baseRevision];
   await gitOutput(repoRoot, worktreeArgs).catch((error) => {
-    throw new Error(`Could not create Git worktree ${identity.worktreeKey} on ${identity.branch}: ${errorMessage2(error)}`);
+    throw new Error(`Could not create Git worktree ${identity.worktreeKey} on ${identity.branch}: ${errorMessage4(error)}`);
   });
   const preparedLocalEnvironmentFileCount = await prepareLocalWorktreeEnvironment(repoRoot, worktreePath);
   return { ...identity, baseRevision, worktreePath, ...preparedLocalEnvironmentFileCount ? { preparedLocalEnvironmentFileCount } : {} };
@@ -7816,9 +8765,9 @@ async function resolveExistingGitWorktreeIsolation(rootDir, workItem) {
   return { ...identity, baseRevision, worktreePath };
 }
 function localWorktreePath(repoRoot, worktreeKey) {
-  const repoName = path14.basename(repoRoot);
+  const repoName = path15.basename(repoRoot);
   const worktreeSlug = worktreeKey.split("/").filter(Boolean).pop() ?? "work";
-  return path14.join(path14.dirname(repoRoot), `${repoName}.worktrees`, worktreeSlug);
+  return path15.join(path15.dirname(repoRoot), `${repoName}.worktrees`, worktreeSlug);
 }
 async function assertExistingWorktree(worktreePath, branch) {
   await gitOutput(worktreePath, ["rev-parse", "--is-inside-work-tree"]);
@@ -7844,8 +8793,8 @@ async function prepareLocalWorktreeEnvironment(repoRoot, worktreePath) {
   const candidates = await localEnvironmentFileCandidates(repoRoot);
   let preparedCount = 0;
   for (const candidate of candidates) {
-    const sourcePath = path14.join(repoRoot, candidate);
-    const targetPath = path14.join(worktreePath, candidate);
+    const sourcePath = path15.join(repoRoot, candidate);
+    const targetPath = path15.join(worktreePath, candidate);
     if (await pathExists(targetPath)) {
       continue;
     }
@@ -7866,7 +8815,7 @@ async function prepareLocalWorktreeEnvironment(repoRoot, worktreePath) {
 }
 async function localEnvironmentFileCandidates(repoRoot) {
   const names = new Set(exactLocalEnvironmentFiles);
-  for (const entry of await readdir6(repoRoot)) {
+  for (const entry of await readdir7(repoRoot)) {
     if (isAllowedLocalEnvironmentFile(entry)) {
       names.add(entry);
     }
@@ -7876,7 +8825,7 @@ async function localEnvironmentFileCandidates(repoRoot) {
     if (!isRootFileName(name)) {
       continue;
     }
-    const source = await lstat(path14.join(repoRoot, name)).catch(() => void 0);
+    const source = await lstat(path15.join(repoRoot, name)).catch(() => void 0);
     if (source?.isFile()) {
       candidates.push(name);
     }
@@ -7887,7 +8836,7 @@ function isAllowedLocalEnvironmentFile(name) {
   return exactLocalEnvironmentFiles.has(name) || localEnvironmentFilePattern.test(name);
 }
 function isRootFileName(name) {
-  return name === path14.basename(name) && !name.includes("/") && !name.includes("\\");
+  return name === path15.basename(name) && !name.includes("/") && !name.includes("\\");
 }
 async function gitOutput(cwd, args) {
   const { stdout } = await execFileAsync5("git", args, { cwd, maxBuffer: 1024 * 1024 });
@@ -7897,7 +8846,7 @@ async function gitCommandSucceeds(cwd, args) {
   return execFileAsync5("git", args, { cwd }).then(() => true, () => false);
 }
 async function pathExists(value) {
-  return stat5(value).then(() => true, () => false);
+  return stat6(value).then(() => true, () => false);
 }
 function workIsolationSlug(scopeId, title) {
   const scopeSlug = slugify(scopeId);
@@ -7908,7 +8857,7 @@ function workIsolationSlug(scopeId, title) {
 function slugify(value) {
   return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "work";
 }
-function errorMessage2(error) {
+function errorMessage4(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function safeFileError(error) {
@@ -7920,7 +8869,7 @@ function safeFileError(error) {
 
 // src/implementation-handoff.ts
 import { execFile as execFile6 } from "node:child_process";
-import path15 from "node:path";
+import path16 from "node:path";
 import { promisify as promisify6 } from "node:util";
 var execFileAsync6 = promisify6(execFile6);
 async function completeImplementationHandoff(input) {
@@ -8188,7 +9137,7 @@ async function cleanupWorktree(run, input) {
     return { status: "failed", message: "Cleanup skipped because the worktree is not clean after PR handoff." };
   }
   try {
-    await gitOutput2(run, input.primaryRepoRoot || path15.dirname(input.worktreePath), ["worktree", "remove", input.worktreePath]);
+    await gitOutput2(run, input.primaryRepoRoot || path16.dirname(input.worktreePath), ["worktree", "remove", input.worktreePath]);
     return { status: "completed" };
   } catch (error) {
     return { status: "failed", message: `Cleanup failed: ${safeErrorMessage(error)}` };
@@ -8300,6 +9249,481 @@ function redactLocalPaths(value) {
   return value.replace(/(^|[\s'"`])(\/{1,2}(?:Users|home|private|tmp|var|Volumes)\/[^\s'"`]+)/g, "$1<local-path>").replace(/(^|[\s'"`])([A-Za-z]:\\[^\s'"`]+)/g, "$1<local-path>");
 }
 
+// src/direct-model-client.ts
+var githubModelsProviderId = "github-models";
+var githubModelsEndpoint = "https://models.github.ai/inference/chat/completions";
+var githubModelsSupportedModelIds = ["openai/gpt-4.1", "openai/gpt-4o", "openai/gpt-5"];
+function shouldUseDirectModelClient(options) {
+  if (options.toolCommand) return false;
+  if (options.providerId !== githubModelsProviderId) return false;
+  return options.tool === void 0 || options.tool === "auto" || options.tool === "none";
+}
+function createDirectModelClientPreview(options) {
+  const modelId = requireSupportedGithubModelsModelId(options.modelId);
+  return {
+    toolName: "amistio-direct",
+    displayCommand: "GitHub Models Direct API <selected model>",
+    supportsSessionReuse: false,
+    resumabilityScope: "none",
+    model: `${githubModelsProviderId}/${modelId}`,
+    providerId: githubModelsProviderId,
+    modelId,
+    ...options.modelVariant ? { modelVariant: options.modelVariant } : {},
+    ...options.reasoningEffort ? { reasoningEffort: options.reasoningEffort } : {}
+  };
+}
+function resolveDirectModelClientPreference(options) {
+  if (options.tool && options.tool !== "auto" && options.tool !== "none") {
+    return void 0;
+  }
+  const modelFromCombinedPreference = options.model?.startsWith(`${githubModelsProviderId}/`) ? options.model.slice(`${githubModelsProviderId}/`.length) : void 0;
+  const providerId = options.providerId ?? (modelFromCombinedPreference ? githubModelsProviderId : void 0);
+  if (providerId !== githubModelsProviderId) {
+    return void 0;
+  }
+  if (options.requestedInvocationChannel === "command") {
+    return { ready: false, status: "channelUnsupported", message: "GitHub Models direct provider uses the Amistio direct client and does not support command invocation." };
+  }
+  let modelId;
+  try {
+    modelId = requireSupportedGithubModelsModelId(options.modelId ?? modelFromCombinedPreference);
+  } catch (error) {
+    return { ready: false, status: "modelUnsupported", message: errorMessage5(error) };
+  }
+  return {
+    ready: true,
+    config: {
+      model: `${githubModelsProviderId}/${modelId}`,
+      providerId: githubModelsProviderId,
+      modelId,
+      ...options.modelVariant ? { modelVariant: options.modelVariant } : {},
+      ...options.reasoningEffort ? { reasoningEffort: options.reasoningEffort } : {}
+    }
+  };
+}
+async function createGithubModelsChatCompletion(options) {
+  const modelId = requireSupportedGithubModelsModelId(options.modelId);
+  const token = resolveGithubModelsToken(options.env ?? process.env);
+  const requestInit = {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${token}`,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      model: modelId,
+      messages: options.messages,
+      ...options.tools?.length ? { tools: options.tools, tool_choice: "auto" } : {},
+      ...options.reasoningEffort && options.reasoningEffort !== "auto" ? { reasoning_effort: options.reasoningEffort } : {}
+    }),
+    ...options.signal ? { signal: options.signal } : {}
+  };
+  const response = await (options.fetchImpl ?? fetch)(githubModelsEndpoint, requestInit);
+  if (!response.ok) {
+    throw new Error(`GitHub Models request failed with HTTP ${response.status}. Check local GitHub Models auth and selected model access.`);
+  }
+  return response.json();
+}
+function requireSupportedGithubModelsModelId(modelId) {
+  const trimmed = modelId?.trim();
+  if (!trimmed) {
+    throw new Error("GitHub Models direct provider requires --provider github-models with --model-id.");
+  }
+  if (!githubModelsSupportedModelIds.includes(trimmed)) {
+    throw new Error(`Unsupported GitHub Models direct model: ${trimmed}. Supported models: ${githubModelsSupportedModelIds.join(", ")}.`);
+  }
+  return trimmed;
+}
+function resolveGithubModelsToken(env) {
+  const token = env.GITHUB_MODELS_TOKEN?.trim() || env.GITHUB_TOKEN?.trim();
+  if (!token) {
+    throw new Error("GitHub Models direct provider requires GITHUB_MODELS_TOKEN or GITHUB_TOKEN on this runner.");
+  }
+  return token;
+}
+function errorMessage5(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/amistio-direct-agent.ts
+var defaultMaxToolRounds = 8;
+async function runAmistioDirectAgent(options) {
+  const preview = createDirectModelClientPreview(options);
+  const messages = [
+    { role: "system", content: directAgentSystemPrompt(options.toolPolicy) },
+    { role: "user", content: options.prompt }
+  ];
+  let tokensIn = 0;
+  let tokensOut = 0;
+  let lastAssistantContent = "";
+  const maxToolRounds = positiveInteger3(options.maxToolRounds) ?? defaultMaxToolRounds;
+  for (let round = 0; round <= maxToolRounds; round += 1) {
+    const response = await createGithubModelsChatCompletion({
+      modelId: preview.modelId,
+      messages,
+      tools: directAgentToolDefinitions,
+      ...options.reasoningEffort ? { reasoningEffort: options.reasoningEffort } : {},
+      ...options.env ? { env: options.env } : {},
+      ...options.fetchImpl ? { fetchImpl: options.fetchImpl } : {},
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    tokensIn += response.usage?.prompt_tokens ?? 0;
+    tokensOut += response.usage?.completion_tokens ?? 0;
+    const message = response.choices?.[0]?.message;
+    const toolCalls = message?.tool_calls ?? [];
+    lastAssistantContent = message?.content ?? lastAssistantContent;
+    if (!toolCalls.length) {
+      if (options.streamOutput && lastAssistantContent) {
+        process.stdout.write(lastAssistantContent);
+      }
+      return {
+        ...preview,
+        exitCode: 0,
+        stdout: lastAssistantContent,
+        stderr: "",
+        ...tokensIn ? { tokensIn } : {},
+        ...tokensOut ? { tokensOut } : {}
+      };
+    }
+    messages.push({ role: "assistant", content: message?.content ?? null, tool_calls: toolCalls });
+    for (const toolCall of toolCalls) {
+      const execution = await executeDirectAgentTool(toolCall, options.toolPolicy);
+      messages.push({ role: "tool", tool_call_id: toolCall.id, content: JSON.stringify(execution) });
+    }
+  }
+  return {
+    ...preview,
+    exitCode: 1,
+    stdout: lastAssistantContent,
+    stderr: `Amistio direct harness stopped after ${maxToolRounds} tool rounds without a final response.`,
+    ...tokensIn ? { tokensIn } : {},
+    ...tokensOut ? { tokensOut } : {}
+  };
+}
+async function executeDirectAgentTool(toolCall, policy) {
+  const args = parseToolArguments(toolCall.function.arguments);
+  const toolName = toolCall.function.name;
+  if (!args.ok) {
+    return { toolName, result: toolFailure(toolName, "command_not_allowed", args.message) };
+  }
+  try {
+    switch (toolName) {
+      case "filesystem_read_file":
+        return { toolName, result: await runFilesystemReadTool({ policy, relativePath: stringArg(args.value, "relativePath") }) };
+      case "filesystem_list_files":
+        return { toolName, result: await runFilesystemListTool({ policy, ...optionalStringField(args.value, "relativeDirectory"), ...optionalNumberField(args.value, "maxFiles") }) };
+      case "filesystem_search_text":
+        return { toolName, result: await runFilesystemSearchTool({ policy, query: stringArg(args.value, "query"), ...optionalStringField(args.value, "relativeDirectory"), ...optionalNumberField(args.value, "maxMatches") }) };
+      case "filesystem_write_file":
+        return { toolName, result: await runFilesystemWriteTool({ policy, relativePath: stringArg(args.value, "relativePath"), content: stringArg(args.value, "content") }) };
+      case "git_status":
+        return { toolName, result: await runGitStatusTool({ policy }) };
+      case "git_diff_name_only":
+        return { toolName, result: await runGitDiffNameOnlyTool({ policy }) };
+      case "package_manager_detect":
+        return { toolName, result: await runPackageManagerDetectTool({ policy }) };
+      case "test_runner_profile":
+        return { toolName, result: await runTestRunnerProfileTool({ policy, ...optionalTestProfileField(args.value, "profileId") }) };
+      case "browser_check":
+        return { toolName, result: await runBrowserCheckTool({ policy, url: stringArg(args.value, "url") }) };
+      default:
+        return { toolName, result: toolFailure(toolName, "command_not_allowed", `Unknown Amistio direct harness tool: ${toolName}.`) };
+    }
+  } catch (error) {
+    return { toolName, result: toolFailure(toolName, "command_not_allowed", error instanceof Error ? error.message : String(error)) };
+  }
+}
+var directAgentToolDefinitions = [
+  toolDefinition("filesystem_read_file", "Read a UTF-8 file under the prepared execution root.", {
+    type: "object",
+    additionalProperties: false,
+    required: ["relativePath"],
+    properties: { relativePath: { type: "string" } }
+  }),
+  toolDefinition("filesystem_list_files", "List files under a directory within the prepared execution root.", {
+    type: "object",
+    additionalProperties: false,
+    properties: { relativeDirectory: { type: "string" }, maxFiles: { type: "integer", minimum: 1, maximum: 500 } }
+  }),
+  toolDefinition("filesystem_search_text", "Search text under the prepared execution root with bounded output.", {
+    type: "object",
+    additionalProperties: false,
+    required: ["query"],
+    properties: { query: { type: "string" }, relativeDirectory: { type: "string" }, maxMatches: { type: "integer", minimum: 1, maximum: 200 } }
+  }),
+  toolDefinition("filesystem_write_file", "Write a UTF-8 file under the prepared execution root. Allowed only for mutating harness policy.", {
+    type: "object",
+    additionalProperties: false,
+    required: ["relativePath", "content"],
+    properties: { relativePath: { type: "string" }, content: { type: "string" } }
+  }),
+  toolDefinition("git_status", "Read git status --short for the execution root.", { type: "object", additionalProperties: false, properties: {} }),
+  toolDefinition("git_diff_name_only", "Read changed Git paths for the execution root.", { type: "object", additionalProperties: false, properties: {} }),
+  toolDefinition("package_manager_detect", "Detect local package manager lockfiles and declared verification scripts.", { type: "object", additionalProperties: false, properties: {} }),
+  toolDefinition("test_runner_profile", "Run a declared local verification profile such as test, typecheck, lint, build, or verify.", {
+    type: "object",
+    additionalProperties: false,
+    properties: { profileId: { type: "string", enum: ["verify", "test", "typecheck", "lint", "build"] } }
+  }),
+  toolDefinition("browser_check", "Run a loopback-only HTTP browser smoke check.", {
+    type: "object",
+    additionalProperties: false,
+    required: ["url"],
+    properties: { url: { type: "string" } }
+  })
+];
+function directAgentSystemPrompt(policy) {
+  return [
+    "You are the built-in Amistio direct harness running on the user's local runner.",
+    "Use the provided tools to inspect files, make permitted edits, run bounded checks, and then return the final Amistio result requested by the user prompt.",
+    `Mutation policy: ${policy.mutationPolicy}.`,
+    policy.mutationPolicy === "mutating" ? "You may write files only through filesystem_write_file and only with repository-relative paths inside the prepared execution root." : "Do not call filesystem_write_file. This work is read-only.",
+    "Prefer targeted list/search/read operations before edits. Prefer known verification profiles over broad commands. Never ask for arbitrary shell execution, absolute local paths, secrets, provider credentials, or environment dumps.",
+    "Tool outputs are normalized and may be truncated; if more detail is needed, make a narrower tool request.",
+    "When finished, answer with the final task result only. Preserve any structured result contract included in the user prompt."
+  ].join("\n");
+}
+function toolDefinition(name, description, parameters) {
+  return { type: "function", function: { name, description, parameters } };
+}
+function parseToolArguments(value) {
+  try {
+    const parsed = JSON.parse(value || "{}");
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return { ok: true, value: parsed };
+    }
+    return { ok: false, message: "Tool arguments must be a JSON object." };
+  } catch {
+    return { ok: false, message: "Tool arguments must be valid JSON." };
+  }
+}
+function stringArg(args, key) {
+  const value = args[key];
+  if (typeof value !== "string") {
+    throw new Error(`Tool argument ${key} must be a string.`);
+  }
+  return value;
+}
+function optionalStringArg(args, key) {
+  const value = args[key];
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function optionalStringField(args, key) {
+  const value = optionalStringArg(args, key);
+  return value ? { [key]: value } : {};
+}
+function optionalNumberArg(args, key) {
+  const value = args[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function optionalNumberField(args, key) {
+  const value = optionalNumberArg(args, key);
+  return value === void 0 ? {} : { [key]: value };
+}
+function optionalTestProfileArg(args, key) {
+  const value = args[key];
+  return value === "verify" || value === "test" || value === "typecheck" || value === "lint" || value === "build" ? value : void 0;
+}
+function optionalTestProfileField(args, key) {
+  const value = optionalTestProfileArg(args, key);
+  return value ? { profileId: value } : {};
+}
+function toolFailure(toolName, code, message) {
+  return { adapterId: toolName, status: "failed", exitCode: 1, stdout: "", stderr: "", truncated: false, error: { code, message } };
+}
+function positiveInteger3(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
+}
+
+// src/harness-adapter.ts
+var AMISTIO_HARNESS_ID = "amistio";
+function harnessMutationPolicyForWorkKind(workKind) {
+  return workKind === "implementation" ? "mutating" : "readOnly";
+}
+function createHarnessConcurrencyMetadata(executionPolicy, preview) {
+  const serializedResourceKeys = /* @__PURE__ */ new Set([
+    `claim-lane:${executionPolicy.claimLaneId}`,
+    `execution-root:${executionPolicy.executionRoot}`
+  ]);
+  if (executionPolicy.mutationPolicy === "mutating") {
+    serializedResourceKeys.add(`repository:${executionPolicy.executionRoot}`);
+  }
+  if (preview.providerId) {
+    serializedResourceKeys.add(`provider:${preview.providerId}`);
+  }
+  if (preview.toolName && preview.toolName !== "custom") {
+    serializedResourceKeys.add(`client:${preview.toolName}`);
+  }
+  return {
+    claimLaneId: executionPolicy.claimLaneId,
+    supportsConcurrentRuns: true,
+    requiresExclusiveRepository: executionPolicy.mutationPolicy === "mutating",
+    requiresExclusiveProviderAuth: Boolean(preview.providerId && preview.toolName !== "amistio-direct"),
+    serializedResourceKeys: [...serializedResourceKeys]
+  };
+}
+var builtinAmistioHarnessAdapter = {
+  id: AMISTIO_HARNESS_ID,
+  displayName: "Amistio",
+  async createRunPreview({ executionPolicy, ...toolOptions }) {
+    const preview = shouldUseDirectModelClient(toolOptions) ? createDirectModelClientPreview(toolOptions) : await createToolRunPreview(toolOptions);
+    const concurrency = createHarnessConcurrencyMetadata(executionPolicy, preview);
+    const toolAdapterPolicy = createBoundedToolAdapterPolicy({
+      executionRoot: executionPolicy.executionRoot,
+      mutationPolicy: executionPolicy.mutationPolicy,
+      concurrencyMode: concurrency.requiresExclusiveRepository ? "serialized" : "parallelSafe",
+      resourceKey: `claim-lane:${executionPolicy.claimLaneId}`
+    });
+    return { harnessId: AMISTIO_HARNESS_ID, displayName: "Amistio", executionPolicy, concurrency, toolAdapterPolicy, availableToolAdapters: boundedToolAdapterCatalog, preview };
+  },
+  async executeRun({ preparedRun, ...toolOptions }) {
+    if (shouldUseDirectModelClient(toolOptions)) {
+      return runAmistioDirectAgent({ ...toolOptions, toolPolicy: preparedRun.toolAdapterPolicy });
+    }
+    return runLocalTool(toolOptions);
+  }
+};
+
+// src/host-helper-conformance.ts
+async function runHostHelperConformance(config, cwd = process.cwd()) {
+  const checks = [];
+  const discovery = await discoverNativeHostHelper(config);
+  checks.push({
+    name: "handshake",
+    passed: discovery.ok,
+    detail: discovery.ok ? `protocol ${discovery.helper.handshake.protocolVersion}` : discovery.failure.message
+  });
+  if (!discovery.ok) {
+    return { passed: false, checks };
+  }
+  const port = await createHostExecutionPort({ nativeHelper: config });
+  const execution = await port.executeCommand({ command: process.execPath, args: ["-e", "console.log('amistio conformance')"], cwd, timeoutMs: 2e3, requireNativeHelper: true });
+  checks.push(commandCheck("command execution", execution, (result) => result.status === "completed" && result.exitCode === 0 && result.stdout.includes("amistio conformance")));
+  const boundedOutput = await port.executeCommand({ command: process.execPath, args: ["-e", "console.log('\u20AC\u20AC\u20AC\u20AC')"], cwd, timeoutMs: 2e3, requireNativeHelper: true, outputBudgetBytes: 7 });
+  checks.push(commandCheck("bounded UTF-8 output", boundedOutput, (result) => result.status === "completed" && Buffer.byteLength(result.stdout, "utf8") <= 7 && !result.stdout.includes("\uFFFD")));
+  if (!discovery.helper.handshake.capabilities.pty.supported) {
+    const pty = await port.executeCommand({ command: process.execPath, args: ["-e", "console.log('pty')"], cwd, timeoutMs: 2e3, requireNativeHelper: true, requirePty: true });
+    checks.push(commandCheck("PTY fail-closed", pty, (result) => result.status === "unsupported" && result.error?.code === "pty_unsupported"));
+  } else {
+    checks.push({ name: "PTY fail-closed", passed: true, detail: "Helper advertises PTY support; platform PTY enforcement must be verified by the helper's own tests." });
+  }
+  if (!discovery.helper.handshake.capabilities.sandbox.supported) {
+    const sandbox = await port.executeCommand({ command: process.execPath, args: ["-e", "console.log('sandbox')"], cwd, timeoutMs: 2e3, requireNativeHelper: true, sandbox: "networkDisabled" });
+    checks.push(commandCheck("sandbox fail-closed", sandbox, (result) => result.status === "unsupported" && result.error?.code === "sandbox_unsupported"));
+  } else {
+    checks.push({ name: "sandbox fail-closed", passed: true, detail: "Helper advertises sandbox support; OS enforcement must be verified by the helper's own platform tests." });
+  }
+  return { passed: checks.every((check) => check.passed), checks };
+}
+function commandCheck(name, result, predicate) {
+  return {
+    name,
+    passed: predicate(result),
+    detail: result.error?.message ?? `${result.status} exit ${result.exitCode}`
+  };
+}
+
+// src/provider-auth.ts
+import { createHash as createHash8 } from "node:crypto";
+var githubCopilotProviderId = "github-copilot";
+var githubCopilotProviderClientId = "github-copilot-sdk";
+var githubCopilotRouteType = "agentClient";
+var githubModelsProviderClientId = "github-models-api";
+var githubModelsRouteType = "directProvider";
+async function checkProviderAuthLink(input) {
+  if (isGithubModelsDirectRequest(input.request)) {
+    return checkGithubModelsDirectAuth(input);
+  }
+  if (!isGithubCopilotSdkRequest(input.request)) {
+    return providerAuthResult(input.request, "unsupported", "Provider link target is not supported by this runner.", input.now);
+  }
+  const checkedAt = input.now?.() ?? (/* @__PURE__ */ new Date()).toISOString();
+  let client;
+  try {
+    client = await (input.createCopilotClient ?? createDefaultCopilotClient)({ cwd: input.root, logLevel: "error", useLoggedInUser: true });
+    await client.start();
+    const authStatus = await client.getAuthStatus();
+    const modelCount = authStatus.isAuthenticated ? await listCopilotModelCount(client) : void 0;
+    const status = {
+      providerId: githubCopilotProviderId,
+      providerClientId: githubCopilotProviderClientId,
+      routeType: githubCopilotRouteType,
+      status: authStatus.isAuthenticated ? "authenticated" : "pendingUserAction",
+      authMethodLabel: authStatus.authType ? `GitHub ${authStatus.authType}` : "GitHub Copilot SDK",
+      ...authStatus.host ? { accountHost: authStatus.host } : {},
+      ...authStatus.login ? { accountLogin: authStatus.login } : {},
+      ...authStatus.host && authStatus.login ? { accountFingerprint: accountFingerprint(authStatus.host, authStatus.login) } : {},
+      ...modelCount !== void 0 ? { modelCount } : {},
+      checkedAt,
+      message: authStatus.isAuthenticated ? "GitHub Copilot SDK is authenticated on this runner." : "Complete GitHub Copilot auth locally on the runner machine, then check again."
+    };
+    return { succeeded: true, message: status.message, providerAuthStatus: status };
+  } catch {
+    return providerAuthResult(input.request, "unavailable", "GitHub Copilot SDK auth status is unavailable on this runner.", input.now, "copilot_sdk_unavailable");
+  } finally {
+    await client?.stop().catch(() => void 0);
+  }
+}
+function isGithubCopilotSdkRequest(request) {
+  return request.providerId === githubCopilotProviderId && request.providerClientId === githubCopilotProviderClientId && request.routeType === githubCopilotRouteType;
+}
+function isGithubModelsDirectRequest(request) {
+  return request.providerId === githubModelsProviderId && request.providerClientId === githubModelsProviderClientId && request.routeType === githubModelsRouteType;
+}
+function checkGithubModelsDirectAuth(input) {
+  const checkedAt = input.now?.() ?? (/* @__PURE__ */ new Date()).toISOString();
+  const tokenSource = githubModelsTokenSource(input.env ?? process.env);
+  const message = tokenSource ? `${tokenSource} is configured for GitHub Models direct execution on this runner.` : "Set GITHUB_MODELS_TOKEN or GITHUB_TOKEN on this runner to enable GitHub Models direct execution.";
+  const status = {
+    providerId: githubModelsProviderId,
+    providerClientId: githubModelsProviderClientId,
+    routeType: githubModelsRouteType,
+    status: tokenSource ? "authenticated" : "notConfigured",
+    authMethodLabel: tokenSource ?? "GITHUB_MODELS_TOKEN or GITHUB_TOKEN",
+    ...tokenSource ? { modelCount: githubModelsSupportedModelIds.length } : {},
+    checkedAt,
+    message
+  };
+  return { succeeded: true, message, providerAuthStatus: status };
+}
+function githubModelsTokenSource(env) {
+  if (hasEnvValue(env.GITHUB_MODELS_TOKEN)) return "GITHUB_MODELS_TOKEN";
+  if (hasEnvValue(env.GITHUB_TOKEN)) return "GITHUB_TOKEN";
+  return void 0;
+}
+function hasEnvValue(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+async function createDefaultCopilotClient(options) {
+  const { CopilotClient } = await import("@github/copilot-sdk");
+  return new CopilotClient(options);
+}
+async function listCopilotModelCount(client) {
+  try {
+    return (await client.listModels()).length;
+  } catch {
+    return void 0;
+  }
+}
+function providerAuthResult(request, status, message, now, errorCode) {
+  return {
+    succeeded: status !== "unsupported",
+    message,
+    providerAuthStatus: {
+      providerId: request.providerId,
+      providerClientId: request.providerClientId,
+      routeType: request.routeType,
+      status,
+      checkedAt: now?.() ?? (/* @__PURE__ */ new Date()).toISOString(),
+      message,
+      ...errorCode ? { errorCode } : {}
+    }
+  };
+}
+function accountFingerprint(host, login) {
+  return `sha256:${createHash8("sha256").update(`${host.toLowerCase()}\0${login.toLowerCase()}`).digest("hex")}`;
+}
+
 // src/version.ts
 import { readFileSync } from "node:fs";
 function readCliPackageVersion() {
@@ -8434,7 +9858,7 @@ program.command("import").description("Pair an existing checkout and import lega
 });
 program.command("pair").description("Pair this repository with an Amistio web project").requiredOption("--account <accountId>", "Amistio account ID").requiredOption("--project <projectId>", "Amistio project ID").option("--repository-link <repositoryLinkId>", "Existing repository link ID").option("--default-branch <branch>", "Default branch", "main").option("--api-url <url>", apiUrlOptionDescription, defaultApiUrl()).option("--pairing-code <code>", "Short-lived pairing code from the Amistio app").option("--token <token>", "Runner/device credential to store outside the repository").option("--root <path>", "Repository root", defaultRoot).action(async (options, command) => {
   const pairingRoot = await resolvePairingRoot(options.root, { explicitRoot: command.getOptionValueSource("root") === "cli" });
-  let repositoryLinkId = options.repositoryLink ?? `repo_${randomUUID()}`;
+  let repositoryLinkId = options.repositoryLink ?? `repo_${randomUUID2()}`;
   let credential = options.token;
   if (options.pairingCode) {
     const pairing = await new ApiClient({
@@ -8620,7 +10044,7 @@ work.command("prompt").description("Print or write an approved work prompt witho
   }
   const prompt = await createRunnerWorkPrompt(context.client, context.metadata.amistioProjectId, workItem);
   if (options.out) {
-    await writeFile10(options.out, prompt, "utf8");
+    await writeFile11(options.out, prompt, "utf8");
     console.log(`Wrote work prompt to ${options.out}.`);
   } else {
     console.log(prompt);
@@ -8634,6 +10058,51 @@ program.command("tools").description("List local AI coding tools that the Amisti
   }
   console.log("custom - pass --tool-command to use any other local runner command.");
 });
+var hostHelper = program.command("host-helper").description("Inspect the optional Amistio host helper used for stronger local execution primitives");
+hostHelper.command("status").description("Show configured host-helper protocol and capability status").option("--path <path>", "Helper executable path; defaults to AMISTIO_HOST_HELPER_PATH").action(async (options) => {
+  const config = options.path?.trim() ? { command: options.path.trim() } : nativeHostHelperConfigFromEnvironment();
+  console.log(`Protocol: ${hostExecutionProtocolVersion}`);
+  if (!config) {
+    console.log("Helper: not configured");
+    console.log("Default execution: Node host port, no PTY, no sandbox.");
+    console.log("Install @amistio/cli and set AMISTIO_HOST_HELPER_PATH to `amistio-host-helper` only on machines where the reviewed local helper is intended.");
+    return;
+  }
+  console.log(`Helper: ${config.command}`);
+  const discovery = await discoverNativeHostHelper(config);
+  if (!discovery.ok) {
+    console.log(`Status: ${discovery.failure.code}`);
+    console.log(`Reason: ${discovery.failure.message}`);
+    if (discovery.failure.stderr?.trim()) console.log(`stderr: ${truncateLogExcerpt(discovery.failure.stderr)}`);
+    process.exitCode = 1;
+    return;
+  }
+  const { capabilities, secretBoundary } = discovery.helper.handshake;
+  console.log("Status: ready");
+  console.log(`Implementation: ${capabilities.implementation}`);
+  console.log(formatHostHelperCapability("Process groups", capabilities.processGroups));
+  console.log(formatHostHelperCapability("Signal escalation", capabilities.signalEscalation));
+  console.log(formatHostHelperCapability("Stream capture", capabilities.streamCapture));
+  console.log(formatHostHelperCapability("PTY", capabilities.pty));
+  console.log(formatHostHelperCapability("Sandbox", capabilities.sandbox));
+  console.log(`Secret boundary: ${secretBoundary.credentialPolicy}, ${secretBoundary.environmentPolicy}`);
+});
+hostHelper.command("conformance").description("Run local compatibility checks against a host helper").option("--path <path>", "Helper executable path; defaults to AMISTIO_HOST_HELPER_PATH").action(async (options) => {
+  const config = options.path?.trim() ? { command: options.path.trim() } : nativeHostHelperConfigFromEnvironment();
+  if (!config) {
+    console.log("No host helper configured. Set AMISTIO_HOST_HELPER_PATH or pass --path.");
+    process.exitCode = 1;
+    return;
+  }
+  const report = await runHostHelperConformance(config);
+  console.log(`Host helper conformance: ${report.passed ? "passed" : "failed"}`);
+  for (const check of report.checks) {
+    console.log(`  ${check.passed ? "ok" : "fail"} ${check.name}: ${check.detail}`);
+  }
+  if (!report.passed) {
+    process.exitCode = 1;
+  }
+});
 program.command("orchestrate").description("Update the Amistio control plane through a user-installed local AI tool").argument("[goal...]", "Goal or next-step instruction for the orchestration pass").option("--root <path>", "Repository root", defaultRoot).option("--tool <name>", "Local tool to use: auto, none, opencode, claude, codex, copilot, gemini, aider, cursor-agent", "auto").option("--invocation-channel <channel>", "Local invocation channel: auto, sdk, or command", parseInvocationChannel, "auto").option("--model <model>", "Model to request when the selected local tool supports model selection").option("--provider <providerId>", "Provider id for provider-backed model configuration").option("--model-id <modelId>", "Provider catalog model id to request").option("--model-variant <variant>", "Provider catalog model variant to request").option("--reasoning-effort <effort>", "Reasoning effort: auto, low, medium, high, or xhigh", parseReasoningEffort).option("--tool-command <command>", "Custom local command. Use {promptFile} and {root} placeholders when supported").option("--session <policy>", "Tool session policy: auto, new, continue:<toolSessionId>, or none", "auto").option("--prompt-out <path>", "Write the generated orchestration prompt to a file before running").option("--dry-run", "Print the generated orchestration prompt without running a tool").option("--no-stream", "Capture local tool output instead of streaming it").action(async (goalParts, options) => {
   const goal = goalParts?.join(" ").trim() || "Review the current repository state and update the Amistio control plane with the next useful orchestration steps.";
   const prompt = await createOrchestrationPrompt({ rootDir: options.root, goal });
@@ -8657,7 +10126,7 @@ program.command("orchestrate").description("Update the Amistio control plane thr
     ...options.toolCommand ? { toolCommand: options.toolCommand } : {},
     ...localModelConfig,
     streamOutput: options.stream,
-    ...sessionPolicy === "none" ? {} : { session: { toolSessionId: `local_orchestration_${randomUUID()}`, policy: sessionPolicy, decision: localSessionDecision(sessionPolicy) } }
+    ...sessionPolicy === "none" ? {} : { session: { toolSessionId: `local_orchestration_${randomUUID2()}`, policy: sessionPolicy, decision: localSessionDecision(sessionPolicy) } }
   });
   if (!options.stream && result.stdout.trim()) {
     console.log(result.stdout.trim());
@@ -8703,7 +10172,7 @@ program.command("run").description("Claim and run approved Amistio work locally"
       projectId: context.metadata.amistioProjectId,
       repositoryLinkId: context.metadata.repositoryLinkId,
       runnerId,
-      rootDir: path16.resolve(options.root),
+      rootDir: path17.resolve(options.root),
       apiUrl: options.apiUrl,
       args: buildBackgroundRunnerArgs(resolvedOptions)
     });
@@ -8894,7 +10363,7 @@ runnerService.command("install").description("Install a user-level startup servi
     projectId: context.metadata.amistioProjectId,
     repositoryLinkId: context.metadata.repositoryLinkId,
     runnerId,
-    rootDir: path16.resolve(options.root),
+    rootDir: path17.resolve(options.root),
     apiUrl: options.apiUrl,
     args,
     platform
@@ -8910,7 +10379,7 @@ runnerService.command("install").description("Install a user-level startup servi
     console.log(`Installed startup service ${metadata.serviceName}.`);
     console.log(`Service file: ${metadata.serviceFilePath}`);
   } catch (error) {
-    console.error(errorMessage3(error));
+    console.error(errorMessage6(error));
     process.exitCode = 1;
   }
 });
@@ -9053,12 +10522,12 @@ function supportsConcurrentLocalToolExecution(toolConfig) {
 function aggregateRunnerLaneResults(results) {
   const stopResult = results.find((result) => result.stopRunner);
   if (stopResult) return stopResult;
-  const failedResult = results.find((result) => result.status === "failed");
-  if (failedResult) return failedResult;
+  const failedResult2 = results.find((result) => result.status === "failed");
+  if (failedResult2) return failedResult2;
   const blockedResult = results.find((result) => result.status === "blocked");
   if (blockedResult) return blockedResult;
-  const completedResult = results.find((result) => result.status === "completed" || result.status === "preview");
-  if (completedResult) return completedResult;
+  const completedResult2 = results.find((result) => result.status === "completed" || result.status === "preview");
+  if (completedResult2) return completedResult2;
   return results.find((result) => result.status === "idle") ?? { status: "idle", exitCode: 0 };
 }
 async function runAutoSyncCycle({ context, maxFileKb, quiet, quietDisabled, root, runnerId }) {
@@ -9110,7 +10579,7 @@ async function runAutoSyncCycle({ context, maxFileKb, quiet, quietDisabled, root
     }
     return { status, message, pushedCount, skippedCount, conflictCount, collection };
   } catch (error) {
-    const message = `Auto-sync failed: ${errorMessage3(error)}`;
+    const message = `Auto-sync failed: ${errorMessage6(error)}`;
     await context.client.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "blocked", { ...heartbeatBase, autoSyncStatus: "failed", autoSyncMessage: message, autoSyncLastFailureAt: startedAt }).catch(() => void 0);
     return { status: "failed", message, pushedCount: 0, skippedCount: 0, conflictCount: 0 };
   }
@@ -9213,7 +10682,20 @@ async function runNextWorkItem({
     ...isolationTelemetry.executionBranch ? { currentBranch: isolationTelemetry.executionBranch } : {}
   });
   const resolvedModelConfig = toolConfigModelOptions(toolConfig);
-  const preview = await createToolRunPreview({ rootDir: executionRoot, prompt, tool: toolConfig.tool, invocationChannel: toolConfig.requestedInvocationChannel ?? "auto", ...toolCommand ? { toolCommand } : {}, ...resolvedModelConfig });
+  const preparedHarnessRun = await builtinAmistioHarnessAdapter.createRunPreview({
+    rootDir: executionRoot,
+    prompt,
+    tool: toolConfig.tool,
+    invocationChannel: toolConfig.requestedInvocationChannel ?? "auto",
+    ...toolCommand ? { toolCommand } : {},
+    ...resolvedModelConfig,
+    executionPolicy: {
+      executionRoot,
+      mutationPolicy: harnessMutationPolicyForWorkKind(result.workItem.workKind),
+      claimLaneId
+    }
+  });
+  const preview = preparedHarnessRun.preview;
   const sessionContext = await prepareToolSession({
     apiClient,
     projectId,
@@ -9237,7 +10719,15 @@ async function runNextWorkItem({
     status: "running",
     summary: `Local runner started ${preview.toolName} execution.`,
     idempotencyKey: `runner_milestone_started_${result.workItem.workItemId}_${result.workItem.attempt}`,
-    metadata: { tool: preview.toolName, invocationChannel: toolConfig.requestedInvocationChannel ?? "auto" }
+    metadata: {
+      tool: preview.toolName,
+      invocationChannel: toolConfig.requestedInvocationChannel ?? "auto",
+      claimLaneId: preparedHarnessRun.concurrency.claimLaneId,
+      harnessSupportsConcurrentRuns: preparedHarnessRun.concurrency.supportsConcurrentRuns,
+      harnessRequiresExclusiveRepository: preparedHarnessRun.concurrency.requiresExclusiveRepository,
+      harnessRequiresExclusiveProviderAuth: preparedHarnessRun.concurrency.requiresExclusiveProviderAuth,
+      harnessSerializedResourceKeys: preparedHarnessRun.concurrency.serializedResourceKeys
+    }
   });
   const startedAt = Date.now();
   const providerSessionStore = new LocalToolSessionStore();
@@ -9245,7 +10735,8 @@ async function runNextWorkItem({
   let toolResult;
   const stopLeaseRenewal = startWorkLeaseRenewal({ apiClient, projectId, repositoryLinkId, runnerId, toolConfig, workItem: result.workItem, telemetry: isolationTelemetry, heartbeatConcurrency });
   try {
-    toolResult = await runLocalTool({
+    toolResult = await builtinAmistioHarnessAdapter.executeRun({
+      preparedRun: preparedHarnessRun,
       rootDir: executionRoot,
       prompt,
       tool: toolConfig.tool,
@@ -9270,7 +10761,7 @@ async function runNextWorkItem({
     const message = `${preview.toolName} failed before returning a result.`;
     const settlements = await Promise.allSettled([
       apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig, currentRunnerMode(), heartbeatConcurrency)),
-      markToolSessionBlocked(apiClient, projectId, sessionContext.toolSession, errorMessage3(error)),
+      markToolSessionBlocked(apiClient, projectId, sessionContext.toolSession, errorMessage6(error)),
       apiClient.updateWorkStatus(projectId, result.workItem.workItemId, "failed", `run_failed_${result.workItem.workItemId}_${result.workItem.attempt}_${runnerId}`, runnerId, {
         ...isolationTelemetry,
         tool: preview.toolName,
@@ -9564,7 +11055,7 @@ async function runNextWorkItem({
       projectId,
       result.workItem.workItemId,
       finalStatus,
-      `run_${result.workItem.workItemId}_${randomUUID()}`,
+      `run_${result.workItem.workItemId}_${randomUUID2()}`,
       runnerId,
       {
         tool: preview.toolName,
@@ -9654,11 +11145,11 @@ async function prepareWorktreeForClaimedItem({ apiClient, heartbeatConcurrency,
     });
     return { status: "ready", isolation };
   } catch (error) {
-    const message = errorMessage3(error);
+    const message = errorMessage6(error);
     const telemetry = workItemIsolationTelemetry(workItem, { ...identity, baseRevision: workItem.baseRevision ?? "unknown", worktreePath: "" });
     const finalAttempt = workItem.attempt >= maxPreflightAttempts;
     const statusMessage = finalAttempt ? `Git worktree preflight failed after ${workItem.attempt}/${maxPreflightAttempts} attempts. ${message}` : `Git worktree preflight attempt ${workItem.attempt}/${maxPreflightAttempts} failed. Requeueing for retry. ${message}`;
-    const statusResult = await apiClient.updateWorkStatus(projectId, workItem.workItemId, finalAttempt ? "failed" : "approved", `worktree_${finalAttempt ? "failed" : "retry"}_${workItem.workItemId}_${workItem.attempt}_${randomUUID()}`, runnerId, {
+    const statusResult = await apiClient.updateWorkStatus(projectId, workItem.workItemId, finalAttempt ? "failed" : "approved", `worktree_${finalAttempt ? "failed" : "retry"}_${workItem.workItemId}_${workItem.attempt}_${randomUUID2()}`, runnerId, {
       ...telemetry,
       message: statusMessage,
       ...finalAttempt ? { blockerReason: message } : { releaseClaim: true },
@@ -9726,8 +11217,8 @@ async function recordFinalizationFailure({ apiClient, durationMs, error, isolati
   const message = `${toolName} completed, but Amistio could not finalize the result. ${safeFinalizationFailureSummary(error)}`;
   const settlements = await Promise.allSettled([
     apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig)),
-    markToolSessionBlocked(apiClient, projectId, sessionContext.toolSession, errorMessage3(error)),
-    apiClient.updateWorkStatus(projectId, workItem.workItemId, "failed", `finalize_failed_${workItem.workItemId}_${workItem.attempt}_${randomUUID()}`, runnerId, {
+    markToolSessionBlocked(apiClient, projectId, sessionContext.toolSession, errorMessage6(error)),
+    apiClient.updateWorkStatus(projectId, workItem.workItemId, "failed", `finalize_failed_${workItem.workItemId}_${workItem.attempt}_${randomUUID2()}`, runnerId, {
       ...isolationTelemetry,
       tool: toolName,
       durationMs,
@@ -9845,7 +11336,7 @@ function autopilotWorkMetadata2(workItem) {
 function logRejectedSettlements(action, settlements) {
   for (const settlement of settlements) {
     if (settlement.status === "rejected") {
-      console.error(`${action} failed: ${errorMessage3(settlement.reason)}`);
+      console.error(`${action} failed: ${errorMessage6(settlement.reason)}`);
     }
   }
 }
@@ -9858,7 +11349,13 @@ async function runPendingRunnerCommand(apiClient, context, heartbeatMetadata) {
   await updateRunnerCommandStatus(apiClient, context, command, "acknowledged", "Command acknowledged by local runner.");
   await updateRunnerCommandStatus(apiClient, context, command, "running", `Running ${runnerCommandLabel(command.commandKind)} command.`);
   const result = await executeRunnerCommand(apiClient, command, context);
-  await updateRunnerCommandStatus(apiClient, context, command, result.succeeded ? "completed" : "failed", result.message, result.error);
+  await updateRunnerCommandStatus(apiClient, context, command, result.succeeded ? "completed" : "failed", result.message, result.error, result.providerAuthStatus);
+  if (result.providerAuthStatus) {
+    await apiClient.sendRunnerHeartbeat(context.projectId, context.runnerId, context.repositoryLinkId, "online", {
+      ...heartbeatMetadata,
+      providerAuthStatuses: mergeProviderAuthStatuses(heartbeatMetadata.providerAuthStatuses, result.providerAuthStatus)
+    }).catch(() => void 0);
+  }
   if (command.commandKind === "remove" && result.succeeded) {
     await new LocalCredentialStore().delete(credentialKey(context.accountId, context.projectId, context.repositoryLinkId));
   }
@@ -9867,14 +11364,15 @@ async function runPendingRunnerCommand(apiClient, context, heartbeatMetadata) {
   }
   return { handled: true, succeeded: result.succeeded, message: result.message, ...result.stopRunner ? { stopRunner: true } : {} };
 }
-async function updateRunnerCommandStatus(apiClient, context, command, status, message, error) {
+async function updateRunnerCommandStatus(apiClient, context, command, status, message, error, providerAuthStatus) {
   const result = await apiClient.updateRunnerCommand(context.projectId, command.commandId, {
     runnerId: context.runnerId,
     repositoryLinkId: context.repositoryLinkId,
     status,
-    idempotencyKey: `runner_command_${command.commandId}_${status}_${randomUUID()}`,
+    idempotencyKey: `runner_command_${command.commandId}_${status}_${randomUUID2()}`,
     message,
-    ...error ? { error } : {}
+    ...error ? { error } : {},
+    ...providerAuthStatus ? { providerAuthStatus } : {}
   });
   return result.command;
 }
@@ -9888,11 +11386,21 @@ async function executeRunnerCommand(apiClient, command, context) {
   if (command.commandKind === "implementationHandoffRecovery") {
     return executeImplementationHandoffRecoveryCommand(apiClient, command, context);
   }
+  if (command.commandKind === "providerAuthLinkRequested") {
+    return executeProviderAuthLinkCommand(command, context);
+  }
   return runOfficialCliUpdateWithRuntimeRefresh({
     mode: currentRunnerMode(),
     restartBackgroundRunner: () => restartCurrentRunner(context, { useUpdatedCliExecutable: true })
   });
 }
+async function executeProviderAuthLinkCommand(command, context) {
+  if (!command.providerAuthLinkRequest) {
+    return { succeeded: false, message: "Provider link command is missing provider auth metadata." };
+  }
+  const result = await checkProviderAuthLink({ request: command.providerAuthLinkRequest, root: context.root });
+  return { succeeded: result.succeeded, message: result.message, providerAuthStatus: result.providerAuthStatus };
+}
 async function executeImplementationHandoffRecoveryCommand(apiClient, command, context) {
   if (!command.workItemId || !command.handoffRecoveryAction) {
     return { succeeded: false, message: "Handoff recovery command is missing a scoped work item or action." };
@@ -9916,7 +11424,7 @@ async function executeImplementationHandoffRecoveryCommand(apiClient, command, c
     }
     return { succeeded: false, message: "Handoff recovery action is not a runner-local command." };
   } catch (error) {
-    return { succeeded: false, message: "Handoff recovery command failed locally.", error: errorMessage3(error) };
+    return { succeeded: false, message: "Handoff recovery command failed locally.", error: errorMessage6(error) };
   }
 }
 async function retryImplementationHandoff(apiClient, context, workItem) {
@@ -9950,7 +11458,7 @@ async function findRecoveryWorkItem(apiClient, projectId, workItemId) {
   return workItems.find((item) => item.workItemId === workItemId);
 }
 async function submitRecoveredHandoff(apiClient, context, workItem, handoff, action) {
-  await apiClient.updateWorkStatus(context.projectId, workItem.workItemId, recoveredHandoffWorkStatus(handoff), `handoff_recovery_${workItem.workItemId}_${action}_${randomUUID()}`, context.runnerId, {
+  await apiClient.updateWorkStatus(context.projectId, workItem.workItemId, recoveredHandoffWorkStatus(handoff), `handoff_recovery_${workItem.workItemId}_${action}_${randomUUID2()}`, context.runnerId, {
     implementationHandoff: handoff,
     ...handoff.message ? { message: handoff.message } : {},
     ...workItem.controllingAdrId ? { controllingAdrId: workItem.controllingAdrId } : {},
@@ -9984,15 +11492,20 @@ async function restartCurrentRunner(context, options = {}) {
     const replacement = await restartRunnerDaemonProcess(metadata, context.backgroundArgs, options.useUpdatedCliExecutable ? updatedCliRunnerLaunchOptions() : {});
     return { succeeded: true, stopRunner: true, message: `Replacement background runner started with PID ${replacement.pid}.` };
   } catch (error) {
-    return { succeeded: false, message: "Background restart failed.", error: errorMessage3(error) };
+    return { succeeded: false, message: "Background restart failed.", error: errorMessage6(error) };
   }
 }
 function runnerCommandLabel(commandKind) {
   if (commandKind === "update") return "update";
   if (commandKind === "restart") return "restart";
   if (commandKind === "implementationHandoffRecovery") return "handoff recovery";
+  if (commandKind === "providerAuthLinkRequested") return "provider auth link";
   return "remove";
 }
+function mergeProviderAuthStatuses(existingStatuses, nextStatus) {
+  const statuses = existingStatuses?.filter((status) => status.providerId !== nextStatus.providerId || status.providerClientId !== nextStatus.providerClientId || status.routeType !== nextStatus.routeType) ?? [];
+  return [...statuses, nextStatus].slice(-20);
+}
 async function replayPendingBrainGenerationFinalizations({ accountId, apiClient, projectId, repositoryLinkId, runnerId }) {
   const pendingEntries = await listPendingBrainGenerationFinalizations({ accountId, projectId, repositoryLinkId, runnerId });
   if (!pendingEntries.length) {
@@ -10038,7 +11551,7 @@ async function submitBrainGenerationFinalizationEntry(apiClient, entry, options
   try {
     result = await apiClient.submitBrainGenerationResult(entry.projectId, entry.workItemId, entry.result);
   } catch (error) {
-    const detail = truncateLogExcerpt(errorMessage3(error));
+    const detail = truncateLogExcerpt(errorMessage6(error));
     if (isRetryableApiError(error)) {
       const updated = await markBrainGenerationFinalizationRetry(entry, detail);
       const message2 = `Pending brain generation finalization ${entry.workItemId} could not be replayed yet (${updated.retryCount} attempt${updated.retryCount === 1 ? "" : "s"}): ${detail}`;
@@ -10051,7 +11564,7 @@ async function submitBrainGenerationFinalizationEntry(apiClient, entry, options
     return { status: "failed", message, retryable: false };
   }
   await deleteBrainGenerationFinalizationEntry(entry).catch((error) => {
-    console.error(`delete pending brain generation finalization ${entry.workItemId} failed: ${errorMessage3(error)}`);
+    console.error(`delete pending brain generation finalization ${entry.workItemId} failed: ${errorMessage6(error)}`);
   });
   if (options.recordReplayTelemetry) {
     await recordRunnerMilestone(apiClient, entry.projectId, result.workItem, entry.runnerId, entry.repositoryLinkId, {
@@ -10072,7 +11585,7 @@ async function submitDurableResultFinalizationEntry(apiClient, entry, options =
   try {
     response = await submitDurableResultMutation(apiClient, entry);
   } catch (error) {
-    const detail = truncateLogExcerpt(errorMessage3(error));
+    const detail = truncateLogExcerpt(errorMessage6(error));
     if (isRetryableApiError(error)) {
       const updated = await markDurableResultFinalizationRetry(entry, detail);
       const message2 = `Pending ${runnerResultFinalizationLabel(entry)} finalization ${entry.workItemId} could not be replayed yet (${updated.retryCount} attempt${updated.retryCount === 1 ? "" : "s"}): ${detail}`;
@@ -10086,7 +11599,7 @@ async function submitDurableResultFinalizationEntry(apiClient, entry, options =
   }
   const workItem = durableResultResponseWorkItem(response);
   await deleteDurableResultFinalizationEntry(entry).catch((error) => {
-    console.error(`delete pending ${runnerResultFinalizationLabel(entry)} finalization ${entry.workItemId} failed: ${errorMessage3(error)}`);
+    console.error(`delete pending ${runnerResultFinalizationLabel(entry)} finalization ${entry.workItemId} failed: ${errorMessage6(error)}`);
   });
   if (options.recordReplayTelemetry) {
     await recordRunnerMilestone(apiClient, entry.projectId, workItem, entry.runnerId, entry.repositoryLinkId, {
@@ -10211,7 +11724,7 @@ async function finalizeBrainGenerationWork({
       artifacts = parseBrainGenerationArtifacts(`${toolResult.stdout}
 ${toolResult.stderr}`);
     } catch (error) {
-      generationError = errorMessage3(error);
+      generationError = errorMessage6(error);
     }
   } else {
     generationError = truncateLogExcerpt(toolResult.stderr || toolResult.stdout) || `${toolName} exited with code ${toolResult.exitCode}.`;
@@ -10229,7 +11742,7 @@ ${toolResult.stderr}`);
     const resultMutation = {
       status: "completed",
       runnerId,
-      idempotencyKey: `generation_${workItem.workItemId}_${workItem.attempt}_${randomUUID()}`,
+      idempotencyKey: `generation_${workItem.workItemId}_${workItem.attempt}_${randomUUID2()}`,
       artifacts,
       tool: toolName,
       durationMs,
@@ -10278,7 +11791,7 @@ ${toolResult.stderr}`);
       metadata: { tool: toolName, durationMs, artifactCount: replay.documentCount, verificationSummary: "Generated artifacts were accepted by the Amistio API for review." }
     });
     await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig)).catch((error) => {
-      console.error(`send generation completion heartbeat failed: ${errorMessage3(error)}`);
+      console.error(`send generation completion heartbeat failed: ${errorMessage6(error)}`);
     });
     console.log(workItem.workKind === "planRevision" ? "Revised plan returned for review." : `Generated ${replay.documentCount} brain artifact${replay.documentCount === 1 ? "" : "s"} for review.`);
     return { status: "completed", exitCode: 0 };
@@ -10301,10 +11814,10 @@ ${toolResult.stderr}`);
     ...updatedToolSession ? { toolSessionId: updatedToolSession.toolSessionId } : {},
     ...updatedToolSession?.sessionGroupKey ? { sessionGroupKey: updatedToolSession.sessionGroupKey } : {}
   };
-  const failedResult = await apiClient.submitBrainGenerationResult(projectId, workItem.workItemId, {
+  const failedResult2 = await apiClient.submitBrainGenerationResult(projectId, workItem.workItemId, {
     status: "failed",
     runnerId,
-    idempotencyKey: `generation_${workItem.workItemId}_${randomUUID()}`,
+    idempotencyKey: `generation_${workItem.workItemId}_${randomUUID2()}`,
     tool: toolName,
     durationMs,
     ...failedSessionTelemetry,
@@ -10314,7 +11827,7 @@ ${toolResult.stderr}`);
   await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
     status: "failed",
     summary: generationError ?? `${toolName} did not produce valid brain artifacts.`,
-    idempotencyKey: `runner_milestone_generation_failed_${workItem.workItemId}_${failedResult.workItem.idempotencyKey}`,
+    idempotencyKey: `runner_milestone_generation_failed_${workItem.workItemId}_${failedResult2.workItem.idempotencyKey}`,
     metadata: { tool: toolName, durationMs, verificationSummary: "Generation output could not be parsed into approved artifact JSON." }
   });
   await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
@@ -10343,7 +11856,7 @@ async function finalizeAssistantQuestionWork({
       answerResult = parseAssistantAnswerResult(`${toolResult.stdout}
 ${toolResult.stderr}`);
     } catch (error) {
-      answerError = errorMessage3(error);
+      answerError = errorMessage6(error);
     }
   } else {
     answerError = truncateLogExcerpt(toolResult.stderr || toolResult.stdout) || `${toolName} exited with code ${toolResult.exitCode}.`;
@@ -10354,7 +11867,7 @@ ${toolResult.stderr}`);
     const resultMutation = {
       status: "completed",
       runnerId,
-      idempotencyKey: `assistant_${workItem.workItemId}_${randomUUID()}`,
+      idempotencyKey: `assistant_${workItem.workItemId}_${randomUUID2()}`,
       answer: answerResult.answer,
       sourceBoundary: answerResult.sourceBoundary,
       citations: answerResult.citations,
@@ -10390,14 +11903,14 @@ ${toolResult.stderr}`);
   const failedMutation = {
     status: "failed",
     runnerId,
-    idempotencyKey: `assistant_${workItem.workItemId}_${randomUUID()}`,
+    idempotencyKey: `assistant_${workItem.workItemId}_${randomUUID2()}`,
     tool: toolName,
     durationMs,
     ...sessionTelemetry,
     message: `${toolName} did not produce a valid project knowledge answer.`,
     ...answerError ? { error: answerError } : {}
   };
-  const failedResult = await submitPrimaryRunnerResult(apiClient, {
+  const failedResult2 = await submitPrimaryRunnerResult(apiClient, {
     accountId: workItem.accountId,
     projectId,
     repositoryLinkId,
@@ -10409,12 +11922,12 @@ ${toolResult.stderr}`);
     idempotencyKey: failedMutation.idempotencyKey,
     result: failedMutation
   });
-  if (!failedResult) return { status: "failed", exitCode: 1 };
+  if (!failedResult2) return { status: "failed", exitCode: 1 };
   await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
   await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
     status: "failed",
     summary: answerError ?? `${toolName} did not produce a valid project knowledge answer.`,
-    idempotencyKey: `runner_milestone_assistant_failed_${workItem.workItemId}_${failedResult.workItem.idempotencyKey}`,
+    idempotencyKey: `runner_milestone_assistant_failed_${workItem.workItemId}_${failedResult2.workItem.idempotencyKey}`,
     metadata: { tool: toolName, durationMs, verificationSummary: "Assistant output did not include a valid structured answer." }
   });
   await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
@@ -10441,7 +11954,7 @@ async function finalizeImpactPreviewWork({
       report = parseImpactPreviewResult(`${toolResult.stdout}
 ${toolResult.stderr}`);
     } catch (error) {
-      previewError = errorMessage3(error);
+      previewError = errorMessage6(error);
     }
   } else {
     previewError = truncateLogExcerpt(toolResult.stderr || toolResult.stdout) || `${toolName} exited with code ${toolResult.exitCode}.`;
@@ -10453,7 +11966,7 @@ ${toolResult.stderr}`);
     const resultMutation = {
       status: "completed",
       runnerId,
-      idempotencyKey: `impact_${workItem.workItemId}_${randomUUID()}`,
+      idempotencyKey: `impact_${workItem.workItemId}_${randomUUID2()}`,
       report: {
         ...report,
         analyzedRepoRevision: report.analyzedRepoRevision ?? metadata?.lastSyncedRevision
@@ -10490,14 +12003,14 @@ ${toolResult.stderr}`);
   const failedMutation = {
     status: "failed",
     runnerId,
-    idempotencyKey: `impact_${workItem.workItemId}_${randomUUID()}`,
+    idempotencyKey: `impact_${workItem.workItemId}_${randomUUID2()}`,
     tool: toolName,
     durationMs,
     ...sessionTelemetry,
     message: `${toolName} did not produce a valid impact preview.`,
     ...previewError ? { error: previewError } : {}
   };
-  const failedResult = await submitPrimaryRunnerResult(apiClient, {
+  const failedResult2 = await submitPrimaryRunnerResult(apiClient, {
     accountId: workItem.accountId,
     projectId,
     repositoryLinkId,
@@ -10509,12 +12022,12 @@ ${toolResult.stderr}`);
     idempotencyKey: failedMutation.idempotencyKey,
     result: failedMutation
   });
-  if (!failedResult) return { status: "failed", exitCode: 1 };
+  if (!failedResult2) return { status: "failed", exitCode: 1 };
   await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
   await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
     status: "failed",
     summary: previewError ?? `${toolName} did not produce a valid impact preview.`,
-    idempotencyKey: `runner_milestone_impact_failed_${workItem.workItemId}_${failedResult.workItem.idempotencyKey}`,
+    idempotencyKey: `runner_milestone_impact_failed_${workItem.workItemId}_${failedResult2.workItem.idempotencyKey}`,
     metadata: { tool: toolName, durationMs, verificationSummary: "Impact preview output did not include valid structured JSON." }
   });
   await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
@@ -10540,7 +12053,7 @@ async function finalizeIssueDiagnosisWork({
       diagnosis = parseIssueDiagnosisResult(`${toolResult.stdout}
 ${toolResult.stderr}`);
     } catch (error) {
-      diagnosisError = errorMessage3(error);
+      diagnosisError = errorMessage6(error);
     }
   } else {
     diagnosisError = truncateLogExcerpt(toolResult.stderr || toolResult.stdout) || `${toolName} exited with code ${toolResult.exitCode}.`;
@@ -10551,7 +12064,7 @@ ${toolResult.stderr}`);
     const resultMutation = {
       status: "completed",
       runnerId,
-      idempotencyKey: `issue_${workItem.workItemId}_${randomUUID()}`,
+      idempotencyKey: `issue_${workItem.workItemId}_${randomUUID2()}`,
       diagnosis,
       tool: toolName,
       durationMs,
@@ -10585,14 +12098,14 @@ ${toolResult.stderr}`);
   const failedMutation = {
     status: "failed",
     runnerId,
-    idempotencyKey: `issue_${workItem.workItemId}_${randomUUID()}`,
+    idempotencyKey: `issue_${workItem.workItemId}_${randomUUID2()}`,
     tool: toolName,
     durationMs,
     ...sessionTelemetry,
     message: `${toolName} did not produce a valid issue diagnosis.`,
     ...diagnosisError ? { error: diagnosisError } : {}
   };
-  const failedResult = await submitPrimaryRunnerResult(apiClient, {
+  const failedResult2 = await submitPrimaryRunnerResult(apiClient, {
     accountId: workItem.accountId,
     projectId,
     repositoryLinkId,
@@ -10604,12 +12117,12 @@ ${toolResult.stderr}`);
     idempotencyKey: failedMutation.idempotencyKey,
     result: failedMutation
   });
-  if (!failedResult) return { status: "failed", exitCode: 1 };
+  if (!failedResult2) return { status: "failed", exitCode: 1 };
   await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
   await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
     status: "failed",
     summary: diagnosisError ?? `${toolName} did not produce a valid issue diagnosis.`,
-    idempotencyKey: `runner_milestone_issue_failed_${workItem.workItemId}_${failedResult.workItem.idempotencyKey}`,
+    idempotencyKey: `runner_milestone_issue_failed_${workItem.workItemId}_${failedResult2.workItem.idempotencyKey}`,
     metadata: { tool: toolName, durationMs, verificationSummary: "Issue diagnosis output did not include valid structured JSON." }
   });
   await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
@@ -10635,7 +12148,7 @@ async function finalizeSecurityPostureScanWork({
       scanResult = parseSecurityPostureScanResult(`${toolResult.stdout}
 ${toolResult.stderr}`);
     } catch (error) {
-      scanError = errorMessage3(error);
+      scanError = errorMessage6(error);
     }
   } else {
     scanError = truncateLogExcerpt(toolResult.stderr || toolResult.stdout) || `${toolName} exited with code ${toolResult.exitCode}.`;
@@ -10646,7 +12159,7 @@ ${toolResult.stderr}`);
     const resultMutation = {
       status: "completed",
       runnerId,
-      idempotencyKey: `security_${workItem.workItemId}_${randomUUID()}`,
+      idempotencyKey: `security_${workItem.workItemId}_${randomUUID2()}`,
       result: scanResult,
       tool: toolName,
       durationMs,
@@ -10680,14 +12193,14 @@ ${toolResult.stderr}`);
   const failedMutation = {
     status: "failed",
     runnerId,
-    idempotencyKey: `security_${workItem.workItemId}_${randomUUID()}`,
+    idempotencyKey: `security_${workItem.workItemId}_${randomUUID2()}`,
     tool: toolName,
     durationMs,
     ...sessionTelemetry,
     message: `${toolName} did not produce a valid security posture scan.`,
     ...scanError ? { error: scanError } : {}
   };
-  const failedResult = await submitPrimaryRunnerResult(apiClient, {
+  const failedResult2 = await submitPrimaryRunnerResult(apiClient, {
     accountId: workItem.accountId,
     projectId,
     repositoryLinkId,
@@ -10699,12 +12212,12 @@ ${toolResult.stderr}`);
     idempotencyKey: failedMutation.idempotencyKey,
     result: failedMutation
   });
-  if (!failedResult) return { status: "failed", exitCode: 1 };
+  if (!failedResult2) return { status: "failed", exitCode: 1 };
   await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
   await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
     status: "failed",
     summary: scanError ?? `${toolName} did not produce a valid security posture scan.`,
-    idempotencyKey: `runner_milestone_security_failed_${workItem.workItemId}_${failedResult.workItem.idempotencyKey}`,
+    idempotencyKey: `runner_milestone_security_failed_${workItem.workItemId}_${failedResult2.workItem.idempotencyKey}`,
     metadata: { tool: toolName, durationMs, verificationSummary: "Security posture output did not include valid structured JSON." }
   });
   await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
@@ -10730,7 +12243,7 @@ async function finalizeAppEvaluationScanWork({
       scanResult = parseAppEvaluationScanResult(`${toolResult.stdout}
 ${toolResult.stderr}`);
     } catch (error) {
-      scanError = errorMessage3(error);
+      scanError = errorMessage6(error);
     }
   } else {
     scanError = truncateLogExcerpt(toolResult.stderr || toolResult.stdout) || `${toolName} exited with code ${toolResult.exitCode}.`;
@@ -10741,7 +12254,7 @@ ${toolResult.stderr}`);
     const resultMutation = {
       status: "completed",
       runnerId,
-      idempotencyKey: `app_evaluation_${workItem.workItemId}_${randomUUID()}`,
+      idempotencyKey: `app_evaluation_${workItem.workItemId}_${randomUUID2()}`,
       result: scanResult,
       tool: toolName,
       durationMs,
@@ -10775,14 +12288,14 @@ ${toolResult.stderr}`);
   const failedMutation = {
     status: "failed",
     runnerId,
-    idempotencyKey: `app_evaluation_${workItem.workItemId}_${randomUUID()}`,
+    idempotencyKey: `app_evaluation_${workItem.workItemId}_${randomUUID2()}`,
     tool: toolName,
     durationMs,
     ...sessionTelemetry,
     message: `${toolName} did not produce a valid app evaluation scan.`,
     ...scanError ? { error: scanError } : {}
   };
-  const failedResult = await submitPrimaryRunnerResult(apiClient, {
+  const failedResult2 = await submitPrimaryRunnerResult(apiClient, {
     accountId: workItem.accountId,
     projectId,
     repositoryLinkId,
@@ -10794,12 +12307,12 @@ ${toolResult.stderr}`);
     idempotencyKey: failedMutation.idempotencyKey,
     result: failedMutation
   });
-  if (!failedResult) return { status: "failed", exitCode: 1 };
+  if (!failedResult2) return { status: "failed", exitCode: 1 };
   await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
   await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
     status: "failed",
     summary: scanError ?? `${toolName} did not produce a valid app evaluation scan.`,
-    idempotencyKey: `runner_milestone_app_evaluation_failed_${workItem.workItemId}_${failedResult.workItem.idempotencyKey}`,
+    idempotencyKey: `runner_milestone_app_evaluation_failed_${workItem.workItemId}_${failedResult2.workItem.idempotencyKey}`,
     metadata: { tool: toolName, durationMs, verificationSummary: "App evaluation output did not include valid structured JSON." }
   });
   await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
@@ -10825,7 +12338,7 @@ async function finalizeBrainConsolidationScanWork({
       scanResult = parseBrainConsolidationScanResult(`${toolResult.stdout}
 ${toolResult.stderr}`);
     } catch (error) {
-      scanError = errorMessage3(error);
+      scanError = errorMessage6(error);
     }
   } else {
     scanError = truncateLogExcerpt(toolResult.stderr || toolResult.stdout) || `${toolName} exited with code ${toolResult.exitCode}.`;
@@ -10836,7 +12349,7 @@ ${toolResult.stderr}`);
     const resultMutation = {
       status: "completed",
       runnerId,
-      idempotencyKey: `brain_consolidation_${workItem.workItemId}_${randomUUID()}`,
+      idempotencyKey: `brain_consolidation_${workItem.workItemId}_${randomUUID2()}`,
       result: scanResult,
       tool: toolName,
       durationMs,
@@ -10870,14 +12383,14 @@ ${toolResult.stderr}`);
   const failedMutation = {
     status: "failed",
     runnerId,
-    idempotencyKey: `brain_consolidation_${workItem.workItemId}_${randomUUID()}`,
+    idempotencyKey: `brain_consolidation_${workItem.workItemId}_${randomUUID2()}`,
     tool: toolName,
     durationMs,
     ...sessionTelemetry,
     message: `${toolName} did not produce a valid semantic brain consolidation scan.`,
     ...scanError ? { error: scanError } : {}
   };
-  const failedResult = await submitPrimaryRunnerResult(apiClient, {
+  const failedResult2 = await submitPrimaryRunnerResult(apiClient, {
     accountId: workItem.accountId,
     projectId,
     repositoryLinkId,
@@ -10889,12 +12402,12 @@ ${toolResult.stderr}`);
     idempotencyKey: failedMutation.idempotencyKey,
     result: failedMutation
   });
-  if (!failedResult) return { status: "failed", exitCode: 1 };
+  if (!failedResult2) return { status: "failed", exitCode: 1 };
   await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
   await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
     status: "failed",
     summary: scanError ?? `${toolName} did not produce a valid semantic brain consolidation scan.`,
-    idempotencyKey: `runner_milestone_brain_consolidation_failed_${workItem.workItemId}_${failedResult.workItem.idempotencyKey}`,
+    idempotencyKey: `runner_milestone_brain_consolidation_failed_${workItem.workItemId}_${failedResult2.workItem.idempotencyKey}`,
     metadata: { tool: toolName, durationMs, verificationSummary: "Brain consolidation output did not include valid structured JSON." }
   });
   await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
@@ -10921,7 +12434,7 @@ async function finalizeProjectContextRefreshWork({
       refreshResult = parseProjectContextRefreshResult(`${toolResult.stdout}
 ${toolResult.stderr}`, { repositoryRoot: executionRoot });
     } catch (error) {
-      refreshError = errorMessage3(error);
+      refreshError = errorMessage6(error);
     }
   } else {
     refreshError = truncateLogExcerpt(toolResult.stderr || toolResult.stdout) || `${toolName} exited with code ${toolResult.exitCode}.`;
@@ -10932,7 +12445,7 @@ ${toolResult.stderr}`, { repositoryRoot: executionRoot });
     const resultMutation = {
       status: "completed",
       runnerId,
-      idempotencyKey: `project_context_${workItem.workItemId}_${randomUUID()}`,
+      idempotencyKey: `project_context_${workItem.workItemId}_${randomUUID2()}`,
       result: refreshResult,
       tool: toolName,
       durationMs,
@@ -10978,14 +12491,14 @@ ${toolResult.stderr}`, { repositoryRoot: executionRoot });
   const failedMutation = {
     status: "failed",
     runnerId,
-    idempotencyKey: `project_context_${workItem.workItemId}_${randomUUID()}`,
+    idempotencyKey: `project_context_${workItem.workItemId}_${randomUUID2()}`,
     tool: toolName,
     durationMs,
     ...sessionTelemetry,
     message: `${toolName} did not produce a valid project context refresh.`,
     ...refreshError ? { error: refreshError } : {}
   };
-  const failedResult = await submitPrimaryRunnerResult(apiClient, {
+  const failedResult2 = await submitPrimaryRunnerResult(apiClient, {
     accountId: workItem.accountId,
     projectId,
     repositoryLinkId,
@@ -10997,12 +12510,12 @@ ${toolResult.stderr}`, { repositoryRoot: executionRoot });
     idempotencyKey: failedMutation.idempotencyKey,
     result: failedMutation
   });
-  if (!failedResult) return { status: "failed", exitCode: 1 };
+  if (!failedResult2) return { status: "failed", exitCode: 1 };
   await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
   await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
     status: "failed",
     summary: refreshError ?? `${toolName} did not produce a valid project context refresh.`,
-    idempotencyKey: `runner_milestone_project_context_failed_${workItem.workItemId}_${failedResult.workItem.idempotencyKey}`,
+    idempotencyKey: `runner_milestone_project_context_failed_${workItem.workItemId}_${failedResult2.workItem.idempotencyKey}`,
     metadata: { tool: toolName, durationMs, verificationSummary: "Project context output did not include valid structured JSON." }
   });
   await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
@@ -11028,7 +12541,7 @@ async function finalizeImplementationVerificationWork({
       verificationResult = parseImplementationVerificationResult(`${toolResult.stdout}
 ${toolResult.stderr}`);
     } catch (error) {
-      verificationError = errorMessage3(error);
+      verificationError = errorMessage6(error);
     }
   } else {
     verificationError = truncateLogExcerpt(toolResult.stderr || toolResult.stdout) || `${toolName} exited with code ${toolResult.exitCode}.`;
@@ -11039,7 +12552,7 @@ ${toolResult.stderr}`);
     const resultMutation = {
       status: "completed",
       runnerId,
-      idempotencyKey: `implementation_verification_${workItem.workItemId}_${randomUUID()}`,
+      idempotencyKey: `implementation_verification_${workItem.workItemId}_${randomUUID2()}`,
       result: verificationResult,
       tool: toolName,
       durationMs,
@@ -11073,14 +12586,14 @@ ${toolResult.stderr}`);
   const failedMutation = {
     status: "failed",
     runnerId,
-    idempotencyKey: `implementation_verification_${workItem.workItemId}_${randomUUID()}`,
+    idempotencyKey: `implementation_verification_${workItem.workItemId}_${randomUUID2()}`,
     tool: toolName,
     durationMs,
     ...sessionTelemetry,
     message: `${toolName} did not produce valid implementation verification proof.`,
     ...verificationError ? { error: verificationError } : {}
   };
-  const failedResult = await submitPrimaryRunnerResult(apiClient, {
+  const failedResult2 = await submitPrimaryRunnerResult(apiClient, {
     accountId: workItem.accountId,
     projectId,
     repositoryLinkId,
@@ -11092,12 +12605,12 @@ ${toolResult.stderr}`);
     idempotencyKey: failedMutation.idempotencyKey,
     result: failedMutation
   });
-  if (!failedResult) return { status: "failed", exitCode: 1 };
+  if (!failedResult2) return { status: "failed", exitCode: 1 };
   await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
   await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
     status: "failed",
     summary: verificationError ?? `${toolName} did not produce valid implementation verification proof.`,
-    idempotencyKey: `runner_milestone_implementation_verification_failed_${workItem.workItemId}_${failedResult.workItem.idempotencyKey}`,
+    idempotencyKey: `runner_milestone_implementation_verification_failed_${workItem.workItemId}_${failedResult2.workItem.idempotencyKey}`,
     metadata: { tool: toolName, durationMs, verificationSummary: "Implementation verification output did not include valid structured JSON." }
   });
   await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
@@ -11123,7 +12636,7 @@ async function finalizeTestQualityScanWork({
       scanResult = parseTestQualityScanResult(`${toolResult.stdout}
 ${toolResult.stderr}`);
     } catch (error) {
-      scanError = errorMessage3(error);
+      scanError = errorMessage6(error);
     }
   } else {
     scanError = truncateLogExcerpt(toolResult.stderr || toolResult.stdout) || `${toolName} exited with code ${toolResult.exitCode}.`;
@@ -11134,7 +12647,7 @@ ${toolResult.stderr}`);
     const resultMutation = {
       status: "completed",
       runnerId,
-      idempotencyKey: `test_quality_${workItem.workItemId}_${randomUUID()}`,
+      idempotencyKey: `test_quality_${workItem.workItemId}_${randomUUID2()}`,
       result: scanResult,
       tool: toolName,
       durationMs,
@@ -11168,14 +12681,14 @@ ${toolResult.stderr}`);
   const failedMutation = {
     status: "failed",
     runnerId,
-    idempotencyKey: `test_quality_${workItem.workItemId}_${randomUUID()}`,
+    idempotencyKey: `test_quality_${workItem.workItemId}_${randomUUID2()}`,
     tool: toolName,
     durationMs,
     ...sessionTelemetry,
     message: `${toolName} did not produce a valid test quality scan.`,
     ...scanError ? { error: scanError } : {}
   };
-  const failedResult = await submitPrimaryRunnerResult(apiClient, {
+  const failedResult2 = await submitPrimaryRunnerResult(apiClient, {
     accountId: workItem.accountId,
     projectId,
     repositoryLinkId,
@@ -11187,12 +12700,12 @@ ${toolResult.stderr}`);
     idempotencyKey: failedMutation.idempotencyKey,
     result: failedMutation
   });
-  if (!failedResult) return { status: "failed", exitCode: 1 };
+  if (!failedResult2) return { status: "failed", exitCode: 1 };
   await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
   await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
     status: "failed",
     summary: scanError ?? `${toolName} did not produce a valid test quality scan.`,
-    idempotencyKey: `runner_milestone_test_quality_failed_${workItem.workItemId}_${failedResult.workItem.idempotencyKey}`,
+    idempotencyKey: `runner_milestone_test_quality_failed_${workItem.workItemId}_${failedResult2.workItem.idempotencyKey}`,
     metadata: { tool: toolName, durationMs, verificationSummary: "Test quality output did not include valid structured JSON." }
   });
   await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
@@ -11218,7 +12731,7 @@ async function finalizeImplementationTestGateWork({
       gateResult = parseImplementationTestGateResult(`${toolResult.stdout}
 ${toolResult.stderr}`);
     } catch (error) {
-      gateError = errorMessage3(error);
+      gateError = errorMessage6(error);
     }
   } else {
     gateError = truncateLogExcerpt(toolResult.stderr || toolResult.stdout) || `${toolName} exited with code ${toolResult.exitCode}.`;
@@ -11229,7 +12742,7 @@ ${toolResult.stderr}`);
     const resultMutation = {
       status: "completed",
       runnerId,
-      idempotencyKey: `implementation_test_gate_${workItem.workItemId}_${randomUUID()}`,
+      idempotencyKey: `implementation_test_gate_${workItem.workItemId}_${randomUUID2()}`,
       result: gateResult,
       tool: toolName,
       durationMs,
@@ -11263,14 +12776,14 @@ ${toolResult.stderr}`);
   const failedMutation = {
     status: "failed",
     runnerId,
-    idempotencyKey: `implementation_test_gate_${workItem.workItemId}_${randomUUID()}`,
+    idempotencyKey: `implementation_test_gate_${workItem.workItemId}_${randomUUID2()}`,
     tool: toolName,
     durationMs,
     ...sessionTelemetry,
     message: `${toolName} did not produce a valid implementation test gate result.`,
     ...gateError ? { error: gateError } : {}
   };
-  const failedResult = await submitPrimaryRunnerResult(apiClient, {
+  const failedResult2 = await submitPrimaryRunnerResult(apiClient, {
     accountId: workItem.accountId,
     projectId,
     repositoryLinkId,
@@ -11282,12 +12795,12 @@ ${toolResult.stderr}`);
     idempotencyKey: failedMutation.idempotencyKey,
     result: failedMutation
   });
-  if (!failedResult) return { status: "failed", exitCode: 1 };
+  if (!failedResult2) return { status: "failed", exitCode: 1 };
   await finalizeToolSessionBestEffort({ apiClient, projectId, runnerId, sessionContext, status: finalStatus, toolResult, workItemId: workItem.workItemId });
   await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
     status: "failed",
     summary: gateError ?? `${toolName} did not produce a valid implementation test gate result.`,
-    idempotencyKey: `runner_milestone_implementation_test_gate_failed_${workItem.workItemId}_${failedResult.workItem.idempotencyKey}`,
+    idempotencyKey: `runner_milestone_implementation_test_gate_failed_${workItem.workItemId}_${failedResult2.workItem.idempotencyKey}`,
     metadata: { tool: toolName, durationMs, verificationSummary: "Implementation test gate output did not include valid structured JSON." }
   });
   await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
@@ -11492,7 +13005,7 @@ async function prepareToolSession({
     });
     return { ...selection, toolSession: toolSession2 };
   }
-  const toolSessionId = `tool_session_${randomUUID()}`;
+  const toolSessionId = `tool_session_${randomUUID2()}`;
   const { toolSession } = await apiClient.createToolSession(projectId, {
     toolSessionId,
     repositoryLinkId,
@@ -11586,7 +13099,7 @@ function summarizeToolOutput(value) {
   }
   return trimmed.length > 300 ? `${trimmed.slice(0, 300)}...` : trimmed;
 }
-function errorMessage3(error) {
+function errorMessage6(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function errorDetail(error) {
@@ -11596,6 +13109,9 @@ function truncateLogExcerpt(value) {
   const trimmed = value.trim();
   return trimmed.length > 1200 ? `${trimmed.slice(0, 1200)}...` : trimmed;
 }
+function formatHostHelperCapability(label, support) {
+  return `${label}: ${support.supported ? "supported" : "unsupported"}${support.reason ? ` (${support.reason})` : ""}`;
+}
 function collectRepeatedOption(value, previous) {
   return [...previous, value];
 }
@@ -11622,10 +13138,10 @@ function parseReasoningEffort(value) {
   throw new Error(`Expected reasoning effort auto, low, medium, high, or xhigh; received ${value}.`);
 }
 function inferRepoName(root) {
-  return path16.basename(path16.resolve(root)) || "repository";
+  return path17.basename(path17.resolve(root)) || "repository";
 }
 function createRepoFingerprint(accountId, projectId, repositoryLinkId) {
-  return createHash8("sha256").update(`${accountId}:${projectId}:${repositoryLinkId}`).digest("hex");
+  return createHash9("sha256").update(`${accountId}:${projectId}:${repositoryLinkId}`).digest("hex");
 }
 function defaultApiUrl() {
   const envApiUrl = process.env[AMISTIO_API_URL_ENV]?.trim();
@@ -11660,6 +13176,13 @@ async function resolveRunnerToolConfig({ apiClient, explicitInvocationChannel, e
   }
   if (explicitTool === "none") {
     const modelConfig2 = normalizeModelConfig({ model: explicitModel, providerId: explicitProviderId, modelId: explicitModelId, modelVariant: explicitModelVariant, reasoningEffort: explicitReasoningEffort });
+    const directModelResolution = resolveDirectModelClientPreference({ ...modelConfig2, tool: "none", requestedInvocationChannel: explicitInvocationChannel ?? "auto" });
+    if (directModelResolution) {
+      if (!directModelResolution.ready) {
+        return unavailableToolConfig({ capabilities, source: "cli", status: directModelResolution.status, message: directModelResolution.message, tool: "none", requestedInvocationChannel: explicitInvocationChannel ?? "auto", ...modelConfig2 });
+      }
+      return { ready: true, tool: "none", capabilities, source: "cli", status: "resolved", requestedInvocationChannel: explicitInvocationChannel ?? "auto", effectiveInvocationChannel: "sdk", ...directModelResolution.config, message: "Using Amistio direct model client." };
+    }
     if (hasModelConfig(modelConfig2)) {
       return unavailableToolConfig({ capabilities, source: "cli", status: "modelUnsupported", message: "Model configuration cannot be used with --tool none.", tool: "none", requestedInvocationChannel: explicitInvocationChannel ?? "auto", ...modelConfig2 });
     }
@@ -11684,6 +13207,13 @@ async function resolveRunnerToolConfig({ apiClient, explicitInvocationChannel, e
 }
 function resolveRequestedTool({ capabilities, modelConfig, requestedInvocationChannel, requestedTool, source }) {
   const needsModelSelection = hasModelConfig(modelConfig);
+  const directModelResolution = resolveDirectModelClientPreference({ ...modelConfig, tool: requestedTool, requestedInvocationChannel });
+  if (directModelResolution) {
+    if (!directModelResolution.ready) {
+      return unavailableToolConfig({ capabilities, source, status: directModelResolution.status, requestedTool, requestedInvocationChannel, tool: requestedTool, ...modelConfig, message: directModelResolution.message });
+    }
+    return { ready: true, tool: requestedTool, capabilities, source, status: "resolved", requestedTool, requestedInvocationChannel, effectiveInvocationChannel: "sdk", ...directModelResolution.config, message: "Using Amistio direct model client." };
+  }
   if (requestedTool === "auto") {
     const candidate = capabilities.find((capability2) => capability2.available && capabilitySupportsInvocationChannel(capability2, requestedInvocationChannel) && (!needsModelSelection || capability2.supportsModelSelection));
     if (!candidate) {
@@ -11910,7 +13440,7 @@ function runnerHeartbeatMetadata(toolConfig, mode = currentRunnerMode(), concurr
   };
 }
 function runnerMachineId() {
-  return createHash8("sha256").update(`${os8.hostname()}:${os8.platform()}:${os8.arch()}`).digest("hex").slice(0, 20);
+  return createHash9("sha256").update(`${os8.hostname()}:${os8.platform()}:${os8.arch()}`).digest("hex").slice(0, 20);
 }
 async function delay(milliseconds) {
   await new Promise((resolve) => setTimeout(resolve, milliseconds));
@@ -11919,4 +13449,3 @@ program.parseAsync().catch((error) => {
   console.error(error instanceof Error ? error.message : String(error));
   process.exitCode = 1;
 });
-//# sourceMappingURL=index.js.map