@haven_ai/connect 0.1.0-alpha → 0.1.2-alpha

package/dist/cli.js

@@ -6,6 +6,8 @@ import { homedir, platform } from 'os';
 import { join, resolve, dirname } from 'path';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
+import { ensureConsent, computeConsentHash, MCP_VERSION, loadCredentials, consentInputFromClient, registeredToolNames } from '@haven_ai/mcp';
+import { ensureSignerConsent, computeSignerConsentHash, loadSignerCredentials, createEdgeSigner, toolSchemas, SIGNER_VERSION } from '@haven_ai/signer';
 
 // src/api.ts
 function createConnectApiClient(baseUrl, fetchImpl = fetch) {
@@ -44,9 +46,14 @@ 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,
           next_user_action: input.nextUserAction,
@@ -128,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,
@@ -147,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
@@ -207,6 +216,8 @@ async function writeRuntimeConfig(input) {
       return {
         hostedConfigured: false,
         signerConfigured: false,
+        localMcpConfigured: false,
+        runtimeMcpMode: "manual",
         target: "manual runtime setup",
         changed: false,
         restartRequired: true,
@@ -231,7 +242,7 @@ function buildHostedServer(hostedMcpUrl, apiKey, runtime) {
 function buildSignerServer(signerPath, runtime) {
   const server = {
     command: "npx",
-    args: ["-y", "@haven_ai/signer", "--credentials", signerPath]
+    args: ["-y", signerPackageName(), "--credentials", signerPath]
   };
   if (runtime === "vscode") return { type: "stdio", ...server };
   return server;
@@ -248,17 +259,13 @@ function mergeJsonMcpConfig(existingJson, serverRoot, hostedServer, signerServer
   return `${JSON.stringify(config, null, 2)}
 `;
 }
-function mergeCodexToml(existingToml, hostedMcpUrl, signerPath) {
+function mergeCodexToml(existingToml, identityPath, signerPath) {
   let next = removeTomlTable(removeTomlTable(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", "@haven_ai/signer", "--credentials", ${tomlString(signerPath)}]`
+    `args = ["-y", ${tomlString(localMcpPackageName())}, "--identity", ${tomlString(identityPath)}, "--signer", ${tomlString(signerPath)}]`
   ].join("\n");
   return `${next ? `${next}
 
@@ -278,6 +285,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",
@@ -287,6 +296,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,
@@ -297,29 +308,29 @@ async function writeJsonRuntimeConfig(input, target, serverRoot) {
 }
 async function writeCodexConfig(input) {
   const target = codexConfigPath(input.homeDir);
-  const envTarget = join(input.credentialDirectory, "identity.env");
   try {
     const existing = await readOptional(target);
-    const merged = mergeCodexToml(existing ?? "", input.hostedMcpUrl, input.signerPath);
+    const merged = mergeCodexToml(existing ?? "", input.identityPath, input.signerPath);
     await writeOwnerOnlyText(target, merged);
-    await writeOwnerOnlyText(envTarget, `HAVEN_TOKEN=${shellToken(input.apiKey)}
-`);
     return {
       hostedConfigured: false,
       signerConfigured: true,
+      localMcpConfigured: true,
+      runtimeMcpMode: "local_stdio",
       target: "Codex CLI config",
       changed: existing !== merged,
       restartRequired: true,
       messages: [
-        "Updated Haven MCP entries in Codex CLI config.",
-        "Wrote the hosted MCP token to a private env file. Launch Codex with that env file before using Haven tools."
-      ],
-      errorCode: "codex_env_activation_required"
+        "Updated local Haven MCP entry in Codex CLI config.",
+        "After Haven approval, restart Codex normally so it can load Haven tools."
+      ]
     };
   } catch (err) {
     return {
       hostedConfigured: false,
       signerConfigured: false,
+      localMcpConfigured: false,
+      runtimeMcpMode: "local_stdio",
       target: "Codex CLI config",
       changed: false,
       restartRequired: true,
@@ -369,9 +380,6 @@ function removeTomlTable(toml, table) {
 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");
 }
@@ -406,6 +414,88 @@ function configTargetLabel(runtime) {
       return "runtime MCP config";
   }
 }
+function signerPackageName() {
+  return `@haven_ai/signer@${SIGNER_VERSION}`;
+}
+function localMcpPackageName() {
+  return `@haven_ai/mcp@${MCP_VERSION}`;
+}
+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;
   try {
@@ -554,51 +644,140 @@ function detectRuntime(env) {
   if (env.VSCODE_CWD || env.VSCODE_IPC_HOOK_CLI || env.TERM_PROGRAM === "vscode") return "vscode";
   return null;
 }
+async function acknowledgeLocalSignerConsent(signerPath, log) {
+  try {
+    const input = await buildSignerConsentInput(signerPath);
+    const decision = await ensureSignerConsent(input, {
+      credentialsPath: signerPath,
+      writeAck: true,
+      out: log ? { write: (chunk) => writeLogChunk2(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 getLocalSignerConsentStatus(signerPath) {
+  try {
+    const input = await buildSignerConsentInput(signerPath);
+    const hash = computeSignerConsentHash(input);
+    const stored = await readSignerAckFile(signerAckPath(signerPath));
+    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 signerAckPath(signerPath) {
+  return resolve(`${signerPath}.signer-ack.json`);
+}
+async function buildSignerConsentInput(signerPath) {
+  const credentials = await loadSignerCredentials(signerPath);
+  const signer = createEdgeSigner(credentials.delegateKey, {
+    x402BindingSigner: credentials.x402BindingSigner
+  });
+  return {
+    delegateAddress: signer.delegateAddress,
+    safeAddress: credentials.safeAddress,
+    agentId: credentials.agentId,
+    chainId: credentials.chainId,
+    network: credentials.network,
+    toolNames: Object.keys(toolSchemas)
+  };
+}
+async function readSignerAckFile(path) {
+  try {
+    const parsed = JSON.parse(await readFile(path, "utf8"));
+    return typeof parsed.ack === "string" ? parsed.ack : null;
+  } catch {
+    return null;
+  }
+}
+function writeLogChunk2(log, chunk) {
+  const message = String(chunk).trimEnd();
+  if (message) log(message);
+}
 
 // src/runtime-install.ts
 var execFileAsync = promisify(execFile);
 async function installRuntime(input, deps = {}) {
   const runtime = normalizeRuntime(input.runtime, deps.env);
   const profile = runtimeProfile(runtime, deps.env);
+  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 signerReady2 = await probeLocalSignerCredential(input.signerPath);
+    const signerCredentialReady2 = await probeLocalSignerCredential(input.signerPath);
+    const signerReady = signerCredentialReady2 && signerConsent?.acknowledged;
     return {
       runtime,
+      runtimeMcpMode: "manual",
       hostedMcpConfigured: false,
       localSignerConfigured: false,
-      probeResult: signerReady2 ? "manual_runtime_setup_required_local_signer_ready" : "manual_runtime_setup_required_local_signer_unavailable",
+      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",
-      messages: ["Runtime was not recognized. Keep the local credentials and add Haven MCP entries manually after wallet approval."]
+      signerAcknowledged: signerConsent?.acknowledged,
+      localMcpAcknowledged: false,
+      messages: [
+        ...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({
     runtime,
     hostedMcpUrl: input.hostedMcpUrl,
     apiKey: input.apiKey,
+    identityPath: input.identityPath,
     signerPath: input.signerPath,
     credentialDirectory: input.credentialDirectory,
     homeDir: deps.homeDir
   });
-  const [hostedProbe, signerReady] = await Promise.all([
+  const [hostedProbe, signerCredentialReady] = await Promise.all([
     configResult.hostedConfigured ? probeHostedMcpTools(input.apiKey, input.hostedMcpUrl, deps.fetch) : Promise.resolve({ status: "bad_response" }),
     probeLocalSignerCredential(input.signerPath)
   ]);
   const hostedOk = configResult.hostedConfigured && hostedProbe.status !== "unauthorized";
-  const signerOk = configResult.signerConfigured && signerReady;
+  const localMcpOk = configResult.runtimeMcpMode === "local_stdio" && configResult.localMcpConfigured && signerCredentialReady && Boolean(localMcpConsent?.acknowledged);
+  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 ?? (configResult.runtimeMcpMode === "local_stdio" ? localMcpConsentErrorCode(signerCredentialReady, localMcpConsent) : signerConsentErrorCode(signerCredentialReady, signerConsent));
   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),
     restartRequired,
-    nextUserAction: nextAction(profile.restartMode, configResult.errorCode),
-    errorCode: configResult.errorCode,
+    nextUserAction: nextAction(runtime, profile.restartMode, errorCode),
+    errorCode,
     configTarget: configResult.target,
-    messages: configResult.messages
+    signerAcknowledged: signerConsent?.acknowledged,
+    localMcpAcknowledged: localMcpConsent?.acknowledged,
+    activationCommand: configResult.activationCommand,
+    messages: [...consentMessages, ...configResult.messages]
   };
 }
 function runtimeInstallCapabilities(runtime, env = process.env) {
@@ -614,39 +793,43 @@ async function configureClaudeCode(input, deps) {
     await runCommand("claude", [
       "mcp",
       "add",
-      "--transport",
-      "http",
       "haven",
-      input.hostedMcpUrl,
-      "--header",
-      `Authorization: Bearer ${input.apiKey}`
-    ]);
-    await runCommand("claude", [
-      "mcp",
-      "add",
-      "haven-signer",
+      "--",
       "npx",
       "-y",
-      "@haven_ai/signer",
-      "--credentials",
+      localMcpPackageName2(),
+      "--identity",
+      input.identityPath,
+      "--signer",
       input.signerPath
     ]);
+    await runCommand("claude", ["mcp", "remove", "haven-signer"]).catch(() => void 0);
     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."]
+      messages: [
+        "Updated local Haven MCP entry with Claude Code.",
+        "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,
-      messages: [`Could not update Claude Code MCP config: ${err instanceof Error ? err.message : String(err)}`],
+      messages: [
+        `Could not update Claude Code MCP config: ${err instanceof Error ? err.message : String(err)}`,
+        "Install Claude Code or rerun the Haven setup command inside a Claude Code terminal."
+      ],
       errorCode: "claude_code_config_failed"
     };
   }
@@ -654,21 +837,66 @@ async function configureClaudeCode(input, deps) {
 async function defaultRunCommand(command, args) {
   await execFileAsync(command, args, { timeout: 1e4 });
 }
-function buildProbeResult(hostedConfigured, hostedStatus, signerReady) {
+function buildProbeResult(mode, hostedConfigured, hostedStatus, signerReady, localMcpReady) {
+  if (mode === "local_stdio") {
+    return localMcpReady ? "local_stdio_mcp_ready" : "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);
 }
-function nextAction(restartMode, errorCode) {
+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 || input.ackLocalTools) {
+    const status = await acknowledgeLocalSignerConsent(input.signerPath, (message) => messages.push(message));
+    if (status.acknowledged) {
+      messages.push("Prepared the local Haven signer acknowledgement.");
+    } else {
+      messages.push("Local Haven signer acknowledgement still needs attention.");
+    }
+    return status;
+  }
+  return getLocalSignerConsentStatus(input.signerPath);
+}
+function signerConsentErrorCode(signerCredentialReady, signerConsent) {
+  if (!signerCredentialReady) return "local_signer_credential_unavailable";
+  if (!signerConsent?.acknowledged) return "local_signer_ack_required";
+  return void 0;
+}
+function localMcpConsentErrorCode(signerCredentialReady, localMcpConsent) {
+  if (!signerCredentialReady) return "local_signer_credential_unavailable";
+  if (!localMcpConsent?.acknowledged) return "local_mcp_ack_required";
+  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";
+  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 localMcpPackageName2() {
+  return `@haven_ai/mcp@${MCP_VERSION}`;
+}
+function usesLocalMcp(runtime) {
+  return runtime === "codex-cli" || runtime === "claude-code";
+}
 
 // src/runtime.ts
-var CONNECTOR_VERSION = "0.1.0";
+var CONNECTOR_VERSION = "0.1.2";
 async function runConnect(options, deps = {}) {
   const connectorVersion = options.connectorVersion ?? CONNECTOR_VERSION;
   const api = deps.api ?? createConnectApiClient(options.apiBaseUrl);
@@ -714,9 +942,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
@@ -730,16 +964,23 @@ async function runConnect(options, deps = {}) {
     signerPath: credentialPaths.signerPath,
     identityPath: credentialPaths.identityPath,
     credentialDirectory: credentialPaths.directory,
-    environmentLabel: options.environmentLabel ?? "Local workspace"
+    environmentLabel: options.environmentLabel ?? "Local workspace",
+    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,
       nextUserAction: runtimeInstall.nextUserAction,
@@ -751,7 +992,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,
@@ -777,10 +1018,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.");
@@ -810,6 +1053,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}
 `);
@@ -838,7 +1086,7 @@ 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 --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.",
@@ -846,6 +1094,8 @@ function helpText() {
     "  --runtime <name>           Agent runtime hint, such as claude-code, codex-cli, 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-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."