@rosthq/cli 0.5.5 → 0.5.6

package/dist/index.d.ts

@@ -5,6 +5,7 @@ import { type TokenStore } from "./token-store.js";
 type CliIo = {
     stdout: Pick<NodeJS.WriteStream, "write">;
     stderr: Pick<NodeJS.WriteStream, "write">;
+    interactive?: boolean;
 };
 type MainOptions = {
     store?: TokenStore;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAMA,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAoB,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACzE,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAYrE,KAAK,KAAK,GAAG;IACX,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;IAC1C,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;CAC3C,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,EAAE,CAAC,EAAE,KAAK,CAAC;IACX,KAAK,CAAC,EAAE,OAAO,gBAAgB,CAAC;IAChC,WAAW,CAAC,EAAE,OAAO,mBAAmB,CAAC;CAC1C,CAAC;AAEF,wBAAsB,IAAI,CAAC,IAAI,WAAwB,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CAiKnG;AAiWD,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAUxF"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAMA,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAoB,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACzE,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAYrE,KAAK,KAAK,GAAG;IACX,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;IAC1C,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;IAK1C,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,EAAE,CAAC,EAAE,KAAK,CAAC;IACX,KAAK,CAAC,EAAE,OAAO,gBAAgB,CAAC;IAChC,WAAW,CAAC,EAAE,OAAO,mBAAmB,CAAC;CAC1C,CAAC;AAEF,wBAAsB,IAAI,CAAC,IAAI,WAAwB,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CAyKnG;AAwXD,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAUxF"}

package/dist/index.js

@@ -42241,7 +42241,7 @@ Agents should explain the job, the required tool category, the minimum permissio
     order: 48,
     title: "CLI and MCP installation guide",
     summary: "Install the public CLI, register remote token-backed MCP clients, and find the full command and tool catalog.",
-    version: "2026-06-18.7",
+    version: "2026-06-18.8",
     public: true,
     audiences: ["human", "cli", "mcp", "in_app_agent"],
     stages: ["company_setup", "staffing"],
@@ -42306,7 +42306,7 @@ The MCP server is remote and token-backed. There is no local MCP daemon to insta
 A headless agent cannot complete setup unattended. Two things always require a human, so plan to announce the handoff rather than stall silently:
 
 - **Device-code approval at first login.** \`{{cli}} login --device\` prints a code; a human must open the workspace URL in a browser, sign in with Google, match the code, and approve.
-- **Durable gated commands.** Setting or approving a Charter, staffing a seat, and taking an agent live each open a confirmation that a human approves (an agent never approves its own request \u2014 see the confirmations-guide). The CLI surfaces the \`confirmation_id\` and an \`approveVia\` URL for the human. (\`{{cli}} mcp install\` is the exception: it completes its own token-mint approval inline for the operator who runs it \u2014 see Approving the token mint below \u2014 so it is not a separate browser handoff.)
+- **Durable gated commands.** Setting or approving a Charter, staffing a seat, and taking an agent live each open a confirmation that a human approves (an agent never approves its own request \u2014 see the confirmations-guide). The CLI surfaces the \`confirmation_id\` and an \`approveVia\` URL for the human. (\`{{cli}} mcp install\` is a partial exception: for an **interactive** operator it completes its own token-mint approval inline; in a **headless/agent** session it surfaces the confirmation and stops unless \`--skip-permissions\` / \`{{envPrefix}}_CLI_SKIP_PERMISSIONS=1\` is set \u2014 see Approving the token mint below.)
 
 Treat these as blocking prerequisites: the agent prepares the request and waits for the human approver.
 
@@ -42420,6 +42420,8 @@ Or use the one-shot helper: \`{{cli}} init\` logs in when needed, optionally sel
 
 A direct \`mcp install\` now **requires an explicit \`--scope\`** \u2014 there is no silent default. Choose \`--scope seat --seat-id <id>\` (the narrowest scope, limited to one seat's Charter and permission manifest \u2014 prefer it for day-to-day operation) or \`--scope tenant-admin\` (can administer the whole company \u2014 reserve it for initial setup). Running \`mcp install\` without \`--scope\` errors and mints nothing, naming both options. (The first-run helper \`{{cli}} init\` is the exception: it defaults to \`--scope tenant-admin\` because no seats exist yet at setup; and \`--rotate\` inherits the old token's scope, so it does not need \`--scope\` either.)
 
+\`mcp install\` accepts an optional \`--skip-permissions\` flag (equivalently \`{{envPrefix}}_CLI_SKIP_PERMISSIONS=1\`). It governs the token-mint approval in a non-interactive session \u2014 see Approving the token mint below. An interactive operator never needs it.
+
 Claude Code (tenant-admin):
 
 \`\`\`bash
@@ -42450,9 +42452,13 @@ The \`<seat-id>\` comes from \`{{cli}} command seat.create\` output or \`rost_ge
 
 ### Approving the token mint
 
-Minting a token is a human-gated authority change at the command layer. For an interactive operator, \`{{cli}} mcp install\` completes that approval **inline**: the operator who ran the command is the human in the loop, so the CLI runs the gated mint, completes the confirmation for that same command, and prints the registration block \u2014 a single step, no separate URL to click.
+Minting a token (and the inline revoke that \`--rotate\` performs) is a human-gated authority change at the command layer. How \`{{cli}} mcp install\` handles that approval depends on whether it runs in an interactive session:
+
+- **Interactive operator (a human at a real terminal).** The CLI completes the approval **inline**: the operator who ran the command is the human in the loop, so it runs the gated mint, completes the confirmation for that same command, and prints the registration block \u2014 a single step, no separate URL to click.
+- **Non-interactive / headless / agent session.** The CLI does **not** approve its own request. By default it **surfaces the confirmation and stops**, minting nothing: it prints the \`confirmation_id\`, the exact \`{{cli}} command confirmation.approve --json '{"confirmation_id":"<id>"}'\` command, and the \`approveVia\` URL when the server provided one, then exits non-zero ("pending human approval"). A human then approves it (in a browser or with that approve command) \u2014 and that approval **executes the mint and returns the token in the approve output** (shown once), so register it with your client from there. Do **not** re-run \`mcp install\` after approving: that starts a second mint and orphans the first token. (For an unattended agent that should mint and register in one step, use \`--skip-permissions\` below.)
+- **Opting into auto-approval in a headless session.** Pass \`--skip-permissions\` on \`mcp install\`, or set \`{{envPrefix}}_CLI_SKIP_PERMISSIONS=1\`, to auto-approve the mint/revoke confirmation inline even without a TTY. This is a deliberate loosening (the running session stands in for the human approver) \u2014 use it only for trusted automation where you accept that the agent approves its own token mint.
 
-The broader rule still holds for durable changes an agent proposes \u2014 charters, decisions, compass and charter amendments \u2014 where an agent never approves its own request and a human approves the surfaced \`approveVia\` confirmation. See the confirmations-guide for the four confirmation levels and that flow. (For a fully unattended headless agent session, treat the inline mint as the one place the running operator's identity stands in for the approval; if you need a separate human in that loop, raise it with your operator.)
+The broader rule still holds for durable changes an agent proposes \u2014 charters, decisions, compass and charter amendments \u2014 where an agent never approves its own request and a human approves the surfaced \`approveVia\` confirmation. See the confirmations-guide for the four confirmation levels and that flow.
 
 ### Handling the printed token (read this before you paste anything)
 
@@ -42654,8 +42660,9 @@ These ergonomic wrappers (including the \`{{cli}} agent\` group) require **{{cli
 
 | Command | Purpose | Scope | Safe example |
 |---|---|---|---|
-| \`{{cli}} mcp install --client claude-code|codex|cursor --scope tenant-admin|seat [--seat-id <id>] [--expires-in <days>|--no-expiry]\` | **Direct install** syntax. \`--scope\` is **required** (seat is narrower \u2014 prefer it for day-to-day; tenant-admin can administer the whole company). \`--expires-in <days>\` (1..365) or \`--no-expiry\` sets the token TTL (default 90 days). | Tenant | \`{{cli}} mcp install --client codex --scope tenant-admin --expires-in 30\` |
+| \`{{cli}} mcp install --client claude-code|codex|cursor --scope tenant-admin|seat [--seat-id <id>] [--expires-in <days>|--no-expiry] [--skip-permissions]\` | **Direct install** syntax. \`--scope\` is **required** (seat is narrower \u2014 prefer it for day-to-day; tenant-admin can administer the whole company). \`--expires-in <days>\` (1..365) or \`--no-expiry\` sets the token TTL (default 90 days). \`--skip-permissions\` auto-approves the token-mint confirmation in a non-interactive session (see below). | Tenant | \`{{cli}} mcp install --client codex --scope tenant-admin --expires-in 30\` |
 | \`{{cli}} mcp install --client claude-code|codex|cursor --rotate <old-token-id>  (inherits the old token's scope; no --scope)\` | **Rotate** syntax. Mints a replacement, **inherits the old token's scope/seat** (so do not pass \`--scope\`), prints the new registration block, and revokes the old token. | Tenant | \`{{cli}} mcp install --client codex --rotate <old-token-id>\` |
+| \`{{cli}} mcp install ... --skip-permissions  (or {{envPrefix}}_CLI_SKIP_PERMISSIONS=1 \u2014 auto-approves the token-mint confirmation in a non-interactive session)\` | **Skip-permissions** opt-in. In a headless/agent session, auto-approve the \`human_required\` token-mint (and rotate revoke) confirmation inline instead of surfacing it for a human (a deliberate loosening). An interactive operator never needs it. | Tenant | \`{{cli}} mcp install --client codex --scope seat --seat-id <seat-id> --skip-permissions\` |
 | \`{{cli}} mcp install --client claude-code --scope tenant-admin\` | Mint a tenant-admin MCP token and print a Claude Code registration command. | Tenant | \`{{cli}} mcp install --client claude-code --scope tenant-admin\` |
 | \`{{cli}} mcp install --client codex --scope tenant-admin\` | Mint a tenant-admin MCP token and print Codex TOML. | Tenant | \`{{cli}} mcp install --client codex --scope tenant-admin\` |
 | \`{{cli}} mcp install --client cursor --scope tenant-admin\` | Mint a tenant-admin MCP token and print Cursor JSON. | Tenant | \`{{cli}} mcp install --client cursor --scope tenant-admin\` |
@@ -44268,9 +44275,14 @@ var mcpTokenListEntrySchema = external_exports.object({
 var mcpTokenListOutputSchema = external_exports.object({
   tokens: external_exports.array(mcpTokenListEntrySchema)
 }).passthrough();
+var approveViaSchema = external_exports.object({
+  webUrl: external_exports.string().min(1).optional(),
+  cliCommand: external_exports.string().min(1).optional()
+}).passthrough();
 var pendingConfirmationSchema = external_exports.object({
   confirmationId: external_exports.string().min(1),
-  commandId: external_exports.string().min(1)
+  commandId: external_exports.string().min(1),
+  approveVia: approveViaSchema.optional().catch(void 0)
 }).passthrough();
 var confirmationApprovalOutputSchema = external_exports.object({
   confirmation_id: external_exports.string().min(1),
@@ -44286,6 +44298,7 @@ function parseMcpInstallOptions(args) {
   let expiresInDays;
   let noExpiry = false;
   let rotateTokenId;
+  let skipPermissions = false;
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
     if (arg === "--client") {
@@ -44308,6 +44321,8 @@ function parseMcpInstallOptions(args) {
       index += 1;
     } else if (arg === "--json") {
       json2 = true;
+    } else if (arg === "--skip-permissions") {
+      skipPermissions = true;
     } else {
       throw new Error(`Unknown mcp install option: ${arg}`);
     }
@@ -44328,24 +44343,71 @@ function parseMcpInstallOptions(args) {
     ...seatId === void 0 ? {} : { seatId },
     json: json2,
     expiry,
-    ...rotateTokenId === void 0 ? {} : { rotateTokenId }
+    ...rotateTokenId === void 0 ? {} : { rotateTokenId },
+    skipPermissions
   };
 }
 var MISSING_SCOPE_MESSAGE = `${cliBrand.binName} mcp install requires an explicit --scope. Choose: --scope seat --seat-id <id> (narrower \u2014 limited to one seat's Charter and permission manifest; prefer this for day-to-day operation), or --scope tenant-admin (can administer the whole company \u2014 reserve it for initial setup). Find a seat id with: ${cliBrand.binName} command graph.get --json '{}'.`;
 var MCP_TOKEN_CAUTION = "Security: this minted MCP token is a live credential that lands in the client's plaintext config \u2014 prefer the narrowest scope (--scope seat --seat-id <id>) and revoke it immediately if it leaks.";
 var NO_EXPIRY_WARNING = "Warning: --no-expiry mints a token with no practical expiry (a ~100-year TTL). This is a long-lived credential by choice \u2014 rotate it deliberately and revoke immediately if it leaks.";
+var PendingConfirmationError = class extends Error {
+  confirmationId;
+  commandId;
+  approveCommand;
+  approveUrl;
+  constructor(input) {
+    super(`Pending human approval for ${input.commandId} (confirmation ${input.confirmationId}).`);
+    this.name = "PendingConfirmationError";
+    this.confirmationId = input.confirmationId;
+    this.commandId = input.commandId;
+    this.approveCommand = input.approveCommand;
+    if (input.approveUrl !== void 0) {
+      this.approveUrl = input.approveUrl;
+    }
+  }
+  // The multi-line human-handoff message rendered on stderr by the caller. It
+  // names the gated command, the confirmation id, the exact approve command, and
+  // the approveVia URL when the server provided one.
+  toHandoffMessage() {
+    const isRevoke = this.commandId === "mcp_token.revoke";
+    const lines = isRevoke ? [
+      `Pending human approval: revoking the old token (${this.commandId}) requires a human to approve confirmation ${this.confirmationId}.`,
+      "The new token was minted and registered, but the OLD token is still live until its revocation is approved.",
+      `Approve the revocation: ${this.approveCommand}`
+    ] : [
+      `Pending human approval: ${this.commandId} requires a human to approve confirmation ${this.confirmationId} before the MCP token is minted.`,
+      "This is a non-interactive session and --skip-permissions is not set, so nothing was minted yet.",
+      // confirmation.approve EXECUTES the deferred mint and returns the token in
+      // its own output (shown once) — it does not just unlock a re-run. So the
+      // approver registers the token from that output; re-running mcp install
+      // would start a SECOND mint and orphan the first.
+      `A human approves with: ${this.approveCommand} \u2014 this mints the token and returns it in that command's output (shown once). Register it with your client from there; do not re-run mcp install afterward (that starts a new mint).`
+    ];
+    if (this.approveUrl !== void 0) {
+      lines.push(`Or approve in a browser: ${this.approveUrl}`);
+    }
+    lines.push(
+      `To auto-approve inline in a headless session instead, pass --skip-permissions or set ${brandEnvKey3("CLI_SKIP_PERMISSIONS")}=1 (a deliberate loosening).`
+    );
+    return lines.join("\n");
+  }
+};
+function brandEnvKey3(suffix) {
+  return `${cliBrand.envPrefix}_${suffix}`;
+}
 async function renderMcpInstall(input) {
   const stderrLines = [];
+  const canAutoApprove = input.canAutoApprove ?? false;
   if (input.options.rotateTokenId === void 0 && input.options.scope === void 0) {
     throw new Error(MISSING_SCOPE_MESSAGE);
   }
-  const mintScope = input.options.rotateTokenId === void 0 ? { scope: input.options.scope, ...input.options.seatId === void 0 ? {} : { seatId: input.options.seatId } } : await resolveRotationScope(input.client, input.options);
-  const token = await createMcpToken(input.client, mcpTokenCreateBody(mintScope, input.options.expiry));
+  const mintScope = input.options.rotateTokenId === void 0 ? { scope: input.options.scope, ...input.options.seatId === void 0 ? {} : { seatId: input.options.seatId } } : await resolveRotationScope(input.client, input.options, canAutoApprove);
+  const token = await createMcpToken(input.client, mcpTokenCreateBody(mintScope, input.options.expiry), canAutoApprove);
   let rotationOldRevoked = null;
   if (input.options.rotateTokenId !== void 0) {
     const oldTokenId = input.options.rotateTokenId;
     try {
-      const output = await executeWithConfirmation(input.client, "mcp_token.revoke", { token_id: oldTokenId });
+      const output = await executeWithConfirmation(input.client, "mcp_token.revoke", { token_id: oldTokenId }, canAutoApprove);
       const revoke = mcpTokenRevokeOutputSchema.safeParse(output);
       rotationOldRevoked = revoke.success && revoke.data.revoked === true;
       if (!rotationOldRevoked) {
@@ -44355,6 +44417,9 @@ async function renderMcpInstall(input) {
         );
       }
     } catch (error51) {
+      if (error51 instanceof PendingConfirmationError) {
+        throw error51;
+      }
       rotationOldRevoked = false;
       stderrLines.push(
         `Warning: the new token (${token.token_id}) was minted, but revoking the old token (${oldTokenId}) failed: ${revokeFailureReason(error51)}. It is still live. Revoke it by hand: ${cliBrand.binName} command mcp_token.revoke --json '{"token_id":"${oldTokenId}"}'`
@@ -44423,9 +44488,9 @@ function mcpTokenCreateBody(mint, expiry) {
   }
   return base;
 }
-async function resolveRotationScope(client, options) {
+async function resolveRotationScope(client, options, canAutoApprove) {
   const oldTokenId = options.rotateTokenId;
-  const listOutput = await executeWithConfirmation(client, "mcp_token.list", { include_revoked: true });
+  const listOutput = await executeWithConfirmation(client, "mcp_token.list", { include_revoked: true }, canAutoApprove);
   const parsed = mcpTokenListOutputSchema.safeParse(listOutput);
   if (!parsed.success) {
     throw new Error("Could not read the token list to rotate \u2014 mcp_token.list returned an unexpected shape.");
@@ -44488,11 +44553,11 @@ function revokeFailureReason(error51) {
   }
   return "unknown error";
 }
-async function createMcpToken(client, body) {
-  const output = await executeWithConfirmation(client, "mcp_token.create", body);
+async function createMcpToken(client, body, canAutoApprove) {
+  const output = await executeWithConfirmation(client, "mcp_token.create", body, canAutoApprove);
   return mcpTokenOutputSchema.parse(output);
 }
-async function executeWithConfirmation(client, commandId, body) {
+async function executeWithConfirmation(client, commandId, body, canAutoApprove) {
   try {
     const result = await client.execute(commandId, body);
     return result.output;
@@ -44501,6 +44566,14 @@ async function executeWithConfirmation(client, commandId, body) {
     if (!pending) {
       throw error51;
     }
+    if (!canAutoApprove) {
+      throw new PendingConfirmationError({
+        confirmationId: pending.confirmationId,
+        commandId: pending.commandId,
+        approveCommand: `${cliBrand.binName} command confirmation.approve --json '{"confirmation_id":"${pending.confirmationId}"}'`,
+        ...pending.approveVia?.webUrl === void 0 ? {} : { approveUrl: pending.approveVia.webUrl }
+      });
+    }
     const approved = await client.execute("confirmation.approve", {
       confirmation_id: pending.confirmationId
     });
@@ -45865,7 +45938,15 @@ function ensureTrailingSlash2(value) {
 
 // src/index.ts
 async function main(argv = process.argv.slice(2), options = {}) {
-  const io = options.io ?? { stdout: process.stdout, stderr: process.stderr };
+  const io = options.io ?? {
+    stdout: process.stdout,
+    stderr: process.stderr,
+    // DER-832: an interactive session is a human at a real terminal — BOTH stdin
+    // and stdout must be TTYs. A piped/headless/agent session fails this and so
+    // will not auto-approve its own mint/revoke confirmation unless skip-
+    // permissions is explicitly enabled.
+    interactive: process.stdin.isTTY === true && process.stdout.isTTY === true
+  };
   const login = options.login ?? loginWithBrowser;
   const deviceLogin = options.deviceLogin ?? loginWithDeviceCode;
   const [rawCommand, ...args] = argv;
@@ -46152,23 +46233,28 @@ async function executeOnboard(io, client, args) {
 `);
   return 1;
 }
-async function executeMcp(io, client, appUrl2, args) {
+async function executeMcp(io, client, appUrl2, args, env = process.env) {
   if (args[0] !== "install") {
     io.stderr.write(
       `Usage:
-  ${cliBrand.binName} mcp install --client claude-code|codex|cursor --scope tenant-admin|seat [--seat-id <id>] [--expires-in <days>|--no-expiry]
+  ${cliBrand.binName} mcp install --client claude-code|codex|cursor --scope tenant-admin|seat [--seat-id <id>] [--expires-in <days>|--no-expiry] [--skip-permissions]
     Direct install \u2014 --scope is required (seat is narrower; prefer it for day-to-day).
-  ${cliBrand.binName} mcp install --client claude-code|codex|cursor --rotate <old-token-id>
+  ${cliBrand.binName} mcp install --client claude-code|codex|cursor --rotate <old-token-id> [--skip-permissions]
     Rotate in place \u2014 inherits the old token's scope, so do not pass --scope.
+    --skip-permissions (or ${cliBrand.envPrefix}_CLI_SKIP_PERMISSIONS=1) auto-approves the token-mint confirmation in a non-interactive session.
 `
     );
     return 1;
   }
   try {
+    const options = parseMcpInstallOptions(args.slice(1));
+    const envSkipPermissions = env[`${cliBrand.envPrefix}_CLI_SKIP_PERMISSIONS`] === "1";
+    const canAutoApprove = io.interactive === true || options.skipPermissions || envSkipPermissions;
     const rendered = await renderMcpInstall({
       client,
       appUrl: appUrl2,
-      options: parseMcpInstallOptions(args.slice(1))
+      options,
+      canAutoApprove
     });
     io.stdout.write(rendered.stdout);
     if (rendered.stderr) {
@@ -46176,6 +46262,11 @@ async function executeMcp(io, client, appUrl2, args) {
     }
     return 0;
   } catch (error51) {
+    if (error51 instanceof PendingConfirmationError) {
+      io.stderr.write(`${redactForLog(error51.toHandoffMessage())}
+`);
+      return 1;
+    }
     if (error51 instanceof CommandClientError) {
       return printCommandError(io, error51);
     }
@@ -46289,8 +46380,9 @@ function printUsage(io) {
     ...operationUsageLines(cliBrand.binName),
     `${cliBrand.binName} onboard status`,
     `${cliBrand.binName} onboard run`,
-    `${cliBrand.binName} mcp install --client claude-code|codex|cursor --scope tenant-admin|seat [--seat-id <id>] [--expires-in <days>|--no-expiry]`,
+    `${cliBrand.binName} mcp install --client claude-code|codex|cursor --scope tenant-admin|seat [--seat-id <id>] [--expires-in <days>|--no-expiry] [--skip-permissions]`,
     `${cliBrand.binName} mcp install --client claude-code|codex|cursor --rotate <old-token-id>  (inherits the old token's scope; no --scope)`,
+    `${cliBrand.binName} mcp install ... --skip-permissions  (or ${cliBrand.envPrefix}_CLI_SKIP_PERMISSIONS=1 \u2014 auto-approves the token-mint confirmation in a non-interactive session)`,
     `${cliBrand.binName} init [--client claude-code|codex|cursor]  (defaults --scope tenant-admin)`,
     `${cliBrand.binName} docs`,
     `${cliBrand.binName} reference <list|search|get> [options]`,