@cursor/july 0.1.68 → 0.1.73

package/src/internal/advertise-tools.ts

@@ -16,9 +16,13 @@
  * auth-less connections go through the shared `host.mcp` registry, which
  * also covers serve-resolved transports (Cursor account bridges, peers).
  *
- * Everything here fails closed: a listing failure, an invalid tool name,
- * or a name collision throws, and the engine fails the turn rather than
- * running it with a silently shrunken toolset.
+ * Advertised names follow the Cursor-account MCP bridge
+ * (`packages/agent-serve/src/internal/cursor/account-mcp.ts`): slug
+ * `[^a-zA-Z0-9_-]` to `_`, collision suffixes `_2` / `_3`, and call the
+ * original advertised name. That is the same mapping `packages/agent`
+ * `normalizeMcpToolName` uses for IDE/Sand MCP tools. A listing failure
+ * still fails the turn rather than running it with a silently shrunken
+ * toolset.
  */
 
 import type {
@@ -33,6 +37,10 @@ import type {
 } from "../types.js";
 import { brandDefinition } from "./brand.js";
 import type { HostMcpOneOff } from "./mcp-host.js";
+import {
+  sanitizeMcpToolName,
+  suffixMcpToolName,
+} from "./sanitize-mcp-tool-name.js";
 
 /**
  * What the resolver needs from the host MCP registry: the shared cached
@@ -50,12 +58,12 @@ export interface AdvertiseHostMcp {
 }
 
 /**
- * The rule advertised tool names must match — the same shape discovery
- * enforces for authored tool filenames (its `NAME_PATTERN`), since both
- * become the tool name the model sees.
+ * Model-facing advertised names after {@link sanitizeMcpToolName} — the
+ * same MCP-client shape the Cursor-account bridge documents
+ * (`^[a-zA-Z0-9_-]{1,128}$`). Authored `agent/tools/` filenames stay on
+ * discovery's stricter `NAME_PATTERN` (must start alphanumeric).
  */
-export const ADVERTISED_TOOL_NAME_PATTERN: RegExp =
-  /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+export const ADVERTISED_TOOL_NAME_PATTERN: RegExp = /^[A-Za-z0-9_-]{1,128}$/;
 
 const ANY_OBJECT_SCHEMA: JsonSchemaObject = {
   type: "object",
@@ -107,9 +115,10 @@ export async function resolveAdvertisedTools(args: {
         { cause: error }
       );
     }
-    for (const info of listed) {
-      resolved.push(toDiscoveredTool(connection, info, claimed, source));
-      claimed.add(info.name);
+    const exposed = exposeListedTools(listed, claimed);
+    for (const { info, exposedName } of exposed) {
+      resolved.push(toDiscoveredTool(connection, info, exposedName, source));
+      claimed.add(exposedName);
     }
   }
   return resolved;
@@ -154,30 +163,69 @@ export async function sourceForConnection(
   });
 }
 
+/**
+ * Same catalog rule as the Cursor-account bridge: slug illegal characters,
+ * then `_2` / `_3` … for colliders (including authored tools already in
+ * `claimed`). Suffix assignment is stable for a colliding group: sort by
+ * original advertised name, independent of `listTools` order.
+ */
+function exposeListedTools(
+  listed: HostMcpToolInfo[],
+  claimed: ReadonlySet<string>
+): Array<{ info: HostMcpToolInfo; exposedName: string }> {
+  const byBase = new Map<string, HostMcpToolInfo[]>();
+  for (const info of listed) {
+    const base = sanitizeMcpToolName(info.name);
+    const group = byBase.get(base);
+    if (group === undefined) {
+      byBase.set(base, [info]);
+    } else {
+      group.push(info);
+    }
+  }
+  const taken = new Set(claimed);
+  const exposedNameByInfo = new Map<HostMcpToolInfo, string>();
+  const sortedBases = [...byBase.keys()].sort((left, right) =>
+    left < right ? -1 : left > right ? 1 : 0
+  );
+  for (const base of sortedBases) {
+    const group = byBase.get(base)!;
+    group.sort((left, right) =>
+      left.name < right.name ? -1 : left.name > right.name ? 1 : 0
+    );
+    group.forEach((info, index) => {
+      let suffixIndex = index;
+      let exposedName = suffixMcpToolName(base, suffixIndex);
+      while (taken.has(exposedName)) {
+        suffixIndex++;
+        exposedName = suffixMcpToolName(base, suffixIndex);
+      }
+      taken.add(exposedName);
+      exposedNameByInfo.set(info, exposedName);
+    });
+  }
+  return listed.map((info) => ({
+    info,
+    exposedName: exposedNameByInfo.get(info)!,
+  }));
+}
+
 function toDiscoveredTool(
   connection: DiscoveredConnection,
   info: HostMcpToolInfo,
-  claimed: ReadonlySet<string>,
+  exposedName: string,
   source: AdvertisedToolSource
 ): DiscoveredTool {
-  if (!ADVERTISED_TOOL_NAME_PATTERN.test(info.name)) {
-    throw new Error(
-      `Advertised connection "${connection.name}" serves tool name "${info.name}", which must match ${ADVERTISED_TOOL_NAME_PATTERN} (it becomes the tool name the model sees).`
-    );
-  }
-  if (claimed.has(info.name)) {
-    throw new Error(
-      `Advertised connection "${connection.name}" serves tool "${info.name}", which collides with an authored agent/tools/ tool or another advertised connection.`
-    );
-  }
   const description =
     info.description === undefined || info.description.trim() === ""
       ? `${info.name} — MCP tool on the "${connection.name}" connection, forwarded 1:1.`
       : info.description;
   const inputSchema = info.inputSchema ?? ANY_OBJECT_SCHEMA;
+  const outputSchema = info.outputSchema;
   const definition: ToolDefinition = brandDefinition("tool", {
     description,
     inputSchema,
+    ...(outputSchema === undefined ? {} : { outputSchema }),
     execute: async (input: Record<string, unknown>) =>
       formatMcpToolResult(
         connection.name,
@@ -186,9 +234,10 @@ function toDiscoveredTool(
       ),
   } as unknown as ToolDefinition);
   return {
-    name: info.name,
+    name: exposedName,
     description,
     inputSchema,
+    ...(outputSchema === undefined ? {} : { outputSchema }),
     execution: "server",
     needsApproval: false,
     definition,

package/src/internal/cli-deploy.ts

@@ -39,10 +39,6 @@ import {
   TERMINAL_DEPLOY_STATUSES,
   validateDeploymentSlug,
 } from "./deploy-client.js";
-import {
-  type AgentDeployManifestV1,
-  buildAgentDeployManifest,
-} from "./deploy-manifest.js";
 import { type GitRunner, inferDeployGitSource } from "./deploy-source.js";
 import {
   type ChildAgentDir,
@@ -666,9 +662,10 @@ async function deployOne(
     ...(egressAllowedDomains.length === 0 ? {} : { egressAllowedDomains }),
     publicRoutePaths:
       publicRoutePaths.length === 0 ? undefined : publicRoutePaths,
-    // Offline metadata extraction (Wd): the CP persists this before any VM
-    // starts. Directories without an agent project send no manifest.
-    ...(manifest === undefined ? {} : { manifest: manifest.deployManifest }),
+    // Deliberately NO manifest here: the control plane captures it from the
+    // provisioned engine (`GET /v1/manifest` after the health probe), which
+    // is the single write path for deploy manifests. `july manifest` remains
+    // available for local visibility only.
   };
 
   let accepted: DeployAccepted;
@@ -864,13 +861,6 @@ interface DeployManifest {
    * (only `/v1/channels/…` subtrees can be public); surfaced as a warning.
    */
   httpChannelPublicEndpoint: boolean;
-  /**
-   * The offline deploy manifest (Wd): derived event declarations, channel
-   * kinds, egress, routes, and the full `/v1/info` payload. Attached to the
-   * deploy request so the control plane stores metadata before any VM
-   * starts; servers that predate manifest storage strip the field.
-   */
-  deployManifest: AgentDeployManifestV1;
 }
 
 /**
@@ -895,7 +885,6 @@ async function readDeployManifest(dir: string): Promise<DeployManifest> {
     httpChannelPublicEndpoint: (project.httpChannel.auth ?? []).some(
       isPublicEndpointPolicy
     ),
-    deployManifest: buildAgentDeployManifest(project),
   };
 }
 

package/src/internal/convert-automation/convert-workflow.ts

@@ -7,6 +7,7 @@
  */
 
 import { CLI_COMMAND_NAME, PACKAGE_NAME } from "../distribution.js";
+import { MEMORY_TS } from "../init-scaffold.js";
 import { pascalCase, SlugRegistry, slugify } from "./slug.js";
 import type {
   ActionJson,
@@ -128,7 +129,7 @@ export function convertWorkflow(
     hasSlackAction && emitSlackAccountConnection(automation, out);
 
   if (workflow.memoryEnabled === true) {
-    out.files.push({ path: "agent/hooks/memory.ts", contents: MEMORY_HOOK });
+    out.files.push({ path: "agent/hooks/memory.ts", contents: MEMORY_TS });
   }
 
   out.setupSteps.push(
@@ -1410,13 +1411,3 @@ function jsonComment(value: unknown): string[] {
 function dedupe(values: string[]): string[] {
   return [...new Set(values)];
 }
-
-/** Memory hook contents — identical to the `initProject` scaffold. */
-const MEMORY_HOOK = `// Journals every turn (timestamp, session, user message, result) so
-// future sessions can recall past work. The journal is shared across every
-// session — and every user — of this agent. Pass your own MemoryBackend to
-// change where memories live, or delete this file to opt out.
-import { memoryHook } from "${PACKAGE_NAME}/memory";
-
-export default memoryHook();
-`;

package/src/internal/cursor/account-mcp.ts

@@ -23,9 +23,22 @@ import {
 import { bearerAuth } from "../../channels.js";
 import type { AgentProject, AuthPolicy } from "../../types.js";
 import { isCursorAccountTransport } from "../../types.js";
+import { probeConnectorAuthUrls } from "../cursor-account-mcp-auth.js";
+import { LOG_PREFIX } from "../distribution.js";
 import { handleStatelessMcpRequest } from "../mcp-endpoint.js";
 import { isLoopbackAddress } from "../net.js";
+import {
+  sanitizeMcpToolName,
+  suffixMcpToolName,
+} from "../sanitize-mcp-tool-name.js";
 import type { EngineResolvedConnection } from "../session-engine.js";
+import {
+  colorEnabledFor,
+  formatTerminalBox,
+  stdoutPalette,
+  type TerminalPalette,
+  terminalHyperlink,
+} from "../terminal-style.js";
 import type {
   AccountMcpServer,
   CursorBackendClient,
@@ -38,8 +51,13 @@ const CATALOG_TTL_MS = 60_000;
  * a model hallucinating tool names cannot turn into a backend hot loop.
  */
 const FORCE_REFRESH_MIN_INTERVAL_MS = 5_000;
-/** MCP clients commonly enforce `^[a-zA-Z0-9_-]{1,128}$` for tool names. */
-const MAX_TOOL_NAME_LENGTH = 128;
+
+/** Dashboard Integrations & MCP — reconnect team / account connectors. */
+export const CURSOR_ACCOUNT_MCP_DASHBOARD_URL =
+  "https://cursor.com/dashboard/integrations";
+/** Cursor app Settings → MCP (Connect / Authenticate on the named row). */
+export const CURSOR_ACCOUNT_MCP_SETTINGS_DEEPLINK =
+  "cursor://anysphere.cursor-deeplink/customize?tab=mcp";
 
 // ============================================================================
 // Authored account MCP connections (validated refs, mirroring peer MCP connections)
@@ -131,6 +149,8 @@ interface CatalogTool {
   serverIdentifier: string;
   description: string;
   inputSchema: Record<string, unknown>;
+  /** Present only when the connector's server declares one. */
+  outputSchema?: Record<string, unknown>;
 }
 
 interface Catalog {
@@ -155,6 +175,7 @@ export class CursorAccountMcpBridge {
   readonly secret: string = randomBytes(32).toString("hex");
   private readonly client: CursorBackendClient;
   private readonly logger: (line: string) => void;
+  private readonly palette: TerminalPalette;
   private readonly secretPolicy: AuthPolicy;
   private readonly allowRemoteCallers: boolean;
   private readonly catalogs = new Map<string, CatalogEntry>();
@@ -162,6 +183,8 @@ export class CursorAccountMcpBridge {
   constructor(args: {
     client: CursorBackendClient;
     logger?: (line: string) => void;
+    /** Defaults to stdout; tests pass `makePalette(false)` for a plain box. */
+    palette?: TerminalPalette;
     /**
      * Admit non-loopback callers presenting the secret. Only set when the
      * serve host configured a `publicUrl` (cloud turns reach the bridge
@@ -171,6 +194,7 @@ export class CursorAccountMcpBridge {
   }) {
     this.client = args.client;
     this.logger = args.logger ?? (() => {});
+    this.palette = args.palette ?? stdoutPalette();
     this.secretPolicy = bearerAuth(this.secret);
     this.allowRemoteCallers = args.allowRemoteCallers === true;
   }
@@ -213,9 +237,9 @@ export class CursorAccountMcpBridge {
 
   /**
    * Startup DX: log the account's connector statuses for `refs` without
-   * blocking serve startup. Surfaces "needsAuth" / "error" connectors with
-   * remediation hints (and a backend probe detail for `error`), and filters
-   * that matched nothing (typo'd connector names).
+   * blocking serve startup. Healthy catalogs stay a one-line summary;
+   * `needsAuth` / `error` / empty catalogs render a yellow warning box with
+   * reconnect URLs.
    *
    * Returns a promise that settles when every ref's log lines are written —
    * callers may ignore it; tests can await it.
@@ -229,28 +253,50 @@ export class CursorAccountMcpBridge {
   private async runPreflight(ref: CursorAccountConnectionRef): Promise<void> {
     try {
       const catalog = await this.getCatalog(ref);
-      if (catalog.servers.length === 0) {
+      const errorDetails = new Map<string, string>();
+      const needsAuthNames = catalog.servers
+        .filter((server) => server.status === "needsAuth")
+        .map((server) => server.serverIdentifier);
+      const [authUrls] = await Promise.all([
+        probeConnectorAuthUrls({
+          client: this.client,
+          identifiers: needsAuthNames,
+        }),
+        Promise.all(
+          catalog.servers
+            .filter((server) => server.status === "error")
+            .map(async (server) => {
+              const detail = await diagnoseConnectorError(
+                this.client,
+                server.serverIdentifier
+              );
+              if (detail !== undefined) {
+                errorDetails.set(server.serverIdentifier, detail);
+              }
+            })
+        ),
+      ]);
+
+      const unhealthy = catalog.servers.some(
+        (server) => server.status === "needsAuth" || server.status === "error"
+      );
+      if (catalog.servers.length === 0 || unhealthy) {
         this.logger(
-          `[agent-sdk] Cursor account MCP connection "${ref.name}": no matching connectors on this account — connect servers in Cursor (dashboard → MCP) or fix the \`servers\` filter`
+          formatCursorAccountMcpWarningBox({
+            connectionName: ref.name,
+            servers: catalog.servers.map((server) => ({
+              serverIdentifier: server.serverIdentifier,
+              status: server.status,
+              toolCount: server.tools.length,
+              errorDetail: errorDetails.get(server.serverIdentifier),
+              authUrl: authUrls.get(server.serverIdentifier),
+            })),
+            palette: this.palette,
+          })
         );
         return;
       }
 
-      const errorDetails = new Map<string, string>();
-      await Promise.all(
-        catalog.servers
-          .filter((server) => server.status === "error")
-          .map(async (server) => {
-            const detail = await diagnoseConnectorError(
-              this.client,
-              server.serverIdentifier
-            );
-            if (detail !== undefined) {
-              errorDetails.set(server.serverIdentifier, detail);
-            }
-          })
-      );
-
       const summary = catalog.servers
         .map((server) =>
           formatServerStatusSummary(
@@ -260,41 +306,11 @@ export class CursorAccountMcpBridge {
         )
         .join(", ");
       this.logger(
-        `[agent-sdk] Cursor account MCP connection "${ref.name}": ${summary}`
-      );
-
-      const needsAuth = catalog.servers.filter(
-        (server) => server.status === "needsAuth"
+        `${LOG_PREFIX} Cursor account MCP connection "${ref.name}": ${summary}`
       );
-      if (needsAuth.length > 0) {
-        this.logger(
-          `[agent-sdk] Cursor account MCP connection "${ref.name}": ${needsAuth
-            .map((server) => server.serverIdentifier)
-            .join(
-              ", "
-            )} need re-authorization in Cursor (dashboard → MCP / Settings → MCP) before their tools appear`
-        );
-      }
-
-      const errored = catalog.servers.filter(
-        (server) => server.status === "error"
-      );
-      if (errored.length > 0) {
-        const details = errored
-          .map((server) => {
-            const detail = errorDetails.get(server.serverIdentifier);
-            return detail === undefined
-              ? server.serverIdentifier
-              : `${server.serverIdentifier} (${detail})`;
-          })
-          .join("; ");
-        this.logger(
-          `[agent-sdk] Cursor account MCP connection "${ref.name}": ${details} — Cursor backend could not use this connector (not a missing agent-sdk login). Re-check the server in Cursor dashboard → MCP, confirm the URL is healthy, and retry after the backend can reach it`
-        );
-      }
     } catch (error: unknown) {
       this.logger(
-        `[agent-sdk] Cursor account MCP connection "${ref.name}" preflight failed: ${describeError(error)}`
+        `${LOG_PREFIX} Cursor account MCP connection "${ref.name}" preflight failed: ${describeError(error)}`
       );
     }
   }
@@ -316,6 +332,9 @@ export class CursorAccountMcpBridge {
           name: tool.exposedName,
           description: tool.description,
           inputSchema: tool.inputSchema,
+          ...(tool.outputSchema === undefined
+            ? {}
+            : { outputSchema: tool.outputSchema }),
         })),
       };
     });
@@ -448,7 +467,7 @@ function buildCatalog(servers: AccountMcpServer[]): Catalog {
   >();
   for (const server of servers) {
     for (const tool of server.tools) {
-      const base = sanitizeToolName(tool.name);
+      const base = sanitizeMcpToolName(tool.name);
       const group = byBase.get(base);
       const item = { serverIdentifier: server.serverIdentifier, tool };
       if (group === undefined) {
@@ -477,10 +496,10 @@ function buildCatalog(servers: AccountMcpServer[]): Catalog {
     });
     group.forEach(({ serverIdentifier, tool }, index) => {
       let suffixIndex = index;
-      let exposedName = suffixToolName(base, suffixIndex);
+      let exposedName = suffixMcpToolName(base, suffixIndex);
       while (byExposedName.has(exposedName)) {
         suffixIndex++;
-        exposedName = suffixToolName(base, suffixIndex);
+        exposedName = suffixMcpToolName(base, suffixIndex);
       }
       const entry: CatalogTool = {
         exposedName,
@@ -488,6 +507,9 @@ function buildCatalog(servers: AccountMcpServer[]): Catalog {
         serverIdentifier,
         description: tool.description,
         inputSchema: tool.inputSchema,
+        ...(tool.outputSchema === undefined
+          ? {}
+          : { outputSchema: tool.outputSchema }),
       };
       tools.push(entry);
       byExposedName.set(entry.exposedName, entry);
@@ -496,29 +518,142 @@ function buildCatalog(servers: AccountMcpServer[]): Catalog {
   return { servers, tools, byExposedName };
 }
 
-/** Connector display names can contain anything (spaces, dots, emoji). */
-function sanitizeToolName(name: string): string {
-  const cleaned = name
-    .replace(/[^a-zA-Z0-9_-]/g, "_")
-    .slice(0, MAX_TOOL_NAME_LENGTH);
-  return cleaned === "" ? "tool" : cleaned;
+function trimTrailingSlash(url: string): string {
+  return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+
+function describeError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export interface CursorAccountMcpWarningServer {
+  serverIdentifier: string;
+  status: string;
+  toolCount: number;
+  errorDetail?: string;
+  /** Minted OAuth URL for a `needsAuth` connector, when the probe succeeded. */
+  authUrl?: string;
 }
 
-/** `base` for the first claimant, `base_2` / `base_3` … for colliders. */
-function suffixToolName(base: string, index: number): string {
-  if (index === 0) {
-    return base;
+const MAX_ERROR_DETAIL_CHARS = 72;
+
+function truncateDetail(detail: string): string {
+  const trimmed = detail.trim();
+  if (trimmed.length <= MAX_ERROR_DETAIL_CHARS) {
+    return trimmed;
   }
-  const suffix = `_${index + 1}`;
-  return `${base.slice(0, MAX_TOOL_NAME_LENGTH - suffix.length)}${suffix}`;
+  return `${trimmed.slice(0, MAX_ERROR_DETAIL_CHARS - 1)}…`;
 }
 
-function trimTrailingSlash(url: string): string {
-  return url.endsWith("/") ? url.slice(0, -1) : url;
+function formatWarningStatusRow(
+  server: CursorAccountMcpWarningServer,
+  nameWidth: number,
+  hyperlinks: boolean
+): string {
+  const name = server.serverIdentifier.padEnd(nameWidth);
+  switch (server.status) {
+    case "needsAuth":
+      return `${name}  ${terminalHyperlink(connectUrl(server.authUrl), "Connect", hyperlinks)}`;
+    case "connected":
+      return `${name}  ${server.toolCount} tools`;
+    case "error": {
+      const detail =
+        server.errorDetail === undefined || server.errorDetail.trim() === ""
+          ? "backend could not reach connector"
+          : truncateDetail(server.errorDetail);
+      return `${name}  error: ${detail}`;
+    }
+    default:
+      return `${name}  ${server.status}`;
+  }
 }
 
-function describeError(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
+function connectUrl(authUrl: string | undefined): string {
+  const minted = authUrl?.trim() ?? "";
+  if (
+    minted.startsWith("https://") &&
+    !minted.includes("\u001b") &&
+    !minted.includes("\u0007")
+  ) {
+    return minted;
+  }
+  return CURSOR_ACCOUNT_MCP_DASHBOARD_URL;
+}
+
+/**
+ * Yellow warning panel for unhealthy / missing Cursor-account connectors.
+ * One box replaces the old stacked `[agent-sdk]` log lines.
+ */
+export function formatCursorAccountMcpWarningBox(args: {
+  connectionName: string;
+  servers: readonly CursorAccountMcpWarningServer[];
+  palette?: TerminalPalette;
+  hyperlinks?: boolean;
+}): string {
+  const palette = args.palette ?? stdoutPalette();
+  const hyperlinks = args.hyperlinks ?? colorEnabledFor();
+  const copy = warningCopy({ ...args, hyperlinks });
+  return `\n${formatTerminalBox(
+    [copy.title, "", ...copy.intro, ...copy.actions],
+    {
+      color: palette.yellow,
+      padding: 2,
+    }
+  )}`;
+}
+
+function warningCopy(args: {
+  connectionName: string;
+  servers: readonly CursorAccountMcpWarningServer[];
+  hyperlinks: boolean;
+}): { title: string; intro: string[]; actions: string[] } {
+  const empty = args.servers.length === 0;
+  const hasAuth = args.servers.some((server) => server.status === "needsAuth");
+  const hasError = args.servers.some((server) => server.status === "error");
+  const nameWidth = Math.max(
+    0,
+    ...args.servers.map((server) => server.serverIdentifier.length)
+  );
+  const statusRows = args.servers.map((server) =>
+    formatWarningStatusRow(server, nameWidth, args.hyperlinks)
+  );
+  const links = [
+    `  ${CURSOR_ACCOUNT_MCP_SETTINGS_DEEPLINK}`,
+    `  ${CURSOR_ACCOUNT_MCP_DASHBOARD_URL}`,
+  ];
+  const restart = "Then press Enter to restart this serve.";
+
+  if (empty) {
+    return {
+      title: "No matching MCP connectors",
+      intro: [
+        `No matching connectors on this account ("${args.connectionName}").`,
+      ],
+      actions: [
+        "",
+        "Connect servers in Cursor, or fix the `servers` filter.",
+        ...links,
+      ],
+    };
+  }
+  if (hasAuth && !hasError) {
+    return {
+      title: "MCP authorization needed",
+      intro: statusRows,
+      actions: ["", restart, "", "Or reconnect at:", ...links],
+    };
+  }
+  return {
+    title: hasAuth ? "MCP authorization needed" : "MCP connector error",
+    intro: statusRows,
+    actions: [
+      "",
+      "Re-check the server URL is healthy, then reconnect at:",
+      ...links,
+      "",
+      restart,
+    ],
+  };
 }
 
 /** One-line status for the preflight summary (`name (12 tools)` / `name (error: …)`). */