@haven_ai/connect 0.1.1-alpha → 0.1.2-alpha

package/dist/cli.js

@@ -6,7 +6,8 @@ import { homedir, platform } from 'os';
 import { join, resolve, dirname } from 'path';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
-import { ensureSignerConsent, computeSignerConsentHash, SIGNER_VERSION, loadSignerCredentials, createEdgeSigner, toolSchemas } from '@haven_ai/signer';
+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) {
@@ -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
@@ -210,6 +216,8 @@ async function writeRuntimeConfig(input) {
       return {
         hostedConfigured: false,
         signerConfigured: false,
+        localMcpConfigured: false,
+        runtimeMcpMode: "manual",
         target: "manual runtime setup",
         changed: false,
         restartRequired: true,
@@ -251,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", ${tomlString(signerPackageName())}, "--credentials", ${tomlString(signerPath)}]`
+    `args = ["-y", ${tomlString(localMcpPackageName())}, "--identity", ${tomlString(identityPath)}, "--signer", ${tomlString(signerPath)}]`
   ].join("\n");
   return `${next ? `${next}
 
@@ -281,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",
@@ -290,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,
@@ -300,41 +308,29 @@ 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);
+    const merged = mergeCodexToml(existing ?? "", input.identityPath, input.signerPath);
     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,
+      localMcpConfigured: true,
+      runtimeMcpMode: "local_stdio",
       target: "Codex CLI config",
       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 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,
@@ -356,11 +352,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)) {
@@ -389,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");
 }
@@ -429,6 +417,85 @@ function configTargetLabel(runtime) {
 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 {
@@ -583,7 +650,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,7 +709,7 @@ async function readSignerAckFile(path) {
     return null;
   }
 }
-function writeLogChunk(log, chunk) {
+function writeLogChunk2(log, chunk) {
   const message = String(chunk).trimEnd();
   if (message) log(message);
 }
@@ -652,23 +719,28 @@ var execFileAsync = 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."
       ]
     };
@@ -677,6 +749,7 @@ async function installRuntime(input, deps = {}) {
     runtime,
     hostedMcpUrl: input.hostedMcpUrl,
     apiKey: input.apiKey,
+    identityPath: input.identityPath,
     signerPath: input.signerPath,
     credentialDirectory: input.credentialDirectory,
     homeDir: deps.homeDir
@@ -686,21 +759,25 @@ async function installRuntime(input, deps = {}) {
     probeLocalSignerCredential(input.signerPath)
   ]);
   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);
+  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" ? 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(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, ...configResult.messages]
   };
 }
 function runtimeInstallCapabilities(runtime, env = process.env) {
@@ -716,39 +793,36 @@ 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",
-      signerPackageName2(),
-      "--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.",
-        "Restart Claude Code after Haven approval so it can load the Haven tools."
+        "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,
@@ -763,13 +837,28 @@ 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);
 }
+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 +871,32 @@ 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 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_with_haven_env";
+  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 signerPackageName2() {
-  return `@haven_ai/signer@${SIGNER_VERSION}`;
+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.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 +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
@@ -862,17 +965,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 +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,
@@ -911,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.");
@@ -944,8 +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}
 `);
@@ -974,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 --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.",
@@ -982,7 +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-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."