@great-arrow/cli 0.1.2 → 0.1.4

package/dist/index.js

@@ -14,11 +14,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 var __commonJS = (cb, mod) => function __require2() {
-  try {
-    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-  } catch (e) {
-    throw mod = 0, e;
-  }
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -37,9 +33,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// node_modules/commander/lib/error.js
+// node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/error.js
 var require_error = __commonJS({
-  "node_modules/commander/lib/error.js"(exports) {
+  "node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/error.js"(exports) {
     var CommanderError2 = class extends Error {
       /**
        * Constructs the CommanderError class
@@ -72,9 +68,9 @@ var require_error = __commonJS({
   }
 });
 
-// node_modules/commander/lib/argument.js
+// node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/argument.js
 var require_argument = __commonJS({
-  "node_modules/commander/lib/argument.js"(exports) {
+  "node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/argument.js"(exports) {
     var { InvalidArgumentError: InvalidArgumentError2 } = require_error();
     var Argument2 = class {
       /**
@@ -199,9 +195,9 @@ var require_argument = __commonJS({
   }
 });
 
-// node_modules/commander/lib/help.js
+// node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/help.js
 var require_help = __commonJS({
-  "node_modules/commander/lib/help.js"(exports) {
+  "node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/help.js"(exports) {
     var { humanReadableArgName } = require_argument();
     var Help2 = class {
       constructor() {
@@ -768,9 +764,9 @@ ${itemIndentStr}`);
   }
 });
 
-// node_modules/commander/lib/option.js
+// node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/option.js
 var require_option = __commonJS({
-  "node_modules/commander/lib/option.js"(exports) {
+  "node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/option.js"(exports) {
     var { InvalidArgumentError: InvalidArgumentError2 } = require_error();
     var Option2 = class {
       /**
@@ -1069,9 +1065,9 @@ var require_option = __commonJS({
   }
 });
 
-// node_modules/commander/lib/suggestSimilar.js
+// node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/suggestSimilar.js
 var require_suggestSimilar = __commonJS({
-  "node_modules/commander/lib/suggestSimilar.js"(exports) {
+  "node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/suggestSimilar.js"(exports) {
     var maxDistance = 3;
     function editDistance(a, b) {
       if (Math.abs(a.length - b.length) > maxDistance)
@@ -1149,9 +1145,9 @@ var require_suggestSimilar = __commonJS({
   }
 });
 
-// node_modules/commander/lib/command.js
+// node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/command.js
 var require_command = __commonJS({
-  "node_modules/commander/lib/command.js"(exports) {
+  "node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/command.js"(exports) {
     var EventEmitter = __require("node:events").EventEmitter;
     var childProcess = __require("node:child_process");
     var path = __require("node:path");
@@ -3308,9 +3304,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
   }
 });
 
-// node_modules/commander/index.js
+// node_modules/.pnpm/commander@13.1.0/node_modules/commander/index.js
 var require_commander = __commonJS({
-  "node_modules/commander/index.js"(exports) {
+  "node_modules/.pnpm/commander@13.1.0/node_modules/commander/index.js"(exports) {
     var { Argument: Argument2 } = require_argument();
     var { Command: Command2 } = require_command();
     var { CommanderError: CommanderError2, InvalidArgumentError: InvalidArgumentError2 } = require_error();
@@ -3330,7 +3326,7 @@ var require_commander = __commonJS({
   }
 });
 
-// node_modules/commander/esm.mjs
+// node_modules/.pnpm/commander@13.1.0/node_modules/commander/esm.mjs
 var import_index = __toESM(require_commander(), 1);
 var {
   program,
@@ -3862,6 +3858,61 @@ async function resolveToken(configToken) {
 
 // src/lib/client.ts
 import { execSync } from "node:child_process";
+
+// src/lib/mcp-payload.ts
+function isTextBlock(value) {
+  return typeof value === "object" && value !== null && value.type === "text" && typeof value.text === "string";
+}
+function extractJsonSlice(text) {
+  const start = text.search(/[{[]/);
+  if (start === -1) return null;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (inString) {
+      if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === "{" || ch === "[") depth++;
+    else if (ch === "}" || ch === "]") {
+      depth--;
+      if (depth === 0) return text.slice(start, i + 1);
+    }
+  }
+  return null;
+}
+function parseMcpPayload(result) {
+  let text = null;
+  if (typeof result === "string") {
+    text = result;
+  } else if (Array.isArray(result)) {
+    const block = result.find(isTextBlock);
+    if (block) text = block.text;
+  }
+  if (text === null) return result;
+  try {
+    return JSON.parse(text);
+  } catch {
+  }
+  const slice = extractJsonSlice(text);
+  if (slice !== null) {
+    try {
+      return JSON.parse(slice);
+    } catch {
+    }
+  }
+  return text;
+}
+
+// src/lib/client.ts
 var DEFAULT_TIMEOUT_MS = 3e4;
 var MAX_RETRIES = 3;
 var BASE_DELAY_MS = 1e3;
@@ -3995,7 +4046,7 @@ var GadClient = class {
    * @param toolName - The MCP tool name to invoke
    * @param args - Arguments to pass to the tool
    * @param timeoutMs - Optional timeout override (e.g., 90s for agent calls)
-   * @returns The tool result content
+   * @returns The decoded JSON payload from the tool result content
    */
   async mcpCall(toolName, args, timeoutMs) {
     const url = `${this.apiUrl}/api/mcp`;
@@ -4035,7 +4086,15 @@ var GadClient = class {
         data.error.data ?? void 0
       );
     }
-    return data.result?.content ?? data.result;
+    const payload = parseMcpPayload(data.result?.content ?? data.result);
+    if (typeof payload === "string" && payload.includes("[truncated: result exceeded")) {
+      throw new CliError(
+        `Tool '${toolName}' response was truncated by the server before the data completed.`,
+        3 /* VALIDATION_ERROR */,
+        "Narrow the request (lower --limit / -k, or add filters) and try again."
+      );
+    }
+    return payload;
   }
   /**
    * Make a GET request to a REST API endpoint.
@@ -4094,6 +4153,18 @@ var GadClient = class {
   }
 };
 
+// src/lib/global-opts.ts
+function globalOutputOpts(cmd) {
+  const merged = cmd.optsWithGlobals();
+  return {
+    json: Boolean(merged.json),
+    quiet: Boolean(merged.quiet),
+    // --no-color sets `color: false`; some commands declare `--no-color`
+    // locally which surfaces as `noColor`.
+    noColor: merged.color === false || Boolean(merged.noColor)
+  };
+}
+
 // src/commands/whoami.ts
 function maskToken2(token) {
   if (token.length <= 8) {
@@ -4108,7 +4179,8 @@ function extractWorkspaceName(data) {
   return data.workspace?.name || data.workspaceName || "unknown";
 }
 function whoamiCommand() {
-  const cmd = new Command("whoami").description("Display authenticated user info").option("--json", "Output as JSON").option("--quiet", "Suppress decorative output").option("--no-color", "Disable color output").action(async (options) => {
+  const cmd = new Command("whoami").description("Display authenticated user info").option("--json", "Output as JSON").option("--quiet", "Suppress decorative output").option("--no-color", "Disable color output").action(async (options, command) => {
+    const g = globalOutputOpts(command);
     const auth = await resolveAuth();
     const client = new GadClient({
       token: auth.token,
@@ -4131,10 +4203,10 @@ function whoamiCommand() {
     const workspaceName = extractWorkspaceName(introspect);
     const tokenPrefix = maskToken2(auth.token);
     const fmt = createFormatter({
-      json: options.json ?? false,
-      quiet: options.quiet ?? false,
+      json: g.json,
+      quiet: g.quiet,
       isTTY: isTTY(),
-      noColor: options.color === false
+      noColor: g.noColor
     });
     const data = {
       email,
@@ -4225,7 +4297,7 @@ var memoryCommand = new Command("memory").description(
 memoryCommand.command("create").description("Create a new memory in the active workspace").requiredOption("--title <title>", "Memory title").option("--content <content>", "Memory content (or pipe via stdin)").option("--tags <tags>", "Comma-separated tags").option(
   "--layer <layer>",
   "Memory layer (WORKING, EPISODIC, SEMANTIC, PROCEDURAL)"
-).action(async (opts) => {
+).action(async (opts, command) => {
   const client = await buildClient();
   let content = opts.content;
   if (!content) {
@@ -4262,7 +4334,8 @@ memoryCommand.command("create").description("Create a new memory in the active w
   const memoryId = typeof rawId === "string" ? rawId : "created";
   fmt.success(`Memory created: ${memoryId}`);
 });
-memoryCommand.command("search <query>").description("Semantic search across memories").option("--json", "Output as JSON").option("-k, --limit <number>", "Max results", "10").option("--layer <layer>", "Filter by layer").action(async (query, opts) => {
+memoryCommand.command("search <query>").description("Semantic search across memories").option("--json", "Output as JSON").option("-k, --limit <number>", "Max results", "10").option("--layer <layer>", "Filter by layer").action(async (query, opts, command) => {
+  const g = globalOutputOpts(command);
   const client = await buildClient();
   const args = {
     query,
@@ -4272,22 +4345,27 @@ memoryCommand.command("search <query>").description("Semantic search across memo
     args.layer = opts.layer;
   }
   const result = await client.mcpCall("memory_search", args);
-  const rawResults = Array.isArray(result) ? result : result?.results ?? [];
+  const data = result ?? {};
+  const rawResults = Array.isArray(result) ? result : data.hits ?? data.results ?? [];
   const rows = rawResults.map((item) => ({
     ...item,
+    title: item.title ?? item.memoryTitle,
     preview: extractPreview(item)
   }));
   const fmt = createFormatter({
-    json: Boolean(opts.json),
+    json: g.json,
     quiet: false,
     isTTY: isTTY(),
     noColor: false
   });
   fmt.table(rows, searchColumns);
 });
-memoryCommand.command("list").description("List recent memories with optional filters").option("--json", "Output as JSON").option("--layer <layer>", "Filter by memory layer").option("--tag <tag>", "Filter by tag").action(async (opts) => {
+memoryCommand.command("list").description("List recent memories with optional filters").option("--json", "Output as JSON").option("--limit <number>", "Max results", "20").option("--layer <layer>", "Filter by memory layer").option("--tag <tag>", "Filter by tag").action(async (opts, command) => {
+  const g = globalOutputOpts(command);
   const client = await buildClient();
-  const args = {};
+  const args = {
+    limit: Number.parseInt(opts.limit, 10)
+  };
   if (opts.layer) {
     args.layer = opts.layer;
   }
@@ -4295,21 +4373,23 @@ memoryCommand.command("list").description("List recent memories with optional fi
     args.tag = opts.tag;
   }
   const result = await client.mcpCall("memory_list", args);
-  const rawResults = Array.isArray(result) ? result : result?.results ?? [];
+  const data = result ?? {};
+  const rawResults = Array.isArray(result) ? result : data.memories ?? data.results ?? [];
   const fmt = createFormatter({
-    json: Boolean(opts.json),
+    json: g.json,
     quiet: false,
     isTTY: isTTY(),
     noColor: false
   });
   fmt.table(rawResults, listColumns);
 });
-memoryCommand.command("get <id>").description("Show full content and metadata of a memory").option("--json", "Output as JSON").action(async (id, opts) => {
+memoryCommand.command("get <id>").description("Show full content and metadata of a memory").option("--json", "Output as JSON").action(async (id, opts, command) => {
+  const g = globalOutputOpts(command);
   const client = await buildClient();
   const result = await client.mcpCall("memory_get", { id });
   const data = result ?? {};
   const fmt = createFormatter({
-    json: Boolean(opts.json),
+    json: g.json,
     quiet: false,
     isTTY: isTTY(),
     noColor: false
@@ -4380,22 +4460,10 @@ async function createClient() {
   const auth = await resolveAuth();
   return new GadClient({ token: auth.token, apiUrl: auth.apiUrl });
 }
-function extractMcpContent(result) {
-  if (Array.isArray(result) && result.length > 0) {
-    const first = result[0];
-    if (typeof first === "object" && first !== null && "type" in first && first.type === "text" && "text" in first) {
-      try {
-        return JSON.parse(first.text);
-      } catch {
-        return first.text;
-      }
-    }
-  }
-  return result;
-}
 var listCommand = new Command("list").description("List all accessible workspaces").option("--json", "Output as JSON").action(async (options) => {
-  const parentOpts = listCommand.parent?.opts() ?? {};
-  const jsonFlag = options.json || parentOpts.json || false;
+  const jsonFlag = Boolean(
+    options.json || listCommand.optsWithGlobals().json
+  );
   const fmt = createFormatter({
     json: jsonFlag,
     quiet: false,
@@ -4404,7 +4472,7 @@ var listCommand = new Command("list").description("List all accessible workspace
   });
   const client = await createClient();
   const result = await client.mcpCall("workspace_list", {});
-  const data = extractMcpContent(result);
+  const data = result;
   let workspaces = [];
   if (Array.isArray(data)) {
     workspaces = data;
@@ -4466,8 +4534,9 @@ var infoColumns = [
   }
 ];
 var infoCommand = new Command("info").description("Show active workspace settings, member count, and integrations").option("--json", "Output as JSON").action(async (options) => {
-  const parentOpts = infoCommand.parent?.opts() ?? {};
-  const jsonFlag = options.json || parentOpts.json || false;
+  const jsonFlag = Boolean(
+    options.json || infoCommand.optsWithGlobals().json
+  );
   const fmt = createFormatter({
     json: jsonFlag,
     quiet: false,
@@ -4476,13 +4545,14 @@ var infoCommand = new Command("info").description("Show active workspace setting
   });
   const client = await createClient();
   const result = await client.mcpCall("workspace_settings_get", {});
-  const data = extractMcpContent(result);
+  const data = result;
   const workspace = typeof data === "object" && data !== null ? data : {};
   fmt.detail(workspace, infoColumns);
 });
 var membersCommand = new Command("members").description("List workspace members with roles and last-active timestamps").option("--json", "Output as JSON").action(async (options) => {
-  const parentOpts = membersCommand.parent?.opts() ?? {};
-  const jsonFlag = options.json || parentOpts.json || false;
+  const jsonFlag = Boolean(
+    options.json || membersCommand.optsWithGlobals().json
+  );
   const fmt = createFormatter({
     json: jsonFlag,
     quiet: false,
@@ -4491,7 +4561,7 @@ var membersCommand = new Command("members").description("List workspace members
   });
   const client = await createClient();
   const result = await client.mcpCall("workspace_members", {});
-  const data = extractMcpContent(result);
+  const data = result;
   let members = [];
   if (Array.isArray(data)) {
     members = data;
@@ -4544,7 +4614,7 @@ var listCommand2 = new Command("list").description("List open todos sorted by pr
   "Filter by status (open, in_progress, review, done, dismissed)"
 ).option("--json", "Output as JSON").action(
   async (options, cmd) => {
-    const parentOpts = cmd.parent?.opts() ?? {};
+    const parentOpts = cmd.optsWithGlobals();
     const jsonOutput = options.json || parentOpts.json || false;
     const fmt = createFormatter({
       json: jsonOutput,
@@ -4554,10 +4624,9 @@ var listCommand2 = new Command("list").description("List open todos sorted by pr
     });
     const auth = await resolveAuth();
     const client = new GadClient({ token: auth.token, apiUrl: auth.apiUrl });
-    const args = {};
-    if (options.status) {
-      args.status = options.status;
-    }
+    const args = {
+      status: options.status ?? "open"
+    };
     const result = await client.mcpCall("todo_list", args);
     let todos = [];
     if (Array.isArray(result)) {
@@ -4634,6 +4703,271 @@ var updateCommand = new Command("update").description("Update a todo's status").
 var todoCommand = new Command("todo").description("Manage kanban todos").addCommand(listCommand2).addCommand(createCommand2).addCommand(doneCommand).addCommand(updateCommand);
 var todo_default = todoCommand;
 
+// src/commands/doctor.ts
+import { existsSync } from "node:fs";
+import { copyFile, mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, join as join2 } from "node:path";
+
+// src/lib/codex-config.ts
+import { execFileSync } from "node:child_process";
+var CODEX_SERVER_NAME = "great-arrow";
+var CODEX_CLIENT_ID = "codex-cli";
+var SAFE_GLOBAL_MCP_SERVERS = /* @__PURE__ */ new Set([
+  CODEX_SERVER_NAME,
+  "great-arrow-kiro-terminal",
+  "chrome-devtools",
+  "node_repl",
+  "playwright",
+  "postman",
+  "stripe",
+  "vercel",
+  "xcodebuildmcp"
+]);
+function normalizeApiUrl(apiUrl) {
+  return apiUrl.replace(/\/+$/, "");
+}
+function mcpEndpoint(apiUrl) {
+  return `${normalizeApiUrl(apiUrl)}/api/mcp`;
+}
+function tomlEscape(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function detectGitOrigin2(cwd = process.cwd()) {
+  try {
+    const env = { ...process.env };
+    for (const key of Object.keys(env)) {
+      if (key.startsWith("GIT_")) delete env[key];
+    }
+    const url = execFileSync(
+      "git",
+      ["-C", cwd, "remote", "get-url", "origin"],
+      {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        env,
+        timeout: 1e3
+      }
+    ).trim();
+    return url || null;
+  } catch {
+    return null;
+  }
+}
+function repoKey(repoUrl) {
+  if (!repoUrl) return null;
+  const trimmed = repoUrl.trim();
+  if (!trimmed) return null;
+  const scpLike = trimmed.match(/^git@([^:]+):(.+)$/);
+  const asUrl = scpLike ? `https://${scpLike[1]}/${scpLike[2]}` : trimmed.replace(/^ssh:\/\/git@/i, "https://");
+  try {
+    const parsed = new URL(asUrl);
+    const host = parsed.hostname.toLowerCase();
+    let path = parsed.pathname.replace(/^\/+/, "").replace(/\/+$/, "");
+    path = path.replace(/\.git$/i, "").toLowerCase();
+    return path ? `${host}/${path}` : null;
+  } catch {
+    return null;
+  }
+}
+function generateCodexConfigToml(apiUrl, repoUrl) {
+  const repoHeader = repoUrl ? `X-Repo-URL = "${tomlEscape(repoUrl)}"
+` : "";
+  return `[mcp_servers.${CODEX_SERVER_NAME}]
+transport = "streamable_http"
+url = "${tomlEscape(mcpEndpoint(apiUrl))}"
+bearer_token_env_var = "GREAT_ARROW_TOKEN"
+
+[mcp_servers.${CODEX_SERVER_NAME}.http_headers]
+X-MCP-Client = "${CODEX_CLIENT_ID}"
+${repoHeader}`;
+}
+function generateCodexEnv(token) {
+  return `GREAT_ARROW_TOKEN=${token}
+`;
+}
+function extractCodexGreatArrowApiUrl(content) {
+  const text = groupedServerText(splitTomlSections(content)).get(
+    CODEX_SERVER_NAME
+  );
+  if (!text) return null;
+  const match = text.match(/^\s*url\s*=\s*"([^"]+)"\s*$/m);
+  if (!match?.[1]) return null;
+  const url = match[1].trim();
+  return url.endsWith("/api/mcp") ? url.slice(0, -"/api/mcp".length) : url.replace(/\/+$/, "");
+}
+function splitTomlSections(content) {
+  const hasTrailingNewline = content.endsWith("\n");
+  const lines = content.split(/\n/);
+  if (hasTrailingNewline) lines.pop();
+  const sections = [];
+  let table = null;
+  let current = [];
+  const flush = () => {
+    if (current.length === 0) return;
+    sections.push({ table, text: `${current.join("\n")}
+` });
+    current = [];
+  };
+  for (const line of lines) {
+    const match = line.match(/^\s*\[([^\]]+)]\s*$/);
+    if (match) {
+      flush();
+      table = match[1] ?? null;
+    }
+    current.push(line);
+  }
+  flush();
+  return sections;
+}
+function tableServerName(table) {
+  if (!table) return null;
+  const match = table.match(/^mcp_servers\.(?:"([^"]+)"|([^.\s]+))(?:\.|$)/);
+  return match?.[1] ?? match?.[2] ?? null;
+}
+function groupedServerText(sections) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const section of sections) {
+    const server = tableServerName(section.table);
+    if (!server) continue;
+    grouped.set(server, `${grouped.get(server) ?? ""}${section.text}`);
+  }
+  return grouped;
+}
+function removeServerSections(content, servers) {
+  const sections = splitTomlSections(content);
+  return sections.filter((section) => {
+    const server = tableServerName(section.table);
+    return !server || !servers.has(server);
+  }).map((section) => section.text).join("").replace(/\n{3,}/g, "\n\n");
+}
+function upsertCodexServerBlock(existingContent, apiUrl, repoUrl) {
+  const block = generateCodexConfigToml(apiUrl, repoUrl).trimEnd();
+  const withoutGreatArrow = removeServerSections(
+    existingContent,
+    /* @__PURE__ */ new Set([CODEX_SERVER_NAME])
+  ).replace(/\s*$/, "");
+  if (!withoutGreatArrow) return `${block}
+`;
+  return `${withoutGreatArrow}
+
+${block}
+`;
+}
+function extractConfiguredRepoKeys(text) {
+  const keys = /* @__PURE__ */ new Set();
+  const repoSetting = /(?:X-Repo-URL|MEMORY_REPO_URL|GAD_REPO_URL)\s*=\s*"([^"]+)"/gi;
+  for (const match of text.matchAll(repoSetting)) {
+    const key = repoKey(match[1]);
+    if (key) keys.add(key);
+  }
+  const gitUrls = /(?:https:\/\/|ssh:\/\/git@|git@)(?:github\.com|gitlab\.com|bitbucket\.org)[:/][^\s"',\]]+/gi;
+  for (const match of text.matchAll(gitUrls)) {
+    const key = repoKey(match[0]);
+    if (key) keys.add(key);
+  }
+  return [...keys];
+}
+function hasJobbyJobMarker(server, text) {
+  return /jobby\s*job|jobbyjob|jobbyjob\.ai/i.test(`${server}
+${text}`);
+}
+function isUnmanagedServer(server) {
+  return !SAFE_GLOBAL_MCP_SERVERS.has(server);
+}
+function inspectCodexConfig(content, expectedRepoUrl) {
+  const expectedRepoKey = repoKey(expectedRepoUrl);
+  const grouped = groupedServerText(splitTomlSections(content));
+  const serverNames = [...grouped.keys()].sort();
+  const greatArrowText = grouped.get(CODEX_SERVER_NAME) ?? "";
+  const hasGreatArrowServer = grouped.has(CODEX_SERVER_NAME);
+  const greatArrowRepoKeys = extractConfiguredRepoKeys(greatArrowText);
+  const greatArrowHasRepoHeader = Boolean(
+    expectedRepoKey && greatArrowRepoKeys.includes(expectedRepoKey)
+  );
+  const unmanagedServers = serverNames.filter(isUnmanagedServer);
+  const staleRepoServers = [];
+  for (const [server, text] of grouped.entries()) {
+    if (server === CODEX_SERVER_NAME) continue;
+    const keys = extractConfiguredRepoKeys(text);
+    const mismatchedExplicitRepo = expectedRepoKey && keys.length > 0 && !keys.some((key) => key === expectedRepoKey);
+    if (mismatchedExplicitRepo || hasJobbyJobMarker(server, text)) {
+      staleRepoServers.push(server);
+    }
+  }
+  staleRepoServers.sort();
+  const issues = [];
+  issues.push(
+    hasGreatArrowServer ? {
+      code: "great_arrow_present",
+      level: "pass",
+      message: "Codex has a Great Arrow MCP server block."
+    } : {
+      code: "great_arrow_missing",
+      level: "fail",
+      message: "Codex is missing the Great Arrow MCP server block.",
+      hint: "Run `gad mcp install codex` from the repo root."
+    }
+  );
+  if (expectedRepoKey) {
+    issues.push(
+      greatArrowHasRepoHeader ? {
+        code: "repo_header_present",
+        level: "pass",
+        message: `Great Arrow is pinned to ${expectedRepoUrl}.`
+      } : {
+        code: "repo_header_missing",
+        level: "warn",
+        message: "Great Arrow is not pinned with X-Repo-URL.",
+        hint: "Run `gad mcp install codex` from the repo root to add repo routing."
+      }
+    );
+  }
+  if (staleRepoServers.length > 0) {
+    issues.push({
+      code: "stale_repo_servers",
+      level: "fail",
+      message: `Found stale repo-scoped MCP server(s): ${staleRepoServers.join(", ")}.`,
+      hint: "Run `gad doctor codex --enforce` to remove the stale server blocks."
+    });
+  } else {
+    issues.push({
+      code: "no_stale_repo_servers",
+      level: "pass",
+      message: "No stale repo-scoped MCP server blocks found."
+    });
+  }
+  if (unmanagedServers.length > 0) {
+    issues.push({
+      code: "unmanaged_servers",
+      level: "warn",
+      message: `Codex has unmanaged MCP server(s): ${unmanagedServers.join(", ")}.`,
+      hint: "Review these manually if they are not intentionally global."
+    });
+  }
+  return {
+    expectedRepoUrl: expectedRepoUrl ?? null,
+    expectedRepoKey,
+    hasGreatArrowServer,
+    greatArrowHasRepoHeader,
+    unmanagedServers,
+    staleRepoServers,
+    issues
+  };
+}
+function repairCodexConfig(content, staleRepoServers) {
+  if (staleRepoServers.length === 0) {
+    return { content, removedServers: [] };
+  }
+  const removed = [...new Set(staleRepoServers)].sort();
+  const repaired = removeServerSections(content, new Set(removed));
+  return {
+    content: repaired.endsWith("\n") ? repaired : `${repaired}
+`,
+    removedServers: removed
+  };
+}
+
 // src/commands/doctor.ts
 function renderCheck(check, color2) {
   const { status, name, message, hint } = check;
@@ -4717,8 +5051,12 @@ async function checkIntegrations(auth) {
   const client = new GadClient({ token: auth.token, apiUrl: auth.apiUrl });
   try {
     const result = await client.mcpCall("integrations_list", {});
-    const integrations = Array.isArray(result) ? result : [];
-    const errorIntegrations = integrations.filter((i) => i.status === "error");
+    const data = result ?? {};
+    const integrations = Array.isArray(result) ? result : Array.isArray(data.integrations) ? data.integrations : [];
+    const errorIntegrations = integrations.filter((i) => {
+      const status = (i.status ?? "").toUpperCase();
+      return status === "ERROR" || status === "NEEDS_REAUTH";
+    });
     if (errorIntegrations.length === 0) {
       return {
         name: "Integrations",
@@ -4730,7 +5068,7 @@ async function checkIntegrations(auth) {
     return {
       name: "Integrations",
       status: "warn",
-      message: `${errorIntegrations.length} integration(s) with errors: ${kinds}`,
+      message: `${errorIntegrations.length} of ${integrations.length} integration(s) need attention: ${kinds}`,
       hint: "Run 'gad integrations list' for details, or 'gad integrations sync <kind>' to retry."
     };
   } catch {
@@ -4768,18 +5106,145 @@ async function checkMcp(auth) {
     };
   }
 }
+function defaultCodexConfigPath() {
+  return join2(homedir2(), ".codex", "config.toml");
+}
+function codexIssuesToChecks(issues) {
+  return issues.map((issue) => {
+    const check = {
+      name: `Codex Config: ${issue.code}`,
+      status: issue.level,
+      message: issue.server ? `${issue.message} (${issue.server})` : issue.message
+    };
+    if (issue.hint) check.hint = issue.hint;
+    return check;
+  });
+}
+function codexCommand() {
+  return new Command("codex").description(
+    "Check Codex MCP config for wrong-repo entries and optional repair"
+  ).option(
+    "--config <path>",
+    "Path to Codex config.toml",
+    defaultCodexConfigPath()
+  ).option(
+    "--expected-repo <url>",
+    "Expected repo URL (defaults to current git origin)"
+  ).option(
+    "--enforce",
+    "Back up config, rewrite Great Arrow repo pin, and remove stale repo-scoped MCP servers"
+  ).option("--json", "Output as JSON").option("--quiet", "Suppress decorative output").option("--no-color", "Disable color output").action(
+    async (options, command) => {
+      const g = globalOutputOpts(command);
+      const color2 = createColor(g.noColor);
+      const fmt = createFormatter({
+        json: g.json,
+        quiet: g.quiet,
+        isTTY: isTTY(),
+        noColor: g.noColor
+      });
+      const configPath = options.config ?? defaultCodexConfigPath();
+      const expectedRepoUrl = options.expectedRepo ?? detectGitOrigin2();
+      let content = existsSync(configPath) ? await readFile2(configPath, "utf8") : "";
+      let backupPath = null;
+      let removedServers = [];
+      if (options.enforce) {
+        const apiUrl = extractCodexGreatArrowApiUrl(content) ?? (await resolveAuth()).apiUrl;
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+        await mkdir2(dirname2(configPath), { recursive: true });
+        if (content.trim()) {
+          backupPath = `${configPath}.bak.${timestamp}`;
+          await copyFile(configPath, backupPath);
+        }
+        content = upsertCodexServerBlock(content, apiUrl, expectedRepoUrl);
+        const preRepair = inspectCodexConfig(content, expectedRepoUrl);
+        const repaired = repairCodexConfig(
+          content,
+          preRepair.staleRepoServers
+        );
+        content = repaired.content;
+        removedServers = repaired.removedServers;
+        await writeFile2(configPath, content, "utf8");
+      }
+      const inspection = inspectCodexConfig(content, expectedRepoUrl);
+      const checks = codexIssuesToChecks(inspection.issues);
+      if (options.enforce) {
+        const enforcementCheck = {
+          name: "Codex Config: enforcement",
+          status: "pass",
+          message: removedServers.length > 0 ? `Removed stale server(s): ${removedServers.join(", ")}` : "No stale server blocks needed removal"
+        };
+        if (backupPath) {
+          enforcementCheck.hint = `Backup written to ${backupPath}`;
+        }
+        checks.push(enforcementCheck);
+      }
+      if (g.json) {
+        process.stdout.write(
+          JSON.stringify(
+            {
+              configPath,
+              expectedRepoUrl,
+              enforce: Boolean(options.enforce),
+              backupPath,
+              removedServers,
+              inspection,
+              checks
+            },
+            null,
+            2
+          ) + "\n"
+        );
+      } else {
+        if (!expectedRepoUrl) {
+          process.stdout.write(
+            renderCheck(
+              {
+                name: "Codex Config: repo detection",
+                status: "warn",
+                message: "No git origin detected for this directory",
+                hint: "Run from a repo root or pass --expected-repo."
+              },
+              color2
+            ) + "\n"
+          );
+        }
+        for (const check of checks) {
+          process.stdout.write(renderCheck(check, color2) + "\n");
+        }
+        if (!g.quiet) {
+          const failed = checks.filter((c) => c.status === "fail").length;
+          const warned = checks.filter((c) => c.status === "warn").length;
+          process.stdout.write("\n");
+          if (failed === 0 && warned === 0) {
+            fmt.success("Codex config guard passed");
+          } else if (failed === 0) {
+            fmt.warn(`Codex config guard passed with ${warned} warning(s)`);
+          } else {
+            fmt.error(
+              `Codex config guard found ${failed} failure(s), ${warned} warning(s)`
+            );
+          }
+        }
+      }
+      if (checks.some((check) => check.status === "fail")) {
+        process.exitCode = 1;
+      }
+    }
+  );
+}
 function doctorCommand() {
-  const cmd = new Command("doctor").description("Run a comprehensive health check").option("--json", "Output as JSON").option("--quiet", "Suppress decorative output").option("--no-color", "Disable color output").action(async (options) => {
-    const noColor = options.color === false;
-    const color2 = createColor(noColor);
+  const cmd = new Command("doctor").description("Run a comprehensive health check").option("--json", "Output as JSON").option("--quiet", "Suppress decorative output").option("--no-color", "Disable color output").action(async (options, command) => {
+    const g = globalOutputOpts(command);
+    const color2 = createColor(g.noColor);
     const fmt = createFormatter({
-      json: options.json ?? false,
-      quiet: options.quiet ?? false,
+      json: g.json,
+      quiet: g.quiet,
       isTTY: isTTY(),
-      noColor
+      noColor: g.noColor
     });
     const checks = [];
-    const isJson = options.json ?? false;
+    const isJson = g.json;
     const { check: tokenCheck, auth } = await checkToken();
     checks.push(tokenCheck);
     if (!isJson) {
@@ -4802,7 +5267,7 @@ function doctorCommand() {
     }
     if (isJson) {
       process.stdout.write(JSON.stringify(checks) + "\n");
-    } else if (!options.quiet) {
+    } else if (!g.quiet) {
       const passed = checks.filter((c) => c.status === "pass").length;
       const warned = checks.filter((c) => c.status === "warn").length;
       const failed = checks.filter((c) => c.status === "fail").length;
@@ -4816,6 +5281,7 @@ function doctorCommand() {
       }
     }
   });
+  cmd.addCommand(codexCommand());
   return cmd;
 }
 
@@ -4865,19 +5331,6 @@ async function createClient2() {
   const auth = await resolveAuth();
   return new GadClient({ token: auth.token, apiUrl: auth.apiUrl });
 }
-function extractMcpContent2(result) {
-  if (Array.isArray(result) && result.length > 0) {
-    const first = result[0];
-    if (typeof first === "object" && first !== null && "type" in first && first.type === "text" && "text" in first) {
-      try {
-        return JSON.parse(first.text);
-      } catch {
-        return first.text;
-      }
-    }
-  }
-  return result;
-}
 function formatErrorDetail(rawError) {
   if (rawError === null || rawError === void 0) return null;
   if (typeof rawError === "string") return rawError;
@@ -4927,8 +5380,9 @@ function handleSyncResponse(fmt, kind, response) {
   }
 }
 var listCommand3 = new Command("list").description("List all connected integrations with sync status").option("--json", "Output as JSON").action(async (options) => {
-  const parentOpts = listCommand3.parent?.opts() ?? {};
-  const jsonFlag = options.json || parentOpts.json || false;
+  const jsonFlag = Boolean(
+    options.json || listCommand3.optsWithGlobals().json
+  );
   const fmt = createFormatter({
     json: jsonFlag,
     quiet: false,
@@ -4937,7 +5391,7 @@ var listCommand3 = new Command("list").description("List all connected integrati
   });
   const client = await createClient2();
   const result = await client.mcpCall("integrations_list", {});
-  const data = extractMcpContent2(result);
+  const data = result;
   let integrations = [];
   if (Array.isArray(data)) {
     integrations = data;
@@ -4964,7 +5418,7 @@ var syncCommand = new Command("sync").description("Trigger a manual sync for the
   fmt.info(`Triggering sync for "${kind}"...`);
   try {
     const result = await client.mcpCall("integration_sync", { kind });
-    const data = extractMcpContent2(result);
+    const data = result;
     if (typeof data === "object" && data !== null) {
       handleSyncResponse(fmt, kind, data);
     } else {
@@ -4990,39 +5444,20 @@ var SUPPORTED_CLIENTS = [
   "codex",
   "gemini"
 ];
-var MCP_SERVER_NAME = "great-arrow";
+var MCP_SERVER_NAME = CODEX_SERVER_NAME;
 var CLIENT_IDS = {
   claude: "claude-code-cli",
   cursor: "cursor",
   kiro: "kiro",
-  codex: "codex-cli",
+  codex: CODEX_CLIENT_ID,
   gemini: "gemini-cli"
 };
-function normalizeApiUrl(apiUrl) {
-  return apiUrl.replace(/\/+$/, "");
-}
-function mcpEndpoint(apiUrl) {
-  return `${normalizeApiUrl(apiUrl)}/api/mcp`;
-}
 async function createClient3() {
   const auth = await resolveAuth();
   const client = new GadClient({ token: auth.token, apiUrl: auth.apiUrl });
   return { client, apiUrl: auth.apiUrl };
 }
-function extractMcpContent3(result) {
-  if (Array.isArray(result) && result.length > 0) {
-    const first = result[0];
-    if (typeof first === "object" && first !== null && "type" in first && first.type === "text" && "text" in first) {
-      try {
-        return JSON.parse(first.text);
-      } catch {
-        return first.text;
-      }
-    }
-  }
-  return result;
-}
-function generateMcpConfig(client, apiUrl, token) {
+function generateMcpConfig(client, apiUrl, token, repoUrl) {
   const endpoint = mcpEndpoint(apiUrl);
   if (client === "codex") {
     return {
@@ -5036,7 +5471,11 @@ function generateMcpConfig(client, apiUrl, token) {
             MEMORY_API_URL: apiUrl,
             MEMORY_CLIENT_NAME: CLIENT_IDS.codex,
             GAD_TOKEN: token,
-            GAD_API_URL: apiUrl
+            GAD_API_URL: apiUrl,
+            ...repoUrl ? {
+              MEMORY_REPO_URL: repoUrl,
+              GAD_REPO_URL: repoUrl
+            } : {}
           }
         }
       }
@@ -5049,44 +5488,13 @@ function generateMcpConfig(client, apiUrl, token) {
         url: endpoint,
         headers: {
           Authorization: `Bearer ${token}`,
-          "X-MCP-Client": CLIENT_IDS[client]
+          "X-MCP-Client": CLIENT_IDS[client],
+          ...repoUrl ? { "X-Repo-URL": repoUrl } : {}
         }
       }
     }
   };
 }
-function tomlEscape(value) {
-  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-}
-function generateCodexConfigToml(apiUrl) {
-  return `[mcp_servers.${MCP_SERVER_NAME}]
-transport = "streamable_http"
-url = "${tomlEscape(mcpEndpoint(apiUrl))}"
-bearer_token_env_var = "GREAT_ARROW_TOKEN"
-`;
-}
-function generateCodexEnv(token) {
-  return `GREAT_ARROW_TOKEN=${token}
-`;
-}
-function upsertCodexServerBlock(existingContent, apiUrl) {
-  const block = generateCodexConfigToml(apiUrl).trimEnd();
-  const serverBlockPattern = /^\[mcp_servers\.great-arrow\]\n[\s\S]*?(?=^\[|\s*$)/m;
-  if (!existingContent.trim()) {
-    return `${block}
-`;
-  }
-  if (serverBlockPattern.test(existingContent)) {
-    const updated = existingContent.replace(serverBlockPattern, block);
-    return updated.endsWith("\n") ? updated : `${updated}
-`;
-  }
-  const trimmedRight = existingContent.replace(/\s*$/, "");
-  return `${trimmedRight}
-
-${block}
-`;
-}
 function upsertEnvValue(existingContent, key, value) {
   const lines = existingContent.split(/\r?\n/).filter((line) => line.trim() !== "" && !line.startsWith(`${key}=`));
   lines.push(`${key}=${value}`);
@@ -5102,29 +5510,29 @@ async function pathExists(path) {
     return false;
   }
 }
-async function installCodexConfig(apiUrl, token) {
-  const { homedir: homedir2 } = await import("node:os");
-  const { join: join2 } = await import("node:path");
-  const { chmod, copyFile, mkdir: mkdir2, readFile: readFile2, writeFile: writeFile2 } = await import("node:fs/promises");
-  const codexDir = join2(homedir2(), ".codex");
-  const configPath = join2(codexDir, "config.toml");
-  const envPath = join2(codexDir, ".env");
+async function installCodexConfig(apiUrl, token, repoUrl) {
+  const { homedir: homedir3 } = await import("node:os");
+  const { join: join3 } = await import("node:path");
+  const { chmod, copyFile: copyFile2, mkdir: mkdir3, readFile: readFile3, writeFile: writeFile3 } = await import("node:fs/promises");
+  const codexDir = join3(homedir3(), ".codex");
+  const configPath = join3(codexDir, "config.toml");
+  const envPath = join3(codexDir, ".env");
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  await mkdir2(codexDir, { recursive: true });
-  const existingConfig = await pathExists(configPath) ? await readFile2(configPath, "utf8") : "";
+  await mkdir3(codexDir, { recursive: true });
+  const existingConfig = await pathExists(configPath) ? await readFile3(configPath, "utf8") : "";
   if (existingConfig.trim()) {
-    await copyFile(configPath, `${configPath}.bak.${timestamp}`);
+    await copyFile2(configPath, `${configPath}.bak.${timestamp}`);
   }
-  await writeFile2(
+  await writeFile3(
     configPath,
-    upsertCodexServerBlock(existingConfig, apiUrl),
+    upsertCodexServerBlock(existingConfig, apiUrl, repoUrl),
     "utf8"
   );
-  const existingEnv = await pathExists(envPath) ? await readFile2(envPath, "utf8") : "";
+  const existingEnv = await pathExists(envPath) ? await readFile3(envPath, "utf8") : "";
   if (existingEnv.trim()) {
-    await copyFile(envPath, `${envPath}.bak.${timestamp}`);
+    await copyFile2(envPath, `${envPath}.bak.${timestamp}`);
   }
-  await writeFile2(
+  await writeFile3(
     envPath,
     upsertEnvValue(existingEnv, "GREAT_ARROW_TOKEN", token),
     "utf8"
@@ -5141,8 +5549,9 @@ var statusColumns = [
 var statusCommand = new Command("status").description(
   "Show MCP server connection status, proxy version, and session count"
 ).option("--json", "Output as JSON").action(async (options) => {
-  const parentOpts = statusCommand.parent?.opts() ?? {};
-  const jsonFlag = options.json || parentOpts.json || false;
+  const jsonFlag = Boolean(
+    options.json || statusCommand.optsWithGlobals().json
+  );
   const fmt = createFormatter({
     json: jsonFlag,
     quiet: false,
@@ -5158,7 +5567,7 @@ var statusCommand = new Command("status").description(
   };
   try {
     const result = await client.mcpCall("workspace_introspect", {});
-    const data = extractMcpContent3(result);
+    const data = result;
     if (typeof data === "object" && data !== null) {
       const info = data;
       statusData = {
@@ -5197,8 +5606,9 @@ function renderLogEntry(entry, c) {
 `);
 }
 var logsCommand = new Command("logs").description("Tail MCP connection log with colorized output").option("--lines <n>", "Number of recent log lines to show", "20").option("--json", "Output as JSON").action(async (options) => {
-  const parentOpts = logsCommand.parent?.opts() ?? {};
-  const jsonFlag = options.json || parentOpts.json || false;
+  const jsonFlag = Boolean(
+    options.json || logsCommand.optsWithGlobals().json
+  );
   const fmt = createFormatter({
     json: jsonFlag,
     quiet: false,
@@ -5212,7 +5622,7 @@ var logsCommand = new Command("logs").description("Tail MCP connection log with
     const result = await client.mcpCall("integration_sync_logs", {
       limit: lineCount
     });
-    const data = extractMcpContent3(result);
+    const data = result;
     if (jsonFlag) {
       fmt.table(Array.isArray(data) ? data : [], [
         { key: "timestamp", header: "Timestamp" },
@@ -5278,7 +5688,7 @@ async function checkJsonRpc(client, verbose, c) {
   if (verbose) process.stdout.write(`${c.dim("\u2192")} JSON-RPC handshake... `);
   try {
     const result = await client.mcpCall("mcp_capabilities", {});
-    const data = extractMcpContent3(result);
+    const data = result;
     let toolCount = "ok";
     if (typeof data === "object" && data !== null) {
       const record = data;
@@ -5300,8 +5710,9 @@ async function checkJsonRpc(client, verbose, c) {
 var testCommand = new Command("test").description(
   "Perform full MCP handshake diagnostic (DNS, edge ping, JSON-RPC)"
 ).option("--json", "Output as JSON").action(async (options) => {
-  const parentOpts = testCommand.parent?.opts() ?? {};
-  const jsonFlag = options.json || parentOpts.json || false;
+  const jsonFlag = Boolean(
+    options.json || testCommand.optsWithGlobals().json
+  );
   const fmt = createFormatter({
     json: jsonFlag,
     quiet: false,
@@ -5336,67 +5747,75 @@ ${summary}.
 var installCommand = new Command("install").description("Generate MCP configuration for a supported AI client").argument(
   "<client>",
   `AI client to configure (${SUPPORTED_CLIENTS.join(", ")})`
-).option("--stdout", "Print config to stdout instead of writing file").action(async (clientName, options) => {
-  const fmt = createFormatter({
-    json: false,
-    quiet: false,
-    isTTY: isTTY(),
-    noColor: false
-  });
-  if (!SUPPORTED_CLIENTS.includes(clientName)) {
-    fmt.error(
-      `Unsupported client: "${clientName}". Supported clients: ${SUPPORTED_CLIENTS.join(", ")}`
-    );
-    process.exit(3);
-  }
-  const auth = await resolveAuth();
-  if (clientName === "codex") {
-    if (options.stdout) {
-      process.stdout.write(`# ~/.codex/config.toml
+).option("--stdout", "Print config to stdout instead of writing file").option(
+  "--repo-url <url>",
+  "Repo URL to pin MCP requests to (defaults to current git origin)"
+).action(
+  async (clientName, options) => {
+    const fmt = createFormatter({
+      json: false,
+      quiet: false,
+      isTTY: isTTY(),
+      noColor: false
+    });
+    if (!SUPPORTED_CLIENTS.includes(clientName)) {
+      fmt.error(
+        `Unsupported client: "${clientName}". Supported clients: ${SUPPORTED_CLIENTS.join(", ")}`
+      );
+      process.exit(3);
+    }
+    const auth = await resolveAuth();
+    const repoUrl = options.repoUrl ?? detectGitOrigin2();
+    if (clientName === "codex") {
+      if (options.stdout) {
+        process.stdout.write(`# ~/.codex/config.toml
 `);
-      process.stdout.write(generateCodexConfigToml(auth.apiUrl));
-      process.stdout.write(`
+        process.stdout.write(generateCodexConfigToml(auth.apiUrl, repoUrl));
+        process.stdout.write(`
 # ~/.codex/.env
 `);
-      process.stdout.write(generateCodexEnv(auth.token));
+        process.stdout.write(generateCodexEnv(auth.token));
+        return;
+      }
+      const { configPath, envPath } = await installCodexConfig(
+        auth.apiUrl,
+        auth.token,
+        repoUrl
+      );
+      fmt.success(`Wrote Codex MCP config to ${configPath} and ${envPath}`);
       return;
     }
-    const { configPath, envPath } = await installCodexConfig(
+    const config = generateMcpConfig(
+      clientName,
       auth.apiUrl,
-      auth.token
+      auth.token,
+      repoUrl
     );
-    fmt.success(`Wrote Codex MCP config to ${configPath} and ${envPath}`);
-    return;
-  }
-  const config = generateMcpConfig(
-    clientName,
-    auth.apiUrl,
-    auth.token
-  );
-  const configJson = JSON.stringify(config, null, 2);
-  if (options.stdout) {
-    process.stdout.write(configJson + "\n");
-    return;
+    const configJson = JSON.stringify(config, null, 2);
+    if (options.stdout) {
+      process.stdout.write(configJson + "\n");
+      return;
+    }
+    const { writeFile: writeFile3 } = await import("node:fs/promises");
+    const { join: join3 } = await import("node:path");
+    const outputPath = join3(process.cwd(), ".mcp.json");
+    await writeFile3(outputPath, configJson + "\n", "utf-8");
+    fmt.success(`Wrote ${clientName} MCP config to .mcp.json`);
   }
-  const { writeFile: writeFile2 } = await import("node:fs/promises");
-  const { join: join2 } = await import("node:path");
-  const outputPath = join2(process.cwd(), ".mcp.json");
-  await writeFile2(outputPath, configJson + "\n", "utf-8");
-  fmt.success(`Wrote ${clientName} MCP config to .mcp.json`);
-});
+);
 var mcpCommand = new Command("mcp").description("Manage and diagnose the MCP server connection").addCommand(statusCommand).addCommand(logsCommand).addCommand(testCommand).addCommand(installCommand);
 var mcp_default = mcpCommand;
 
 // src/commands/deploy.ts
 var DEPLOY_TIMEOUT_MS = 9e4;
 function deployCommand() {
-  const cmd = new Command("deploy").description("Trigger a production deployment").option("--confirm", "Skip interactive confirmation (required in CI)").option("--json", "Output as JSON").option("--quiet", "Suppress decorative output").option("--no-color", "Disable color output").action(async (options) => {
-    const noColor = options.color === false;
+  const cmd = new Command("deploy").description("Trigger a production deployment").option("--confirm", "Skip interactive confirmation (required in CI)").option("--json", "Output as JSON").option("--quiet", "Suppress decorative output").option("--no-color", "Disable color output").action(async (options, command) => {
+    const g = globalOutputOpts(command);
     const fmt = createFormatter({
-      json: options.json ?? false,
-      quiet: options.quiet ?? false,
+      json: g.json,
+      quiet: g.quiet,
       isTTY: isTTY(),
-      noColor
+      noColor: g.noColor
     });
     if (!options.confirm) {
       if (!isTTY()) {
@@ -5424,7 +5843,7 @@ function deployCommand() {
       fmt.info("Deploying to production...");
     }
     const result = await client.mcpCall("deploy_to_vercel", {});
-    if (options.json) {
+    if (g.json) {
       process.stdout.write(JSON.stringify(result) + "\n");
       return;
     }
@@ -5484,11 +5903,12 @@ function displayResults(result, fmt) {
     ]);
   }
 }
-var migrateCommand = new Command("migrate").description("Run pending database migrations").option("--confirm", "Skip confirmation prompt (required in non-TTY)").option("--json", "Output results as JSON").option("--quiet", "Suppress decorative output").action(async (opts) => {
+var migrateCommand = new Command("migrate").description("Run pending database migrations").option("--confirm", "Skip confirmation prompt (required in non-TTY)").option("--json", "Output results as JSON").option("--quiet", "Suppress decorative output").action(async (opts, command) => {
+  const g = globalOutputOpts(command);
   const tty = isTTY();
   const fmt = createFormatter({
-    json: Boolean(opts.json),
-    quiet: Boolean(opts.quiet),
+    json: g.json,
+    quiet: g.quiet,
     isTTY: tty,
     noColor: !tty
   });
@@ -5500,7 +5920,7 @@ var migrateCommand = new Command("migrate").description("Run pending database mi
   const client = new GadClient({ token: auth.token, apiUrl: auth.apiUrl });
   fmt.info("Running pending migrations\u2026");
   const result = await client.mcpCall("apply_migration", {});
-  if (opts.json) {
+  if (g.json) {
     const applied = result?.applied ?? 0;
     const status = result?.status ?? "complete";
     fmt.table(
@@ -5590,17 +6010,17 @@ function outputJsonSummary(results, totalDurationMs) {
   process.stdout.write(JSON.stringify(output) + "\n");
 }
 function smokeCommand() {
-  const cmd = new Command("smoke").description("Run MCP smoke tests to verify platform connectivity").option("--json", "Output as JSON").option("--quiet", "Suppress decorative output").option("--no-color", "Disable color output").action(async (options) => {
-    const noColor = options.color === false;
-    const color2 = createColor(noColor);
+  const cmd = new Command("smoke").description("Run MCP smoke tests to verify platform connectivity").option("--json", "Output as JSON").option("--quiet", "Suppress decorative output").option("--no-color", "Disable color output").action(async (options, command) => {
+    const g = globalOutputOpts(command);
+    const color2 = createColor(g.noColor);
     const fmt = createFormatter({
-      json: options.json ?? false,
-      quiet: options.quiet ?? false,
+      json: g.json,
+      quiet: g.quiet,
       isTTY: isTTY(),
-      noColor
+      noColor: g.noColor
     });
-    const isJson = options.json ?? false;
-    const isQuiet = options.quiet ?? false;
+    const isJson = g.json;
+    const isQuiet = g.quiet;
     const auth = await resolveAuth();
     const client = new GadClient({
       token: auth.token,
@@ -5656,7 +6076,8 @@ async function buildClient2() {
 var agentCommand = new Command("agent").description(
   "List and invoke AI agents"
 );
-agentCommand.command("list").description("Display available specialist and custom agents").option("--json", "Output as JSON").action(async (opts) => {
+agentCommand.command("list").description("Display available specialist and custom agents").option("--json", "Output as JSON").action(async (opts, command) => {
+  const g = globalOutputOpts(command);
   const client = await buildClient2();
   const result = await client.mcpCall("agent_list", {});
   let agents;
@@ -5667,14 +6088,15 @@ agentCommand.command("list").description("Display available specialist and custo
     agents = data?.agents ?? data?.results ?? [];
   }
   const fmt = createFormatter({
-    json: Boolean(opts.json),
+    json: g.json,
     quiet: false,
     isTTY: isTTY(),
     noColor: false
   });
   fmt.table(agents, agentListColumns);
 });
-agentCommand.command("invoke <agent-id>").description("Execute an agent with a task").requiredOption("--task <task>", "Task description for the agent").option("--json", "Output raw agent response as JSON").option("--context <context>", "Additional context for the agent").action(async (agentId, opts) => {
+agentCommand.command("invoke <agent-id>").description("Execute an agent with a task").requiredOption("--task <task>", "Task description for the agent").option("--json", "Output raw agent response as JSON").option("--context <context>", "Additional context for the agent").action(async (agentId, opts, command) => {
+  const g = globalOutputOpts(command);
   const client = await buildClient2();
   const args = {
     agentId,
@@ -5684,7 +6106,7 @@ agentCommand.command("invoke <agent-id>").description("Execute an agent with a t
     args.context = opts.context;
   }
   const result = await client.mcpCall("agent_invoke", args, AGENT_TIMEOUT_MS);
-  if (opts.json) {
+  if (g.json) {
     const output = typeof result === "string" ? result : JSON.stringify(result, null, 2);
     process.stdout.write(output + "\n");
     return;
@@ -5720,15 +6142,16 @@ function extractAnswer(data) {
   return result.answer || result.text || result.result || result.content || "";
 }
 function askCommand() {
-  const cmd = new Command("ask").description("Ask the orchestrator a question").argument("<question>", "The question to ask").option("--json", "Output raw response as JSON").option("--quiet", "Suppress decorative output").option("--no-color", "Disable color output").action(async (question, options) => {
+  const cmd = new Command("ask").description("Ask the orchestrator a question").argument("<question>", "The question to ask").option("--json", "Output raw response as JSON").option("--quiet", "Suppress decorative output").option("--no-color", "Disable color output").action(async (question, options, command) => {
+    const g = globalOutputOpts(command);
     const auth = await resolveAuth();
     const client = new GadClient({
       token: auth.token,
       apiUrl: auth.apiUrl
     });
     const fmt = createFormatter({
-      json: options.json ?? false,
-      quiet: options.quiet ?? false,
+      json: g.json,
+      quiet: g.quiet,
       isTTY: isTTY(),
       noColor: options.color === false
     });
@@ -5737,7 +6160,7 @@ function askCommand() {
       { query: question },
       ORCHESTRATOR_TIMEOUT_MS
     );
-    if (options.json) {
+    if (g.json) {
       process.stdout.write(JSON.stringify(result) + "\n");
       return;
     }
@@ -6002,7 +6425,7 @@ if (nodeVersion < 20) {
   console.error("  Upgrade Node.js: https://nodejs.org/");
   process.exit(1);
 }
-var VERSION = "0.1.2";
+var VERSION = "0.1.4";
 var program2 = new Command().name("gad").description("Great Arrow Digital CLI \u2014 terminal access to the GAD platform").version(VERSION, "-v, --version").option("--json", "Output as JSON").option("--quiet", "Suppress decorative output").option("--no-color", "Disable color output");
 program2.addCommand(login_default);
 program2.addCommand(logoutCommand);