@sunasteriskrnd/takumi 1.0.0-dev.43 → 1.0.0-dev.45

package/dist/index.js

@@ -19815,7 +19815,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@sunasteriskrnd/takumi",
-    version: "1.0.0-dev.43",
+    version: "1.0.0-dev.45",
     description: "CLI tool for bootstrapping and managing Takumi projects",
     type: "module",
     repository: {
@@ -49807,6 +49807,73 @@ var init_artifact_command_help = __esm(() => {
   };
 });
 
+// src/domains/help/commands/mcp-command-help.ts
+var mcpCommandHelp;
+var init_mcp_command_help = __esm(() => {
+  mcpCommandHelp = {
+    name: "mcp",
+    description: "Manage internal MCP connectors for coding agents (add|list|remove)",
+    usage: "tkm mcp <add|list|remove> [service] [options] [-- <extra args...>]",
+    examples: [
+      {
+        command: "tkm mcp list",
+        description: "Show available internal MCP services and per-agent configured state"
+      },
+      {
+        command: "tkm mcp add meet-plus",
+        description: "Register the 'meet-plus' MCP with the current project's coding agent(s)"
+      },
+      {
+        command: "tkm mcp add playwright -- --browser msedge --headless",
+        description: "Add a stdio MCP with extra launch args appended after the registry defaults"
+      }
+    ],
+    optionGroups: [
+      {
+        title: "Actions",
+        options: [
+          {
+            flags: "add <service> [-- <extra args...>]",
+            description: "Add a registry service to detected agent(s); argv after -- is appended to a stdio service's args (e.g. -- --browser msedge)"
+          },
+          {
+            flags: "list",
+            description: "List registry services with per-agent configured status"
+          },
+          {
+            flags: "remove <service>",
+            description: "Remove a service from detected agent(s); absent entries are skipped"
+          }
+        ]
+      },
+      {
+        title: "Options",
+        options: [
+          {
+            flags: "-a, --agent <agents...>",
+            description: "Target specific agent(s): claude-code | codex (repeatable)"
+          },
+          {
+            flags: "-s, --scope <scope>",
+            description: "Config scope: local | user | project (default: user; agent-dependent)"
+          },
+          { flags: "-y, --yes", description: "Non-interactive mode: skip selection prompts" },
+          { flags: "--json", description: "Machine-readable JSON output (list only)" }
+        ]
+      }
+    ],
+    sections: [
+      {
+        title: "Registry source",
+        content: `Cache-first: an existing local cache (<TAKUMI_HOME>/mcp/registry-cache.json) is
+` + `served immediately while a background request refreshes it for the next run.
+` + `With no cache yet, the CLI fetches the Takumi server directly and reports an
+` + "error when the server is unreachable (no stale in-package fallback)."
+      }
+    ]
+  };
+});
+
 // src/domains/help/commands/index.ts
 var init_commands2 = __esm(() => {
   init_init_command_help();
@@ -49817,6 +49884,7 @@ var init_commands2 = __esm(() => {
   init_config_command_help();
   init_auth_command_help();
   init_artifact_command_help();
+  init_mcp_command_help();
   init_common_options();
 });
 
@@ -49836,7 +49904,8 @@ var init_help_commands = __esm(() => {
     doctor: doctorCommandHelp,
     uninstall: uninstallCommandHelp,
     auth: authCommandHelp,
-    artifact: artifactCommandHelp
+    artifact: artifactCommandHelp,
+    mcp: mcpCommandHelp
   };
 });
 
@@ -53485,6 +53554,7 @@ function tryOpenBrowser(target) {
 }
 
 // src/domains/sessions/server.ts
+init_logger();
 import * as http from "node:http";
 
 // src/domains/sessions/analytics.ts
@@ -53521,16 +53591,26 @@ function accumulateTokens(a3, b3) {
   a3.cacheRead += b3.cacheRead;
   a3.cacheWrite += b3.cacheWrite;
 }
-function buildLast30(byDay, now) {
+function buildDenseWindow(byDay, startDayMs, endDayMs) {
   const out = [];
-  const todayMs = Date.parse(`${dayKey(now)}T00:00:00.000Z`);
-  for (let i = LAST_N_DAYS - 1;i >= 0; i -= 1) {
-    const date = dayKey(todayMs - i * DAY_MS);
+  for (let ms = startDayMs;ms <= endDayMs; ms += DAY_MS) {
+    const date = dayKey(ms);
     out.push({ date, count: byDay.get(date) ?? 0 });
   }
   return out;
 }
-function foldAnalytics(aggregates, now) {
+function windowBounds(now, range) {
+  if (!range) {
+    const todayMs = Date.parse(`${dayKey(now)}T00:00:00.000Z`);
+    return { start: todayMs - (LAST_N_DAYS - 1) * DAY_MS, end: todayMs };
+  }
+  const lo = Math.min(range.from, range.to);
+  const hi = Math.max(range.from, range.to);
+  const end = Date.parse(`${dayKey(hi)}T00:00:00.000Z`);
+  const start = Math.max(Date.parse(`${dayKey(lo)}T00:00:00.000Z`), end - (PER_DAY_MAX - 1) * DAY_MS);
+  return { start, end };
+}
+function foldAnalytics(aggregates, now, range) {
   const totals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
   const eventsByDay = new Map;
   const tokensByDow = new Map;
@@ -53585,7 +53665,8 @@ function foldAnalytics(aggregates, now) {
   const perDay = [...eventsByDay.entries()].filter(([date]) => Date.parse(`${date}T00:00:00.000Z`) >= oldestAllowedMs).map(([date, count]) => ({ date, count })).sort((a3, b3) => a3.date.localeCompare(b3.date));
   const byProjectAll = [...tokensByProject.entries()].map(([label, tokens]) => ({ label, tokens })).sort((a3, b3) => b3.tokens - a3.tokens || a3.label.localeCompare(b3.label));
   const byProject = byProjectAll.slice(0, TOP_PROJECTS);
-  const daily = buildLast30(tokensByDay, now);
+  const { start: windowStart, end: windowEnd } = windowBounds(now, range);
+  const daily = buildDenseWindow(tokensByDay, windowStart, windowEnd);
   const rankedModels = [...tokensByModel.entries()].map(([label, tokens]) => ({ label, tokens, total: sumTokens(tokens) })).filter((m2) => m2.total > 0).sort((a3, b3) => b3.total - a3.total || a3.label.localeCompare(b3.label)).slice(0, TOP_PROJECTS);
   const byModel = rankedModels.map(({ label, total }) => ({ label, tokens: total }));
   const byModelDetailed = rankedModels.map(({ label, tokens }) => ({ label, tokens }));
@@ -53602,7 +53683,7 @@ function foldAnalytics(aggregates, now) {
     events: {
       total: eventTotal,
       perDay,
-      last30: buildLast30(eventsByDay, now)
+      last30: buildDenseWindow(eventsByDay, windowStart, windowEnd)
     },
     tokens: {
       byType: { ...totals },
@@ -54912,6 +54993,24 @@ function invalidate() {
   }
 }
 
+// src/domains/sessions/session-meta-filter.ts
+function filterSessionMetas(metas, filter) {
+  return metas.filter((m2) => {
+    if (filter.project !== undefined && m2.project !== filter.project)
+      return false;
+    if (filter.from === undefined && filter.to === undefined)
+      return true;
+    const ms = m2.startedAt === null ? Number.NaN : Date.parse(m2.startedAt);
+    if (Number.isNaN(ms))
+      return false;
+    if (filter.from !== undefined && ms < filter.from)
+      return false;
+    if (filter.to !== undefined && ms > filter.to)
+      return false;
+    return true;
+  });
+}
+
 // src/domains/sessions/store/ingest.ts
 import { createHash as createHash9 } from "node:crypto";
 import { closeSync as closeSync4, openSync as openSync4, readSync as readSync4, readdirSync as readdirSync6, statSync as statSync5 } from "node:fs";
@@ -64676,6 +64775,32 @@ async function readStoreAggregates(db) {
     get2(r2.session_id).agentCount += Number(r2.n ?? 0);
   return map;
 }
+async function attachSessionTokenTotals(db, list2) {
+  const totals = await readSessionTokenTotals(db);
+  return list2.map((s) => {
+    const tokens = totals.get(s.id);
+    return tokens ? { ...s, tokens } : s;
+  });
+}
+async function readSessionTokenTotals(db) {
+  const rows = await db.selectFrom("event").where("type", "=", "tokens").select((eb) => [
+    "session_id",
+    eb.fn.sum("input").as("input"),
+    eb.fn.sum("output").as("output"),
+    eb.fn.sum("cache_read").as("cache_read"),
+    eb.fn.sum("cache_write").as("cache_write")
+  ]).groupBy("session_id").execute();
+  const map = new Map;
+  for (const r2 of rows) {
+    map.set(r2.session_id, {
+      input: Number(r2.input ?? 0),
+      output: Number(r2.output ?? 0),
+      cacheCreate: Number(r2.cache_write ?? 0),
+      cacheRead: Number(r2.cache_read ?? 0)
+    });
+  }
+  return map;
+}
 function buildAggregatesFromStore(sessions, store) {
   return sessions.map((s) => {
     const a3 = store.get(s.id) ?? emptyStoreAggregate();
@@ -64692,30 +64817,52 @@ function buildAggregatesFromStore(sessions, store) {
 }
 
 // src/domains/sessions/analytics-source.ts
-var cache2 = null;
+var DAY_MS2 = 24 * 60 * 60 * 1000;
+var DEFAULT_WINDOW_DAYS = 30;
+var cache2 = new Map;
 var storeHandle = null;
 function setStore(handle) {
   storeHandle = handle;
 }
 function invalidate2() {
-  cache2 = null;
+  cache2 = new Map;
+}
+var cacheKey = (o2) => `${o2.from ?? ""}|${o2.to ?? ""}|${o2.project === undefined ? "" : `p:${o2.project}`}`;
+function rangeOf(o2, now) {
+  if (o2.from === undefined && o2.to === undefined)
+    return;
+  const to = o2.to ?? now;
+  const from = o2.from ?? to - (DEFAULT_WINDOW_DAYS - 1) * DAY_MS2;
+  return { from, to };
 }
-async function computeFromStore(handle, refresh2, now) {
+async function computeFromStore(handle, opts, now) {
+  const refresh2 = opts.refresh ?? false;
   if (refresh2)
     await ingestAll(handle, { refresh: true });
   const sessions = await list({ refresh: refresh2 });
+  const metas = filterSessionMetas(sessions.map((s) => ({ id: s.id, startedAt: s.startedAt, project: s.project })), { from: opts.from, to: opts.to, project: opts.project });
   const storeAggs = await readStoreAggregates(handle.db);
-  const metas = sessions.map((s) => ({ id: s.id, startedAt: s.startedAt, project: s.project }));
-  return foldAnalytics(buildAggregatesFromStore(metas, storeAggs), now);
+  const payload = foldAnalytics(buildAggregatesFromStore(metas, storeAggs), now, rangeOf(opts, now));
+  return {
+    ...payload,
+    filters: {
+      from: opts.from ?? null,
+      to: opts.to ?? null,
+      project: opts.project ?? null
+    }
+  };
 }
 async function getAnalytics(opts = {}) {
-  if (cache2 && !opts.refresh)
-    return cache2;
+  const key = cacheKey(opts);
+  const hit = cache2.get(key);
+  if (hit && !opts.refresh)
+    return hit;
   if (!storeHandle)
     throw new StoreUnavailableError;
   const now = Date.now();
-  cache2 = await computeFromStore(storeHandle, opts.refresh ?? false, now);
-  return cache2;
+  const payload = await computeFromStore(storeHandle, opts, now);
+  cache2.set(key, payload);
+  return payload;
 }
 
 // src/domains/sessions/origin-allowlist.ts
@@ -64743,13 +64890,33 @@ function isAllowedOrigin(origin) {
   return LOOPBACK_HOST_PATTERN.test(origin);
 }
 
+// src/domains/sessions/range-params.ts
+function intParam(search, key) {
+  const raw = search.get(key);
+  if (raw === null || raw === "")
+    return;
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 0)
+    return { error: `invalid ${key}: ${raw}` };
+  return n;
+}
+function parseRangeProjectParams(search) {
+  const from = intParam(search, "from");
+  if (typeof from === "object")
+    return from;
+  const to = intParam(search, "to");
+  if (typeof to === "object")
+    return to;
+  return { from, to, project: search.get("project") || undefined };
+}
+
 // src/domains/sessions/store/bridge-store.ts
 init_logger();
 
 // src/domains/sessions/store/prune.ts
 import { existsSync as existsSync34, statSync as statSync6 } from "node:fs";
 init_logger();
-var DAY_MS2 = 24 * 60 * 60 * 1000;
+var DAY_MS3 = 24 * 60 * 60 * 1000;
 var DEFAULT_RETENTION_DAYS = 180;
 var SIZE_DELETE_BATCH = 500;
 var SIZE_PRUNE_MAX_ITERS = 200;
@@ -64775,7 +64942,7 @@ async function runPrune(handle, opts = {}) {
   const now = opts.now ?? Date.now();
   const retentionDays = opts.retentionDays ?? DEFAULT_RETENTION_DAYS;
   const dbPath = opts.dbPath ?? getConsoleStorePath();
-  const cutoff = now - retentionDays * DAY_MS2;
+  const cutoff = now - retentionDays * DAY_MS3;
   await db.deleteFrom("event").where("ts", "<", cutoff).execute();
   if (opts.maxSizeMb && opts.maxSizeMb > 0) {
     const cap = opts.maxSizeMb * 1024 * 1024;
@@ -64953,6 +65120,17 @@ async function attachStore(deps = {}) {
 }
 
 // src/domains/sessions/server.ts
+var tokenStore = null;
+async function withTokenTotals(list2) {
+  if (!tokenStore)
+    return list2;
+  try {
+    return await attachSessionTokenTotals(tokenStore.db, list2);
+  } catch (err) {
+    logger.verbose(`console bridge: token totals enrichment failed (${String(err)})`);
+    return list2;
+  }
+}
 var PORT_BUMP_MAX = 9;
 function applyCorsHeaders(req, res) {
   const origin = req.headers.origin;
@@ -65010,15 +65188,20 @@ async function route(req, res, version3) {
     if (refresh2)
       invalidate();
     const list2 = await list({ refresh: refresh2 });
-    sendJSON(res, 200, list2);
+    sendJSON(res, 200, await withTokenTotals(list2));
     return;
   }
   if (pathname === "/api/analytics") {
     const refresh2 = url.searchParams.get("refresh") === "1";
+    const rp = parseRangeProjectParams(url.searchParams);
+    if ("error" in rp) {
+      sendJSON(res, 400, { error: rp.error });
+      return;
+    }
     if (refresh2)
       invalidate2();
     try {
-      const payload = await getAnalytics({ refresh: refresh2 });
+      const payload = await getAnalytics({ refresh: refresh2, ...rp });
       sendJSON(res, 200, payload);
     } catch (err) {
       if (err instanceof StoreUnavailableError) {
@@ -65091,6 +65274,7 @@ function start(options2 = {}) {
             close: async () => {
               if (attached) {
                 setStore(null);
+                tokenStore = null;
                 await attached.stop().catch(() => {});
               }
               await closeServer();
@@ -65101,8 +65285,10 @@ function start(options2 = {}) {
         };
         const doAttach = options2.attachStore ?? attachStore;
         doAttach({ onInvalidate: () => invalidate2() }).then((attached) => {
-          if (attached)
+          if (attached) {
             setStore(attached.handle);
+            tokenStore = attached.handle;
+          }
           finish(attached);
         }).catch(() => finish(null));
       });
@@ -84144,22 +84330,984 @@ async function initCommand(options2) {
     throw error;
   }
 }
+// src/domains/mcp/mcp-service.ts
+init_logger();
+
+// src/domains/mcp/mcp-service-core.ts
+init_environment();
+init_logger();
+init_dist2();
+
+// src/domains/mcp/agent-detector.ts
+init_environment();
+import { existsSync as existsSync58 } from "node:fs";
+import { join as join126 } from "node:path";
+
+// src/domains/mcp/shell-out.ts
+import { spawnSync as spawnSync5 } from "node:child_process";
+var DEFAULT_TIMEOUT_MS7 = 60000;
+var PROBE_TIMEOUT_MS = 5000;
+var SERVICE_NAME_PATTERN = /^[a-z0-9-]+$/;
+function isValidServiceName(name2) {
+  return SERVICE_NAME_PATTERN.test(name2);
+}
+function runAgentCli(bin, args, timeoutMs = DEFAULT_TIMEOUT_MS7) {
+  const result = spawnSync5(bin, args, {
+    timeout: timeoutMs,
+    encoding: "utf-8",
+    shell: false,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (result.error) {
+    return {
+      ok: false,
+      code: null,
+      stdout: "",
+      stderr: result.error.message
+    };
+  }
+  return {
+    ok: result.status === 0,
+    code: result.status,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? ""
+  };
+}
+function isBinaryOnPath(bin) {
+  const probeCmd = process.platform === "win32" ? "where" : "which";
+  const result = spawnSync5(probeCmd, [bin], {
+    timeout: PROBE_TIMEOUT_MS,
+    encoding: "utf-8",
+    shell: false
+  });
+  if (result.error || result.status !== 0)
+    return false;
+  if (process.platform !== "win32")
+    return true;
+  return (result.stdout ?? "").split(/\r?\n/).some((line) => /\.(exe|com)$/i.test(line.trim()));
+}
+function isAlreadyExistsError(result) {
+  return /already exists/i.test(`${result.stderr}
+${result.stdout}`);
+}
+
+// src/domains/mcp/types.ts
+init_zod();
+var McpAgentSchema = exports_external.enum(["claude-code", "codex"]);
+var ALL_MCP_AGENTS = ["claude-code", "codex"];
+var McpScopeSchema = exports_external.enum(["local", "user", "project"]);
+var ALL_MCP_SCOPES = ["local", "user", "project"];
+var DEFAULT_MCP_SCOPE = "user";
+var McpTransportSchema = exports_external.enum(["http", "sse", "stdio"]);
+var McpRemoteServiceEntrySchema = exports_external.object({
+  name: exports_external.string(),
+  description: exports_external.string(),
+  transport: exports_external.enum(["http", "sse"]),
+  url: exports_external.string().url()
+});
+var McpStdioServiceEntrySchema = exports_external.object({
+  name: exports_external.string(),
+  description: exports_external.string(),
+  transport: exports_external.literal("stdio"),
+  command: exports_external.string().min(1),
+  args: exports_external.array(exports_external.string()).nullish()
+});
+var McpServiceEntrySchema = exports_external.union([
+  McpRemoteServiceEntrySchema,
+  McpStdioServiceEntrySchema
+]);
+var McpRegistrySchema = exports_external.object({
+  services: exports_external.array(McpServiceEntrySchema)
+});
+
+// src/domains/mcp/agent-detector.ts
+var AGENT_BINARY = {
+  "claude-code": "claude",
+  codex: "codex"
+};
+function getAgentConfigPath(agent) {
+  const home6 = getHomeDirectoryFromEnv();
+  if (!home6)
+    return null;
+  switch (agent) {
+    case "claude-code":
+      return join126(home6, ".claude.json");
+    case "codex":
+      return join126(home6, ".codex", "config.toml");
+    default: {
+      const _exhaustive = agent;
+      return _exhaustive;
+    }
+  }
+}
+var defaultCheckers = {
+  binaryOnPath: isBinaryOnPath,
+  configExists: existsSync58
+};
+function isAgentPresent(agent, checkers = defaultCheckers) {
+  if (checkers.binaryOnPath(AGENT_BINARY[agent])) {
+    return true;
+  }
+  const configPath = getAgentConfigPath(agent);
+  return configPath !== null && checkers.configExists(configPath);
+}
+function detectAgents(checkers = defaultCheckers) {
+  return ALL_MCP_AGENTS.filter((agent) => isAgentPresent(agent, checkers));
+}
+var PROJECT_MARKERS = {
+  "claude-code": [".claude", "CLAUDE.md"],
+  codex: [".codex", "AGENTS.md"]
+};
+function detectProjectAgents(cwd2 = process.cwd(), exists2 = existsSync58) {
+  return ALL_MCP_AGENTS.filter((agent) => PROJECT_MARKERS[agent].some((marker) => exists2(join126(cwd2, marker))));
+}
+
+// src/domains/mcp/registry-client.ts
+init_zod();
+init_logger();
+init_auth_client();
+
+// src/domains/mcp/registry-cache.ts
+init_logger();
+init_paths2();
+import { promises as fs33 } from "node:fs";
+import { join as join127 } from "node:path";
+function getCacheDir() {
+  return join127(getConfigDir(), "mcp");
+}
+function getCachePath2() {
+  return join127(getCacheDir(), "registry-cache.json");
+}
+async function readCachedRegistry() {
+  try {
+    const raw = await fs33.readFile(getCachePath2(), "utf8");
+    const parsed = JSON.parse(raw);
+    const result = McpRegistrySchema.safeParse({ services: parsed.services });
+    if (!result.success)
+      return null;
+    return {
+      registry: result.data,
+      cachedAt: typeof parsed.cachedAt === "number" ? parsed.cachedAt : 0
+    };
+  } catch (err) {
+    if (err?.code === "ENOENT")
+      return null;
+    logger.verbose(`registry-cache: read failed (${err instanceof Error ? err.message : String(err)})`);
+    return null;
+  }
+}
+async function writeCachedRegistry(registry) {
+  const dir = getCacheDir();
+  await fs33.mkdir(dir, { recursive: true, mode: 448 });
+  const body = { services: registry.services, cachedAt: Date.now() };
+  await fs33.writeFile(getCachePath2(), JSON.stringify(body, null, 2), {
+    mode: 384,
+    encoding: "utf8"
+  });
+}
+
+// src/domains/mcp/writers/json-config-file.ts
+import { readFile as readFile44 } from "node:fs/promises";
+function toMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isEnoent(error) {
+  return error?.code === "ENOENT";
+}
+async function readJsonConfigFile(path11) {
+  let content;
+  try {
+    content = await readFile44(path11, "utf-8");
+  } catch (error) {
+    if (isEnoent(error))
+      return { ok: true, raw: {} };
+    return { ok: false, detail: toMessage(error) };
+  }
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return { ok: true, raw: parsed };
+    }
+    return { ok: false, detail: `Refusing to overwrite malformed ${path11}: not a JSON object` };
+  } catch (error) {
+    return { ok: false, detail: `Refusing to overwrite malformed ${path11}: ${toMessage(error)}` };
+  }
+}
+function extractMcpServers(raw) {
+  const servers = raw.mcpServers;
+  return servers && typeof servers === "object" && !Array.isArray(servers) ? servers : {};
+}
+
+// src/domains/mcp/registry-client.ts
+class RegistryUnavailableError extends Error {
+  constructor(cause) {
+    super(`Cannot load the MCP registry: ${cause}. Check your network connection (the registry is fetched from the Takumi server) and retry.`);
+    this.name = "RegistryUnavailableError";
+  }
+}
+var REGISTRY_PATH2 = "/api/v1/mcp/registry";
+var REGISTRY_FETCH_TIMEOUT_MS = 3000;
+var LooseRegistrySchema = exports_external.object({ services: exports_external.array(exports_external.unknown()) });
+function parseRegistryLenient(data) {
+  const loose = LooseRegistrySchema.parse(data);
+  const services = [];
+  for (const raw of loose.services) {
+    const parsed = McpServiceEntrySchema.safeParse(raw);
+    if (parsed.success) {
+      services.push(parsed.data);
+    } else {
+      const name2 = raw?.name;
+      logger.verbose(`registry: dropped invalid entry ${typeof name2 === "string" ? `"${name2}"` : "(unnamed)"}`);
+    }
+  }
+  if (loose.services.length > 0 && services.length === 0) {
+    throw new Error("registry: every entry failed validation (schema drift?)");
+  }
+  return { services };
+}
+async function fetchRemoteRegistry() {
+  const res = await fetch(`${getServerUrl()}${REGISTRY_PATH2}`, {
+    headers: { "X-TKM-Client": "takumi-cli/mcp" },
+    signal: AbortSignal.timeout(REGISTRY_FETCH_TIMEOUT_MS)
+  });
+  if (!res.ok)
+    throw new Error(`registry: HTTP ${res.status}`);
+  return parseRegistryLenient(await res.json());
+}
+async function refreshCache() {
+  try {
+    await writeCachedRegistry(await fetchRemoteRegistry());
+    return true;
+  } catch (err) {
+    logger.verbose(`registry: revalidate skipped (${toMessage(err)})`);
+    return false;
+  }
+}
+async function getRegistryWithSource() {
+  const cached = await readCachedRegistry();
+  if (cached) {
+    return { registry: cached.registry, source: "cache", revalidated: refreshCache() };
+  }
+  try {
+    const remote = await fetchRemoteRegistry();
+    try {
+      await writeCachedRegistry(remote);
+    } catch (err) {
+      logger.verbose(`registry: cache write skipped (${toMessage(err)})`);
+    }
+    return { registry: remote, source: "server" };
+  } catch (err) {
+    throw new RegistryUnavailableError(toMessage(err));
+  }
+}
+function resolveService(registry, name2) {
+  return registry.services.find((service) => service.name === name2);
+}
+
+// src/domains/mcp/writers/claude-config-file.ts
+import { existsSync as existsSync59 } from "node:fs";
+import { mkdir as mkdir29, writeFile as writeFile31 } from "node:fs/promises";
+import { dirname as dirname36, join as join128 } from "node:path";
+var AGENT = "claude-code";
+var LOCAL_SCOPE_FALLBACK_WARNING = "claude CLI not found; local scope isn't representable via direct file write, wrote to user-level ~/.claude.json instead";
+function userConfigPath() {
+  return getAgentConfigPath(AGENT);
+}
+function projectConfigPath() {
+  return join128(process.cwd(), ".mcp.json");
+}
+function configPathFor(scope) {
+  return scope === "project" ? projectConfigPath() : userConfigPath();
+}
+function withLocalScopeFallbackWarning(detail, scope) {
+  if (scope !== "local")
+    return detail;
+  return detail ? `${detail} (${LOCAL_SCOPE_FALLBACK_WARNING})` : LOCAL_SCOPE_FALLBACK_WARNING;
+}
+async function fileAdd(entry, scope) {
+  const path11 = configPathFor(scope);
+  if (!path11) {
+    return { agent: AGENT, status: "failed", detail: "Could not resolve home directory" };
+  }
+  const existing = await readJsonConfigFile(path11);
+  if (!existing.ok) {
+    return { agent: AGENT, status: "failed", detail: existing.detail };
+  }
+  try {
+    const servers = extractMcpServers(existing.raw);
+    servers[entry.name] = entry.transport === "stdio" ? {
+      type: "stdio",
+      command: entry.command,
+      ...entry.args?.length ? { args: entry.args } : {}
+    } : { type: entry.transport, url: entry.url };
+    await mkdir29(dirname36(path11), { recursive: true });
+    await writeFile31(path11, JSON.stringify({ ...existing.raw, mcpServers: servers }, null, 2), "utf-8");
+    return {
+      agent: AGENT,
+      status: "added",
+      detail: withLocalScopeFallbackWarning(`Wrote ${path11} (file fallback)`, scope)
+    };
+  } catch (error) {
+    return { agent: AGENT, status: "failed", detail: toMessage(error) };
+  }
+}
+async function fileRemove(name2, scope) {
+  const path11 = configPathFor(scope);
+  if (!path11 || !existsSync59(path11)) {
+    return { agent: AGENT, status: "skipped", detail: "No config file present" };
+  }
+  const existing = await readJsonConfigFile(path11);
+  if (!existing.ok) {
+    return { agent: AGENT, status: "failed", detail: existing.detail };
+  }
+  try {
+    const servers = extractMcpServers(existing.raw);
+    if (!(name2 in servers)) {
+      return { agent: AGENT, status: "skipped", detail: "Not configured" };
+    }
+    delete servers[name2];
+    await writeFile31(path11, JSON.stringify({ ...existing.raw, mcpServers: servers }, null, 2), "utf-8");
+    return {
+      agent: AGENT,
+      status: "removed",
+      detail: withLocalScopeFallbackWarning(`Updated ${path11} (file fallback)`, scope)
+    };
+  } catch (error) {
+    return { agent: AGENT, status: "failed", detail: toMessage(error) };
+  }
+}
+async function fileConfigured(name2, scope) {
+  const path11 = configPathFor(scope);
+  if (!path11)
+    return false;
+  const existing = await readJsonConfigFile(path11);
+  return existing.ok && name2 in extractMcpServers(existing.raw);
+}
+async function listUserConfigured() {
+  const path11 = userConfigPath();
+  if (!path11)
+    return { has: () => false };
+  const existing = await readJsonConfigFile(path11);
+  if (!existing.ok)
+    return { has: () => false };
+  const servers = extractMcpServers(existing.raw);
+  return { has: (name2) => (name2 in servers) };
+}
+
+// src/domains/mcp/writers/claude-writer.ts
+var AGENT2 = "claude-code";
+var BIN = "claude";
+async function add(entry, opts) {
+  if (!isValidServiceName(entry.name)) {
+    return { agent: AGENT2, status: "failed", detail: `Invalid service name: ${entry.name}` };
+  }
+  if (opts.scope !== "local" && await fileConfigured(entry.name, opts.scope)) {
+    return { agent: AGENT2, status: "skipped", detail: "already configured — no change" };
+  }
+  if (isBinaryOnPath(BIN)) {
+    const argv = entry.transport === "stdio" ? [
+      "mcp",
+      "add",
+      "--scope",
+      opts.scope,
+      entry.name,
+      "--",
+      entry.command,
+      ...entry.args ?? []
+    ] : [
+      "mcp",
+      "add",
+      "--transport",
+      entry.transport,
+      entry.name,
+      entry.url,
+      "--scope",
+      opts.scope
+    ];
+    const result = runAgentCli(BIN, argv);
+    if (result.ok) {
+      return { agent: AGENT2, status: "added", detail: result.stdout.trim() || undefined };
+    }
+    if (isAlreadyExistsError(result)) {
+      return { agent: AGENT2, status: "skipped", detail: "already configured — no change" };
+    }
+    return {
+      agent: AGENT2,
+      status: "failed",
+      detail: result.stderr.trim() || `exit code ${result.code}`
+    };
+  }
+  return fileAdd(entry, opts.scope);
+}
+async function remove10(name2, opts) {
+  if (!isValidServiceName(name2)) {
+    return { agent: AGENT2, status: "failed", detail: `Invalid service name: ${name2}` };
+  }
+  if (isBinaryOnPath(BIN)) {
+    if (opts.scope !== "local" && !await fileConfigured(name2, opts.scope)) {
+      return { agent: AGENT2, status: "skipped", detail: "Not configured" };
+    }
+    const result = runAgentCli(BIN, ["mcp", "remove", name2, "--scope", opts.scope]);
+    if (result.ok) {
+      return { agent: AGENT2, status: "removed", detail: result.stdout.trim() || undefined };
+    }
+    return {
+      agent: AGENT2,
+      status: "failed",
+      detail: result.stderr.trim() || `exit code ${result.code}`
+    };
+  }
+  return fileRemove(name2, opts.scope);
+}
+var claudeWriter = {
+  agent: AGENT2,
+  add,
+  remove: remove10,
+  listConfigured: listUserConfigured
+};
+
+// src/domains/mcp/writers/codex-writer.ts
+init_path_safety();
+import { existsSync as existsSync60 } from "node:fs";
+import { readFile as readFile45, writeFile as writeFile32 } from "node:fs/promises";
+
+// src/domains/mcp/writers/codex-config-file.ts
+function escapeRegex2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function sectionRegex(header) {
+  const escaped = escapeRegex2(header);
+  return new RegExp(`\\n?^\\[${escaped}\\]\\s*\\r?\\n(?:(?!\\[)[^\\r\\n]*\\r?\\n?)*`, "gm");
+}
+function tomlString(value) {
+  return JSON.stringify(value).replace(/\u007f/g, "\\u007F");
+}
+function buildMcpServerSection(name2, entry) {
+  if (!isValidServiceName(name2)) {
+    throw new Error(`Refusing to build TOML section for invalid service name: ${name2}`);
+  }
+  if (entry.transport === "stdio") {
+    const argsLine = entry.args?.length ? `args = [${entry.args.map(tomlString).join(", ")}]
+` : "";
+    return `[mcp_servers.${name2}]
+command = ${tomlString(entry.command)}
+${argsLine}`;
+  }
+  return `[mcp_servers.${name2}]
+url = ${tomlString(entry.url)}
+`;
+}
+function upsertMcpServerSection(content, name2, section) {
+  const regex2 = sectionRegex(`mcp_servers.${name2}`);
+  if (regex2.test(content)) {
+    return content.replace(regex2, () => `
+${section}`).trimStart();
+  }
+  const separator = content.trim().length > 0 ? `
+
+` : "";
+  return `${content.trimEnd()}${separator}${section}`;
+}
+function removeMcpServerSection(content, name2) {
+  const regex2 = sectionRegex(`mcp_servers.${name2}`);
+  if (!regex2.test(content)) {
+    return { content, existed: false };
+  }
+  return { content: content.replace(regex2, ""), existed: true };
+}
+function hasMcpServerSection(content, name2) {
+  return sectionRegex(`mcp_servers.${name2}`).test(content);
+}
+
+// src/domains/mcp/writers/codex-writer.ts
+var AGENT3 = "codex";
+var BIN2 = "codex";
+var SCOPE_WARNING = "codex has no local/project scope; wrote to user-level ~/.codex/config.toml";
+function configPath() {
+  return getAgentConfigPath(AGENT3);
+}
+function withScopeWarning(detail, scope) {
+  if (scope === "user")
+    return detail;
+  return detail ? `${detail} (${SCOPE_WARNING})` : SCOPE_WARNING;
+}
+async function fileAdd2(entry, scope) {
+  const path11 = configPath();
+  if (!path11) {
+    return { agent: AGENT3, status: "failed", detail: "Could not resolve home directory" };
+  }
+  try {
+    return await withCodexTargetLock2(path11, async () => {
+      let existing = "";
+      try {
+        existing = await readFile45(path11, "utf-8");
+      } catch {
+        existing = "";
+      }
+      const section = buildMcpServerSection(entry.name, entry);
+      const updated = upsertMcpServerSection(existing, entry.name, section);
+      await writeFile32(path11, updated, "utf-8");
+      return {
+        agent: AGENT3,
+        status: "added",
+        detail: withScopeWarning(`Wrote ${path11} (file fallback)`, scope)
+      };
+    });
+  } catch (error) {
+    return { agent: AGENT3, status: "failed", detail: toMessage(error) };
+  }
+}
+async function fileRemove2(name2) {
+  const path11 = configPath();
+  if (!path11 || !existsSync60(path11)) {
+    return { agent: AGENT3, status: "skipped", detail: "No config file present" };
+  }
+  try {
+    return await withCodexTargetLock2(path11, async () => {
+      const existing = await readFile45(path11, "utf-8");
+      const { content, existed } = removeMcpServerSection(existing, name2);
+      if (!existed) {
+        return {
+          agent: AGENT3,
+          status: "skipped",
+          detail: "Not configured"
+        };
+      }
+      await writeFile32(path11, content, "utf-8");
+      return {
+        agent: AGENT3,
+        status: "removed",
+        detail: `Updated ${path11} (file fallback)`
+      };
+    });
+  } catch (error) {
+    return { agent: AGENT3, status: "failed", detail: toMessage(error) };
+  }
+}
+async function add2(entry, opts) {
+  if (!isValidServiceName(entry.name)) {
+    return { agent: AGENT3, status: "failed", detail: `Invalid service name: ${entry.name}` };
+  }
+  if (await isConfigured(entry.name)) {
+    return { agent: AGENT3, status: "skipped", detail: "already configured — no change" };
+  }
+  if (isBinaryOnPath(BIN2)) {
+    const argv = entry.transport === "stdio" ? ["mcp", "add", entry.name, "--", entry.command, ...entry.args ?? []] : ["mcp", "add", entry.name, "--url", entry.url];
+    const result = runAgentCli(BIN2, argv, 300000);
+    if (result.ok) {
+      return {
+        agent: AGENT3,
+        status: "added",
+        detail: withScopeWarning(result.stdout.trim() || undefined, opts.scope)
+      };
+    }
+    if (isAlreadyExistsError(result)) {
+      return { agent: AGENT3, status: "skipped", detail: "already configured — no change" };
+    }
+    return {
+      agent: AGENT3,
+      status: "failed",
+      detail: result.stderr.trim() || `exit code ${result.code}`
+    };
+  }
+  return fileAdd2(entry, opts.scope);
+}
+async function remove11(name2, opts) {
+  if (!isValidServiceName(name2)) {
+    return { agent: AGENT3, status: "failed", detail: `Invalid service name: ${name2}` };
+  }
+  if (isBinaryOnPath(BIN2)) {
+    if (!(await listConfigured()).has(name2)) {
+      return { agent: AGENT3, status: "skipped", detail: "Not configured" };
+    }
+    const result = runAgentCli(BIN2, ["mcp", "remove", name2]);
+    if (result.ok) {
+      return {
+        agent: AGENT3,
+        status: "removed",
+        detail: withScopeWarning(result.stdout.trim() || undefined, opts.scope)
+      };
+    }
+    return {
+      agent: AGENT3,
+      status: "failed",
+      detail: result.stderr.trim() || `exit code ${result.code}`
+    };
+  }
+  return fileRemove2(name2);
+}
+async function listConfigured() {
+  const path11 = configPath();
+  if (!path11 || !existsSync60(path11))
+    return { has: () => false };
+  try {
+    const content = await readFile45(path11, "utf-8");
+    return { has: (name2) => hasMcpServerSection(content, name2) };
+  } catch {
+    return { has: () => false };
+  }
+}
+async function isConfigured(name2) {
+  return (await listConfigured()).has(name2);
+}
+var codexWriter = {
+  agent: AGENT3,
+  add: add2,
+  remove: remove11,
+  listConfigured
+};
+
+// src/domains/mcp/writers/writer-registry.ts
+var writers = {
+  "claude-code": claudeWriter,
+  codex: codexWriter
+};
+function getWriter(agent) {
+  return writers[agent];
+}
+
+// src/domains/mcp/mcp-service-core.ts
+var defaultDeps2 = {
+  getRegistry: getRegistryWithSource,
+  detectAgents,
+  detectProjectAgents,
+  getWriter
+};
+function renderResults(results) {
+  for (const result of results) {
+    const line = `${result.agent}: ${result.status}${result.detail ? ` — ${result.detail}` : ""}`;
+    switch (result.status) {
+      case "added":
+      case "removed":
+        logger.success(line);
+        break;
+      case "skipped":
+        logger.warning(line);
+        break;
+      case "failed":
+        logger.error(line);
+        break;
+      default: {
+        const _exhaustive = result.status;
+      }
+    }
+  }
+}
+async function selectAgents2(verb, entryName, candidates, opts) {
+  if (opts.yes || isNonInteractive() || candidates.length <= 1) {
+    return candidates;
+  }
+  const preposition = verb === "add" ? "to" : "from";
+  const selected = await ae({
+    message: `Select agents to ${verb} "${entryName}" ${preposition}:`,
+    options: candidates.map((agent) => ({ value: agent, label: agent })),
+    initialValues: candidates,
+    required: false
+  });
+  if (lD(selected))
+    return null;
+  return selected;
+}
+async function resolveAgentTargets(verb, service, agentFilter, deps) {
+  const { registry, revalidated } = await deps.getRegistry();
+  const entry = resolveService(registry, service);
+  if (!entry) {
+    logger.error(`Unknown MCP service: ${service}`);
+    logger.info(`Known services: ${registry.services.map((s3) => s3.name).join(", ") || "(none)"}`);
+    return { ok: false, result: { results: [], exitCode: 1 }, revalidated };
+  }
+  if (agentFilter && agentFilter.length > 0) {
+    return { ok: true, entry, targets: agentFilter, prompt: false, revalidated };
+  }
+  const installed = deps.detectAgents();
+  const projectTargets = deps.detectProjectAgents().filter((agent) => installed.includes(agent));
+  if (projectTargets.length > 0) {
+    const action = verb === "add" ? "adding to" : "removing from";
+    logger.info(`Detected ${projectTargets.join(" + ")} project → ${action} ${projectTargets.join(", ")}.`);
+    return { ok: true, entry, targets: projectTargets, prompt: false, revalidated };
+  }
+  if (installed.length === 0) {
+    logger.warning("No coding agents detected (claude-code / codex).");
+    return { ok: false, result: { results: [], exitCode: 1 }, revalidated };
+  }
+  return { ok: true, entry, targets: installed, prompt: true, revalidated };
+}
+
+// src/domains/mcp/mcp-service.ts
+async function runMutation(verb, opts, deps) {
+  const resolved = await resolveAgentTargets(verb, opts.service, opts.agents, deps);
+  try {
+    if (!resolved.ok)
+      return resolved.result;
+    const { prompt } = resolved;
+    let { entry } = resolved;
+    let targets = resolved.targets;
+    if (verb === "add" && opts.extraArgs && opts.extraArgs.length > 0) {
+      if (entry.transport !== "stdio") {
+        logger.error(`Extra args after "--" only apply to stdio MCP services; "${entry.name}" is ${entry.transport} (remote).`);
+        return { results: [], exitCode: 1 };
+      }
+      entry = { ...entry, args: [...entry.args ?? [], ...opts.extraArgs] };
+    }
+    if (prompt) {
+      const chosen = await selectAgents2(verb, entry.name, targets, { yes: opts.yes });
+      if (chosen === null) {
+        logger.info("Cancelled.");
+        return { results: [], exitCode: 1 };
+      }
+      if (chosen.length === 0) {
+        logger.warning(`No agents selected — nothing to ${verb}.`);
+        return { results: [], exitCode: 1 };
+      }
+      targets = chosen;
+    }
+    const writerOpts = { scope: opts.scope };
+    const results = [];
+    for (const agent of targets) {
+      const writer = deps.getWriter(agent);
+      results.push(verb === "add" ? await writer.add(entry, writerOpts) : await writer.remove(entry.name, writerOpts));
+    }
+    renderResults(results);
+    const allFailed = results.length > 0 && results.every((r2) => r2.status === "failed");
+    return { results, exitCode: allFailed ? 1 : 0 };
+  } finally {
+    await resolved.revalidated;
+  }
+}
+async function runAdd(opts, deps = defaultDeps2) {
+  return runMutation("add", opts, deps);
+}
+async function runRemove(opts, deps = defaultDeps2) {
+  return runMutation("remove", opts, deps);
+}
+async function runList(deps = defaultDeps2) {
+  const { registry, source, revalidated } = await deps.getRegistry();
+  const projectAgents = deps.detectProjectAgents();
+  const detected = projectAgents.length > 0 ? projectAgents : deps.detectAgents();
+  const lookups = await Promise.all(detected.map(async (agent) => ({
+    agent,
+    lookup: await deps.getWriter(agent).listConfigured()
+  })));
+  const entries = registry.services.map((entry) => ({
+    entry,
+    perAgent: lookups.map(({ agent, lookup }) => ({
+      agent,
+      configured: lookup.has(entry.name)
+    }))
+  }));
+  return { entries, source, revalidated };
+}
+
+// src/commands/mcp/mutation-command.ts
+init_logger();
+
+// src/commands/mcp/agent-option.ts
+class InvalidAgentOptionError extends Error {
+  invalidValues;
+  constructor(invalidValues) {
+    super(`Invalid --agent value(s): ${invalidValues.join(", ")}. Accepted agents: ${ALL_MCP_AGENTS.join(", ")}.`);
+    this.invalidValues = invalidValues;
+    this.name = "InvalidAgentOptionError";
+  }
+}
+function normalizeAgentOption(agent) {
+  if (agent === undefined)
+    return;
+  const values = Array.isArray(agent) ? agent : [agent];
+  const invalid = values.filter((value) => !McpAgentSchema.safeParse(value).success);
+  if (invalid.length > 0) {
+    throw new InvalidAgentOptionError(invalid);
+  }
+  return values;
+}
+
+// src/commands/mcp/scope-option.ts
+class InvalidScopeOptionError extends Error {
+  invalidValue;
+  constructor(invalidValue) {
+    super(`Invalid --scope value: ${invalidValue}. Accepted scopes: ${ALL_MCP_SCOPES.join(", ")}.`);
+    this.invalidValue = invalidValue;
+    this.name = "InvalidScopeOptionError";
+  }
+}
+function normalizeScopeOption(scope) {
+  if (scope === undefined)
+    return DEFAULT_MCP_SCOPE;
+  const parsed = McpScopeSchema.safeParse(scope);
+  if (!parsed.success) {
+    throw new InvalidScopeOptionError(scope);
+  }
+  return parsed.data;
+}
+
+// src/commands/mcp/mutation-command.ts
+async function mutationCommand(verb, service, options2 = {}) {
+  if (!service) {
+    logger.error(`Usage: tkm mcp ${verb} <service> [--agent <name>...] [-s, --scope local|user|project] [--yes]${verb === "add" ? " [-- <extra args...>]" : ""}`);
+    process.exitCode = 1;
+    return;
+  }
+  const extraArgs = options2["--"] ?? [];
+  if (verb === "remove" && extraArgs.length > 0) {
+    logger.warning(`Extra args after "--" only apply to add — ignored for remove.`);
+  }
+  let agents;
+  try {
+    agents = normalizeAgentOption(options2.agent);
+  } catch (error) {
+    if (error instanceof InvalidAgentOptionError) {
+      logger.error(error.message);
+      process.exitCode = 1;
+      return;
+    }
+    throw error;
+  }
+  let scope;
+  try {
+    scope = normalizeScopeOption(options2.scope);
+  } catch (error) {
+    if (error instanceof InvalidScopeOptionError) {
+      logger.error(error.message);
+      process.exitCode = 1;
+      return;
+    }
+    throw error;
+  }
+  const run2 = verb === "add" ? runAdd : runRemove;
+  try {
+    const { exitCode } = await run2({
+      service,
+      agents,
+      scope,
+      yes: options2.yes,
+      extraArgs: verb === "add" ? extraArgs : undefined
+    });
+    process.exitCode = exitCode;
+  } catch (error) {
+    if (error instanceof RegistryUnavailableError) {
+      logger.error(error.message);
+      process.exitCode = 1;
+      return;
+    }
+    throw error;
+  }
+}
+
+// src/commands/mcp/add-command.ts
+async function addCommand(service, options2 = {}) {
+  await mutationCommand("add", service, options2);
+}
+// src/commands/mcp/list-command.ts
+init_logger();
+var import_picocolors25 = __toESM(require_picocolors(), 1);
+function statusCell(configured) {
+  return configured ? { value: "● configured", paint: import_picocolors25.default.green } : { value: "○ not set", paint: import_picocolors25.default.dim };
+}
+function renderTable(header, rows) {
+  const lastCol = header.length - 1;
+  const widths = header.map((h2, col) => Math.max(h2.length, ...rows.map((r2) => r2[col]?.value.length ?? 0)));
+  const padPlain = (text, col) => col === lastCol ? text : text.padEnd(widths[col]);
+  const headerLine = import_picocolors25.default.bold(header.map((h2, col) => padPlain(h2, col)).join("  ").trimEnd());
+  const rowLine = (cells) => cells.map((cell, col) => {
+    const padded = padPlain(cell.value, col);
+    return cell.paint ? cell.paint(padded) : padded;
+  }).join("  ").trimEnd();
+  return [headerLine, ...rows.map(rowLine)].join(`
+`);
+}
+async function listCommand(options2 = {}) {
+  let listed;
+  try {
+    listed = await runList();
+  } catch (error) {
+    if (error instanceof RegistryUnavailableError) {
+      logger.error(error.message);
+      process.exitCode = 1;
+      return;
+    }
+    throw error;
+  }
+  const { entries, source, revalidated } = listed;
+  if (options2.json) {
+    const services = entries.map(({ entry, perAgent }) => ({
+      name: entry.name,
+      description: entry.description,
+      transport: entry.transport,
+      configured: Object.fromEntries(perAgent.map((p2) => [p2.agent, p2.configured]))
+    }));
+    process.stdout.write(`${JSON.stringify({ source, services })}
+`);
+    await revalidated;
+    return;
+  }
+  if (entries.length === 0) {
+    logger.info("No MCP services in the registry.");
+    return;
+  }
+  const agents = entries[0].perAgent.map((p2) => p2.agent);
+  const header = ["NAME", "TRANSPORT", ...agents.map((a3) => a3.toUpperCase()), "DESCRIPTION"];
+  const rows = entries.map(({ entry, perAgent }) => [
+    { value: entry.name },
+    { value: entry.transport },
+    ...perAgent.map((p2) => statusCell(p2.configured)),
+    { value: entry.description }
+  ]);
+  logger.info(`MCP registry — ${entries.length} services (source: ${source})`);
+  if (agents.length === 0) {
+    logger.info("No coding agents detected (claude-code / codex).");
+  }
+  process.stdout.write(`${renderTable(header, rows)}
+`);
+  await revalidated;
+}
+// src/commands/mcp/mcp-command.ts
+init_logger();
+
+// src/commands/mcp/remove-command.ts
+async function removeCommand(service, options2 = {}) {
+  await mutationCommand("remove", service, options2);
+}
+
+// src/commands/mcp/mcp-command.ts
+function printUsage() {
+  logger.error("Usage: tkm mcp <add|list|remove> [service] [options] — see `tkm mcp --help`");
+}
+async function mcpCommand(action, service, options2 = {}) {
+  switch (action) {
+    case "add":
+      await addCommand(service, options2);
+      break;
+    case "list":
+      await listCommand(options2);
+      break;
+    case "remove":
+      await removeCommand(service, options2);
+      break;
+    case undefined:
+      printUsage();
+      process.exitCode = 1;
+      break;
+    default:
+      logger.error(`Unknown mcp action: ${action}. Available: add, list, remove`);
+      process.exitCode = 1;
+  }
+}
 // src/commands/plan/plan-command.ts
 init_output_manager();
-import { existsSync as existsSync62, statSync as statSync11 } from "node:fs";
-import { dirname as dirname41, join as join129, parse as parse4, resolve as resolve33 } from "node:path";
+import { existsSync as existsSync65, statSync as statSync11 } from "node:fs";
+import { dirname as dirname42, join as join132, parse as parse4, resolve as resolve33 } from "node:path";
 
 // src/commands/plan/plan-read-handlers.ts
-import { existsSync as existsSync61, statSync as statSync10 } from "node:fs";
-import { basename as basename21, dirname as dirname40, join as join128, relative as relative20, resolve as resolve31 } from "node:path";
+import { existsSync as existsSync64, statSync as statSync10 } from "node:fs";
+import { basename as basename21, dirname as dirname41, join as join131, relative as relative20, resolve as resolve31 } from "node:path";
 
 // src/domains/plan-parser/index.ts
-import { dirname as dirname39 } from "node:path";
+import { dirname as dirname40 } from "node:path";
 
 // src/domains/plan-parser/plan-table-parser.ts
 var import_gray_matter5 = __toESM(require_gray_matter(), 1);
 import { readFileSync as readFileSync23 } from "node:fs";
-import { dirname as dirname36, resolve as resolve30 } from "node:path";
+import { dirname as dirname37, resolve as resolve30 } from "node:path";
 function normalizeStatus(raw) {
   const s3 = raw.toLowerCase().trim();
   if (s3.includes("complete") || s3.includes("done") || s3.includes("✓") || s3.includes("✅")) {
@@ -84420,7 +85568,7 @@ function parseFormat4(content, planFilePath, options2) {
       const hasCheck = /[✅✓]/.test(line);
       current = { name: name2, status: hasCheck ? "completed" : "pending" };
     } else if (fileMatch && current) {
-      const planDir = dirname36(planFilePath);
+      const planDir = dirname37(planFilePath);
       current.file = resolve30(planDir, fileMatch[1].trim());
     } else if (statusMatch && current) {
       current.status = normalizeStatus(statusMatch[2]);
@@ -84525,30 +85673,30 @@ function parsePhasesFromBody(body, dir, options2) {
 }
 function parsePlanFile(planFilePath, options2) {
   const content = readFileSync23(planFilePath, "utf8");
-  const dir = dirname36(planFilePath);
+  const dir = dirname37(planFilePath);
   const { data: frontmatter, content: body } = import_gray_matter5.default(content);
   const phases = parsePhasesFromBody(body, dir, options2);
   return { frontmatter, phases };
 }
 // src/domains/plan-parser/plan-scanner.ts
-import { existsSync as existsSync58, readdirSync as readdirSync10 } from "node:fs";
-import { join as join126 } from "node:path";
+import { existsSync as existsSync61, readdirSync as readdirSync10 } from "node:fs";
+import { join as join129 } from "node:path";
 function scanPlanDir(dir) {
-  if (!existsSync58(dir))
+  if (!existsSync61(dir))
     return [];
   try {
-    return readdirSync10(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join126(dir, entry.name, "plan.md")).filter(existsSync58);
+    return readdirSync10(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join129(dir, entry.name, "plan.md")).filter(existsSync61);
   } catch {
     return [];
   }
 }
 // src/domains/plan-parser/plan-validator.ts
 var import_gray_matter6 = __toESM(require_gray_matter(), 1);
-import { existsSync as existsSync59, readFileSync as readFileSync24 } from "node:fs";
-import { basename as basename19, dirname as dirname37 } from "node:path";
+import { existsSync as existsSync62, readFileSync as readFileSync24 } from "node:fs";
+import { basename as basename19, dirname as dirname38 } from "node:path";
 function validatePlanFile(filePath, strict = false) {
   const content = readFileSync24(filePath, "utf8");
-  const dir = dirname37(filePath);
+  const dir = dirname38(filePath);
   const issues = [];
   const lines = content.split(`
 `);
@@ -84584,7 +85732,7 @@ function validatePlanFile(filePath, strict = false) {
     });
   }
   for (const phase of phases) {
-    if (phase.file && !existsSync59(phase.file)) {
+    if (phase.file && !existsSync62(phase.file)) {
       const fileBasename = basename19(phase.file);
       const refLine = lines.findIndex((l2) => l2.includes(fileBasename));
       issues.push({
@@ -84605,8 +85753,8 @@ function validatePlanFile(filePath, strict = false) {
 // src/domains/plan-parser/plan-writer.ts
 var import_gray_matter7 = __toESM(require_gray_matter(), 1);
 import { mkdirSync as mkdirSync9, readFileSync as readFileSync25, writeFileSync as writeFileSync12 } from "node:fs";
-import { existsSync as existsSync60 } from "node:fs";
-import { basename as basename20, dirname as dirname38, join as join127 } from "node:path";
+import { existsSync as existsSync63 } from "node:fs";
+import { basename as basename20, dirname as dirname39, join as join130 } from "node:path";
 function phaseNameToFilename(id, name2) {
   const numMatch = /^(\d+)([a-z]*)$/i.exec(id);
   const num4 = numMatch ? numMatch[1] : id;
@@ -84714,12 +85862,12 @@ function scaffoldPlan(options2) {
   mkdirSync9(dir, { recursive: true });
   const resolvedPhases = resolvePhaseIds(options2.phases);
   const optionsWithResolved = { ...options2, phases: resolvedPhases };
-  const planFile = join127(dir, "plan.md");
+  const planFile = join130(dir, "plan.md");
   writeFileSync12(planFile, generatePlanMd(optionsWithResolved), "utf8");
   const phaseFiles = [];
   for (const phase of resolvedPhases) {
     const filename = phaseNameToFilename(phase.id, phase.name);
-    const phaseFile = join127(dir, filename);
+    const phaseFile = join130(dir, filename);
     writeFileSync12(phaseFile, generatePhaseTemplate(phase), "utf8");
     phaseFiles.push(phaseFile);
   }
@@ -84785,9 +85933,9 @@ function updatePhaseStatus(planFile, phaseId, newStatus) {
   const updatedFrontmatter = { ...frontmatter, status: planStatus };
   const updatedContent = import_gray_matter7.default.stringify(updatedBody, updatedFrontmatter);
   writeFileSync12(planFile, updatedContent, "utf8");
-  const planDir = dirname38(planFile);
+  const planDir = dirname39(planFile);
   const phaseFilename = phaseNameFilenameFromTableRow(updatedBody, phaseId, planDir);
-  if (phaseFilename && existsSync60(phaseFilename)) {
+  if (phaseFilename && existsSync63(phaseFilename)) {
     updatePhaseFileFrontmatter(phaseFilename, newStatus);
   }
 }
@@ -84799,7 +85947,7 @@ function phaseNameFilenameFromTableRow(body, phaseId, planDir) {
       continue;
     const linkMatch = /\[([^\]]+)\]\(\.\/([^)]+)\)/.exec(row);
     if (linkMatch)
-      return join127(planDir, linkMatch[2]);
+      return join130(planDir, linkMatch[2]);
   }
   return null;
 }
@@ -84817,7 +85965,7 @@ function addPhase(planFile, name2, afterId) {
     throw new Error("Non-canonical plan.md — cannot add phase");
   }
   const { data: frontmatter, content: body } = import_gray_matter7.default(raw);
-  const planDir = dirname38(planFile);
+  const planDir = dirname39(planFile);
   const existingIds = [];
   for (const match of body.matchAll(/^\|\s*(\d+[a-z]?)\s*\|/gim)) {
     existingIds.push(match[1].toLowerCase());
@@ -84880,7 +86028,7 @@ function addPhase(planFile, name2, afterId) {
 `);
   }
   writeFileSync12(planFile, import_gray_matter7.default.stringify(updatedBody, frontmatter), "utf8");
-  const phaseFilePath = join127(planDir, filename);
+  const phaseFilePath = join130(planDir, filename);
   writeFileSync12(phaseFilePath, generatePhaseTemplate({ id: phaseId, name: name2 }), "utf8");
   return { phaseId, phaseFile: phaseFilePath };
 }
@@ -84892,7 +86040,7 @@ function buildPlanSummary(planFile) {
   const inProgress = phases.filter((p2) => p2.status === "in-progress").length;
   const pending = phases.filter((p2) => p2.status === "pending").length;
   return {
-    planDir: dirname39(planFile),
+    planDir: dirname40(planFile),
     planFile,
     title: typeof frontmatter.title === "string" ? frontmatter.title : undefined,
     description: typeof frontmatter.description === "string" ? frontmatter.description : undefined,
@@ -84908,7 +86056,7 @@ function buildPlanSummary(planFile) {
 // src/commands/plan/plan-read-handlers.ts
 init_logger();
 init_output_manager();
-var import_picocolors25 = __toESM(require_picocolors(), 1);
+var import_picocolors26 = __toESM(require_picocolors(), 1);
 async function handleParse(target, options2) {
   const planFile = resolvePlanFile(target);
   if (!planFile) {
@@ -84929,9 +86077,9 @@ async function handleParse(target, options2) {
     console.log(JSON.stringify({ file: relative20(process.cwd(), planFile), frontmatter, phases }, null, 2));
     return;
   }
-  const title = typeof frontmatter.title === "string" ? frontmatter.title : basename21(dirname40(planFile));
+  const title = typeof frontmatter.title === "string" ? frontmatter.title : basename21(dirname41(planFile));
   console.log();
-  console.log(import_picocolors25.default.bold(`  Plan: ${title}`));
+  console.log(import_picocolors26.default.bold(`  Plan: ${title}`));
   console.log(`  File: ${planFile}`);
   console.log(`  Phases found: ${phases.length}`);
   console.log();
@@ -84962,7 +86110,7 @@ async function handleValidate(target, options2) {
     return;
   }
   console.log();
-  console.log(import_picocolors25.default.bold(`  Validating: ${planFile}`));
+  console.log(import_picocolors26.default.bold(`  Validating: ${planFile}`));
   console.log();
   if (result.issues.length === 0) {
     console.log(`  [OK] No issues found — ${result.phases.length} phases detected`);
@@ -84976,7 +86124,7 @@ async function handleValidate(target, options2) {
     }
   }
   console.log();
-  const validStr = result.valid ? import_picocolors25.default.green("[OK] Valid") : import_picocolors25.default.red("[X] Invalid");
+  const validStr = result.valid ? import_picocolors26.default.green("[OK] Valid") : import_picocolors26.default.red("[X] Invalid");
   console.log(`  ${validStr} — ${result.issues.filter((i) => i.severity === "error").length} errors, ${result.issues.filter((i) => i.severity === "warning").length} warnings`);
   console.log();
   if (!result.valid)
@@ -84984,7 +86132,7 @@ async function handleValidate(target, options2) {
 }
 async function handleStatus(target, options2) {
   const t = target ? resolve31(target) : null;
-  const plansDir = t && existsSync61(t) && statSync10(t).isDirectory() && !existsSync61(join128(t, "plan.md")) ? t : null;
+  const plansDir = t && existsSync64(t) && statSync10(t).isDirectory() && !existsSync64(join131(t, "plan.md")) ? t : null;
   if (plansDir) {
     const planFiles = scanPlanDir(plansDir);
     if (planFiles.length === 0) {
@@ -85003,20 +86151,20 @@ async function handleStatus(target, options2) {
       return;
     }
     console.log();
-    console.log(import_picocolors25.default.bold(`  Plans in: ${plansDir}`));
+    console.log(import_picocolors26.default.bold(`  Plans in: ${plansDir}`));
     console.log();
     for (const pf of planFiles) {
       try {
         const s3 = buildPlanSummary(pf);
         const bar = progressBar(s3.completed, s3.totalPhases);
-        const title2 = s3.title ?? basename21(dirname40(pf));
-        console.log(`  ${import_picocolors25.default.bold(title2)}`);
+        const title2 = s3.title ?? basename21(dirname41(pf));
+        console.log(`  ${import_picocolors26.default.bold(title2)}`);
         console.log(`  ${bar}`);
         if (s3.inProgress > 0)
           console.log(`  [~] ${s3.inProgress} in progress`);
         console.log();
       } catch {
-        console.log(`  [X] Failed to read: ${basename21(dirname40(pf))}`);
+        console.log(`  [X] Failed to read: ${basename21(dirname41(pf))}`);
         console.log();
       }
     }
@@ -85040,9 +86188,9 @@ async function handleStatus(target, options2) {
     console.log(JSON.stringify(summary, null, 2));
     return;
   }
-  const title = summary.title ?? basename21(dirname40(planFile));
+  const title = summary.title ?? basename21(dirname41(planFile));
   console.log();
-  console.log(import_picocolors25.default.bold(`  ${title}`));
+  console.log(import_picocolors26.default.bold(`  ${title}`));
   if (summary.status)
     console.log(`  Status: ${summary.status}`);
   console.log();
@@ -85068,7 +86216,7 @@ async function handleKanban(target, _options) {
 // src/commands/plan/plan-write-handlers.ts
 import { basename as basename22, relative as relative21, resolve as resolve32 } from "node:path";
 init_output_manager();
-var import_picocolors26 = __toESM(require_picocolors(), 1);
+var import_picocolors27 = __toESM(require_picocolors(), 1);
 async function handleCreate(target, options2) {
   if (!options2.title) {
     output.error("[X] --title is required for create");
@@ -85115,7 +86263,7 @@ async function handleCreate(target, options2) {
     return;
   }
   console.log();
-  console.log(import_picocolors26.default.bold(`  [OK] Plan created: ${options2.title}`));
+  console.log(import_picocolors27.default.bold(`  [OK] Plan created: ${options2.title}`));
   console.log(`  Directory: ${resolve32(dir)}`);
   console.log(`  Phases: ${result.phaseFiles.length}`);
   for (const f4 of result.phaseFiles) {
@@ -85215,22 +86363,22 @@ async function handleAddPhase(target, options2) {
 // src/commands/plan/plan-command.ts
 function resolvePlanFile(target) {
   const t = target ? resolve33(target) : process.cwd();
-  if (existsSync62(t)) {
+  if (existsSync65(t)) {
     const stat14 = statSync11(t);
     if (stat14.isFile())
       return t;
-    const candidate = join129(t, "plan.md");
-    if (existsSync62(candidate))
+    const candidate = join132(t, "plan.md");
+    if (existsSync65(candidate))
       return candidate;
   }
   if (!target) {
     let dir = process.cwd();
     const root = parse4(dir).root;
     while (dir !== root) {
-      const candidate = join129(dir, "plan.md");
-      if (existsSync62(candidate))
+      const candidate = join132(dir, "plan.md");
+      if (existsSync65(candidate))
         return candidate;
-      dir = dirname41(dir);
+      dir = dirname42(dir);
     }
   }
   return null;
@@ -85278,7 +86426,7 @@ async function planCommand(action, target, options2) {
   let resolvedTarget = target;
   if (resolvedAction && !knownActions.has(resolvedAction)) {
     const looksLikePath = resolvedAction.includes("/") || resolvedAction.includes("\\") || resolvedAction.endsWith(".md") || resolvedAction === "." || resolvedAction === "..";
-    const existsOnDisk = !looksLikePath && existsSync62(resolve33(resolvedAction));
+    const existsOnDisk = !looksLikePath && existsSync65(resolve33(resolvedAction));
     if (looksLikePath || existsOnDisk) {
       resolvedTarget = resolvedAction;
       resolvedAction = undefined;
@@ -85322,22 +86470,22 @@ init_logger();
 init_logger();
 
 // src/commands/telemetry/shared.ts
-import { existsSync as existsSync63, readFileSync as readFileSync26, readdirSync as readdirSync11 } from "node:fs";
+import { existsSync as existsSync66, readFileSync as readFileSync26, readdirSync as readdirSync11 } from "node:fs";
 import { homedir as homedir29 } from "node:os";
-import { join as join130 } from "node:path";
+import { join as join133 } from "node:path";
 init_token_store();
 init_manifest_path_resolver();
 init_takumi_constants();
-var USER_CACHE_PATH = join130(homedir29(), ".claude", "sk-user.json");
-var EVENT_BUFFER_DIR = join130(homedir29(), ".claude", "sk-events");
-var RATE_STATE_PATH = join130(homedir29(), ".claude", "sk-rate-state.json");
-var TAKUMI_MANIFEST_PATH = join130(homedir29(), ".claude", MANIFEST_FILENAME);
-var LEGACY_METADATA_PATH = join130(homedir29(), ".claude", LEGACY_MANIFEST_FILENAME);
+var USER_CACHE_PATH = join133(homedir29(), ".claude", "sk-user.json");
+var EVENT_BUFFER_DIR = join133(homedir29(), ".claude", "sk-events");
+var RATE_STATE_PATH = join133(homedir29(), ".claude", "sk-rate-state.json");
+var TAKUMI_MANIFEST_PATH = join133(homedir29(), ".claude", MANIFEST_FILENAME);
+var LEGACY_METADATA_PATH = join133(homedir29(), ".claude", LEGACY_MANIFEST_FILENAME);
 var TELEMETRY_HOOK_FIELD = "hooks.telemetry";
 var TOKEN_PLACEHOLDER = "__INJECT_AT_RELEASE__";
 function readUserCache() {
   try {
-    if (!existsSync63(USER_CACHE_PATH))
+    if (!existsSync66(USER_CACHE_PATH))
       return null;
     const parsed = JSON.parse(readFileSync26(USER_CACHE_PATH, "utf8"));
     if (!parsed || typeof parsed !== "object")
@@ -85349,7 +86497,7 @@ function readUserCache() {
 }
 function countBufferFiles() {
   try {
-    if (!existsSync63(EVENT_BUFFER_DIR))
+    if (!existsSync66(EVENT_BUFFER_DIR))
       return 0;
     return readdirSync11(EVENT_BUFFER_DIR).filter((f4) => f4.endsWith(".jsonl")).length;
   } catch {
@@ -85361,7 +86509,7 @@ function readTelemetryConfig() {
   const envToken = process.env.TAKUMI_TELEMETRY_TOKEN;
   let metadata = null;
   try {
-    const resolved = findManifestPathSync(join130(homedir29(), ".claude"));
+    const resolved = findManifestPathSync(join133(homedir29(), ".claude"));
     if (resolved) {
       metadata = JSON.parse(readFileSync26(resolved.path, "utf8"));
     }
@@ -85387,8 +86535,8 @@ function collectRuntimeContext() {
     cacheSource: cache3?.source === "gh" || cache3?.source === "manual" ? cache3.source : null,
     bufferFileCount: countBufferFiles(),
     bufferDir: EVENT_BUFFER_DIR,
-    rateStateExists: existsSync63(RATE_STATE_PATH),
-    userCacheExists: existsSync63(USER_CACHE_PATH),
+    rateStateExists: existsSync66(RATE_STATE_PATH),
+    userCacheExists: existsSync66(USER_CACHE_PATH),
     endpoint,
     tokenConfigured: Boolean(token)
   };
@@ -85489,7 +86637,7 @@ init_manifest_writer();
 init_logger();
 init_safe_prompts();
 init_types2();
-var import_picocolors28 = __toESM(require_picocolors(), 1);
+var import_picocolors29 = __toESM(require_picocolors(), 1);
 
 // src/commands/uninstall/installation-detector.ts
 init_paths();
@@ -85539,7 +86687,7 @@ init_safe_prompts();
 init_safe_spinner();
 var import_fs_extra37 = __toESM(require_lib(), 1);
 import { readdirSync as readdirSync13, rmSync as rmSync9 } from "node:fs";
-import { join as join132, resolve as resolve34, sep as sep9 } from "node:path";
+import { join as join135, resolve as resolve34, sep as sep9 } from "node:path";
 
 // src/commands/uninstall/analysis-handler.ts
 init_metadata_migration();
@@ -85548,14 +86696,14 @@ init_ownership_checker();
 init_logger();
 init_safe_prompts();
 init_takumi_constants();
-var import_picocolors27 = __toESM(require_picocolors(), 1);
-import { existsSync as existsSync64, readdirSync as readdirSync12, rmSync as rmSync8 } from "node:fs";
-import { dirname as dirname42, join as join131 } from "node:path";
+var import_picocolors28 = __toESM(require_picocolors(), 1);
+import { existsSync as existsSync67, readdirSync as readdirSync12, rmSync as rmSync8 } from "node:fs";
+import { dirname as dirname43, join as join134 } from "node:path";
 function listPresentManifestNames(installPath) {
   const present = [];
-  if (existsSync64(getManifestPath(installPath)))
+  if (existsSync67(getManifestPath(installPath)))
     present.push(MANIFEST_FILENAME);
-  if (existsSync64(getLegacyManifestPath(installPath)))
+  if (existsSync67(getLegacyManifestPath(installPath)))
     present.push(LEGACY_MANIFEST_FILENAME);
   return present;
 }
@@ -85573,7 +86721,7 @@ function classifyFileByOwnership(ownership, forceOverwrite, deleteReason) {
 }
 async function cleanupEmptyDirectories3(filePath, installationRoot) {
   let cleaned = 0;
-  let currentDir = dirname42(filePath);
+  let currentDir = dirname43(filePath);
   while (currentDir !== installationRoot && currentDir.startsWith(installationRoot)) {
     try {
       const entries = readdirSync12(currentDir);
@@ -85581,7 +86729,7 @@ async function cleanupEmptyDirectories3(filePath, installationRoot) {
         rmSync8(currentDir, { recursive: true });
         cleaned++;
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = dirname42(currentDir);
+        currentDir = dirname43(currentDir);
       } else {
         break;
       }
@@ -85603,7 +86751,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
   if (uninstallManifest.isMultiKit && kit && metadata?.kits?.[kit]) {
     const kitFiles = metadata.kits[kit].files || [];
     for (const trackedFile of kitFiles) {
-      const filePath = join131(installation.path, trackedFile.path);
+      const filePath = join134(installation.path, trackedFile.path);
       if (uninstallManifest.filesToPreserve.includes(trackedFile.path)) {
         result.toPreserve.push({ path: trackedFile.path, reason: "shared with other kit" });
         continue;
@@ -85635,7 +86783,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
     return result;
   }
   for (const trackedFile of allTrackedFiles) {
-    const filePath = join131(installation.path, trackedFile.path);
+    const filePath = join134(installation.path, trackedFile.path);
     const ownershipResult = await OwnershipChecker.checkOwnership(filePath, metadata, installation.path);
     if (!ownershipResult.exists)
       continue;
@@ -85653,27 +86801,27 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
 }
 function displayDryRunPreview(analysis, installationType) {
   console.log("");
-  log.info(import_picocolors27.default.bold(`DRY RUN - Preview for ${installationType} installation:`));
+  log.info(import_picocolors28.default.bold(`DRY RUN - Preview for ${installationType} installation:`));
   console.log("");
   if (analysis.toDelete.length > 0) {
-    console.log(import_picocolors27.default.red(import_picocolors27.default.bold(`Files to DELETE (${analysis.toDelete.length}):`)));
+    console.log(import_picocolors28.default.red(import_picocolors28.default.bold(`Files to DELETE (${analysis.toDelete.length}):`)));
     const showDelete = analysis.toDelete.slice(0, 10);
     for (const item of showDelete) {
-      console.log(`  ${import_picocolors27.default.red("✖")} ${item.path}`);
+      console.log(`  ${import_picocolors28.default.red("✖")} ${item.path}`);
     }
     if (analysis.toDelete.length > 10) {
-      console.log(import_picocolors27.default.gray(`  ... and ${analysis.toDelete.length - 10} more`));
+      console.log(import_picocolors28.default.gray(`  ... and ${analysis.toDelete.length - 10} more`));
     }
     console.log("");
   }
   if (analysis.toPreserve.length > 0) {
-    console.log(import_picocolors27.default.green(import_picocolors27.default.bold(`Files to PRESERVE (${analysis.toPreserve.length}):`)));
+    console.log(import_picocolors28.default.green(import_picocolors28.default.bold(`Files to PRESERVE (${analysis.toPreserve.length}):`)));
     const showPreserve = analysis.toPreserve.slice(0, 10);
     for (const item of showPreserve) {
-      console.log(`  ${import_picocolors27.default.green("✓")} ${item.path} ${import_picocolors27.default.gray(`(${item.reason})`)}`);
+      console.log(`  ${import_picocolors28.default.green("✓")} ${item.path} ${import_picocolors28.default.gray(`(${item.reason})`)}`);
     }
     if (analysis.toPreserve.length > 10) {
-      console.log(import_picocolors27.default.gray(`  ... and ${analysis.toPreserve.length - 10} more`));
+      console.log(import_picocolors28.default.gray(`  ... and ${analysis.toPreserve.length - 10} more`));
     }
     console.log("");
   }
@@ -85734,7 +86882,7 @@ async function removeInstallations(installations, options2) {
       let removedCount = 0;
       let cleanedDirs = 0;
       for (const item of analysis.toDelete) {
-        const filePath = join132(installation.path, item.path);
+        const filePath = join135(installation.path, item.path);
         if (!await import_fs_extra37.pathExists(filePath))
           continue;
         if (!await isPathSafeToRemove(filePath, installation.path)) {
@@ -85795,15 +86943,15 @@ function displayInstallations(installations, scope) {
   const hasLegacy = installations.some((i) => !i.hasMetadata);
   const lines = installations.map((i) => {
     const typeLabel = i.type === "local" ? "Local " : "Global";
-    const legacyTag = !i.hasMetadata ? import_picocolors28.default.yellow(" [legacy]") : "";
+    const legacyTag = !i.hasMetadata ? import_picocolors29.default.yellow(" [legacy]") : "";
     const components = formatComponentSummary(i);
     return `  ${typeLabel}: ${i.path}${legacyTag}${components}`;
   });
   prompts.note(lines.join(`
 `), `Detected Takumi installations (${scopeLabel})`);
   if (hasLegacy) {
-    log.warn(import_picocolors28.default.yellow(`[!] Legacy installation(s) detected without metadata.json.
-`) + import_picocolors28.default.yellow("    These files cannot be selectively removed. Full directory cleanup will be performed."));
+    log.warn(import_picocolors29.default.yellow(`[!] Legacy installation(s) detected without metadata.json.
+`) + import_picocolors29.default.yellow("    These files cannot be selectively removed. Full directory cleanup will be performed."));
   }
   log.warn("[!] This will permanently delete Takumi files from the above paths.");
 }
@@ -85863,7 +87011,7 @@ async function uninstallCommand(options2) {
     }
     const isAtHome = isLocalSameAsGlobal();
     if (validOptions.local && !validOptions.global && isAtHome) {
-      log.warn(import_picocolors28.default.yellow("Cannot use --local at HOME directory (local path equals global path)."));
+      log.warn(import_picocolors29.default.yellow("Cannot use --local at HOME directory (local path equals global path)."));
       log.info("Use -g/--global or run from a project directory.");
       return;
     }
@@ -85875,7 +87023,7 @@ async function uninstallCommand(options2) {
     } else if (validOptions.global) {
       scope = "global";
     } else if (isAtHome) {
-      log.info(import_picocolors28.default.cyan("Running at HOME directory - targeting global installation"));
+      log.info(import_picocolors29.default.cyan("Running at HOME directory - targeting global installation"));
       scope = "global";
     } else {
       const promptedScope = await promptScope(allInstallations);
@@ -85897,10 +87045,10 @@ async function uninstallCommand(options2) {
     }
     displayInstallations(installations, scope);
     if (validOptions.kit) {
-      log.info(import_picocolors28.default.cyan(`Kit-scoped uninstall: ${validOptions.kit} kit only`));
+      log.info(import_picocolors29.default.cyan(`Kit-scoped uninstall: ${validOptions.kit} kit only`));
     }
     if (validOptions.dryRun) {
-      log.info(import_picocolors28.default.yellow("DRY RUN MODE - No files will be deleted"));
+      log.info(import_picocolors29.default.yellow("DRY RUN MODE - No files will be deleted"));
       await removeInstallations(installations, {
         dryRun: true,
         forceOverwrite: validOptions.forceOverwrite,
@@ -85910,8 +87058,8 @@ async function uninstallCommand(options2) {
       return;
     }
     if (validOptions.forceOverwrite) {
-      log.warn(`${import_picocolors28.default.yellow(import_picocolors28.default.bold("FORCE MODE ENABLED"))}
-${import_picocolors28.default.yellow("User modifications will be permanently deleted!")}`);
+      log.warn(`${import_picocolors29.default.yellow(import_picocolors29.default.bold("FORCE MODE ENABLED"))}
+${import_picocolors29.default.yellow("User modifications will be permanently deleted!")}`);
     }
     if (!validOptions.yes) {
       const kitLabel = validOptions.kit ? ` (${validOptions.kit} kit only)` : "";
@@ -86364,7 +87512,7 @@ init_auth_client();
 init_github_client();
 init_logger();
 init_types2();
-var import_picocolors29 = __toESM(require_picocolors(), 1);
+var import_picocolors30 = __toESM(require_picocolors(), 1);
 function formatRelativeTime(dateString) {
   if (!dateString)
     return "Unknown";
@@ -86386,21 +87534,21 @@ function formatRelativeTime(dateString) {
 }
 function displayKitReleases(kitName, releases) {
   console.log(`
-${import_picocolors29.default.bold(import_picocolors29.default.cyan(kitName))} - Available Versions:
+${import_picocolors30.default.bold(import_picocolors30.default.cyan(kitName))} - Available Versions:
 `);
   if (releases.length === 0) {
-    console.log(import_picocolors29.default.dim("  No releases found"));
+    console.log(import_picocolors30.default.dim("  No releases found"));
     return;
   }
   for (const release of releases) {
-    const version3 = import_picocolors29.default.green(release.tag);
+    const version3 = import_picocolors30.default.green(release.tag);
     const publishedAt = formatRelativeTime(release.publishedAt);
-    const badge = release.prerelease ? ` ${import_picocolors29.default.yellow("[prerelease]")}` : "";
+    const badge = release.prerelease ? ` ${import_picocolors30.default.yellow("[prerelease]")}` : "";
     const versionPart = version3.padEnd(20);
-    const timePart = import_picocolors29.default.dim(publishedAt.padEnd(20));
+    const timePart = import_picocolors30.default.dim(publishedAt.padEnd(20));
     console.log(`  ${versionPart}  ${timePart}${badge}`);
   }
-  console.log(import_picocolors29.default.dim(`
+  console.log(import_picocolors30.default.dim(`
 Showing ${releases.length} ${releases.length === 1 ? "release" : "releases"}`));
 }
 async function fetchReleasesForKit(kitType, options2) {
@@ -86445,8 +87593,8 @@ async function versionCommand(options2) {
     for (const result of results) {
       if (result.error) {
         console.log(`
-${import_picocolors29.default.bold(import_picocolors29.default.cyan(result.kitConfig.name))} - ${import_picocolors29.default.red("Error")}`);
-        console.log(import_picocolors29.default.dim(`  ${result.error}`));
+${import_picocolors30.default.bold(import_picocolors30.default.cyan(result.kitConfig.name))} - ${import_picocolors30.default.red("Error")}`);
+        console.log(import_picocolors30.default.dim(`  ${result.error}`));
       } else {
         displayKitReleases(result.kitConfig.name, result.releases);
       }
@@ -86592,6 +87740,9 @@ function registerCommands(cli) {
         process.exitCode = 1;
     }
   });
+  cli.command("mcp [action] [service]", "Manage internal MCP connectors for coding agents (add|list|remove)").option("-a, --agent <agents...>", "Target agent(s): claude-code, codex").option("-s, --scope <scope>", "Config scope: local | user | project (default: user)").option("-y, --yes", "Non-interactive mode: skip confirmation prompts").option("--json", "Machine-readable JSON output (list only; ignored by add/remove)").action(async (action, service, options2 = {}) => {
+    await mcpCommand(action, service, options2);
+  });
 }
 
 // src/cli/version-display.ts
@@ -86603,7 +87754,7 @@ init_manifest_path_resolver();
 init_logger();
 init_types2();
 import { readFileSync as readFileSync27 } from "node:fs";
-import { join as join133 } from "node:path";
+import { join as join136 } from "node:path";
 var PROVIDER_LOCAL_SUBDIRS = {
   "claude-code": ".claude",
   codex: ".codex"
@@ -86658,7 +87809,7 @@ async function displayVersion() {
     const localSubdir = PROVIDER_LOCAL_SUBDIRS[provider];
     if (!localSubdir)
       continue;
-    const localRoot = join133(process.cwd(), localSubdir);
+    const localRoot = join136(process.cwd(), localSubdir);
     if (localRoot === inst.globalRoot())
       continue;
     const resolved = findManifestPathSync(localRoot);
@@ -86739,7 +87890,7 @@ function getPackageVersion3() {
 
 // src/shared/logger.ts
 init_output_manager();
-var import_picocolors30 = __toESM(require_picocolors(), 1);
+var import_picocolors31 = __toESM(require_picocolors(), 1);
 import { createWriteStream as createWriteStream4 } from "node:fs";
 
 class Logger2 {
@@ -86748,23 +87899,23 @@ class Logger2 {
   exitHandlerRegistered = false;
   info(message) {
     const symbols = output.getSymbols();
-    console.log(import_picocolors30.default.blue(symbols.info), message);
+    console.log(import_picocolors31.default.blue(symbols.info), message);
   }
   success(message) {
     const symbols = output.getSymbols();
-    console.log(import_picocolors30.default.green(symbols.success), message);
+    console.log(import_picocolors31.default.green(symbols.success), message);
   }
   warning(message) {
     const symbols = output.getSymbols();
-    console.log(import_picocolors30.default.yellow(symbols.warning), message);
+    console.log(import_picocolors31.default.yellow(symbols.warning), message);
   }
   error(message) {
     const symbols = output.getSymbols();
-    console.error(import_picocolors30.default.red(symbols.error), message);
+    console.error(import_picocolors31.default.red(symbols.error), message);
   }
   debug(message) {
     if (process.env.DEBUG) {
-      console.log(import_picocolors30.default.gray("[DEBUG]"), message);
+      console.log(import_picocolors31.default.gray("[DEBUG]"), message);
     }
   }
   verbose(message, context) {
@@ -86773,7 +87924,7 @@ class Logger2 {
     const timestamp = this.getTimestamp();
     const sanitizedMessage = this.sanitize(message);
     const formattedContext = context ? this.formatContext(context) : "";
-    const logLine = `${timestamp} ${import_picocolors30.default.gray("[VERBOSE]")} ${sanitizedMessage}${formattedContext}`;
+    const logLine = `${timestamp} ${import_picocolors31.default.gray("[VERBOSE]")} ${sanitizedMessage}${formattedContext}`;
     console.error(logLine);
     if (this.logFileStream) {
       const plainLogLine = `${timestamp} [VERBOSE] ${sanitizedMessage}${formattedContext}`;
@@ -86876,7 +88027,7 @@ var logger3 = new Logger2;
 
 // src/shared/output-manager.ts
 init_terminal_utils();
-var import_picocolors31 = __toESM(require_picocolors(), 1);
+var import_picocolors32 = __toESM(require_picocolors(), 1);
 var SYMBOLS2 = {
   unicode: {
     prompt: "◇",
@@ -86957,7 +88108,7 @@ class OutputManager2 {
     if (this.config.quiet)
       return;
     const symbol = this.getSymbols().success;
-    console.log(import_picocolors31.default.green(`${symbol} ${message}`));
+    console.log(import_picocolors32.default.green(`${symbol} ${message}`));
   }
   error(message, data) {
     if (this.config.json) {
@@ -86965,7 +88116,7 @@ class OutputManager2 {
       return;
     }
     const symbol = this.getSymbols().error;
-    console.error(import_picocolors31.default.red(`${symbol} ${message}`));
+    console.error(import_picocolors32.default.red(`${symbol} ${message}`));
   }
   warning(message, data) {
     if (this.config.json) {
@@ -86975,7 +88126,7 @@ class OutputManager2 {
     if (this.config.quiet)
       return;
     const symbol = this.getSymbols().warning;
-    console.log(import_picocolors31.default.yellow(`${symbol} ${message}`));
+    console.log(import_picocolors32.default.yellow(`${symbol} ${message}`));
   }
   info(message, data) {
     if (this.config.json) {
@@ -86985,7 +88136,7 @@ class OutputManager2 {
     if (this.config.quiet)
       return;
     const symbol = this.getSymbols().info;
-    console.log(import_picocolors31.default.blue(`${symbol} ${message}`));
+    console.log(import_picocolors32.default.blue(`${symbol} ${message}`));
   }
   verbose(message, data) {
     if (!this.config.verbose)
@@ -86994,7 +88145,7 @@ class OutputManager2 {
       this.addJsonEntry({ type: "info", message, data });
       return;
     }
-    console.log(import_picocolors31.default.dim(`  ${message}`));
+    console.log(import_picocolors32.default.dim(`  ${message}`));
   }
   indent(message) {
     if (this.config.json)
@@ -87019,7 +88170,7 @@ class OutputManager2 {
       return;
     const symbols = this.getSymbols();
     console.log();
-    console.log(import_picocolors31.default.bold(import_picocolors31.default.cyan(`${symbols.line} ${title}`)));
+    console.log(import_picocolors32.default.bold(import_picocolors32.default.cyan(`${symbols.line} ${title}`)));
   }
   addJsonEntry(entry) {
     this.jsonBuffer.push({