codex-copilot-dx 0.6.6 → 0.6.7

package/README.md

@@ -37,6 +37,10 @@ breaking release. For a one-off run without a global install, use
 `npm exec --yes --package=codex-copilot-dx@latest -- ccdx`.
 Run `ccdx <command> --help` (including `auth login claude --help` and
 `pms status --help`) for command-specific behavior and side-effect details.
+The read-only `usage`, `models`, `auth status`, and `pms status` commands use
+aligned tables in interactive terminals. Redirected or piped output keeps the
+legacy plain-text layout for script compatibility; use `--format table` or
+`--format plain` to choose explicitly.
 
 To query the models currently advertised as selectable for the saved Codex
 Copilot account, run:
@@ -47,7 +51,8 @@ ccdx models
 
 This performs a fresh, read-only GitHub Copilot model-directory lookup without
 starting the adapter, opening device login, reading the local model cache, or
-consuming an inference request. It lists model IDs by provider with their
+consuming an inference request. It lists model IDs in a provider, API, and
+preview-status table with their
 advertised API capabilities and reports the live Claude/Anthropic count. A model
 being advertised does not guarantee that a later inference request will avoid
 quota, rate-limit, or policy enforcement.
@@ -384,6 +389,10 @@ The adapter records token usage metadata to `~/.local/share/codex-copilot-dx/usa
 ccdx usage
 ```
 
+The summary covers the retained current usage log and its single rotated
+backup, not an unbounded lifetime history. Its table reports recorded usage
+responses and per-model input, cache-read, output, and total token metadata.
+
 ### Debug logging
 
 Set `CCDX_LOG_PATH=1` to mirror terminal logs to `~/.local/share/codex-copilot-dx/debug.log`, or set `CCDX_LOG_PATH` to a custom file. Add `CCDX_LOG_LEVEL=debug` to include upstream request attempts, retry causes, status codes, and timings. Debug logs do not include prompts, completions, request bodies, or authorization tokens.

package/bin/cli.mjs

@@ -47,7 +47,10 @@ if (CLI.command === "version") {
   process.exit(0);
 }
 if (CLI.command === "usage") {
-  await printUsageSummary();
+  await printUsageSummary({
+    format: CLI.outputFormat || "auto",
+    output: process.stdout,
+  });
   process.exit(0);
 }
 if (CLI.command === "auth") {
@@ -59,6 +62,8 @@ if (CLI.command === "auth") {
       reauth: CLI.reauth,
       expectedLogin: CLI.expectedLogin,
       commandName: CLI_NAME,
+      format: CLI.outputFormat || "auto",
+      output: process.stdout,
     });
     if (result.output) console.log(result.output);
     if (result.action === "login") {
@@ -97,7 +102,11 @@ if (CLI.command === "status") {
 if (CLI.command === "models") {
   try {
     const catalog = await fetchLiveCopilotModels({ profile: CLI.profile });
-    console.log(formatLiveCopilotModels(catalog, { commandName: CLI_NAME }));
+    console.log(formatLiveCopilotModels(catalog, {
+      commandName: CLI_NAME,
+      format: CLI.outputFormat || "auto",
+      output: process.stdout,
+    }));
     process.exit(0);
   } catch (e) {
     console.error(status("err", e.message));
@@ -127,7 +136,11 @@ if (CLI.command === "pms") {
   try {
     if (CLI.action === "status") {
       const { runPmStudioStatus } = await import("../src/pm-studio-status.mjs");
-      const result = await runPmStudioStatus({ commandName: CLI_NAME });
+      const result = await runPmStudioStatus({
+        commandName: CLI_NAME,
+        format: CLI.outputFormat || "auto",
+        output: process.stdout,
+      });
       process.exit(result.ok ? 0 : 1);
     }
     const { runPmStudioSetup } = await import("../src/pm-studio-setup.mjs");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.6.6",
+  "version": "0.6.7",
   "description": "Use Codex Desktop, Claude Code, and Claude App with GitHub Copilot",
   "author": "Dale Xiao",
   "type": "module",

package/src/cli-auth.mjs

@@ -24,6 +24,12 @@ import { saveModelCache } from "./model-cache.mjs";
 import { isClaudeCopilotModel } from "./models.mjs";
 import { profileRouting } from "./profile-routing.mjs";
 import { status } from "./status.mjs";
+import {
+  cliOutputFormat,
+  cliOutputWidth,
+  formatResponsiveCliTable,
+  terminalCell,
+} from "./cli-table.mjs";
 
 const CLIENT_ID = "Iv1.b507a08c87ecfe98";
 const SCOPE = "read:user";
@@ -479,7 +485,7 @@ function onlineStatusLine(name, profile) {
   return status("ok", `${name} online: ${account}${online.models} models, ${online.claudeModels} Claude`);
 }
 
-export function formatAuthStatus(snapshot = authStatus(), { commandName = "ccdx" } = {}) {
+function authStatusPlainLines(snapshot, { commandName }) {
   const claudeLabel = snapshot.profiles.claude.configured
     ? `${accountLabel(snapshot.profiles.claude)} [isolated profile]`
     : "inherits Codex [no isolated profile]";
@@ -493,7 +499,95 @@ export function formatAuthStatus(snapshot = authStatus(), { commandName = "ccdx"
     status(claudeKind, `Claude: ${claudeLabel}`),
     onlineStatusLine("Claude", snapshot.profiles.claude),
     status("info", `Routing: responses -> ${snapshot.routing.responses}; messages -> ${snapshot.routing.messages}`),
-  ].filter(Boolean).join("\n");
+  ].filter(Boolean);
+}
+
+function authTableOnline(profile) {
+  const online = profile.online;
+  if (!online) return { state: "[INFO] not checked", models: "—", claudeModels: "—" };
+  if (online.inherited) return { state: "[INFO] inherits Codex", models: "—", claudeModels: "—" };
+  if (!online.ok) {
+    const httpStatus = online.httpStatus ? ` (HTTP ${online.httpStatus})` : "";
+    return {
+      state: `[WARN] ${online.reason || "unavailable"}${httpStatus}`,
+      models: "—",
+      claudeModels: "—",
+    };
+  }
+  return {
+    state: `[OK] verified${online.login ? ` as ${online.login}` : ""}`,
+    models: Number.isFinite(online.models) ? String(online.models) : "—",
+    claudeModels: Number.isFinite(online.claudeModels) ? String(online.claudeModels) : "—",
+  };
+}
+
+function authTableRow(name, profile, { claude = false } = {}) {
+  const inherited = claude && !profile.configured;
+  const online = authTableOnline(profile);
+  const local = inherited
+    ? "[INFO] inherits Codex"
+    : profile.valid
+      ? "[OK] ready"
+      : `[WARN] ${accountLabel(profile)}`;
+  const account = inherited ? "inherits Codex" : accountLabel(profile);
+  const mode = inherited ? "inherited" : claude ? "isolated" : "legacy path";
+  return {
+    profile: name,
+    account,
+    mode,
+    local,
+    online: online.state,
+    models: online.models,
+    claudeModels: online.claudeModels,
+  };
+}
+
+export function formatAuthStatus(snapshot = authStatus(), {
+  commandName = "ccdx",
+  format = "plain",
+  output = process.stdout,
+  width = cliOutputWidth(output),
+} = {}) {
+  const plainLines = authStatusPlainLines(snapshot, { commandName });
+  if (cliOutputFormat(format, output) === "plain") {
+    return plainLines.join("\n");
+  }
+
+  const rows = [
+    authTableRow("Codex", snapshot.profiles.codex),
+    authTableRow("Claude", snapshot.profiles.claude, { claude: true }),
+  ];
+  const table = formatResponsiveCliTable({
+    columns: [
+      { key: "profile", label: "PROFILE" },
+      { key: "account", label: "ACCOUNT" },
+      { key: "mode", label: "MODE" },
+      { key: "local", label: "LOCAL" },
+      { key: "online", label: "ONLINE" },
+      { key: "models", label: "MODELS", align: "right" },
+      { key: "claudeModels", label: "CLAUDE", align: "right" },
+    ],
+    compactColumns: [
+      { key: "profile", label: "PROFILE" },
+      { key: "local", label: "LOCAL" },
+      { key: "online", label: "ONLINE" },
+    ],
+    rows,
+    width,
+  });
+  if (format === "auto" && table.overflow) {
+    return plainLines.map((line) => terminalCell(line, { fallback: "" })).join("\n");
+  }
+  const lines = [
+    `${commandName} auth status`,
+    "",
+    table.output,
+  ];
+  if (table.compact) {
+    lines.push("", "Details:", ...plainLines.slice(1, -1).map((line) => terminalCell(line, { fallback: "" })));
+  }
+  lines.push(terminalCell(plainLines.at(-1), { fallback: "" }));
+  return lines.join("\n");
 }
 
 export async function runAuthCommand({
@@ -503,11 +597,13 @@ export async function runAuthCommand({
   reauth = false,
   expectedLogin = "",
   commandName = "ccdx",
+  format = "plain",
+  output = process.stdout,
   ...options
 } = {}) {
   if (action === "status") {
     const snapshot = online ? await authStatusOnline(options) : authStatus(options);
-    return { action, output: formatAuthStatus(snapshot, { commandName }), snapshot };
+    return { action, output: formatAuthStatus(snapshot, { commandName, format, output }), snapshot };
   }
   if (profile !== AUTH_PROFILE_CLAUDE) throw new Error("Only the isolated Claude profile can be changed by this command");
   if (action === "login") return { action, ...(await authorizeClaudeProfile({ ...options, reauth, expectedLogin })) };

package/src/cli-models.mjs

@@ -11,6 +11,12 @@ import {
   isClaudeCopilotModel,
 } from "./models.mjs";
 import { status } from "./status.mjs";
+import {
+  cliOutputFormat,
+  cliOutputWidth,
+  formatResponsiveCliTable,
+  terminalCell,
+} from "./cli-table.mjs";
 
 const DEFAULT_MODELS_TIMEOUT_MS = 10000;
 const SUPPORTED_ENDPOINTS = [
@@ -166,21 +172,22 @@ export async function fetchLiveCopilotModels({
   }
 }
 
-export function formatLiveCopilotModels(catalog, { commandName = "ccdx" } = {}) {
-  const models = Array.isArray(catalog?.models) ? catalog.models : [];
-  const profile = catalog?.profile === AUTH_PROFILE_CLAUDE ? AUTH_PROFILE_CLAUDE : AUTH_PROFILE_CODEX;
+function liveCatalogHeader(catalog, { commandName, profile, models }) {
   const responses = models.filter((model) => model.endpoints.includes("responses")).length;
   const chat = models.filter((model) => model.endpoints.includes("chat")).length;
   const claude = models.filter(isClaudeCopilotCatalogEntry).length;
-  const lines = [
+  return [
     `${commandName} models${profile === AUTH_PROFILE_CLAUDE ? " --profile claude" : ""}`,
     status("ok", `Live catalog from ${safeText(catalog?.upstreamHost, "GitHub Copilot")}: ${models.length} selectable of ${Number(catalog?.advertised) || 0} advertised`),
     status("info", `Responses: ${responses}; Chat: ${chat}; Claude/Anthropic: ${claude}`),
   ];
+}
 
+function formatLiveCopilotModelsPlain(catalog, { commandName, profile, models }, { sanitize = false } = {}) {
+  const lines = liveCatalogHeader(catalog, { commandName, profile, models });
   if (!models.length) {
     lines.push(status("warn", "No selectable models were advertised for this account"));
-    return lines.join("\n");
+    return (sanitize ? lines.map((line) => terminalCell(line, { fallback: "" })) : lines).join("\n");
   }
 
   let vendor = "";
@@ -192,5 +199,53 @@ export function formatLiveCopilotModels(catalog, { commandName = "ccdx" } = {})
     const flags = [...model.endpoints, ...(model.preview ? ["preview"] : [])];
     lines.push(`  ${model.id} [${flags.join(", ")}]`);
   }
+  return (sanitize ? lines.map((line) => terminalCell(line, { fallback: "" })) : lines).join("\n");
+}
+
+export function formatLiveCopilotModels(catalog, {
+  commandName = "ccdx",
+  format = "plain",
+  output = process.stdout,
+  width = cliOutputWidth(output),
+} = {}) {
+  const models = Array.isArray(catalog?.models) ? catalog.models : [];
+  const profile = catalog?.profile === AUTH_PROFILE_CLAUDE ? AUTH_PROFILE_CLAUDE : AUTH_PROFILE_CODEX;
+  const context = { commandName, profile, models };
+  if (cliOutputFormat(format, output) === "plain") {
+    return formatLiveCopilotModelsPlain(catalog, context);
+  }
+
+  const lines = liveCatalogHeader(catalog, context);
+  if (!models.length) {
+    lines.push(status("warn", "No selectable models were advertised for this account"));
+    return lines.join("\n");
+  }
+
+  const rows = models.map((model) => ({
+    vendor: model.vendor,
+    model: model.id,
+    vendorModel: `${model.vendor}/${model.id}`,
+    apis: model.endpoints.join(", "),
+    preview: model.preview ? "yes" : "no",
+  }));
+  const table = formatResponsiveCliTable({
+    columns: [
+      { key: "vendor", label: "VENDOR" },
+      { key: "model", label: "MODEL" },
+      { key: "apis", label: "APIS" },
+      { key: "preview", label: "PREVIEW" },
+    ],
+    compactColumns: [
+      { key: "vendorModel", label: "VENDOR/MODEL" },
+      { key: "apis", label: "APIS" },
+      { key: "preview", label: "PREVIEW" },
+    ],
+    rows,
+    width,
+  });
+  if (format === "auto" && table.overflow) {
+    return formatLiveCopilotModelsPlain(catalog, context, { sanitize: true });
+  }
+  lines.push("", table.output);
   return lines.join("\n");
 }

package/src/cli-options.mjs

@@ -60,6 +60,18 @@ function checkedProfile(value, { allowAll = false } = {}) {
   return profile;
 }
 
+function checkedOutputFormat(value) {
+  const format = value || "";
+  if (!new Set(["table", "plain"]).has(format)) {
+    throw new Error(`Format must be table or plain: ${value}`);
+  }
+  return format;
+}
+
+function outputFormatOption(value) {
+  return value ? { outputFormat: checkedOutputFormat(value) } : {};
+}
+
 function baseCommand(command, extra = {}) {
   return {
     command,
@@ -137,28 +149,42 @@ export function parseCliArgs(args = []) {
     return baseCommand("status");
   }
   if (command === "usage") {
-    if (rest.length) unexpectedArgs(rest);
-    return baseCommand("usage");
+    const options = parseOptions(rest, new Map([["--format", "value"]]));
+    return baseCommand("usage", outputFormatOption(options["--format"]));
   }
   if (PM_COMMANDS.has(command)) {
     const [action, ...pmsArgs] = rest;
     if (!action) throw new Error("Missing pms action: expected setup or status");
     if (!new Set(["setup", "status"]).has(action)) throw new Error(`Unknown pms action: ${action}`);
-    if (pmsArgs.length) unexpectedArgs(pmsArgs);
-    return baseCommand("pms", { action });
+    if (action === "setup") {
+      if (pmsArgs.length) unexpectedArgs(pmsArgs);
+      return baseCommand("pms", { action });
+    }
+    const options = parseOptions(pmsArgs, new Map([["--format", "value"]]));
+    return baseCommand("pms", {
+      action,
+      ...outputFormatOption(options["--format"]),
+    });
   }
   if (command === "models") {
-    const options = parseOptions(rest, new Map([["--profile", "value"]]));
+    const options = parseOptions(rest, new Map([
+      ["--profile", "value"],
+      ["--format", "value"],
+    ]));
     return {
       ...baseCommand("models"),
       profile: checkedProfile(options["--profile"]),
+      ...outputFormatOption(options["--format"]),
     };
   }
   if (command === "auth") {
     const [action, ...authArgs] = rest;
     if (!action) throw new Error("Missing auth action: expected status or login");
     if (action === "status") {
-      const options = parseOptions(authArgs, new Map([["--online", "flag"]]));
+      const options = parseOptions(authArgs, new Map([
+        ["--online", "flag"],
+        ["--format", "value"],
+      ]));
       return {
         ...baseCommand("auth"),
         action: "status",
@@ -166,6 +192,7 @@ export function parseCliArgs(args = []) {
         online: Boolean(options["--online"]),
         expectedLogin: "",
         reauth: false,
+        ...outputFormatOption(options["--format"]),
       };
     }
     if (action === "login") {
@@ -259,16 +286,16 @@ export function cliCommandName() {
 function topicHelp(name, topic) {
   const sections = {
     start: `Usage:\n  ${name} [start] [--configure-claude-app] [--show-request-id]\n\nStarts or reuses the local adapter, updates Codex and Claude Code configuration, and attempts to open Codex or ChatGPT when auto-launch is enabled and supported.\n--configure-claude-app also creates or updates the managed Claude App gateway profile.`,
-    auth: `Usage:\n  ${name} auth status [--online]\n  ${name} auth login claude [--github-login <login>] [--reauth]\n\nShows the two account profiles or configures the isolated Claude account. Device login starts only when no reusable local Copilot credential is available or --reauth is used.`,
-    "auth status": `Usage:\n  ${name} auth status [--online]\n\nShows account routing without exposing credentials. --online also verifies both configured Copilot entitlements and model catalogs.`,
+    auth: `Usage:\n  ${name} auth status [--online] [--format table|plain]\n  ${name} auth login claude [--github-login <login>] [--reauth]\n\nShows the two account profiles or configures the isolated Claude account. Device login starts only when no reusable local Copilot credential is available or --reauth is used.`,
+    "auth status": `Usage:\n  ${name} auth status [--online] [--format table|plain]\n\nShows account routing without exposing credentials. --online also verifies both configured Copilot entitlements and model catalogs. Interactive terminals use a table by default.`,
     "auth login": `Usage:\n  ${name} auth login claude [--github-login <login>] [--reauth]\n\nReuses a compatible local Copilot credential when possible. --reauth forces GitHub Device Flow.`,
     doctor: `Usage:\n  ${name} doctor [--online] [--compat] [--profile codex|claude|all]\n\nChecks local credentials, client configuration, PM Studio state, and the adapter. --online validates account entitlement; --compat sends minimal inference requests and consumes a small amount of Copilot usage.`,
     status: `Usage:\n  ${name} status\n\nShows bounded runtime, routing, performance, cache, queue, and PM relay metrics from a running adapter.`,
-    models: `Usage:\n  ${name} models [--profile codex|claude]\n\nPerforms a fresh, read-only Copilot model-directory lookup for one saved profile.`,
-    pms: `Usage:\n  ${name} pms status\n  ${name} pms setup\n  ${name} pm-studio status\n  ${name} pm-studio setup\n\nInspects or installs the version-locked PM Studio loopback patch. setup modifies the installed app only after all preflight checks pass.`,
+    models: `Usage:\n  ${name} models [--profile codex|claude] [--format table|plain]\n\nPerforms a fresh, read-only Copilot model-directory lookup for one saved profile. Interactive terminals use a table by default.`,
+    pms: `Usage:\n  ${name} pms status [--format table|plain]\n  ${name} pms setup\n  ${name} pm-studio status [--format table|plain]\n  ${name} pm-studio setup\n\nInspects or installs the version-locked PM Studio loopback patch. setup modifies the installed app only after all preflight checks pass.`,
     "pms setup": `Usage:\n  ${name} pms setup\n\nBacks up, patches, verifies, and ad-hoc signs an exactly supported PM Studio bundle. Unknown versions and drift are never modified.`,
-    "pms status": `Usage:\n  ${name} pms status\n\nRead-only inspection of the installed PM Studio version, patch integrity, Claude profile, and relay availability.`,
-    usage: `Usage:\n  ${name} usage\n\nSummarizes local token usage metadata without reading prompt or completion content.`,
+    "pms status": `Usage:\n  ${name} pms status [--format table|plain]\n\nRead-only inspection of the installed PM Studio version, patch integrity, Claude profile, and relay availability. Interactive terminals use a table by default.`,
+    usage: `Usage:\n  ${name} usage [--format table|plain]\n\nSummarizes local token usage metadata without reading prompt or completion content. Interactive terminals use a table by default.`,
     "auto-review-model": `Usage:\n  ${name} auto-review-model\n\nInteractively selects an enabled Responses model for Codex Auto-review.`,
     update: `Usage:\n  ${name} update [npm|github]\n\nUpdates the global package from the configured npm registry or GitHub main. With no source, an interactive terminal prompts for one.`,
     version: `Usage:\n  ${name} --version`,
@@ -282,14 +309,14 @@ export function cliHelp(commandName = "ccdx", topic = "") {
   if (normalizedTopic) return topicHelp(name, normalizedTopic);
   return `Usage:
   ${name} [start] [--configure-claude-app] [--show-request-id]
-  ${name} auth status [--online]
+  ${name} auth status [--online] [--format table|plain]
   ${name} auth login claude [--github-login <login>] [--reauth]
   ${name} doctor [--online] [--compat] [--profile codex|claude|all]
   ${name} status
-  ${name} models [--profile codex|claude]
-  ${name} pms status
+  ${name} models [--profile codex|claude] [--format table|plain]
+  ${name} pms status [--format table|plain]
   ${name} pms setup
-  ${name} usage
+  ${name} usage [--format table|plain]
   ${name} auto-review-model
   ${name} update [npm|github]
   ${name} --version

package/src/cli-table.mjs

@@ -0,0 +1,114 @@
+import { stripVTControlCharacters } from "node:util";
+
+const DEFAULT_TERMINAL_COLUMNS = 120;
+const COMBINING_MARK = /\p{Mark}/u;
+const EMOJI = /\p{Extended_Pictographic}|\p{Regional_Indicator}/u;
+const SIMPLE_WIDTH = /^[\u0020-\u007e\u2014]*$/;
+let graphemeSegmenter;
+
+function wideCodePoint(codePoint) {
+  return codePoint >= 0x1100 && (
+    codePoint <= 0x115f
+    || codePoint === 0x2329
+    || codePoint === 0x232a
+    || (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f)
+    || (codePoint >= 0xac00 && codePoint <= 0xd7a3)
+    || (codePoint >= 0xf900 && codePoint <= 0xfaff)
+    || (codePoint >= 0xfe10 && codePoint <= 0xfe19)
+    || (codePoint >= 0xfe30 && codePoint <= 0xfe6f)
+    || (codePoint >= 0xff00 && codePoint <= 0xff60)
+    || (codePoint >= 0xffe0 && codePoint <= 0xffe6)
+    || (codePoint >= 0x20000 && codePoint <= 0x3fffd)
+  );
+}
+
+function graphemeWidth(segment) {
+  if (EMOJI.test(segment)) return 2;
+  let width = 0;
+  for (const character of segment) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint === 0x200d || (codePoint >= 0xfe00 && codePoint <= 0xfe0f) || COMBINING_MARK.test(character)) continue;
+    width += wideCodePoint(codePoint) ? 2 : 1;
+  }
+  return width;
+}
+
+function displayWidth(value) {
+  if (SIMPLE_WIDTH.test(value)) return value.length;
+  graphemeSegmenter ||= new Intl.Segmenter("en", { granularity: "grapheme" });
+  let width = 0;
+  for (const { segment } of graphemeSegmenter.segment(value)) width += graphemeWidth(segment);
+  return width;
+}
+
+function padding(length) {
+  return length > 0 ? " ".repeat(length) : "";
+}
+
+function padded(value, width, align) {
+  const spaces = padding(width - displayWidth(value));
+  return align === "right" ? `${spaces}${value}` : `${value}${spaces}`;
+}
+
+export function terminalCell(value, { fallback = "—" } = {}) {
+  if (value === undefined || value === null) return fallback;
+  const text = stripVTControlCharacters(String(value))
+    .replace(/[\u0000-\u001f\u007f-\u009f]/g, " ")
+    .replace(/[\u061c\u200b\u200e\u200f\u202a-\u202e\u2060\u2066-\u2069\ufeff]/g, "")
+    .replace(/\s+/g, " ")
+    .trim();
+  return text || fallback;
+}
+
+export function cliOutputFormat(format = "auto", output = process.stdout) {
+  if (format === "table" || format === "plain") return format;
+  return output?.isTTY === true ? "table" : "plain";
+}
+
+export function cliOutputWidth(output = process.stdout) {
+  const columns = Number(output?.columns);
+  return Number.isSafeInteger(columns) && columns > 0 ? columns : DEFAULT_TERMINAL_COLUMNS;
+}
+
+export function formatCliTable({ columns, rows, gap = 2 }) {
+  const normalizedColumns = columns.map((column) => ({
+    ...column,
+    label: terminalCell(column.label, { fallback: "" }),
+  }));
+  const normalizedRows = rows.map((row) => Object.fromEntries(normalizedColumns.map((column) => [
+    column.key,
+    terminalCell(row[column.key]),
+  ])));
+  const widths = normalizedColumns.map((column) => Math.max(
+    displayWidth(column.label),
+    ...normalizedRows.map((row) => displayWidth(row[column.key])),
+  ));
+  const line = (values) => normalizedColumns
+    .map((column, index) => padded(values[column.key], widths[index], column.align))
+    .join(" ".repeat(gap))
+    .trimEnd();
+  const header = Object.fromEntries(normalizedColumns.map((column) => [column.key, column.label]));
+  const separator = Object.fromEntries(normalizedColumns.map((column, index) => [
+    column.key,
+    "-".repeat(widths[index]),
+  ]));
+  return [line(header), line(separator), ...normalizedRows.map(line)].join("\n");
+}
+
+export function cliTableWidth(table) {
+  return Math.max(0, ...String(table).split("\n").map(displayWidth));
+}
+
+export function formatResponsiveCliTable({ columns, compactColumns, rows, width = DEFAULT_TERMINAL_COLUMNS, gap = 2 }) {
+  const full = formatCliTable({ columns, rows, gap });
+  const fullWidth = cliTableWidth(full);
+  if (!compactColumns?.length || fullWidth <= width) {
+    return { output: full, compact: false, overflow: fullWidth > width };
+  }
+  const compact = formatCliTable({ columns: compactColumns, rows, gap });
+  return {
+    output: compact,
+    compact: true,
+    overflow: cliTableWidth(compact) > width,
+  };
+}

package/src/pm-studio-status.mjs

@@ -18,6 +18,12 @@ import {
 import { readAdapterStatus } from "./cli-status.mjs";
 import { checkRunningAdapter } from "./running-adapter.mjs";
 import { status } from "./status.mjs";
+import {
+  cliOutputFormat,
+  cliOutputWidth,
+  formatResponsiveCliTable,
+  terminalCell,
+} from "./cli-table.mjs";
 
 const PM_RELAY_HOST = "127.0.0.1";
 const PM_RELAY_PORT = 2026;
@@ -166,54 +172,106 @@ export async function inspectPmStudioStatus({
   return { ok: operational, appPath, app, claude, adapter, runtime };
 }
 
-function appStatusLine(result, commandName) {
+function appStatusItem(result, commandName) {
   const { app } = result;
   const version = app.metadata ? `${app.metadata.version} build ${app.metadata.build}` : "";
   if (app.state === "patched" && app.patchRecord?.valid === true) {
-    return status("ok", `PM Studio ${version} is patched and verified against its installed patch record`);
+    return { kind: "ok", component: "App patch", detail: `${version}; patched and verified`, message: `PM Studio ${version} is patched and verified against its installed patch record` };
   }
   if (app.state === "patched") {
     const reason = app.patchRecord?.reason || "installed patch record is missing";
-    return status("err", `PM Studio ${version} matches the patch recipe, but its installed patch record is not verified: ${reason}`);
+    return { kind: "err", component: "App patch", detail: `${version}; patch record not verified`, message: `PM Studio ${version} matches the patch recipe, but its installed patch record is not verified: ${reason}` };
   }
-  if (app.state === "clean") return status("warn", `PM Studio ${version} is supported but not patched; run ${commandName} pms setup`);
-  if (app.state === "unsupported") return status("err", `PM Studio ${version} has no exact patch recipe; no files will be changed`);
+  if (app.state === "clean") return { kind: "warn", component: "App patch", detail: `${version}; supported, not patched`, message: `PM Studio ${version} is supported but not patched; run ${commandName} pms setup` };
+  if (app.state === "unsupported") return { kind: "err", component: "App patch", detail: `${version}; unsupported version`, message: `PM Studio ${version} has no exact patch recipe; no files will be changed` };
   if (app.state === "drift" && app.patchRecipeMatched) {
-    return status("err", `PM Studio ${version} matches the patch recipe, but its installed patch record is not verified: ${app.issues.join("; ")}`);
+    return { kind: "err", component: "App patch", detail: `${version}; patch record drift`, message: `PM Studio ${version} matches the patch recipe, but its installed patch record is not verified: ${app.issues.join("; ")}` };
   }
-  if (app.state === "drift") return status("err", `PM Studio ${version} does not match the clean or patched recipe: ${app.issues.join("; ")}`);
-  if (app.state === "not_installed") return status("warn", `PM Studio is not installed at ${result.appPath}`);
-  return status("err", `PM Studio could not be inspected: ${app.issues.join("; ")}`);
+  if (app.state === "drift") return { kind: "err", component: "App patch", detail: `${version}; integrity drift`, message: `PM Studio ${version} does not match the clean or patched recipe: ${app.issues.join("; ")}` };
+  if (app.state === "not_installed") return { kind: "warn", component: "App patch", detail: "not installed", message: `PM Studio is not installed at ${result.appPath}` };
+  return { kind: "err", component: "App patch", detail: "inspection failed", message: `PM Studio could not be inspected: ${app.issues.join("; ")}` };
 }
 
-export function formatPmStudioStatus(result, { commandName = "ccdx" } = {}) {
-  const lines = [
-    `${commandName} pms status`,
-    appStatusLine(result, commandName),
-  ];
+function pmStudioStatusItems(result, commandName) {
+  const items = [appStatusItem(result, commandName)];
   if (result.claude.valid) {
     const account = result.claude.login ? ` for ${result.claude.login}` : "";
-    lines.push(status("ok", `Isolated Claude profile is valid${account}`));
+    const detail = result.claude.login ? `${result.claude.login}; isolated profile valid` : "isolated profile valid";
+    items.push({ kind: "ok", component: "Claude profile", detail, message: `Isolated Claude profile is valid${account}` });
   } else {
     const reason = result.claude.configured && result.claude.reason ? ` (${result.claude.reason})` : "";
-    lines.push(status("err", `Isolated Claude profile is not ready${reason}; run ${PM_STUDIO_CLAUDE_AUTH_COMMAND}`));
+    items.push({ kind: "err", component: "Claude profile", detail: "not ready", message: `Isolated Claude profile is not ready${reason}; run ${PM_STUDIO_CLAUDE_AUTH_COMMAND}` });
   }
   if (result.adapter?.ok && result.runtime?.ok) {
-    lines.push(status("ok", `PM relay and isolated Claude routing are verified at ${result.adapter.baseUrl}`));
+    items.push({ kind: "ok", component: "PM relay", detail: `verified at ${result.adapter.baseUrl}`, message: `PM relay and isolated Claude routing are verified at ${result.adapter.baseUrl}` });
   } else if (result.adapter?.ok) {
     const reason = result.runtime?.issues?.join("; ") || "runtime status is unavailable";
-    lines.push(status("err", `The adapter is running at ${result.adapter.baseUrl}, but PM relay routing is not ready: ${reason}; stop it and run ${commandName} start`));
+    items.push({ kind: "err", component: "PM relay", detail: "running but routing not ready", message: `The adapter is running at ${result.adapter.baseUrl}, but PM relay routing is not ready: ${reason}; stop it and run ${commandName} start` });
   } else if (result.adapter?.incompatible) {
-    lines.push(status("err", `The adapter at ${result.adapter.baseUrl} is incompatible; stop it and run ${commandName} start`));
+    items.push({ kind: "err", component: "PM relay", detail: `incompatible at ${result.adapter.baseUrl}`, message: `The adapter at ${result.adapter.baseUrl} is incompatible; stop it and run ${commandName} start` });
   } else {
-    lines.push(status("warn", `PM relay is not running at http://${PM_RELAY_HOST}:${PM_RELAY_PORT}; run ${commandName} start`));
+    items.push({ kind: "warn", component: "PM relay", detail: `not running at ${PM_RELAY_HOST}:${PM_RELAY_PORT}`, message: `PM relay is not running at http://${PM_RELAY_HOST}:${PM_RELAY_PORT}; run ${commandName} start` });
   }
   if (result.runtime?.ok) {
-    lines.push(status("info", "Routing: PM GPT uses the PM Studio bearer; eligible Claude chat uses the isolated Claude profile"));
+    items.push({ kind: "info", component: "Routing", detail: "GPT -> PM bearer; Claude -> isolated profile", message: "Routing: PM GPT uses the PM Studio bearer; eligible Claude chat uses the isolated Claude profile" });
   } else {
-    lines.push(status("info", "Expected routing: PM GPT uses the PM Studio bearer; eligible Claude chat uses the isolated Claude profile"));
+    items.push({ kind: "info", component: "Routing", detail: "expected: GPT -> PM bearer; Claude -> isolated profile", message: "Expected routing: PM GPT uses the PM Studio bearer; eligible Claude chat uses the isolated Claude profile" });
+  }
+  return items;
+}
+
+function formatPmStudioStatusPlain(result, commandName, { sanitize = false } = {}) {
+  const lines = [
+    `${commandName} pms status`,
+    ...pmStudioStatusItems(result, commandName).map((item) => status(item.kind, item.message)),
+  ];
+  return (sanitize ? lines.map((line) => terminalCell(line, { fallback: "" })) : lines).join("\n");
+}
+
+function tableState(kind) {
+  return `[${String(kind).toUpperCase()}]`;
+}
+
+function formatPmStudioStatusTable(result, { commandName, output }) {
+  const items = pmStudioStatusItems(result, commandName);
+  const rows = items.map((item) => ({
+    component: item.component,
+    state: tableState(item.kind),
+    detail: item.detail,
+  }));
+  const table = formatResponsiveCliTable({
+    columns: [
+      { key: "component", label: "COMPONENT" },
+      { key: "state", label: "STATE" },
+      { key: "detail", label: "DETAIL" },
+    ],
+    compactColumns: [
+      { key: "component", label: "COMPONENT" },
+      { key: "state", label: "STATE" },
+    ],
+    rows,
+    width: cliOutputWidth(output),
+  });
+  const lines = [`${commandName} pms status`, table.output];
+  const details = table.compact ? items : items.filter((item) => item.kind === "warn" || item.kind === "err");
+  if (details.length) {
+    lines.push("", "Details:", ...details.map((item) => terminalCell(status(item.kind, item.message), { fallback: "" })));
+  }
+  return { output: lines.join("\n"), overflow: table.overflow };
+}
+
+export function formatPmStudioStatus(result, {
+  commandName = "ccdx",
+  format = "plain",
+  output = process.stdout,
+} = {}) {
+  if (cliOutputFormat(format, output) === "plain") {
+    return formatPmStudioStatusPlain(result, commandName);
   }
-  return lines.join("\n");
+  const table = formatPmStudioStatusTable(result, { commandName, output });
+  return format === "auto" && table.overflow
+    ? formatPmStudioStatusPlain(result, commandName, { sanitize: true })
+    : table.output;
 }
 
 export async function runPmStudioStatus(options = {}) {

package/src/usage.mjs

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import readline from "node:readline";
+import { cliOutputFormat, cliOutputWidth, formatResponsiveCliTable, terminalCell } from "./cli-table.mjs";
 import { parseByteLimit, rotateFileIfNeededSync, rotatedFilePath } from "./file-rotation.mjs";
 
 const DEFAULT_USAGE_PATH = path.join(os.homedir(), ".local", "share", "codex-copilot-dx", "usage.jsonl");
@@ -219,17 +220,111 @@ function fmt(n) {
   return Number.isFinite(n) ? n.toLocaleString("en-US") : "0";
 }
 
-export async function printUsageSummary() {
-  const summary = await summarizeUsageLogs();
-  console.log(`Usage log: ${usageLogPath()}`);
+function tableNumber(n) {
+  return Number.isFinite(n) ? n.toLocaleString("en-US") : undefined;
+}
+
+function cacheReadTokens(usage = {}) {
+  const values = [usage.cache_read_input_tokens, usage.cached_input_tokens]
+    .filter((value) => Number.isFinite(value));
+  const value = values.length > 0 ? values.reduce((total, current) => total + current, 0) : undefined;
+  return Number.isFinite(value) ? value : undefined;
+}
+
+function formatPlainUsageSummary(summary, filePath, { sanitize = false } = {}) {
+  const lines = [`Usage log: ${filePath}`];
   if (summary.requests === 0) {
-    console.log("No usage records yet.");
-    return;
+    lines.push("No usage records yet.");
+    return (sanitize ? lines.map((line) => terminalCell(line, { fallback: "" })) : lines).join("\n");
   }
-  console.log(`Requests: ${fmt(summary.requests)}`);
-  console.log(`Tokens: input=${fmt(summary.totals.input_tokens)} cache_read=${fmt(summary.totals.cache_read_input_tokens || summary.totals.cached_input_tokens)} output=${fmt(summary.totals.output_tokens)} total=${fmt(summary.totals.total_tokens)}`);
-  console.log("\nBy model:");
+  lines.push(
+    `Requests: ${fmt(summary.requests)}`,
+    `Tokens: input=${fmt(summary.totals.input_tokens)} cache_read=${fmt(cacheReadTokens(summary.totals))} output=${fmt(summary.totals.output_tokens)} total=${fmt(summary.totals.total_tokens)}`,
+    "",
+    "By model:",
+  );
   for (const [model, row] of Object.entries(summary.byModel)) {
-    console.log(`  ${model}: requests=${fmt(row.requests)} input=${fmt(row.input_tokens)} cache_read=${fmt(row.cache_read_input_tokens || row.cached_input_tokens)} output=${fmt(row.output_tokens)} total=${fmt(row.total_tokens)}`);
+    lines.push(`  ${model}: requests=${fmt(row.requests)} input=${fmt(row.input_tokens)} cache_read=${fmt(cacheReadTokens(row))} output=${fmt(row.output_tokens)} total=${fmt(row.total_tokens)}`);
+  }
+  return (sanitize ? lines.map((line) => terminalCell(line, { fallback: "" })) : lines).join("\n");
+}
+
+function compareModelUsage(left, right) {
+  const leftTotal = Number.isFinite(left.row.total_tokens) ? left.row.total_tokens : -Infinity;
+  const rightTotal = Number.isFinite(right.row.total_tokens) ? right.row.total_tokens : -Infinity;
+  if (leftTotal !== rightTotal) return rightTotal - leftTotal;
+  return left.model < right.model ? -1 : left.model > right.model ? 1 : 0;
+}
+
+function usageTableRow(model, usage) {
+  return {
+    model,
+    records: tableNumber(usage.requests),
+    input: tableNumber(usage.input_tokens),
+    cacheRead: tableNumber(cacheReadTokens(usage)),
+    output: tableNumber(usage.output_tokens),
+    total: tableNumber(usage.total_tokens),
+  };
+}
+
+function usageDetailLine(model, usage) {
+  return `${terminalCell(model)}: input=${fmt(usage.input_tokens)} cache_read=${fmt(cacheReadTokens(usage))} output=${fmt(usage.output_tokens)}`;
+}
+
+function formatTableUsageSummary(summary, filePath, output) {
+  const safePath = terminalCell(filePath, { fallback: "" });
+  if (summary.requests === 0) return { output: `Usage log: ${safePath}\nNo usage records yet.`, overflow: false };
+  const columns = [
+    { key: "model", label: "MODEL" },
+    { key: "records", label: "RECORDS", align: "right" },
+    { key: "input", label: "INPUT", align: "right" },
+    { key: "cacheRead", label: "CACHE READ", align: "right" },
+    { key: "output", label: "OUTPUT", align: "right" },
+    { key: "total", label: "TOTAL", align: "right" },
+  ];
+  const compactColumns = [columns[0], columns[1], columns[5]];
+  const modelUsage = Object.entries(summary.byModel)
+    .map(([model, row]) => ({ model, row }))
+    .sort(compareModelUsage);
+  const totalUsage = { requests: summary.requests, ...summary.totals };
+  const rows = [usageTableRow("TOTAL", totalUsage), ...modelUsage.map(({ model, row }) => usageTableRow(model, row))];
+  const table = formatResponsiveCliTable({
+    columns,
+    compactColumns,
+    rows,
+    width: cliOutputWidth(output),
+    gap: 1,
+  });
+  const lines = [`Usage log: ${safePath}`, "", table.output];
+  if (table.compact) {
+    lines.push(
+      "",
+      "Details:",
+      usageDetailLine("TOTAL", totalUsage),
+      ...modelUsage.map(({ model, row }) => usageDetailLine(model, row)),
+    );
   }
+  return { output: lines.join("\n"), overflow: table.overflow };
+}
+
+export function formatUsageSummary(summary, {
+  filePath = usageLogPath(),
+  format = "auto",
+  output = process.stdout,
+} = {}) {
+  if (cliOutputFormat(format, output) === "plain") return formatPlainUsageSummary(summary, filePath);
+  const table = formatTableUsageSummary(summary, filePath, output);
+  return format === "auto" && table.overflow
+    ? formatPlainUsageSummary(summary, filePath, { sanitize: true })
+    : table.output;
+}
+
+export async function printUsageSummary({
+  filePath = usageLogPath(),
+  format = "auto",
+  output = process.stdout,
+  log = console.log,
+} = {}) {
+  const summary = await summarizeUsageLogs(filePath);
+  log(formatUsageSummary(summary, { filePath, format, output }));
 }