@haven_ai/connect 0.1.1-alpha → 0.1.3-alpha

package/dist/cli.js

@@ -4,9 +4,10 @@ import { Wallet } from 'ethers';
 import { mkdir, rm, chmod, access, writeFile, readFile } from 'fs/promises';
 import { homedir, platform } from 'os';
 import { join, resolve, dirname } from 'path';
-import { execFile } from 'child_process';
+import { execFile, spawn } from 'child_process';
 import { promisify } from 'util';
-import { ensureSignerConsent, computeSignerConsentHash, SIGNER_VERSION, loadSignerCredentials, createEdgeSigner, toolSchemas } from '@haven_ai/signer';
+import { MCP_VERSION, ensureConsent, computeConsentHash, loadCredentials, consentInputFromClient, registeredToolNames } from '@haven_ai/mcp';
+import { ensureSignerConsent, computeSignerConsentHash, loadSignerCredentials, createEdgeSigner, toolSchemas } from '@haven_ai/signer';
 
 // src/api.ts
 function createConnectApiClient(baseUrl, fetchImpl = fetch) {
@@ -45,10 +46,13 @@ function createConnectApiClient(baseUrl, fetchImpl = fetch) {
         body: JSON.stringify({
           runtime: input.runtime,
           connector_version: input.connectorVersion,
+          runtime_mcp_mode: input.runtimeMcpMode,
           hosted_mcp_configured: input.hostedMcpConfigured,
           local_signer_configured: input.localSignerConfigured,
+          local_mcp_configured: input.localMcpConfigured,
           credential_files_written: input.credentialFilesWritten,
           signer_acknowledged: input.signerAcknowledged,
+          local_mcp_acknowledged: input.localMcpAcknowledged,
           activation_command_available: input.activationCommandAvailable,
           probe_result: input.probeResult,
           restart_required: input.restartRequired,
@@ -131,6 +135,7 @@ async function writeCredentialFiles(input) {
     signerPath,
     {
       delegate_key: input.delegateKey,
+      delegate_address: input.delegateAddress,
       agent_id: input.agentId,
       safe_address: input.safeAddress,
       chain_id: input.chainId,
@@ -150,6 +155,7 @@ async function writeCredentialFiles(input) {
         network: input.network,
         api_url: input.apiUrl,
         hosted_mcp_url: input.hostedMcpUrl,
+        agent_budget: input.agentBudget,
         note: "Haven API key identifies the agent only. It cannot spend without the local signer key and on-chain Haven wallet rules."
       },
       input.warn
@@ -196,9 +202,50 @@ async function restrictPermissions(path, mode, warn) {
     );
   }
 }
+var MCP_RUNTIME_MANIFEST = {
+  mcpPackage: "@haven_ai/mcp",
+  mcpVersion: MCP_VERSION,
+  sdkPackage: "@haven_ai/sdk",
+  sdkVersion: "0.1.6",
+  signerPackage: "@haven_ai/signer",
+  signerVersion: "0.1.0-alpha",
+  minimumNodeVersion: "20.0.0",
+  supportedClients: ["codex-cli", "codex-desktop", "claude-code"],
+  requiredTools: [
+    "haven_quote_x402",
+    "haven_pay_x402_quote",
+    "haven_resume_x402_payment",
+    "haven_quote_mpp",
+    "haven_pay_mpp_challenge",
+    "haven_resume_mpp_payment",
+    "haven_get_payment_status",
+    "haven_get_resume_state",
+    "haven_get_agent",
+    "haven_get_allowances",
+    "haven_list_receipts"
+  ]
+};
+function mcpPackageSpec() {
+  return `${MCP_RUNTIME_MANIFEST.mcpPackage}@${MCP_RUNTIME_MANIFEST.mcpVersion}`;
+}
+function sdkPackageSpec() {
+  return `${MCP_RUNTIME_MANIFEST.sdkPackage}@${MCP_RUNTIME_MANIFEST.sdkVersion}`;
+}
+function signerPackageSpec() {
+  return `${MCP_RUNTIME_MANIFEST.signerPackage}@${MCP_RUNTIME_MANIFEST.signerVersion}`;
+}
+
+// src/config-writers.ts
+var InvalidCodexTomlError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidCodexTomlError";
+  }
+};
 async function writeRuntimeConfig(input) {
   switch (input.runtime) {
     case "codex-cli":
+    case "codex-desktop":
       return writeCodexConfig(input);
     case "cursor":
       return writeJsonRuntimeConfig(input, cursorConfigPath(input.homeDir), "mcpServers");
@@ -210,6 +257,8 @@ async function writeRuntimeConfig(input) {
       return {
         hostedConfigured: false,
         signerConfigured: false,
+        localMcpConfigured: false,
+        runtimeMcpMode: "manual",
         target: "manual runtime setup",
         changed: false,
         restartRequired: true,
@@ -251,22 +300,21 @@ function mergeJsonMcpConfig(existingJson, serverRoot, hostedServer, signerServer
   return `${JSON.stringify(config, null, 2)}
 `;
 }
-function mergeCodexToml(existingToml, hostedMcpUrl, signerPath) {
-  let next = removeTomlTable(removeTomlTable(existingToml, "mcp_servers.haven"), "mcp_servers.haven_signer");
+function mergeCodexToml(existingToml, localMcpCommand) {
+  let next = removeTomlTableTree(removeTomlTableTree(existingToml, "mcp_servers.haven"), "mcp_servers.haven_signer");
   next = next.trimEnd();
   const block = [
     "[mcp_servers.haven]",
-    `url = ${tomlString(hostedMcpUrl)}`,
-    'bearer_token_env_var = "HAVEN_TOKEN"',
-    "",
-    "[mcp_servers.haven_signer]",
-    'command = "npx"',
-    `args = ["-y", ${tomlString(signerPackageName())}, "--credentials", ${tomlString(signerPath)}]`
+    `command = ${tomlString(localMcpCommand)}`,
+    "args = []",
+    "startup_timeout_sec = 120"
   ].join("\n");
-  return `${next ? `${next}
+  validateCodexToml(block, "Generated Codex Haven config");
+  const merged = `${next ? `${next}
 
 ` : ""}${block}
 `;
+  return merged;
 }
 async function writeJsonRuntimeConfig(input, target, serverRoot) {
   try {
@@ -281,6 +329,8 @@ async function writeJsonRuntimeConfig(input, target, serverRoot) {
     return {
       hostedConfigured: true,
       signerConfigured: true,
+      localMcpConfigured: false,
+      runtimeMcpMode: "hosted_plus_signer",
       target: configTargetLabel(input.runtime),
       changed: existing !== merged,
       restartRequired: input.runtime === "claude-desktop",
@@ -290,6 +340,8 @@ async function writeJsonRuntimeConfig(input, target, serverRoot) {
     return {
       hostedConfigured: false,
       signerConfigured: false,
+      localMcpConfigured: false,
+      runtimeMcpMode: "hosted_plus_signer",
       target: configTargetLabel(input.runtime),
       changed: false,
       restartRequired: true,
@@ -300,46 +352,38 @@ async function writeJsonRuntimeConfig(input, target, serverRoot) {
 }
 async function writeCodexConfig(input) {
   const target = codexConfigPath(input.homeDir);
-  const envTarget = join(input.credentialDirectory, "identity.env");
-  const launchTarget = join(input.credentialDirectory, "start-codex.sh");
   try {
     const existing = await readOptional(target);
-    const merged = mergeCodexToml(existing ?? "", input.hostedMcpUrl, input.signerPath);
+    if (!input.localMcpCommand) {
+      throw new Error("local MCP wrapper command is required");
+    }
+    const merged = mergeCodexToml(existing ?? "", input.localMcpCommand);
     await writeOwnerOnlyText(target, merged);
-    await writeOwnerOnlyText(envTarget, `export HAVEN_TOKEN=${shellToken(input.apiKey)}
-`);
-    await writeOwnerExecutableText(
-      launchTarget,
-      [
-        "#!/bin/sh",
-        "set -eu",
-        `. ${shellToken(envTarget)}`,
-        'exec codex "$@"',
-        ""
-      ].join("\n")
-    );
     return {
-      hostedConfigured: true,
+      hostedConfigured: false,
       signerConfigured: true,
-      target: "Codex CLI config",
+      localMcpConfigured: true,
+      runtimeMcpMode: "local_stdio",
+      target: configTargetLabel(input.runtime),
       changed: existing !== merged,
       restartRequired: true,
-      activationCommand: shellToken(launchTarget),
       messages: [
-        "Updated Haven MCP entries in Codex CLI config.",
-        "Wrote the hosted MCP token to a private env file.",
-        `Restart Codex with: ${shellToken(launchTarget)}`
+        `Updated local Haven MCP entry in ${configTargetLabel(input.runtime)}.`,
+        "After Haven approval, restart Codex normally so it can load Haven tools."
       ]
     };
   } catch (err) {
+    const invalidToml = err instanceof InvalidCodexTomlError;
     return {
       hostedConfigured: false,
       signerConfigured: false,
-      target: "Codex CLI config",
+      localMcpConfigured: false,
+      runtimeMcpMode: "local_stdio",
+      target: configTargetLabel(input.runtime),
       changed: false,
       restartRequired: true,
-      messages: [`Could not update Codex CLI config: ${err instanceof Error ? err.message : String(err)}`],
-      errorCode: "runtime_config_write_failed"
+      messages: [`Could not update ${configTargetLabel(input.runtime)}: ${err instanceof Error ? err.message : String(err)}`],
+      errorCode: invalidToml ? "codex_config_invalid" : "runtime_config_write_failed"
     };
   }
 }
@@ -356,11 +400,6 @@ async function writeOwnerOnlyText(path, value) {
   await writeFile(path, value, { mode: 384 });
   await chmod(path, 384).catch(() => void 0);
 }
-async function writeOwnerExecutableText(path, value) {
-  await mkdir(dirname(path), { recursive: true, mode: 448 });
-  await writeFile(path, value, { mode: 448 });
-  await chmod(path, 448).catch(() => void 0);
-}
 function parseJsonObject(value) {
   const parsed = JSON.parse(value);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
@@ -368,30 +407,194 @@ function parseJsonObject(value) {
   }
   return parsed;
 }
-function removeTomlTable(toml, table) {
+function removeTomlTableTree(toml, table) {
   const lines = toml.split(/\r?\n/);
-  const start = `[${table}]`;
   const kept = [];
   let skipping = false;
   for (const line of lines) {
     const trimmed = line.trim();
-    if (trimmed === start) {
-      skipping = true;
-      continue;
-    }
-    if (skipping && trimmed.startsWith("[") && trimmed.endsWith("]")) {
-      skipping = false;
+    const tableName = tomlTableName(trimmed);
+    if (tableName) {
+      skipping = tableName === table || tableName.startsWith(`${table}.`);
+      if (skipping) continue;
     }
     if (!skipping) kept.push(line);
   }
   return kept.join("\n");
 }
+function tomlTableName(line) {
+  if (line.startsWith("[[") && line.endsWith("]]")) return line.slice(2, -2).trim();
+  if (line.startsWith("[") && line.endsWith("]")) return line.slice(1, -1).trim();
+  return null;
+}
+function validateCodexToml(toml, label = "Codex config") {
+  const lines = toml.split(/\r?\n/);
+  let pendingValue = null;
+  for (let index = 0; index < lines.length; index += 1) {
+    const raw = lines[index];
+    const line = stripTomlComment(raw).trim();
+    if (!line) continue;
+    if (pendingValue) {
+      pendingValue.value = `${pendingValue.value}
+${line}`;
+      if (hasBalancedTomlContainers(pendingValue.value)) {
+        if (!isTomlValue(pendingValue.value)) {
+          throw new InvalidCodexTomlError(`${label} has invalid TOML near line ${pendingValue.line}.`);
+        }
+        pendingValue = null;
+      }
+      continue;
+    }
+    if (isTomlTable(line)) continue;
+    const equalsIndex = line.indexOf("=");
+    if (equalsIndex <= 0) {
+      throw new InvalidCodexTomlError(`${label} has invalid TOML near line ${index + 1}.`);
+    }
+    const key = line.slice(0, equalsIndex).trim();
+    const value = line.slice(equalsIndex + 1).trim();
+    if (!isTomlKey(key)) {
+      throw new InvalidCodexTomlError(`${label} has invalid TOML near line ${index + 1}.`);
+    }
+    if (startsTomlContainer(value) && !hasBalancedTomlContainers(value)) {
+      pendingValue = { value, line: index + 1 };
+      continue;
+    }
+    if (!isTomlValue(value)) {
+      throw new InvalidCodexTomlError(`${label} has invalid TOML near line ${index + 1}.`);
+    }
+  }
+  if (pendingValue) {
+    throw new InvalidCodexTomlError(`${label} has invalid TOML near line ${pendingValue.line}.`);
+  }
+}
+function isTomlTable(line) {
+  const table = tomlTableName(line);
+  return Boolean(table && splitTomlDottedKey(table).every(isTomlKeyPart));
+}
+function isTomlKey(value) {
+  return splitTomlDottedKey(value).every(isTomlKeyPart);
+}
+function splitTomlDottedKey(value) {
+  const parts = [];
+  let current = "";
+  let quote = null;
+  let escaped = false;
+  for (let i = 0; i < value.length; i += 1) {
+    const char = value[i];
+    if (quote) {
+      current += char;
+      if (quote === '"' && char === "\\" && !escaped) {
+        escaped = true;
+        continue;
+      }
+      if (char === quote && !escaped) quote = null;
+      escaped = false;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      current += char;
+      continue;
+    }
+    if (char === ".") {
+      parts.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  parts.push(current.trim());
+  return quote ? [] : parts;
+}
+function isTomlKeyPart(value) {
+  return isTomlBareKey(value) || isTomlQuotedString(value);
+}
+function isTomlBareKey(value) {
+  return /^[A-Za-z0-9_-]+$/.test(value);
+}
+function isTomlValue(value) {
+  if (!value) return false;
+  if (isTomlQuotedString(value)) return true;
+  if (/^(true|false)$/i.test(value)) return true;
+  if (/^[+-]?(?:inf|nan)$/i.test(value)) return true;
+  if (/^[+-]?(?:0|[1-9][0-9_]*)(?:\.[0-9_]+)?(?:[eE][+-]?[0-9_]+)?$/.test(value)) return true;
+  if (/^\d{4}-\d{2}-\d{2}(?:[Tt ][0-9:.+-Zz]+)?$/.test(value)) return true;
+  if (value.startsWith("[") && value.endsWith("]") || value.startsWith("{") && value.endsWith("}")) {
+    return hasBalancedTomlContainers(value);
+  }
+  return false;
+}
+function startsTomlContainer(value) {
+  return value.startsWith("[") || value.startsWith("{");
+}
+function isTomlQuotedString(value) {
+  if (value.startsWith('"""') || value.startsWith("'''")) {
+    const marker = value.slice(0, 3);
+    return value.length >= 6 && value.endsWith(marker);
+  }
+  if ((!value.startsWith('"') || !value.endsWith('"')) && (!value.startsWith("'") || !value.endsWith("'"))) {
+    return false;
+  }
+  return hasBalancedTomlContainers(value);
+}
+function stripTomlComment(value) {
+  let quote = null;
+  let escaped = false;
+  for (let i = 0; i < value.length; i += 1) {
+    const char = value[i];
+    if (quote) {
+      if (quote === '"' && char === "\\" && !escaped) {
+        escaped = true;
+        continue;
+      }
+      if (char === quote && !escaped) quote = null;
+      escaped = false;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char === "#") return value.slice(0, i);
+  }
+  return value;
+}
+function hasBalancedTomlContainers(value) {
+  const stack = [];
+  let quote = null;
+  let escaped = false;
+  for (let i = 0; i < value.length; i += 1) {
+    const char = value[i];
+    if (quote) {
+      if (quote === '"' && char === "\\" && !escaped) {
+        escaped = true;
+        continue;
+      }
+      if (char === quote && !escaped) quote = null;
+      escaped = false;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char === "[" || char === "{") {
+      stack.push(char);
+      continue;
+    }
+    if (char === "]") {
+      if (stack.pop() !== "[") return false;
+      continue;
+    }
+    if (char === "}") {
+      if (stack.pop() !== "{") return false;
+    }
+  }
+  return stack.length === 0 && quote === null;
+}
 function tomlString(value) {
   return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
 }
-function shellToken(value) {
-  return `'${value.replace(/'/g, `'\\''`)}'`;
-}
 function cursorConfigPath(homeDir = homedir()) {
   return resolve(homeDir, ".cursor", "mcp.json");
 }
@@ -416,6 +619,10 @@ function claudeDesktopConfigPath(homeDir = homedir()) {
 }
 function configTargetLabel(runtime) {
   switch (runtime) {
+    case "codex-cli":
+      return "Codex CLI config";
+    case "codex-desktop":
+      return "Codex Desktop config";
     case "cursor":
       return "Cursor MCP config";
     case "vscode":
@@ -427,7 +634,83 @@ function configTargetLabel(runtime) {
   }
 }
 function signerPackageName() {
-  return `@haven_ai/signer@${SIGNER_VERSION}`;
+  return signerPackageSpec();
+}
+async function acknowledgeLocalMcpConsent(identityPath, signerPath, log) {
+  try {
+    const input = await buildLocalMcpConsentInput(identityPath, signerPath);
+    const decision = await ensureConsent(input, {
+      credentialsPath: identityPath,
+      writeAck: true,
+      out: log ? { write: (chunk) => writeLogChunk(log, chunk) } : void 0
+    });
+    return {
+      acknowledged: decision.ok,
+      hash: decision.hash,
+      reason: decision.reason
+    };
+  } catch (err) {
+    return {
+      acknowledged: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function getLocalMcpConsentStatus(identityPath, signerPath) {
+  try {
+    const input = await buildLocalMcpConsentInput(identityPath, signerPath);
+    const hash = computeConsentHash(input);
+    const stored = await readLocalMcpAckFile(localMcpAckPath(identityPath));
+    if (stored === hash) {
+      return { acknowledged: true, hash, reason: "ack_file_match" };
+    }
+    return {
+      acknowledged: false,
+      hash,
+      reason: stored ? "ack_file_mismatch" : "ack_file_missing"
+    };
+  } catch (err) {
+    return {
+      acknowledged: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function localMcpAckPath(identityPath) {
+  return resolve(`${identityPath}.ack.json`);
+}
+async function buildLocalMcpConsentInput(identityPath, signerPath) {
+  const credentials = await loadCredentials({ identityPath, signerPath });
+  const unavailableDuringSetup = {
+    getAllowances: async () => {
+      throw new Error("Haven approval is not complete yet.");
+    }
+  };
+  return consentInputFromClient(
+    unavailableDuringSetup,
+    {
+      apiKey: credentials.apiKey,
+      apiUrl: credentials.apiUrl,
+      agentId: credentials.agentId,
+      safeAddress: credentials.safeAddress,
+      delegateAddress: credentials.delegateAddress,
+      chainId: credentials.chainId,
+      allowanceSummary: credentials.allowanceSummary
+    },
+    registeredToolNames()
+  );
+}
+async function readLocalMcpAckFile(path) {
+  try {
+    const parsed = JSON.parse(await readFile(path, "utf8"));
+    return typeof parsed.ack === "string" ? parsed.ack : null;
+  } catch {
+    return null;
+  }
+}
+function writeLogChunk(log, chunk) {
+  const message = String(chunk).trimEnd();
+  if (message) log(message);
 }
 async function probeHostedMcpTools(apiKey, hostedMcpUrl, fetchImpl = fetch) {
   let response;
@@ -465,6 +748,72 @@ async function probeLocalSignerCredential(signerPath) {
     return false;
   }
 }
+async function probeLocalMcpTools(command, args, requiredTools, timeoutMs = 1e4) {
+  return new Promise((resolve6) => {
+    const child = spawn(command, args, { stdio: ["pipe", "pipe", "ignore"] });
+    let stdout = "";
+    let settled = false;
+    let sawInitialize = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      child.kill();
+      resolve6(result);
+    };
+    const timeout = setTimeout(() => finish({ status: "timeout" }), timeoutMs);
+    child.on("error", () => finish({ status: "process_error" }));
+    child.on("exit", (code) => {
+      if (!settled && code !== 0) finish({ status: "process_error" });
+    });
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+      const lines = stdout.split(/\r?\n/);
+      stdout = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        let payload;
+        try {
+          payload = JSON.parse(trimmed);
+        } catch {
+          continue;
+        }
+        if (payload.error) {
+          finish({ status: "bad_response" });
+          return;
+        }
+        if (payload.id === 1 && !sawInitialize) {
+          sawInitialize = true;
+          writeJsonRpc(child, { jsonrpc: "2.0", method: "notifications/initialized", params: {} });
+          writeJsonRpc(child, { jsonrpc: "2.0", id: 2, method: "tools/list", params: {} });
+          continue;
+        }
+        if (payload.id === 2) {
+          const tools = payload.result?.tools;
+          const toolNames = Array.isArray(tools) ? tools.map((tool) => tool && typeof tool === "object" && "name" in tool ? tool.name : void 0).filter((name) => typeof name === "string") : [];
+          const missing = requiredTools.filter((name) => !toolNames.includes(name));
+          finish({ status: missing.length === 0 ? "ok" : "missing_tools", toolNames });
+          return;
+        }
+      }
+    });
+    writeJsonRpc(child, {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "initialize",
+      params: {
+        protocolVersion: "2025-06-18",
+        capabilities: {},
+        clientInfo: { name: "haven-connect-probe", version: "0.0.0" }
+      }
+    });
+  });
+}
+function writeJsonRpc(child, payload) {
+  child.stdin?.write(`${JSON.stringify(payload)}
+`);
+}
 function parseJsonRpcPayload(raw) {
   const trimmed = raw.trim();
   if (!trimmed) return null;
@@ -493,6 +842,161 @@ async function fetchWithTimeout(fetchImpl, url, init) {
     clearTimeout(timeout);
   }
 }
+var execFileAsync = promisify(execFile);
+var UnsupportedNodeVersionError = class extends Error {
+  code = "local_mcp_unsupported_node_version";
+  constructor(nodeVersion, minimumNodeVersion) {
+    super(`Node.js ${nodeVersion} is not supported. Haven local MCP requires Node.js >=${minimumNodeVersion}.`);
+    this.name = "UnsupportedNodeVersionError";
+  }
+};
+async function prepareLocalMcpRuntime(input, deps = {}) {
+  assertSupportedNodeVersion(input.nodeVersion);
+  const homeDir = input.homeDir ?? homedir();
+  const runtimeDirectory = resolve(homeDir, ".haven", "mcp-runtime", MCP_RUNTIME_MANIFEST.mcpVersion);
+  const npmCacheDirectory = resolve(homeDir, ".haven", "npm-cache");
+  const cliPath = join(runtimeDirectory, "node_modules", "@haven_ai", "mcp", "dist", "cli.js");
+  const messages = [];
+  await mkdir(runtimeDirectory, { recursive: true, mode: 448 });
+  await chmod(runtimeDirectory, 448).catch(() => void 0);
+  await mkdir(npmCacheDirectory, { recursive: true, mode: 448 });
+  await chmod(npmCacheDirectory, 448).catch(() => void 0);
+  if (await installedRuntimeMatches(runtimeDirectory, cliPath)) {
+    messages.push(`Using existing local Haven MCP runtime ${mcpPackageSpec()}.`);
+  } else {
+    await installRuntimePackages(runtimeDirectory, npmCacheDirectory, deps.runCommand);
+    messages.push(`Installed local Haven MCP runtime ${mcpPackageSpec()}.`);
+  }
+  await assertFileExists(cliPath, "local Haven MCP CLI");
+  const wrapperPath = join(input.credentialDirectory, "bin", "haven-mcp");
+  await writeWrapper({
+    wrapperPath,
+    cliPath,
+    identityPath: input.identityPath,
+    signerPath: input.signerPath
+  });
+  await writeRuntimeSidecar({
+    path: join(input.credentialDirectory, "mcp-runtime.json"),
+    wrapperPath,
+    runtimeDirectory,
+    npmCacheDirectory,
+    cliPath
+  });
+  messages.push(`Prepared stable local Haven MCP wrapper: ${wrapperPath}`);
+  return {
+    command: wrapperPath,
+    args: [],
+    wrapperPath,
+    runtimeDirectory,
+    npmCacheDirectory,
+    cliPath,
+    messages
+  };
+}
+function assertSupportedNodeVersion(nodeVersion = process.versions.node, minimumNodeVersion = MCP_RUNTIME_MANIFEST.minimumNodeVersion) {
+  if (compareNodeVersions(nodeVersion, minimumNodeVersion) < 0) {
+    throw new UnsupportedNodeVersionError(nodeVersion, minimumNodeVersion);
+  }
+}
+function compareNodeVersions(left, right) {
+  const leftParts = parseNodeVersion(left);
+  const rightParts = parseNodeVersion(right);
+  for (let i = 0; i < 3; i += 1) {
+    if (leftParts[i] !== rightParts[i]) return leftParts[i] > rightParts[i] ? 1 : -1;
+  }
+  return 0;
+}
+function parseNodeVersion(value) {
+  const match = value.trim().match(/^v?(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+  if (!match) return [0, 0, 0];
+  return [
+    Number(match[1] ?? 0),
+    Number(match[2] ?? 0),
+    Number(match[3] ?? 0)
+  ];
+}
+async function installRuntimePackages(runtimeDirectory, npmCacheDirectory, runCommand) {
+  const args = [
+    "install",
+    "--prefix",
+    runtimeDirectory,
+    "--cache",
+    npmCacheDirectory,
+    "--no-audit",
+    "--no-fund",
+    "--omit=dev",
+    mcpPackageSpec(),
+    sdkPackageSpec()
+  ];
+  try {
+    if (runCommand) await runCommand("npm", args);
+    else await execFileAsync("npm", args, { timeout: 12e4, maxBuffer: 1024 * 1024 });
+  } catch (err) {
+    throw new Error(`Could not install local Haven MCP runtime ${mcpPackageSpec()}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function installedRuntimeMatches(runtimeDirectory, cliPath) {
+  try {
+    await assertFileExists(cliPath, "local Haven MCP CLI");
+    const [mcpPackage, sdkPackage] = await Promise.all([
+      readPackageJson(join(runtimeDirectory, "node_modules", "@haven_ai", "mcp", "package.json")),
+      readPackageJson(join(runtimeDirectory, "node_modules", "@haven_ai", "sdk", "package.json"))
+    ]);
+    return mcpPackage.version === MCP_RUNTIME_MANIFEST.mcpVersion && sdkPackage.version === MCP_RUNTIME_MANIFEST.sdkVersion;
+  } catch {
+    return false;
+  }
+}
+async function readPackageJson(path) {
+  return JSON.parse(await readFile(path, "utf8"));
+}
+async function writeWrapper(input) {
+  await mkdir(dirname(input.wrapperPath), { recursive: true, mode: 448 });
+  await chmod(dirname(input.wrapperPath), 448).catch(() => void 0);
+  const source = [
+    "#!/usr/bin/env node",
+    "import { spawn } from 'node:child_process'",
+    "",
+    `const cliPath = ${JSON.stringify(input.cliPath)}`,
+    `const identityPath = ${JSON.stringify(input.identityPath)}`,
+    `const signerPath = ${JSON.stringify(input.signerPath)}`,
+    "",
+    "const child = spawn(process.execPath, [cliPath, '--identity', identityPath, '--signer', signerPath, ...process.argv.slice(2)], {",
+    "  stdio: 'inherit',",
+    "})",
+    "",
+    "child.on('exit', (code, signal) => {",
+    "  if (signal) process.kill(process.pid, signal)",
+    "  else process.exit(code ?? 1)",
+    "})",
+    ""
+  ].join("\n");
+  await writeFile(input.wrapperPath, source, { mode: 448 });
+  await chmod(input.wrapperPath, 448).catch(() => void 0);
+}
+async function writeRuntimeSidecar(input) {
+  const value = {
+    mcp_package: MCP_RUNTIME_MANIFEST.mcpPackage,
+    mcp_version: MCP_RUNTIME_MANIFEST.mcpVersion,
+    sdk_package: MCP_RUNTIME_MANIFEST.sdkPackage,
+    sdk_version: MCP_RUNTIME_MANIFEST.sdkVersion,
+    minimum_node_version: MCP_RUNTIME_MANIFEST.minimumNodeVersion,
+    wrapper_path: input.wrapperPath,
+    runtime_directory: input.runtimeDirectory,
+    npm_cache_directory: input.npmCacheDirectory,
+    cli_path: input.cliPath
+  };
+  await writeFile(input.path, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+  await chmod(input.path, 384).catch(() => void 0);
+}
+async function assertFileExists(path, label) {
+  try {
+    await access(path);
+  } catch {
+    throw new Error(`Missing ${label}: ${path}`);
+  }
+}
 
 // src/runtime-registry.ts
 var RUNTIME_PROFILES = {
@@ -508,6 +1012,12 @@ var RUNTIME_PROFILES = {
     restartMode: "restart-session",
     canWriteRuntimeConfig: true
   },
+  "codex-desktop": {
+    id: "codex-desktop",
+    label: "Codex Desktop",
+    restartMode: "restart-session",
+    canWriteRuntimeConfig: true
+  },
   cursor: {
     id: "cursor",
     label: "Cursor",
@@ -542,6 +1052,12 @@ var RUNTIME_ALIASES = {
   "codex-cli": "codex-cli",
   codexcli: "codex-cli",
   "codex_cli": "codex-cli",
+  "codex-desktop": "codex-desktop",
+  "codex_desktop": "codex-desktop",
+  codexdesktop: "codex-desktop",
+  "codex-app": "codex-desktop",
+  "codex_app": "codex-desktop",
+  codexapp: "codex-desktop",
   cursor: "cursor",
   vscode: "vscode",
   "vs-code": "vscode",
@@ -583,7 +1099,7 @@ async function acknowledgeLocalSignerConsent(signerPath, log) {
     const decision = await ensureSignerConsent(input, {
       credentialsPath: signerPath,
       writeAck: true,
-      out: log ? { write: (chunk) => writeLogChunk(log, chunk) } : void 0
+      out: log ? { write: (chunk) => writeLogChunk2(log, chunk) } : void 0
     });
     return {
       acknowledged: decision.ok,
@@ -642,65 +1158,110 @@ async function readSignerAckFile(path) {
     return null;
   }
 }
-function writeLogChunk(log, chunk) {
+function writeLogChunk2(log, chunk) {
   const message = String(chunk).trimEnd();
   if (message) log(message);
 }
 
 // src/runtime-install.ts
-var execFileAsync = promisify(execFile);
+var execFileAsync2 = promisify(execFile);
 async function installRuntime(input, deps = {}) {
   const runtime = normalizeRuntime(input.runtime, deps.env);
   const profile = runtimeProfile(runtime, deps.env);
-  const signerConsentMessages = [];
-  const signerConsent = await resolveSignerConsent(input, signerConsentMessages);
+  const localRuntime = usesLocalMcp(runtime);
+  const consentMessages = [];
+  const localMcpConsent = localRuntime ? await resolveLocalMcpConsent(input, consentMessages) : void 0;
+  const signerConsent = localRuntime ? void 0 : await resolveSignerConsent(input, consentMessages);
   if (runtime === "other") {
     const signerCredentialReady2 = await probeLocalSignerCredential(input.signerPath);
-    const signerReady = signerCredentialReady2 && signerConsent.acknowledged;
+    const signerReady = signerCredentialReady2 && signerConsent?.acknowledged;
     return {
       runtime,
+      runtimeMcpMode: "manual",
       hostedMcpConfigured: false,
       localSignerConfigured: false,
+      localMcpConfigured: false,
       probeResult: signerReady ? "manual_runtime_setup_required_local_signer_ready" : "manual_runtime_setup_required_local_signer_unavailable",
       restartRequired: true,
       nextUserAction: "return_to_haven_for_wallet_approval_then_configure_runtime",
       errorCode: "manual_runtime_setup_required",
       configTarget: "manual runtime setup",
-      signerAcknowledged: signerConsent.acknowledged,
+      signerAcknowledged: signerConsent?.acknowledged,
+      localMcpAcknowledged: false,
       messages: [
-        ...signerConsentMessages,
+        ...consentMessages,
         "Runtime was not recognized. Keep the local credentials and add Haven MCP entries manually after wallet approval."
       ]
     };
   }
-  const configResult = runtime === "claude-code" ? await configureClaudeCode(input, deps) : await writeRuntimeConfig({
+  let localRuntimeInstall;
+  let localRuntimeError;
+  if (localRuntime) {
+    try {
+      localRuntimeInstall = await prepareRuntimeForLocalMcp(input, deps);
+    } catch (err) {
+      localRuntimeError = err;
+    }
+  }
+  if (localRuntimeError) {
+    const errorCode2 = localRuntimePrepareErrorCode(localRuntimeError);
+    return {
+      runtime,
+      runtimeMcpMode: "local_stdio",
+      hostedMcpConfigured: false,
+      localSignerConfigured: false,
+      localMcpConfigured: false,
+      probeResult: errorCode2 === "local_mcp_unsupported_node_version" ? "local_stdio_mcp_unsupported_node_version" : "local_stdio_mcp_runtime_install_failed",
+      restartRequired: true,
+      nextUserAction: nextAction(runtime, profile.restartMode, errorCode2),
+      errorCode: errorCode2,
+      configTarget: profile.label,
+      signerAcknowledged: signerConsent?.acknowledged,
+      localMcpAcknowledged: localMcpConsent?.acknowledged,
+      activationCommand: void 0,
+      messages: [
+        ...consentMessages,
+        `Could not prepare local Haven MCP runtime: ${localRuntimeError instanceof Error ? localRuntimeError.message : String(localRuntimeError)}`
+      ]
+    };
+  }
+  const configResult = runtime === "claude-code" ? await configureClaudeCode(deps, localRuntimeInstall?.command ?? "") : await writeRuntimeConfig({
     runtime,
     hostedMcpUrl: input.hostedMcpUrl,
     apiKey: input.apiKey,
+    identityPath: input.identityPath,
     signerPath: input.signerPath,
     credentialDirectory: input.credentialDirectory,
+    localMcpCommand: localRuntimeInstall?.command,
     homeDir: deps.homeDir
   });
-  const [hostedProbe, signerCredentialReady] = await Promise.all([
+  const localProbePromise = configResult.runtimeMcpMode === "local_stdio" && localRuntimeInstall ? runLocalMcpProbe(localRuntimeInstall, deps) : Promise.resolve(void 0);
+  const [hostedProbe, signerCredentialReady, localMcpProbe] = await Promise.all([
     configResult.hostedConfigured ? probeHostedMcpTools(input.apiKey, input.hostedMcpUrl, deps.fetch) : Promise.resolve({ status: "bad_response" }),
-    probeLocalSignerCredential(input.signerPath)
+    probeLocalSignerCredential(input.signerPath),
+    localProbePromise
   ]);
   const hostedOk = configResult.hostedConfigured && hostedProbe.status !== "unauthorized";
-  const signerOk = configResult.signerConfigured && signerCredentialReady && signerConsent.acknowledged;
+  const localMcpOk = configResult.runtimeMcpMode === "local_stdio" && configResult.localMcpConfigured && signerCredentialReady && Boolean(localMcpConsent?.acknowledged) && localMcpProbe?.status === "ok";
+  const signerOk = configResult.runtimeMcpMode === "local_stdio" ? localMcpOk : configResult.signerConfigured && signerCredentialReady && Boolean(signerConsent?.acknowledged);
   const restartRequired = configResult.restartRequired || restartRequiredForRuntime(runtime, deps.env);
-  const errorCode = configResult.errorCode ?? signerConsentErrorCode(signerCredentialReady, signerConsent);
+  const errorCode = configResult.errorCode ?? (configResult.runtimeMcpMode === "local_stdio" ? localMcpErrorCode(signerCredentialReady, localMcpConsent, localMcpProbe?.status) : signerConsentErrorCode(signerCredentialReady, signerConsent));
+  const localProbeMessages = localMcpProbe && localMcpProbe.status !== "ok" ? [`Local Haven MCP handshake failed: ${localMcpProbe.status}.`] : localMcpProbe?.status === "ok" ? ["Verified local Haven MCP tools with a stdio handshake."] : [];
   return {
     runtime,
+    runtimeMcpMode: configResult.runtimeMcpMode,
     hostedMcpConfigured: hostedOk,
     localSignerConfigured: signerOk,
-    probeResult: buildProbeResult(configResult.hostedConfigured, hostedProbe.status, signerOk),
+    localMcpConfigured: localMcpOk,
+    probeResult: buildProbeResult(configResult.runtimeMcpMode, configResult.hostedConfigured, hostedProbe.status, signerOk, localMcpOk, localMcpProbe?.status),
     restartRequired,
     nextUserAction: nextAction(runtime, profile.restartMode, errorCode),
     errorCode,
     configTarget: configResult.target,
-    signerAcknowledged: signerConsent.acknowledged,
+    signerAcknowledged: signerConsent?.acknowledged,
+    localMcpAcknowledged: localMcpConsent?.acknowledged,
     activationCommand: configResult.activationCommand,
-    messages: [...signerConsentMessages, ...configResult.messages]
+    messages: [...consentMessages, ...localRuntimeInstall?.messages ?? [], ...configResult.messages, ...localProbeMessages]
   };
 }
 function runtimeInstallCapabilities(runtime, env = process.env) {
@@ -710,45 +1271,41 @@ function runtimeInstallCapabilities(runtime, env = process.env) {
     restartRequired: restartRequiredForRuntime(runtime, env)
   };
 }
-async function configureClaudeCode(input, deps) {
+async function configureClaudeCode(deps, localMcpCommand) {
   const runCommand = deps.runCommand ?? defaultRunCommand;
+  const serverJson = JSON.stringify({
+    type: "stdio",
+    command: localMcpCommand,
+    args: [],
+    env: {}
+  });
   try {
-    await runCommand("claude", [
-      "mcp",
-      "add",
-      "--transport",
-      "http",
-      "haven",
-      input.hostedMcpUrl,
-      "--header",
-      `Authorization: Bearer ${input.apiKey}`
-    ]);
-    await runCommand("claude", [
-      "mcp",
-      "add",
-      "haven-signer",
-      "--",
-      "npx",
-      "-y",
-      signerPackageName2(),
-      "--credentials",
-      input.signerPath
-    ]);
+    if (!localMcpCommand) throw new Error("local MCP wrapper command is required");
+    await runCommand("claude", ["mcp", "add-json", "haven", serverJson, "--scope", "user"]).catch(async () => {
+      await runCommand("claude", ["mcp", "add", "haven", "--scope", "user", "--", localMcpCommand]);
+    });
+    await runCommand("claude", ["mcp", "remove", "haven-signer"]).catch(() => void 0);
+    const verified = await runCommand("claude", ["mcp", "get", "haven"]).then(() => true).catch(() => false);
     return {
-      hostedConfigured: true,
+      hostedConfigured: false,
       signerConfigured: true,
+      localMcpConfigured: true,
+      runtimeMcpMode: "local_stdio",
       target: "Claude Code MCP config",
       changed: true,
       restartRequired: true,
       messages: [
-        "Updated Haven MCP entries with Claude Code.",
-        "Restart Claude Code after Haven approval so it can load the Haven tools."
+        "Updated local Haven MCP entry with Claude Code.",
+        ...verified ? ["Verified Claude Code MCP entry."] : [],
+        "After Haven approval, restart Claude Code normally so it can load Haven tools."
       ]
     };
   } catch (err) {
     return {
       hostedConfigured: false,
       signerConfigured: false,
+      localMcpConfigured: false,
+      runtimeMcpMode: "local_stdio",
       target: "Claude Code MCP config",
       changed: false,
       restartRequired: true,
@@ -761,15 +1318,31 @@ async function configureClaudeCode(input, deps) {
   }
 }
 async function defaultRunCommand(command, args) {
-  await execFileAsync(command, args, { timeout: 1e4 });
+  await execFileAsync2(command, args, { timeout: 1e4 });
 }
-function buildProbeResult(hostedConfigured, hostedStatus, signerReady) {
+function buildProbeResult(mode, hostedConfigured, hostedStatus, signerReady, localMcpReady, localMcpProbeStatus) {
+  if (mode === "local_stdio") {
+    if (localMcpReady) return "local_stdio_mcp_ready";
+    return localMcpProbeStatus ? `local_stdio_mcp_${localMcpProbeStatus}` : "local_stdio_mcp_unavailable";
+  }
   const hostedPart = hostedConfigured ? `hosted_${hostedStatus}` : "hosted_not_configured";
   const signerPart = signerReady ? "local_signer_ready" : "local_signer_unavailable";
   return `${hostedPart}_${signerPart}`.slice(0, 120);
 }
+async function resolveLocalMcpConsent(input, messages) {
+  if (input.ackLocalTools || input.ackSigner) {
+    const status = await acknowledgeLocalMcpConsent(input.identityPath, input.signerPath, (message) => messages.push(message));
+    if (status.acknowledged) {
+      messages.push("Prepared the local Haven tools acknowledgement.");
+    } else {
+      messages.push("Local Haven tools acknowledgement still needs attention.");
+    }
+    return status;
+  }
+  return getLocalMcpConsentStatus(input.identityPath, input.signerPath);
+}
 async function resolveSignerConsent(input, messages) {
-  if (input.ackSigner) {
+  if (input.ackSigner || input.ackLocalTools) {
     const status = await acknowledgeLocalSignerConsent(input.signerPath, (message) => messages.push(message));
     if (status.acknowledged) {
       messages.push("Prepared the local Haven signer acknowledgement.");
@@ -782,24 +1355,53 @@ async function resolveSignerConsent(input, messages) {
 }
 function signerConsentErrorCode(signerCredentialReady, signerConsent) {
   if (!signerCredentialReady) return "local_signer_credential_unavailable";
-  if (!signerConsent.acknowledged) return "local_signer_ack_required";
+  if (!signerConsent?.acknowledged) return "local_signer_ack_required";
+  return void 0;
+}
+function localMcpErrorCode(signerCredentialReady, localMcpConsent, localMcpProbeStatus) {
+  if (!signerCredentialReady) return "local_signer_credential_unavailable";
+  if (!localMcpConsent?.acknowledged) return "local_mcp_ack_required";
+  if (localMcpProbeStatus && localMcpProbeStatus !== "ok") return `local_mcp_probe_${localMcpProbeStatus}`;
   return void 0;
 }
 function nextAction(runtime, restartMode, errorCode) {
   if (errorCode) return "return_to_haven_for_wallet_approval_then_finish_runtime_setup";
   if (restartMode === "hot-reload") return "return_to_haven_for_wallet_approval";
-  if (runtime === "codex-cli") return "return_to_haven_for_wallet_approval_then_restart_codex_with_haven_env";
+  if (runtime === "codex-cli" || runtime === "codex-desktop") return "return_to_haven_for_wallet_approval_then_restart_codex";
   if (runtime === "claude-code") return "return_to_haven_for_wallet_approval_then_restart_claude_code";
   if (restartMode === "restart-app") return "return_to_haven_for_wallet_approval_then_restart_app";
   if (restartMode === "restart-session") return "return_to_haven_for_wallet_approval_then_restart_agent_session";
   return "return_to_haven_for_wallet_approval_then_configure_runtime";
 }
-function signerPackageName2() {
-  return `@haven_ai/signer@${SIGNER_VERSION}`;
+function usesLocalMcp(runtime) {
+  return runtime === "codex-cli" || runtime === "codex-desktop" || runtime === "claude-code";
+}
+async function prepareRuntimeForLocalMcp(input, deps) {
+  const prepare = deps.prepareLocalMcpRuntime ?? ((runtimeInput) => prepareLocalMcpRuntime(runtimeInput, { runCommand: deps.runCommand }));
+  return prepare({
+    credentialDirectory: input.credentialDirectory,
+    identityPath: input.identityPath,
+    signerPath: input.signerPath,
+    homeDir: deps.homeDir
+  });
+}
+async function runLocalMcpProbe(runtimeInstall, deps) {
+  const probe = deps.probeLocalMcpTools ?? probeLocalMcpTools;
+  try {
+    return await probe(runtimeInstall.command, runtimeInstall.args, MCP_RUNTIME_MANIFEST.requiredTools);
+  } catch {
+    return { status: "process_error" };
+  }
+}
+function localRuntimePrepareErrorCode(err) {
+  if (err && typeof err === "object" && "code" in err && err.code === "local_mcp_unsupported_node_version") {
+    return "local_mcp_unsupported_node_version";
+  }
+  return "local_mcp_runtime_install_failed";
 }
 
 // src/runtime.ts
-var CONNECTOR_VERSION = "0.1.1-alpha";
+var CONNECTOR_VERSION = "0.1.2";
 async function runConnect(options, deps = {}) {
   const connectorVersion = options.connectorVersion ?? CONNECTOR_VERSION;
   const api = deps.api ?? createConnectApiClient(options.apiBaseUrl);
@@ -845,9 +1447,15 @@ async function runConnect(options, deps = {}) {
     agentId: registration.agent_id,
     apiKey: localApiKey,
     delegateKey: localKey.privateKey,
+    delegateAddress: localKey.address,
     safeAddress: setup.haven_wallet.address,
     chainId: setup.haven_wallet.chain_id,
     network: setup.haven_wallet.network,
+    agentBudget: setup.agent_budget.map((budget) => ({
+      token_symbol: budget.token_symbol,
+      allowance_amount: budget.allowance_amount,
+      reset_period_min: budget.reset_period_min
+    })),
     apiUrl: options.apiBaseUrl,
     hostedMcpUrl: registration.hosted_mcp_url,
     warn: log
@@ -862,17 +1470,21 @@ async function runConnect(options, deps = {}) {
     identityPath: credentialPaths.identityPath,
     credentialDirectory: credentialPaths.directory,
     environmentLabel: options.environmentLabel ?? "Local workspace",
-    ackSigner: options.ackSigner
+    ackSigner: options.ackSigner,
+    ackLocalTools: options.ackLocalTools
   });
   printRuntimeInstall(runtimeInstall, log);
   try {
     await api.updateInstallStatus(registration.setup_id, localApiKey, {
       runtime: runtimeInstall.runtime,
       connectorVersion,
+      runtimeMcpMode: runtimeInstall.runtimeMcpMode,
       hostedMcpConfigured: runtimeInstall.hostedMcpConfigured,
       localSignerConfigured: runtimeInstall.localSignerConfigured,
+      localMcpConfigured: runtimeInstall.localMcpConfigured,
       credentialFilesWritten: true,
       signerAcknowledged: runtimeInstall.signerAcknowledged,
+      localMcpAcknowledged: runtimeInstall.localMcpAcknowledged,
       activationCommandAvailable: Boolean(runtimeInstall.activationCommand),
       probeResult: runtimeInstall.probeResult,
       restartRequired: runtimeInstall.restartRequired,
@@ -885,7 +1497,7 @@ async function runConnect(options, deps = {}) {
   }
   log("Return to Haven to approve the agent rules.");
   if (runtimeInstall.restartRequired) {
-    log("Restart this agent session after approval if your runtime loads MCP tools at startup.");
+    log("After approval, restart this agent normally so it can load Haven tools.");
   }
   return {
     setupId: registration.setup_id,
@@ -911,10 +1523,12 @@ function secureLogger(log) {
 }
 function printRuntimeInstall(result, log) {
   for (const message of result.messages) log(message);
-  if (result.hostedMcpConfigured) {
+  if (result.localMcpConfigured) {
+    log("Configured local Haven MCP tools.");
+  } else if (result.hostedMcpConfigured) {
     log("Configured hosted Haven MCP identity.");
   } else {
-    log("Hosted Haven MCP identity still needs runtime setup.");
+    log("Haven MCP tools still need runtime setup.");
   }
   if (result.localSignerConfigured) {
     log("Configured local Haven signer.");
@@ -944,8 +1558,11 @@ function parseArgs(argv, env = process.env) {
       options.credentialsDir = requireValue(argv, ++i, arg);
     } else if (arg === "--environment-label") {
       options.environmentLabel = requireValue(argv, ++i, arg);
+    } else if (arg === "--ack-local-tools") {
+      options.ackLocalTools = true;
     } else if (arg === "--ack-signer") {
       options.ackSigner = true;
+      options.ackLocalTools = true;
     } else if (arg === "--version") {
       process.stdout.write(`${CONNECTOR_VERSION}
 `);
@@ -974,15 +1591,16 @@ function helpText() {
     "sends Haven only the public signing address plus a proof signature.",
     "",
     "Usage:",
-    "  npx -y @haven_ai/connect --setup hv_setup_... --api https://api.haven.example --ack-signer --runtime claude-code",
+    "  npx -y @haven_ai/connect --setup hv_setup_... --api https://api.haven.example --ack-local-tools --runtime claude-code",
     "",
     "Options:",
     "  --setup <token>            Short-lived setup token from Haven.",
     "  --api <url>                Haven backend API URL. Defaults to HAVEN_API_URL or http://localhost:3001.",
-    "  --runtime <name>           Agent runtime hint, such as claude-code, codex-cli, cursor, vscode, or claude-desktop.",
+    "  --runtime <name>           Agent runtime hint, such as claude-code, codex-cli, codex-desktop, cursor, vscode, or claude-desktop.",
     "  --credentials-dir <path>   Credential directory fallback. Defaults to ~/.haven/agents.",
     "  --environment-label <text> Non-sensitive label shown in Haven setup review.",
-    "  --ack-signer               Write the one-time local signer acknowledgement during setup.",
+    "  --ack-local-tools          Write the one-time local Haven tools acknowledgement during setup.",
+    "  --ack-signer               Backward-compatible alias for --ack-local-tools.",
     "  --help                     Show this help.",
     "",
     "The connector never prints the private key and never sends it to Haven."