@mycadet/cli 0.12.8 → 0.12.9-dev.202610131620.d833e01

package/src/commands/pair.ts

@@ -3,9 +3,12 @@
  *
  * Print the pairing link for another device, and the same link rendered as a
  * QR code. Runs on the machine hosting the assistant: it mints a remote-web
- * pairing challenge over the loopback gateway and approves it immediately, so
- * running this command IS the local-presence proof and one scan (or one paste
- * into `cadet connect import`) completes the pairing.
+ * pairing challenge through the gateway CLI (`gateway pairing mint <url>` —
+ * locally, or docker-exec'd into the gateway container) which approves it
+ * immediately, so running this command IS the local-presence proof and one
+ * scan (or one paste into `cadet connect import`) completes the pairing.
+ * local and docker assistants mint without any HTTP; other topologies keep
+ * the loopback HTTP mint.
  *
  * `--web-approve` is the reverse direction: approve a code a device already
  * shows, for pairings that device started on its own.
@@ -38,8 +41,11 @@ import {
 import { GATEWAY_PORT } from "../lib/constants.js";
 import { getCurrentEnvironment } from "../lib/environments/resolve.js";
 import { isLoopbackUrl, loopbackSafeFetch } from "../lib/loopback-fetch.js";
+import { dockerResourceNames } from "../lib/docker.js";
+import { gatewayCliInvocation } from "../lib/local.js";
 import { formatWebApproveFailure, parseGatewayErrorCode } from "../lib/pair.js";
 import { STALE_CLI_UPDATE_HINT } from "../lib/stale-cli-hint.js";
+import { execOutput } from "../lib/step-runner.js";
 
 function assistantDisplayName(entry: AssistantEntry): string {
   return entry.name || entry.assistantName || entry.assistantId;
@@ -89,9 +95,10 @@ function printUsage(): void {
 USAGE:
     cadet pair [assistant] [options]
 
-Mints a pairing challenge on the assistant's gateway over loopback and
-approves it on the spot (running this command on the host machine is the
-approval), then prints the pairing link and the same link as a QR code.
+Mints a pairing challenge on the assistant's gateway (via the gateway CLI
+for local and docker assistants, over loopback HTTP otherwise) and approves
+it on the spot (running this command on the host machine is the approval),
+then prints the pairing link and the same link as a QR code.
 Scanning the QR, opening the link, or passing it to 'cadet connect import'
 on the other device completes the pairing in one step.
 
@@ -214,26 +221,122 @@ async function exitOnHttpError(response: Response): Promise<Response> {
   return response;
 }
 
-/** Create a remote-web pairing challenge (RFC 8628 device-code flow). */
-async function createRemoteWebPairingChallenge(
-  gatewayUrl: string,
+/**
+ * Mint (and approve) a remote-web pairing challenge. `local` and `docker`
+ * remotes mint through the gateway CLI — `gateway pairing mint <url>` run on
+ * the assistant's host (locally, or docker-exec'd into the gateway container)
+ * — replacing the old loopback HTTP mint whose loopback-peer gate
+ * containerized gateways could never satisfy (published-port NAT rewrites
+ * host-originated peers to the docker bridge address). The mint executes the
+ * pairing logic directly against the file-backed challenge store, so the
+ * running gateway's verification routes see it with no IPC round-trip.
+ * Process execution is the local-presence proof; the mint command approves
+ * on the spot, so the returned challenge is already paired-ready. Other
+ * topologies keep the loopback HTTP mint they used before.
+ */
+async function mintPairingChallengeOrExit(
+  entry: AssistantEntry,
+  publicBaseUrl: string,
+): Promise<RemoteWebPairingChallengeResponse> {
+  if (entry.cloud !== "local" && entry.cloud !== "docker") {
+    return mintPairingChallengeOverLoopbackOrExit(entry, publicBaseUrl);
+  }
+
+  let stdout: string;
+  try {
+    if (entry.cloud === "docker") {
+      stdout = await execOutput(
+        "docker",
+        [
+          "exec",
+          dockerResourceNames(entry.assistantId).gatewayContainer,
+          "bun",
+          "run",
+          "src/cli/index.ts",
+          "pairing",
+          "mint",
+          publicBaseUrl,
+        ],
+        { timeoutMs: 30_000 },
+      );
+    } else {
+      const invocation = gatewayCliInvocation(entry.resources);
+      stdout = await execOutput(
+        invocation.command,
+        [...invocation.args, "pairing", "mint", publicBaseUrl],
+        {
+          cwd: invocation.cwd,
+          env: invocation.env,
+          timeoutMs: 30_000,
+        },
+      );
+    }
+  } catch (err) {
+    console.error(
+      `Error: could not mint a pairing challenge on the gateway ` +
+        `(${err instanceof Error ? err.message : String(err)}).`,
+    );
+    console.error("Is the assistant running? Try `cadet wake`.");
+    process.exit(1);
+  }
+
+  const lastLine = stdout.split("\n").filter(Boolean).pop() ?? "";
+  let challenge: RemoteWebPairingChallengeResponse;
+  try {
+    challenge = JSON.parse(lastLine) as RemoteWebPairingChallengeResponse;
+  } catch {
+    console.error(
+      "Error: could not parse the gateway's pairing mint output.",
+    );
+    process.exit(1);
+  }
+  if (!challenge.deviceCode || !challenge.userCode) {
+    console.error(
+      "Error: the gateway's pairing mint output is missing the challenge codes.",
+    );
+    process.exit(1);
+  }
+  return challenge;
+}
+
+/**
+ * Mint a challenge over the gateway's loopback HTTP route — the path every
+ * topology took before the gateway-CLI mint existed. Kept for remotes that
+ * are neither `local` nor `docker` (apple containers, SSH-managed hosts,
+ * cloud-managed), where no gateway-CLI execution surface is defined.
+ */
+async function mintPairingChallengeOverLoopbackOrExit(
+  entry: AssistantEntry,
   publicBaseUrl: string,
 ): Promise<RemoteWebPairingChallengeResponse> {
+  // Mint over loopback (localUrl avoids mDNS for same-machine calls), then
+  // approve immediately: running this CLI on the host IS the local-presence
+  // proof, so the other device completes pairing in one step from the link.
+  const mintUrl = (
+    entry.localUrl ||
+    entry.runtimeUrl ||
+    `http://127.0.0.1:${GATEWAY_PORT}`
+  ).replace(/\/+$/, "");
   const response = await gatewayPostOrExit(
-    gatewayUrl,
+    mintUrl,
     "/v1/remote-web/pairing-challenge",
     { publicBaseUrl } satisfies RemoteWebPairingChallengeRequest,
   );
-  return (await response.json()) as RemoteWebPairingChallengeResponse;
+  const challenge: RemoteWebPairingChallengeResponse =
+    await response.json();
+  await gatewayPostOrExit(mintUrl, "/v1/remote-web/pairing-verification", {
+    userCode: challenge.userCode,
+  } satisfies RemoteWebPairingVerificationRequest);
+  return challenge;
 }
 
 /**
  * Approve a pending pairing challenge by its user code, the local-presence
  * proof for the device-code flow. Single owner of the pairing-verification
- * route and request body: the link flow approves via
- * {@link approveRemoteWebPairing} (generic exit on non-2xx), while
- * `--web-approve` calls this directly to inspect rejections and print mismatch
- * diagnostics (see {@link formatWebApproveFailure}).
+ * route and request body: `--web-approve` calls this directly to inspect
+ * rejections and print mismatch diagnostics (see
+ * {@link formatWebApproveFailure}); the link flow needs no separate
+ * verification call — the gateway-CLI mint approves on the spot.
  */
 async function postPairingVerification(
   gatewayUrl: string,
@@ -244,20 +347,6 @@ async function postPairingVerification(
   } satisfies RemoteWebPairingVerificationRequest);
 }
 
-/**
- * Approve the challenge this command just minted so one scan completes
- * pairing, exiting with a generic message on non-2xx.
- */
-async function approveRemoteWebPairing(
-  gatewayUrl: string,
-  userCode: string,
-): Promise<RemoteWebPairingVerificationResponse> {
-  const response = await exitOnHttpError(
-    await postPairingVerification(gatewayUrl, userCode),
-  );
-  return (await response.json()) as RemoteWebPairingVerificationResponse;
-}
-
 export const pair = Object.assign(
   async function pair(): Promise<void> {
   const rawArgs = process.argv.slice(3);
@@ -355,6 +444,24 @@ export const pair = Object.assign(
     }
   }
 
+  // Minting requires host presence on this machine. Native and docker
+  // topologies qualify (the latter via docker exec); an assistant this
+  // machine only knows through `connect import` has no host presence here
+  // at all, and `cadet pair` never worked against it (its loopback gate
+  // denied remote mints). Refuse clearly instead of a confusing mint
+  // failure.
+  if (entry.cloud === "paired") {
+    console.error(
+      `Error: ${formatAssistantReference(entry)} was paired as a remote ` +
+        "assistant (cadet connect import), so this machine does not host it.",
+    );
+    console.error(
+      "Run `cadet pair` on the machine hosting the assistant, or approve " +
+        "a code it shows with `cadet pair --web-approve <code>`.",
+    );
+    process.exit(1);
+  }
+
   // Mint over loopback (localUrl avoids mDNS for same-machine calls), but
   // advertise a REACHABLE url in the link, since the loopback url would point
   // the other device at its own localhost. Prefer an explicit --url, then the
@@ -437,14 +544,10 @@ export const pair = Object.assign(
   }
   const publicBaseUrl = resolved.url;
 
-  // Mint a challenge and immediately approve it: running this CLI on the host
-  // IS the local-presence proof, so the other device completes pairing in one
-  // step from the link alone.
-  const challenge = await createRemoteWebPairingChallenge(
-    mintUrl,
-    publicBaseUrl,
-  );
-  await approveRemoteWebPairing(mintUrl, challenge.userCode);
+  // Mint a challenge (approved on the spot by the gateway-CLI invocation):
+  // running this CLI on the host IS the local-presence proof, so the other
+  // device completes pairing in one step from the link alone.
+  const challenge = await mintPairingChallengeOrExit(entry, publicBaseUrl);
   const pairUrl = buildRemoteWebPairingUrl(challenge);
   const displayName = assistantDisplayName(entry);
   const appUrl = appVariant

package/src/commands/ps.ts

@@ -64,8 +64,54 @@ interface ColWidths {
   info: number;
 }
 
+/**
+ * Terminal display width for table alignment: emoji render two cells wide
+ * (including ZWJ sequences like 🧑‍🚀 and VS16 pairs like ⚠️), while the ZWJ
+ * and variation selectors themselves render zero. `.length` counts UTF-16
+ * units and none of that, which is what broke the STATUS and INFO columns
+ * whenever an emoji appeared in an earlier one.
+ */
+export function displayWidth(s: string): number {
+  const chars = [...s];
+  let width = 0;
+  // A ZWJ joins the previous and next glyphs into ONE grapheme (🧑‍🚀 renders
+  // as a single 2-cell astronaut), so the glyph after a ZWJ adds no width.
+  let joinedByZwj = false;
+  for (let i = 0; i < chars.length; i++) {
+    const cp = chars[i]?.codePointAt(0) ?? 0;
+    // Zero-width: the joiner, the variation selectors, skin-tone modifiers.
+    if (cp === 0x200d) {
+      joinedByZwj = true;
+      continue;
+    }
+    if (cp === 0xfe0e || cp === 0xfe0f) continue;
+    if (cp >= 0x1f3fb && cp <= 0x1f3ff) continue;
+    const next = chars[i + 1]?.codePointAt(0);
+    if (!joinedByZwj) {
+      // A VS16 after a narrow symbol forces emoji presentation — two cells.
+      width += isWideCodePoint(cp) || next === 0xfe0f ? 2 : 1;
+    }
+    joinedByZwj = false;
+  }
+  return width;
+}
+
+function isWideCodePoint(cp: number): boolean {
+  return (
+    (cp >= 0x1100 && cp <= 0x115f) || // Hangul Jamo
+    (cp >= 0x2e80 && cp <= 0x303e) || // CJK radicals and punctuation
+    (cp >= 0x3040 && cp <= 0x318f) || // Hiragana, Katakana, bopomofo
+    (cp >= 0xac00 && cp <= 0xd7a3) || // Hangul syllables
+    (cp >= 0xf900 && cp <= 0xfaff) || // CJK compatibility ideographs
+    (cp >= 0xfe30 && cp <= 0xfe6f) || // CJK compatibility forms
+    (cp >= 0xff00 && cp <= 0xff60) || // fullwidth forms
+    (cp >= 0xffe0 && cp <= 0xffe6) ||
+    cp >= 0x1f000 // emoji and symbol blocks (🟢, 🚀, 🧑, …)
+  );
+}
+
 function pad(s: string, w: number): string {
-  return s + " ".repeat(Math.max(0, w - s.length));
+  return s + " ".repeat(Math.max(0, w - displayWidth(s)));
 }
 
 function computeColWidths(
@@ -79,14 +125,17 @@ function computeColWidths(
 ): ColWidths {
   const all = [headers, ...rows];
   return {
-    name: Math.max(...all.map((r) => r.name.length)),
-    type: Math.max(...all.map((r) => r.type.length)),
-    status: Math.max(...all.map((r) => r.status.length), "checking...".length),
-    info: Math.max(...all.map((r) => r.info.length)),
+    name: Math.max(...all.map((r) => displayWidth(r.name))),
+    type: Math.max(...all.map((r) => displayWidth(r.type))),
+    status: Math.max(
+      ...all.map((r) => displayWidth(r.status)),
+      "checking...".length,
+    ),
+    info: Math.max(...all.map((r) => displayWidth(r.info))),
   };
 }
 
-function formatRow(r: TableRow, colWidths: ColWidths): string {
+export function formatRow(r: TableRow, colWidths: ColWidths): string {
   return `  ${pad(r.name, colWidths.name)}  ${pad(r.type, colWidths.type)}  ${pad(r.status, colWidths.status)}  ${r.info}`;
 }
 
@@ -459,7 +508,7 @@ async function getAssistantProcessRows(
 ): Promise<TableRow[]> {
   const cloud = entry.cloud;
 
-  console.log(`Processes for ${formatAssistantReference(entry)} (${cloud}):`);
+  console.log(`Processes for ${formatAssistantReference(entry)} — ${cloud}:`);
   console.log(`Location: ${locationFor(entry)}\n`);
 
   if (cloud === "local") {
@@ -611,35 +660,23 @@ async function getRootManagedRows(): Promise<RootManagedRow[]> {
 }
 
 /**
- * Fold the CLI-managed process rows into ONE table with the assistant rows:
- * a process fronts an assistant when it recorded that assistant's id, and
- * those rows nest under it; anything unattributed (or fronting an assistant
- * this environment no longer lists) renders at the bottom, machine-level.
+ * Fold the CLI-managed process rows into ONE table with the assistant rows.
+ * Tunnel agents and the nginx edge are root resources of the machine, not
+ * children of whichever assistant they front — especially as the web bundle
+ * splits into /app and /ui — so every CLI-managed row renders machine-level.
  */
 async function assistantRowsWithRootProcesses(
   assistants: AssistantEntry[],
   healths: AssistantHealth[],
   activeAssistantId: string | null,
 ): Promise<TableRow[]> {
-  const nestedByAssistant = new Map<string, TableRow[]>();
-  const unattributed: TableRow[] = [];
-  const knownIds = new Set(assistants.map((entry) => entry.assistantId));
-  for (const managed of await getRootManagedRows()) {
-    if (managed.assistantId && knownIds.has(managed.assistantId)) {
-      const nested = nestedByAssistant.get(managed.assistantId) ?? [];
-      nested.push({ ...managed.row, name: `  └ ${managed.row.name}` });
-      nestedByAssistant.set(managed.assistantId, nested);
-    } else {
-      unattributed.push(managed.row);
-    }
-  }
+  const rootRows = (await getRootManagedRows()).map((managed) => managed.row);
 
   const rows: TableRow[] = [];
   assistants.forEach((entry, i) => {
     rows.push(formatAssistantListRow(entry, activeAssistantId, healths[i]!));
-    rows.push(...(nestedByAssistant.get(entry.assistantId) ?? []));
   });
-  rows.push(...unattributed);
+  rows.push(...rootRows);
   return rows;
 }
 
@@ -830,5 +867,5 @@ export const ps = Object.assign(
     }
     printTable(rows);
   },
-  { description: "List assistants (or processes for a specific assistant)" },
+  { description: "List assistants" },
 );

package/src/commands/restore.ts

@@ -474,7 +474,7 @@ async function restorePlatform(
           }
         }
         // Transient error (5xx, network) — retry
-        console.warn(`Polling failed, retrying... (${msg})`);
+        console.warn(`Polling failed: ${msg}. Retrying...`);
         continue;
       }
 
@@ -680,7 +680,7 @@ export const restore = Object.assign(
   }
 
   const sizeMB = formatBundleSizeMb(bundleFileSizeBytes(fromPath));
-  console.log(`Reading ${fromPath} (${sizeMB} MB)...`);
+  console.log(`Reading ${fromPath} — ${sizeMB} MB...`);
 
   // Detect topology and route platform assistants through Django import
   const cloud =

package/src/commands/retire.ts

@@ -287,12 +287,12 @@ async function retireInner(): Promise<void> {
     console.log("");
     console.log("Delete an assistant instance and archive its data.");
     console.log(
-      "With no name or ID, retires the active assistant (see `cadet use`). By default, retire prints the assistant name, ID, cloud, and runtime before asking for confirmation.",
+      "With no name or ID, retires the active assistant — see `cadet use`. By default, retire prints the assistant name, ID, cloud, and runtime before asking for confirmation.",
     );
     console.log("");
     console.log("Arguments:");
     console.log(
-      "  <name-or-id>         Assistant display name or ID to retire (defaults to the active assistant)",
+      "  <name-or-id>         Assistant display name or ID to retire, defaults to the active assistant",
     );
     console.log("");
     console.log("Options:");

package/src/commands/rollback.ts

@@ -51,12 +51,12 @@ function parseArgs(): { name: string | null; version: string | null } {
       console.log("");
       console.log("Arguments:");
       console.log(
-        "  <name>               Name of the assistant (default: active or only assistant)",
+        "  <name>               Name of the assistant, defaults to active or only assistant",
       );
       console.log("");
       console.log("Options:");
       console.log(
-        "  --version <version>  Target version (optional for managed — omit to roll back to previous)",
+        "  --version <version>  Target version, optional for managed — omit to roll back to previous",
       );
       console.log("");
       console.log("Examples:");

package/src/commands/sleep.ts

@@ -71,7 +71,7 @@ export const sleep = Object.assign(
     console.log("");
     console.log("Arguments:");
     console.log(
-      "  <name>    Name of the assistant to stop (default: active or only local)",
+      "  <name>    Name of the assistant to stop, defaults to active or only local",
     );
     console.log("");
     console.log("Options:");
@@ -88,7 +88,7 @@ export const sleep = Object.assign(
       "            schedules) to finish before stopping. Waits as long as it",
     );
     console.log(
-      "            takes by default; pass a duration (e.g. --wait 90s, --wait 10m)",
+      "            takes by default; pass a duration, e.g. --wait 90s or --wait 10m",
     );
     console.log(
       "            to bound the wait. Ctrl-C cancels and leaves the assistant running.",

package/src/commands/teleport.ts

@@ -100,7 +100,7 @@ function printHelp(): void {
   console.log(
     "The source and target must be different environments. Same-environment",
   );
-  console.log("transfers (e.g. local to local) are not supported.");
+  console.log("transfers such as local to local are not supported.");
   console.log("");
   console.log(
     "Before exporting, the source assistant is backed up. Platform sources",
@@ -159,7 +159,7 @@ function printHelp(): void {
     "      Import data from my-local into existing docker assistant my-docker",
   );
   console.log(
-    "      (or hatch a new docker assistant named my-docker if it doesn't exist)",
+    "      or hatch a new docker assistant named my-docker if it doesn't exist",
   );
   console.log("");
   console.log("  cadet teleport --from my-local --platform");
@@ -185,7 +185,6 @@ function printHelp(): void {
 
 export function parseArgs(argv: string[]): {
   from: string | undefined;
-  to: string | undefined;
   targetEnv: "local" | "docker" | "platform" | undefined;
   targetName: string | undefined;
   keepSource: boolean;
@@ -193,7 +192,6 @@ export function parseArgs(argv: string[]): {
   help: boolean;
 } {
   let from: string | undefined;
-  let to: string | undefined;
   let targetEnv: "local" | "docker" | "platform" | undefined;
   let targetName: string | undefined;
   let keepSource = false;
@@ -209,11 +207,6 @@ export function parseArgs(argv: string[]): {
         continue;
       }
       from = argv[++i];
-    } else if (arg === "--to" && i + 1 < argv.length) {
-      if (argv[i + 1].startsWith("--")) {
-        continue;
-      }
-      to = argv[++i];
     } else if (
       arg === "--local" ||
       arg === "--docker" ||
@@ -242,7 +235,7 @@ export function parseArgs(argv: string[]): {
     process.exit(1);
   }
 
-  return { from, to, targetEnv, targetName, keepSource, dryRun, help };
+  return { from, targetEnv, targetName, keepSource, dryRun, help };
 }
 
 // ---------------------------------------------------------------------------
@@ -415,7 +408,7 @@ async function backupSourceBeforeTeleport(
   cloud: string,
   displayName: string,
 ): Promise<void> {
-  console.log(`Backing up ${displayName} (${cloud})...`);
+  console.log(`Backing up ${displayName} on ${cloud}...`);
   try {
     if (isCloudHome(cloud)) {
       const cloudToken = readCloudToken();
@@ -443,7 +436,7 @@ async function backupSourceBeforeTeleport(
       timeoutMs: LOCAL_SOURCE_BACKUP_TIMEOUT_MS,
     });
     if (!backupPath) {
-      throw new Error("backup export failed (see warning above)");
+      throw new Error("backup export failed — see the warning above");
     }
     pruneOldBackups(entry.assistantId, 3, "pre-teleport");
     console.log(`Backup saved: ${backupPath}`);
@@ -470,7 +463,7 @@ async function exportFromAssistant(
   const cloudToken = readCloudToken();
   if (!cloudToken) {
     console.error(
-      "Not logged in. Run 'cadet login' first (required for GCS-based teleport).",
+      "Not logged in. Run 'cadet login' first.",
     );
     process.exit(1);
   }
@@ -688,7 +681,7 @@ async function importToAssistant(
   const cloudToken = readCloudToken();
   if (!cloudToken) {
     console.error(
-      "Not logged in. Run 'cadet login' first (required for GCS-based teleport).",
+      "Not logged in. Run 'cadet login' first.",
     );
     process.exit(1);
   }
@@ -990,7 +983,7 @@ export async function resolveOrHatchTarget(
         );
         process.exit(1);
       }
-      console.log(`Target: ${targetName} (${targetEnv})`);
+      console.log(`Target: ${targetName} — ${targetEnv}`);
       return existing;
     }
 
@@ -1204,7 +1197,7 @@ async function tryInjectCloudCredentials(
 ): Promise<void> {
   const token = readCloudToken();
   if (!token) {
-    console.log("  Skipped cloud credential injection (not logged in).");
+    console.log("  Skipped cloud credential injection — not logged in.");
     return;
   }
 
@@ -1253,7 +1246,6 @@ async function tryInjectCloudCredentials(
       bearerToken: entry.bearerToken,
       assistantApiKey,
       cloudAssistantId: registration.assistant.id,
-      cloudBaseUrl: cloudUrl,
       organizationId: orgId,
       userId: user.id,
       webhookSecret: registration.webhook_secret,
@@ -1277,7 +1269,7 @@ async function tryInjectCloudCredentials(
 export const teleport = Object.assign(
   async function teleport(): Promise<void> {
   const args = process.argv.slice(3);
-  const { from, to, targetEnv, targetName, keepSource, dryRun, help } =
+  const { from, targetEnv, targetName, keepSource, dryRun, help } =
     parseArgs(args);
 
   if (help) {
@@ -1285,17 +1277,6 @@ export const teleport = Object.assign(
     process.exit(0);
   }
 
-  // Legacy --to flag deprecation
-  if (to) {
-    console.error("Error: --to is deprecated. Use environment flags instead:");
-    console.error(
-      "  cadet teleport --from <source> --local|--docker|--platform [name]",
-    );
-    console.error("");
-    console.error("Run 'cadet teleport --help' for details.");
-    process.exit(1);
-  }
-
   if (!from) {
     printHelp();
     process.exit(1);
@@ -1393,13 +1374,13 @@ export const teleport = Object.assign(
             ? fromEntry.runtimeUrl
             : undefined;
 
-      console.log(`Exporting from ${from} (${fromCloud})...`);
+      console.log(`Exporting from ${from} on ${fromCloud}...`);
       const { bundleKey } = await exportFromAssistant(
         fromEntry,
         fromCloud,
         bundleCloudUrl,
       );
-      console.log(`Importing to ${existingTarget.assistantId} (${toCloud})...`);
+      console.log(`Importing to ${existingTarget.assistantId} on ${toCloud}...`);
       await importToAssistant(
         existingTarget,
         toCloud,
@@ -1410,7 +1391,7 @@ export const teleport = Object.assign(
     } else {
       // No existing target — just describe what would happen
       console.log("Dry run summary:");
-      console.log(`  Would export data from: ${from} (${fromCloud})`);
+      console.log(`  Would export data from: ${from} on ${fromCloud}`);
       console.log(`  Would upload bundle via signed URL`);
       console.log(
         `  Would hatch a new ${targetEnv} assistant${targetName ? ` named '${targetName}'` : ""}`,
@@ -1482,7 +1463,7 @@ export const teleport = Object.assign(
     // resolveOrHatchTarget writes to the new entry).
     await backupSourceBeforeTeleport(fromEntry, fromCloud, from);
 
-    console.log(`Exporting from ${from} (${fromCloud})...`);
+    console.log(`Exporting from ${from} on ${fromCloud}...`);
     const bundleCloudUrl = targetCloudUrl ?? getCloudUrl();
     const { bundleKey } = await exportFromAssistant(
       fromEntry,
@@ -1495,7 +1476,7 @@ export const teleport = Object.assign(
     const toCloud = toEntry.cloud;
 
     // Import from GCS
-    console.log(`Importing to ${toEntry.assistantId} (${toCloud})...`);
+    console.log(`Importing to ${toEntry.assistantId} on ${toCloud}...`);
     await importToAssistant(
       toEntry,
       toCloud,
@@ -1555,7 +1536,7 @@ export const teleport = Object.assign(
   await backupSourceBeforeTeleport(fromEntry, fromCloud, from);
 
   // Export from source (bundle lives in GCS after this returns).
-  console.log(`Exporting from ${from} (${fromCloud})...`);
+  console.log(`Exporting from ${from} on ${fromCloud}...`);
   const { bundleKey } = await exportFromAssistant(
     fromEntry,
     fromCloud,
@@ -1632,7 +1613,7 @@ export const teleport = Object.assign(
   }
 
   // Import to target (also GCS-driven)
-  console.log(`Importing to ${toEntry.assistantId} (${toCloud})...`);
+  console.log(`Importing to ${toEntry.assistantId} on ${toCloud}...`);
   await importToAssistant(
     toEntry,
     toCloud,
@@ -1660,7 +1641,7 @@ export const teleport = Object.assign(
       removeAssistantEntry(fromEntry.assistantId);
       console.log(`Source assistant '${from}' retired.`);
     } else {
-      console.log(`Source assistant '${from}' kept (--keep-source).`);
+      console.log(`Source assistant '${from}' kept via --keep-source.`);
     }
   }
 

package/src/commands/terminal.ts

@@ -71,7 +71,7 @@ function printHelp(): void {
   console.log("");
   console.log("Options:");
   console.log(
-    "  <name>              Name of the assistant (defaults to active)",
+    "  <name>              Name of the assistant, defaults to active",
   );
   console.log(
     "  --assistant <name>  Explicit assistant name (alternative to positional)",