@hasna/todos 0.11.36 → 0.11.38

package/dist/cli/index.js

@@ -4063,6 +4063,30 @@ var init_projects = __esm(() => {
   init_machines();
 });
 
+// src/lib/package-version.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+import { fileURLToPath } from "url";
+function getPackageVersion(fromUrl = import.meta.url) {
+  try {
+    let dir = dirname2(fileURLToPath(fromUrl));
+    for (let i = 0;i < 5; i++) {
+      const pkgPath = join2(dir, "package.json");
+      if (existsSync2(pkgPath)) {
+        return JSON.parse(readFileSync(pkgPath, "utf-8")).version || "0.0.0";
+      }
+      const parent = dirname2(dir);
+      if (parent === dir)
+        break;
+      dir = parent;
+    }
+  } catch {
+    return "0.0.0";
+  }
+  return "0.0.0";
+}
+var init_package_version = () => {};
+
 // src/cli/helpers.ts
 var exports_helpers = {};
 __export(exports_helpers, {
@@ -4082,17 +4106,7 @@ __export(exports_helpers, {
 });
 import chalk from "chalk";
 import { execSync } from "child_process";
-import { readFileSync } from "fs";
-import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
-import { fileURLToPath } from "url";
-function getPackageVersion() {
-  try {
-    const pkgPath = join2(dirname2(fileURLToPath(import.meta.url)), "..", "..", "package.json");
-    return JSON.parse(readFileSync(pkgPath, "utf-8")).version || "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
+import { resolve as resolve2 } from "path";
 function handleError(e) {
   let jsonMode = false;
   try {
@@ -4189,6 +4203,7 @@ var programForOptions = null, statusColors, priorityColors;
 var init_helpers = __esm(() => {
   init_database();
   init_projects();
+  init_package_version();
   statusColors = {
     pending: chalk.yellow,
     in_progress: chalk.blue,
@@ -4205,14 +4220,14 @@ var init_helpers = __esm(() => {
 });
 
 // src/lib/sync-utils.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync, statSync, writeFileSync } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync, statSync, writeFileSync } from "fs";
 import { join as join3 } from "path";
 function ensureDir2(dir) {
-  if (!existsSync2(dir))
+  if (!existsSync3(dir))
     mkdirSync2(dir, { recursive: true });
 }
 function listJsonFiles(dir) {
-  if (!existsSync2(dir))
+  if (!existsSync3(dir))
     return [];
   return readdirSync(dir).filter((f) => f.endsWith(".json"));
 }
@@ -4229,7 +4244,7 @@ function writeJsonFile(path, data) {
 }
 function readHighWaterMark(dir) {
   const path = join3(dir, ".highwatermark");
-  if (!existsSync2(path))
+  if (!existsSync3(path))
     return 1;
   const val = parseInt(readFileSync2(path, "utf-8").trim(), 10);
   return isNaN(val) ? 1 : val;
@@ -4272,7 +4287,7 @@ __export(exports_config, {
   getAgentTaskListId: () => getAgentTaskListId,
   getAgentPoolForProject: () => getAgentPoolForProject
 });
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { join as join4 } from "path";
 function getTodosGlobalDir() {
   const home = process.env["HOME"] || HOME;
@@ -4280,7 +4295,7 @@ function getTodosGlobalDir() {
   const legacyDir = join4(home, ".todos");
   const newConfig = join4(newDir, "config.json");
   const legacyConfig = join4(legacyDir, "config.json");
-  if (!existsSync3(newConfig) && existsSync3(legacyConfig))
+  if (!existsSync4(newConfig) && existsSync4(legacyConfig))
     return legacyDir;
   return newDir;
 }
@@ -4296,7 +4311,7 @@ function normalizeAgent(agent) {
 function loadConfig() {
   if (cached)
     return cached;
-  if (!existsSync3(getConfigPath())) {
+  if (!existsSync4(getConfigPath())) {
     cached = {};
     return cached;
   }
@@ -8275,6 +8290,18 @@ var init_orgs = __esm(() => {
 
 // src/server/routes.ts
 import { join as join8, resolve as resolve5, sep } from "path";
+function parseFieldsParam(url) {
+  const fieldsParam = url.searchParams.get("fields");
+  return fieldsParam ? fieldsParam.split(",").map((f) => f.trim()).filter(Boolean) : undefined;
+}
+function parseBoundedLimit(value, fallback, max) {
+  if (!value)
+    return fallback;
+  const parsed = parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0)
+    return fallback;
+  return Math.min(parsed, max);
+}
 function handleSseEvents(_req, url, ctx) {
   const agentId = url.searchParams.get("agent_id") || undefined;
   const projectId = url.searchParams.get("project_id") || undefined;
@@ -8387,8 +8414,7 @@ async function handleListTasks(_req, url, _ctx, json2, taskToSummary2) {
   const agentId = url.searchParams.get("agent_id") || undefined;
   const limitParam = url.searchParams.get("limit");
   const offsetParam = url.searchParams.get("offset");
-  const fieldsParam = url.searchParams.get("fields");
-  const fields = fieldsParam ? fieldsParam.split(",").map((f) => f.trim()).filter(Boolean) : undefined;
+  const fields = parseFieldsParam(url);
   const tasks = listTasks({
     status,
     project_id: projectId,
@@ -8489,8 +8515,9 @@ function handleTasksNext(_req, url, _ctx, json2, taskToSummary2) {
   try {
     const projectId = url.searchParams.get("project_id") || undefined;
     const agentId = url.searchParams.get("agent_id") || undefined;
+    const fields = parseFieldsParam(url);
     const task = getNextTask(agentId, projectId ? { project_id: projectId } : undefined);
-    return json2({ task: task ? taskToSummary2(task) : null });
+    return json2({ task: task ? taskToSummary2(task, fields) : null });
   } catch (e) {
     return json2({ error: e instanceof Error ? e.message : "Failed" }, 500);
   }
@@ -8508,8 +8535,9 @@ function handleTasksStale(_req, url, _ctx, json2, taskToSummary2) {
   try {
     const projectId = url.searchParams.get("project_id") || undefined;
     const minutes = parseInt(url.searchParams.get("minutes") || "30", 10);
+    const fields = parseFieldsParam(url);
     const tasks = getStaleTasks(minutes, projectId ? { project_id: projectId } : undefined);
-    return json2({ tasks: tasks.map((t) => taskToSummary2(t)), count: tasks.length });
+    return json2({ tasks: tasks.map((t) => taskToSummary2(t, fields)), count: tasks.length });
   } catch (e) {
     return json2({ error: e instanceof Error ? e.message : "Failed" }, 500);
   }
@@ -8520,8 +8548,9 @@ function handleTasksChanged(_req, url, _ctx, json2, taskToSummary2) {
     if (!since)
       return json2({ error: "since parameter required (ISO date string)" }, 400);
     const projectId = url.searchParams.get("project_id") || undefined;
+    const fields = parseFieldsParam(url);
     const tasks = getTasksChangedSince(since, projectId ? { project_id: projectId } : undefined);
-    return json2({ tasks: tasks.map((t) => taskToSummary2(t)), count: tasks.length, since });
+    return json2({ tasks: tasks.map((t) => taskToSummary2(t, fields)), count: tasks.length, since });
   } catch (e) {
     return json2({ error: e instanceof Error ? e.message : "Failed" }, 500);
   }
@@ -8530,11 +8559,12 @@ function handleTasksContext(_req, url, _ctx, json2, taskToSummary2) {
   const agentId = url.searchParams.get("agent_id") || undefined;
   const projectId = url.searchParams.get("project_id") || undefined;
   const format = url.searchParams.get("format") || "text";
+  const fields = parseFieldsParam(url);
   const filters = projectId ? { project_id: projectId } : undefined;
   const status = getStatus(filters, agentId);
   const next = getNextTask(agentId, filters);
   if (format === "json") {
-    return json2({ status, next_task: next ? taskToSummary2(next) : null });
+    return json2({ status, next_task: next ? taskToSummary2(next, fields) : null });
   }
   const lines = [];
   lines.push(`Tasks: ${status.pending} pending | ${status.in_progress} active | ${status.completed} done`);
@@ -8559,7 +8589,7 @@ function handleTaskAttachments(id, _ctx, json2) {
   const attachmentIds = evidence.attachments || [];
   return json2({ task_id: id, short_id: task.short_id, attachment_ids: attachmentIds, count: attachmentIds.length, files_changed: evidence.files_changed, commit_hash: evidence.commit_hash, notes: evidence.notes });
 }
-async function handleTaskProgress(id, req, method, _ctx, json2) {
+async function handleTaskProgress(id, req, method, _ctx, json2, url) {
   const task = getTask(id);
   if (!task)
     return json2({ error: "Task not found" }, 404);
@@ -8567,7 +8597,21 @@ async function handleTaskProgress(id, req, method, _ctx, json2) {
     const all = listComments(id);
     const progress = all.filter((c) => c.type === "progress");
     const latest = progress[progress.length - 1] || null;
-    return json2({ task_id: id, progress_entries: progress, latest, count: progress.length });
+    const format = url?.searchParams.get("format") || "compact";
+    const limit = parseBoundedLimit(url?.searchParams.get("limit") || null, 20, 200);
+    const progressEntries = format === "full" ? progress : progress.slice(-limit);
+    return json2({
+      task_id: id,
+      progress_entries: progressEntries,
+      latest,
+      count: progress.length,
+      summary: {
+        total: progress.length,
+        returned: progressEntries.length,
+        omitted: Math.max(0, progress.length - progressEntries.length),
+        format
+      }
+    });
   }
   if (method === "POST") {
     try {
@@ -8582,11 +8626,11 @@ async function handleTaskProgress(id, req, method, _ctx, json2) {
   }
   return null;
 }
-function handleGetTask(id, _ctx, json2, taskToSummary2) {
+function handleGetTask(id, _ctx, json2, taskToSummary2, url) {
   const task = getTask(id);
   if (!task)
     return json2({ error: "Task not found" }, 404);
-  return json2(taskToSummary2(task));
+  return json2(taskToSummary2(task, url ? parseFieldsParam(url) : undefined));
 }
 async function handlePatchTask(id, req, _ctx, json2, taskToSummary2) {
   try {
@@ -8849,8 +8893,11 @@ function handleActivity(_req, url, _ctx, json2) {
   const limit = parseInt(url.searchParams.get("limit") || "50", 10);
   return json2(getRecentActivity(limit));
 }
-function handleTaskHistory(id, _ctx, json2) {
-  return json2(getTaskHistory(id));
+function handleTaskHistory(id, _ctx, json2, url) {
+  const history = getTaskHistory(id);
+  const format = url?.searchParams.get("format") || "compact";
+  const limit = parseBoundedLimit(url?.searchParams.get("limit") || null, 20, 500);
+  return json2(format === "full" ? history : history.slice(0, limit));
 }
 function handleListWebhooks(_ctx, json2) {
   return json2(listWebhooks());
@@ -8990,7 +9037,7 @@ __export(exports_serve, {
   SECURITY_HEADERS: () => SECURITY_HEADERS,
   MIME_TYPES: () => MIME_TYPES
 });
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { join as join9, dirname as dirname3, extname } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveDashboardDir() {
@@ -9007,7 +9054,7 @@ function resolveDashboardDir() {
   }
   candidates.push(join9(process.cwd(), "dashboard", "dist"));
   for (const candidate of candidates) {
-    if (existsSync6(candidate))
+    if (existsSync7(candidate))
       return candidate;
   }
   return join9(process.cwd(), "dashboard", "dist");
@@ -9060,7 +9107,7 @@ function json(data, status = 200, headers) {
   });
 }
 function serveStaticFile(filePath) {
-  if (!existsSync6(filePath))
+  if (!existsSync7(filePath))
     return null;
   const ext = extname(filePath);
   const contentType = MIME_TYPES[ext] || "application/octet-stream";
@@ -9139,7 +9186,7 @@ data: ${data}
       filteredSseClients.delete(client);
   }
   const dashboardDir = resolveDashboardDir();
-  const dashboardExists = existsSync6(dashboardDir);
+  const dashboardExists = existsSync7(dashboardDir);
   if (!dashboardExists) {
     console.error(`
 Dashboard not found at: ${dashboardDir}`);
@@ -9245,7 +9292,7 @@ Dashboard not found at: ${dashboardDir}`);
       }
       const progressMatch = path.match(/^\/api\/tasks\/([^/]+)\/progress$/);
       if (progressMatch) {
-        const res = await handleTaskProgress(progressMatch[1], req, method, ctx, json);
+        const res = await handleTaskProgress(progressMatch[1], req, method, ctx, json, url);
         if (res !== null)
           return res;
       }
@@ -9253,7 +9300,7 @@ Dashboard not found at: ${dashboardDir}`);
       if (taskMatch) {
         const id = taskMatch[1];
         if (method === "GET") {
-          return handleGetTask(id, ctx, jsonWithCors, taskToSummary);
+          return handleGetTask(id, ctx, jsonWithCors, taskToSummary, url);
         }
         if (method === "PATCH") {
           return handlePatchTask(id, req, ctx, jsonWithCors, taskToSummary);
@@ -9344,7 +9391,7 @@ Dashboard not found at: ${dashboardDir}`);
       }
       const historyMatch = path.match(/^\/api\/tasks\/([^/]+)\/history$/);
       if (historyMatch && method === "GET") {
-        return handleTaskHistory(historyMatch[1], ctx, json);
+        return handleTaskHistory(historyMatch[1], ctx, json, url);
       }
       if (path === "/api/webhooks" && method === "GET") {
         return handleListWebhooks(ctx, json);
@@ -11082,7 +11129,7 @@ __export(exports_dist, {
 import { createRequire } from "module";
 import { Database as Database2 } from "bun:sqlite";
 import {
-  existsSync as existsSync8,
+  existsSync as existsSync9,
   mkdirSync as mkdirSync4,
   readdirSync as readdirSync3,
   copyFileSync
@@ -11996,9 +12043,9 @@ function getDbPath2(serviceName) {
 function migrateDotfile(serviceName) {
   const legacyDir = join11(homedir(), `.${serviceName}`);
   const newDir = join11(HASNA_DIR, serviceName);
-  if (!existsSync8(legacyDir))
+  if (!existsSync9(legacyDir))
     return [];
-  if (existsSync8(newDir))
+  if (existsSync9(newDir))
     return [];
   mkdirSync4(newDir, { recursive: true });
   const migrated = [];
@@ -12020,7 +12067,7 @@ function copyDirRecursive(src, dest, root, migrated) {
   }
 }
 function hasLegacyDotfile(serviceName) {
-  return existsSync8(join11(homedir(), `.${serviceName}`));
+  return existsSync9(join11(homedir(), `.${serviceName}`));
 }
 function getHasnaDir() {
   mkdirSync4(HASNA_DIR, { recursive: true });
@@ -26864,6 +26911,384 @@ var init_dispatch2 = __esm(() => {
   init_database();
 });
 
+// src/mcp/token-utils.ts
+function splitTokens(value) {
+  return (value || "").split(",").map((item) => item.trim().toLowerCase()).filter(Boolean);
+}
+function addGroupTools(toolNames, groupName) {
+  const tools = MCP_TOOL_GROUPS[groupName];
+  if (!tools)
+    return false;
+  for (const tool of tools)
+    toolNames.add(tool);
+  return true;
+}
+function shouldRegisterToolForProfile(name, profileValue = process.env["TODOS_PROFILE"], groupValue = process.env["TODOS_TOOL_GROUPS"]) {
+  const profileTokens = splitTokens(profileValue || "minimal");
+  const groupTokens = splitTokens(groupValue);
+  if (profileTokens.includes("full") || profileTokens.includes("all"))
+    return true;
+  const tools = new Set;
+  let matchedProfile = false;
+  for (const token of profileTokens) {
+    const profileGroups = MCP_PROFILE_GROUPS[token];
+    if (profileGroups) {
+      matchedProfile = true;
+      for (const group of profileGroups)
+        addGroupTools(tools, group);
+      continue;
+    }
+    if (addGroupTools(tools, token)) {
+      matchedProfile = true;
+      continue;
+    }
+    if (token.startsWith("tool:")) {
+      matchedProfile = true;
+      tools.add(token.slice("tool:".length));
+    }
+  }
+  if (!matchedProfile) {
+    addGroupTools(tools, "core");
+  }
+  for (const token of groupTokens) {
+    if (token === "full" || token === "all")
+      return true;
+    if (!addGroupTools(tools, token) && token.startsWith("tool:")) {
+      tools.add(token.slice("tool:".length));
+    }
+  }
+  return tools.has(name);
+}
+function truncateText(value, maxChars = 240) {
+  if (!value)
+    return null;
+  if (maxChars <= 0)
+    return "";
+  if (value.length <= maxChars)
+    return value;
+  return `${value.slice(0, Math.max(0, maxChars - 3))}...`;
+}
+function compactTask(task, maxDescriptionChars = 180) {
+  const summary = {
+    id: task.id,
+    short_id: task.short_id || task.id.slice(0, 8),
+    title: task.title,
+    status: task.status,
+    priority: task.priority,
+    assigned_to: task.assigned_to,
+    project_id: task.project_id,
+    due_at: task.due_at,
+    updated_at: task.updated_at
+  };
+  if (task.tags?.length)
+    summary["tags"] = task.tags.slice(0, 8);
+  const description = truncateText(task.description, maxDescriptionChars);
+  if (description)
+    summary["description"] = description;
+  return summary;
+}
+function compactStatus(status) {
+  const compact = {};
+  for (const key of [
+    "total",
+    "pending",
+    "in_progress",
+    "completed",
+    "failed",
+    "cancelled",
+    "stale_count",
+    "overdue_recurring",
+    "blocked_count"
+  ]) {
+    if (status[key] !== undefined)
+      compact[key] = status[key];
+  }
+  const activeWork = status["active_work"];
+  if (Array.isArray(activeWork)) {
+    compact["active_work"] = activeWork.slice(0, 5).map((task) => {
+      if (!task || typeof task !== "object")
+        return task;
+      const record = task;
+      return {
+        id: record["id"],
+        short_id: record["short_id"],
+        title: record["title"],
+        priority: record["priority"],
+        assigned_to: record["assigned_to"],
+        updated_at: record["updated_at"]
+      };
+    });
+    if (activeWork.length > 5)
+      compact["active_work_omitted"] = activeWork.length - 5;
+  }
+  const blocked = status["blocked"];
+  if (Array.isArray(blocked)) {
+    compact["blocked"] = blocked.slice(0, 5);
+    if (blocked.length > 5)
+      compact["blocked_omitted"] = blocked.length - 5;
+  }
+  return compact;
+}
+function compactHandoff(handoff) {
+  if (!handoff || typeof handoff !== "object")
+    return handoff ?? null;
+  const record = handoff;
+  return {
+    id: record["id"],
+    from_agent: record["from_agent"],
+    to_agent: record["to_agent"],
+    summary: truncateText(typeof record["summary"] === "string" ? record["summary"] : null, 240),
+    created_at: record["created_at"]
+  };
+}
+function compactJson(value) {
+  return JSON.stringify(value);
+}
+function tokenTelemetryEnabled() {
+  return /^(1|true|yes|on)$/i.test(process.env["TODOS_MCP_TOKEN_TELEMETRY"] || "");
+}
+function withMcpTokenTelemetry(result, toolName, enabled = tokenTelemetryEnabled()) {
+  if (!enabled || !result || typeof result !== "object")
+    return result;
+  const response = result;
+  if (!Array.isArray(response.content))
+    return result;
+  const content = response.content;
+  const textChars = content.reduce((sum, item) => item["type"] === "text" && typeof item["text"] === "string" ? sum + item["text"].length : sum, 0);
+  const telemetry = `[mcp-token-telemetry tool=${toolName} chars=${textChars} approx_tokens=${Math.max(1, Math.ceil(textChars / 4))}]`;
+  const nextContent = [...content];
+  let lastTextIndex = -1;
+  for (let index = nextContent.length - 1;index >= 0; index -= 1) {
+    const item = nextContent[index];
+    if (item["type"] === "text" && typeof item["text"] === "string") {
+      lastTextIndex = index;
+      break;
+    }
+  }
+  if (lastTextIndex >= 0) {
+    const item = nextContent[lastTextIndex];
+    nextContent[lastTextIndex] = { ...item, text: `${item["text"]}
+
+${telemetry}` };
+  } else {
+    nextContent.push({ type: "text", text: telemetry });
+  }
+  return { ...response, content: nextContent };
+}
+function installMcpTokenTelemetry(server) {
+  const originalTool = server.tool.bind(server);
+  server.tool = (...args) => {
+    const name = String(args[0]);
+    const last = args[args.length - 1];
+    if (typeof last !== "function")
+      return originalTool(...args);
+    const wrapped = async (...handlerArgs) => {
+      const result = await last(...handlerArgs);
+      return withMcpTokenTelemetry(result, name);
+    };
+    return originalTool(...args.slice(0, -1), wrapped);
+  };
+}
+var CORE_MCP_TOOLS, MCP_TOOL_GROUPS, MCP_PROFILE_GROUPS;
+var init_token_utils = __esm(() => {
+  CORE_MCP_TOOLS = new Set([
+    "add_comment",
+    "bootstrap",
+    "claim_next_task",
+    "complete_task",
+    "create_task",
+    "fail_task",
+    "get_context",
+    "get_health",
+    "get_next_task",
+    "get_status",
+    "get_task",
+    "get_tasks_changed_since",
+    "heartbeat",
+    "list_agents",
+    "list_tasks",
+    "register_agent",
+    "release_agent",
+    "start_task",
+    "suggest_agent_name"
+  ]);
+  MCP_TOOL_GROUPS = {
+    core: [...CORE_MCP_TOOLS],
+    tasks: [
+      "archive_completed",
+      "approve_task",
+      "bulk_create_tasks",
+      "bulk_delete_tasks",
+      "bulk_update_tasks",
+      "cancel_task",
+      "claim_task",
+      "clone_task",
+      "delete_task",
+      "extend_task",
+      "get_active_work",
+      "get_archived_tasks",
+      "get_blocked_tasks",
+      "get_blocking_tasks",
+      "get_my_tasks",
+      "get_review_queue",
+      "get_stale_tasks",
+      "list_my_tasks",
+      "move_task",
+      "patrol_tasks",
+      "prioritize_task",
+      "reassign_task",
+      "release_task",
+      "reschedule_task",
+      "search_tasks",
+      "standup",
+      "task_context",
+      "unarchive_task",
+      "update_task"
+    ],
+    projects: [
+      "create_plan",
+      "create_project",
+      "create_task_list",
+      "delete_plan",
+      "delete_project",
+      "delete_task_list",
+      "get_focus",
+      "get_plan",
+      "get_project",
+      "get_task_list",
+      "list_plans",
+      "list_projects",
+      "list_task_lists",
+      "set_focus",
+      "unfocus",
+      "update_plan",
+      "update_project",
+      "update_task_list"
+    ],
+    resources: [
+      "add_task_dependency",
+      "add_task_file",
+      "add_task_relationship",
+      "bulk_find_tasks_by_files",
+      "check_file_lock",
+      "create_comment",
+      "delete_comment",
+      "detect_file_relationships",
+      "find_path",
+      "find_task_by_commit",
+      "find_tasks_by_file",
+      "get_comments",
+      "get_critical_path",
+      "get_file_heat_map",
+      "get_impact_analysis",
+      "get_latest_handoff",
+      "get_related_entities",
+      "get_task_commits",
+      "get_task_dependencies",
+      "get_task_relationships",
+      "get_task_watchers",
+      "link_task_to_commit",
+      "list_active_files",
+      "list_comments",
+      "list_file_locks",
+      "list_task_files",
+      "lock_file",
+      "log_time",
+      "remove_task_dependency",
+      "remove_task_relationship",
+      "sync_kg",
+      "unlock_file",
+      "unwatch_task",
+      "update_comment",
+      "watch_task"
+    ],
+    agents: [
+      "auto_assign_task",
+      "delete_agent",
+      "get_agent",
+      "get_agent_metrics",
+      "get_capable_agents",
+      "get_leaderboard",
+      "get_my_workload",
+      "get_org_chart",
+      "get_project_org_chart",
+      "get_time_report",
+      "list_project_agent_roles",
+      "rebalance_workload",
+      "rename_agent",
+      "set_project_agent_role",
+      "set_reports_to",
+      "unarchive_agent",
+      "update_agent"
+    ],
+    metadata: [
+      "create_label",
+      "create_tag",
+      "delete_label",
+      "delete_tag",
+      "get_label",
+      "get_recent_activity",
+      "get_tag",
+      "get_task_graph",
+      "get_task_history",
+      "get_task_stats",
+      "list_labels",
+      "list_tags",
+      "search_tools",
+      "describe_tools",
+      "update_label",
+      "update_tag"
+    ],
+    dispatch: [
+      "cancel_dispatch",
+      "dispatch_task_list",
+      "dispatch_tasks",
+      "dispatch_to_multiple",
+      "list_dispatches",
+      "run_due_dispatches"
+    ],
+    templates: [
+      "create_task_from_template",
+      "create_template",
+      "delete_template",
+      "export_template",
+      "import_template",
+      "init_templates",
+      "list_templates",
+      "preview_template",
+      "template_history",
+      "update_template"
+    ],
+    webhooks: ["create_webhook", "delete_webhook", "list_webhooks"],
+    machines: [
+      "machines_archive",
+      "machines_delete",
+      "machines_list",
+      "machines_register",
+      "machines_set_primary",
+      "machines_unarchive"
+    ],
+    cloud: [
+      "sync_all",
+      "todos_cloud_conflicts",
+      "todos_cloud_feedback",
+      "todos_cloud_pull",
+      "todos_cloud_push",
+      "todos_cloud_status",
+      "todos_inbox",
+      "todos_retro"
+    ],
+    maintenance: ["extract_todos", "migrate_pg", "notify_upcoming_deadlines", "score_task"]
+  };
+  MCP_PROFILE_GROUPS = {
+    minimal: ["core"],
+    core: ["core"],
+    standard: ["core", "tasks", "projects", "resources", "agents", "metadata"],
+    agent: ["core", "tasks", "projects", "resources"],
+    maintainer: ["core", "tasks", "projects", "resources", "agents", "metadata", "dispatch", "maintenance"]
+  };
+});
+
 // src/mcp/tools/task-crud.ts
 function registerTaskCrudTools(server, ctx) {
   const { shouldRegisterTool, resolveId, formatError, formatTask } = ctx;
@@ -26954,15 +27379,31 @@ function registerTaskCrudTools(server, ctx) {
     });
   }
   if (shouldRegisterTool("get_task")) {
-    server.tool("get_task", "Get full details for a task.", {
-      task_id: exports_external2.string().describe("Task ID (full or short)")
-    }, async ({ task_id }) => {
+    server.tool("get_task", "Get compact task details by default. Pass detail=full for the full multi-line view.", {
+      task_id: exports_external2.string().describe("Task ID (full or short)"),
+      detail: exports_external2.enum(["compact", "full"]).optional().describe("Response detail (default: compact)"),
+      max_description_chars: exports_external2.number().optional().describe("Max description chars in compact mode (default: 240)"),
+      include_metadata: exports_external2.boolean().optional().describe("Include metadata in compact mode")
+    }, async ({ task_id, detail, max_description_chars, include_metadata }) => {
       try {
         const resolvedId = resolveId(task_id);
         const task = getTask(resolvedId);
         if (!task)
           throw new TaskNotFoundError(task_id);
         const focus = ctx.getAgentFocus(task.assigned_to || "");
+        if (detail !== "full") {
+          const compact = compactTask(task, max_description_chars || 240);
+          compact["version"] = task.version;
+          compact["created_at"] = task.created_at;
+          compact["focus"] = focus ? { agent_id: focus.agent_id, project_id: focus.project_id || null } : null;
+          if (include_metadata && task.metadata && Object.keys(task.metadata).length > 0) {
+            compact["metadata"] = task.metadata;
+          }
+          if (task.description && !compact["description"]) {
+            compact["description"] = truncateText(task.description, max_description_chars || 240);
+          }
+          return { content: [{ type: "text", text: compactJson(compact) }] };
+        }
         const lines = [
           `ID:       ${task.id}`,
           `Short ID: ${task.short_id || "(none)"}`,
@@ -27061,6 +27502,7 @@ var init_task_crud2 = __esm(() => {
   init_zod2();
   init_tasks();
   init_types();
+  init_token_utils();
 });
 
 // src/mcp/tools/task-project-tools.ts
@@ -27212,8 +27654,17 @@ function registerTaskProjectTools(server, ctx) {
       direction: exports_external2.enum(["upstream", "downstream", "both"]).optional().describe("Upstream = tasks this task depends on; downstream = tasks depending on this")
     }, async ({ task_id, direction }) => {
       try {
-        const { getTaskDependencies: getTaskDependencies3 } = (init_tasks(), __toCommonJS(exports_tasks));
-        const deps = getTaskDependencies3(resolveId(task_id), direction);
+        const { getTaskDependencies: getTaskDependencies3, getTaskDependents: getTaskDependents2, getTask: getTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
+        const resolvedId = resolveId(task_id);
+        const upstream = direction !== "downstream" ? getTaskDependencies3(resolvedId).map((dep) => {
+          const dependency = getTask2(dep.depends_on);
+          return { direction: "upstream", task_id: dep.depends_on, status: dependency?.status || "unknown" };
+        }) : [];
+        const downstream = direction !== "upstream" ? getTaskDependents2(resolvedId).map((dep) => {
+          const dependent = getTask2(dep.task_id);
+          return { direction: "downstream", task_id: dep.task_id, status: dependent?.status || "unknown" };
+        }) : [];
+        const deps = [...upstream, ...downstream];
         if (deps.length === 0)
           return { content: [{ type: "text", text: "No dependencies." }] };
         const lines = deps.map((d) => `[${d.direction}] ${d.task_id.slice(0, 8)} (${d.status})`);
@@ -28010,8 +28461,10 @@ function registerTaskWorkflowTools(server, ctx) {
       agent_id: exports_external2.string().optional().describe("Agent ID or name"),
       project_id: exports_external2.string().optional().describe("Filter by project"),
       task_list_id: exports_external2.string().optional().describe("Filter by task list"),
-      explain_blocked: exports_external2.boolean().optional().describe("Include blocked task details")
-    }, async ({ agent_id, project_id, task_list_id, explain_blocked }) => {
+      explain_blocked: exports_external2.boolean().optional().describe("Include blocked task details"),
+      detail: exports_external2.enum(["compact", "full"]).optional().describe("Response detail (default: compact)"),
+      max_description_chars: exports_external2.number().optional().describe("Max task description chars in compact mode (default: 180)")
+    }, async ({ agent_id, project_id, task_list_id, explain_blocked, detail, max_description_chars }) => {
       try {
         const { getStatus: getStatus2, getNextTask: getNextTask2, getOverdueTasks: getOverdueTasks2 } = (init_tasks(), __toCommonJS(exports_tasks));
         const { getLatestHandoff: getLatestHandoff2 } = (init_handoffs(), __toCommonJS(exports_handoffs));
@@ -28024,16 +28477,31 @@ function registerTaskWorkflowTools(server, ctx) {
         const next_task = getNextTask2(agent_id, filters);
         const overdue = getOverdueTasks2(filters.project_id);
         const latest_handoff = getLatestHandoff2(agent_id, filters.project_id);
+        const payload = {
+          status,
+          next_task,
+          overdue_count: overdue.length,
+          latest_handoff,
+          as_of: new Date().toISOString()
+        };
+        if (detail === "full") {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify(payload, null, 2)
+            }]
+          };
+        }
         return {
           content: [{
             type: "text",
-            text: JSON.stringify({
-              status,
-              next_task,
+            text: compactJson({
+              status: compactStatus(status),
+              next_task: next_task ? compactTask(next_task, max_description_chars || 180) : null,
               overdue_count: overdue.length,
-              latest_handoff,
-              as_of: new Date().toISOString()
-            }, null, 2)
+              latest_handoff: compactHandoff(latest_handoff),
+              as_of: payload.as_of
+            })
           }]
         };
       } catch (e) {
@@ -28097,6 +28565,7 @@ function registerTaskWorkflowTools(server, ctx) {
 var init_task_workflow_tools = __esm(() => {
   init_zod2();
   init_types();
+  init_token_utils();
 });
 
 // src/mcp/tools/task-auto-tools.ts
@@ -28476,14 +28945,37 @@ var init_task_relationships = __esm(() => {
 // src/mcp/tools/task-adv-tools.ts
 function registerTaskAdvTools(server, ctx) {
   const { shouldRegisterTool, resolveId, formatError, formatTask, formatTaskDetail } = ctx;
+  function getDependencyContext(taskId) {
+    const { getTaskDependencies: getTaskDependencies3, getTaskDependents: getTaskDependents2, getTask: getTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
+    const upstream = getTaskDependencies3(taskId).map((dep) => {
+      const dependency = getTask2(dep.depends_on);
+      return {
+        direction: "upstream",
+        task_id: dep.depends_on,
+        status: dependency?.status || "unknown"
+      };
+    });
+    const downstream = getTaskDependents2(taskId).map((dep) => {
+      const dependent = getTask2(dep.task_id);
+      return {
+        direction: "downstream",
+        task_id: dep.task_id,
+        status: dependent?.status || "unknown"
+      };
+    });
+    return [...upstream, ...downstream];
+  }
   if (shouldRegisterTool("get_status")) {
     server.tool("get_status", "Get queue status summary, or pass task_id for a task's detailed status.", {
       task_id: exports_external2.string().optional().describe("Task ID for task-specific status"),
       project_id: exports_external2.string().optional().describe("Filter summary by project"),
       task_list_id: exports_external2.string().optional().describe("Filter summary by task list"),
       agent_id: exports_external2.string().optional().describe("Agent for next-task affinity"),
-      explain_blocked: exports_external2.boolean().optional().describe("Include blocked task explanations in summary")
-    }, async ({ task_id, project_id, task_list_id, agent_id, explain_blocked }) => {
+      explain_blocked: exports_external2.boolean().optional().describe("Include blocked task explanations in summary"),
+      detail: exports_external2.enum(["compact", "full"]).optional().describe("Response detail (default: compact)"),
+      comment_limit: exports_external2.number().optional().describe("Max recent comments for task status (default: 5)"),
+      file_limit: exports_external2.number().optional().describe("Max files for task status (default: 10)")
+    }, async ({ task_id, project_id, task_list_id, agent_id, explain_blocked, detail, comment_limit, file_limit }) => {
       try {
         if (!task_id) {
           const { getStatus: getStatus2 } = (init_tasks(), __toCommonJS(exports_tasks));
@@ -28493,21 +28985,51 @@ function registerTaskAdvTools(server, ctx) {
           if (task_list_id)
             filters.task_list_id = resolveId(task_list_id, "task_lists");
           const status = getStatus2(filters, agent_id, { explain_blocked });
-          return { content: [{ type: "text", text: JSON.stringify(status, null, 2) }] };
+          return { content: [{ type: "text", text: detail === "full" ? JSON.stringify(status, null, 2) : compactJson(compactStatus(status)) }] };
         }
         const resolvedId = resolveId(task_id);
         const { getTask: getTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
         const task = getTask2(resolvedId);
         if (!task)
           throw new Error(`Task not found: ${task_id}`);
-        const { getTaskDependencies: getTaskDependencies3 } = (init_tasks(), __toCommonJS(exports_tasks));
         const { listComments: listComments2 } = (init_comments(), __toCommonJS(exports_comments));
         const { listTaskFiles: listTaskFiles2 } = (init_task_files(), __toCommonJS(exports_task_files));
         const [deps, comments, files] = await Promise.all([
-          Promise.resolve(getTaskDependencies3(resolvedId, "both")),
+          Promise.resolve(getDependencyContext(resolvedId)),
           Promise.resolve(listComments2(resolvedId)),
           Promise.resolve(listTaskFiles2(resolvedId))
         ]);
+        if (detail !== "full") {
+          const commentsShown = comments.slice(-(comment_limit || 5));
+          const filesShown = files.slice(0, file_limit || 10);
+          return {
+            content: [{
+              type: "text",
+              text: compactJson({
+                task: compactTask(task, 160),
+                dependencies: {
+                  count: deps.length,
+                  items: deps.slice(0, 10).map((d) => ({ direction: d.direction, task_id: d.task_id, status: d.status })),
+                  omitted: Math.max(0, deps.length - 10)
+                },
+                comments: {
+                  count: comments.length,
+                  recent: commentsShown.map((c) => ({
+                    agent_id: c.agent_id || null,
+                    created_at: c.created_at,
+                    content: truncateText(c.content, 120)
+                  })),
+                  omitted: Math.max(0, comments.length - commentsShown.length)
+                },
+                files: {
+                  count: files.length,
+                  items: filesShown.map((f) => ({ status: f.status, path: f.path })),
+                  omitted: Math.max(0, files.length - filesShown.length)
+                }
+              })
+            }]
+          };
+        }
         const lines = [
           `Status: ${task.status} | Priority: ${task.priority}`,
           task.assigned_to ? `Assigned: ${task.assigned_to}` : "Unassigned",
@@ -28531,29 +29053,81 @@ Files (${files.length}):` : null,
     });
   }
   if (shouldRegisterTool("task_context")) {
-    server.tool("task_context", "Get full context for a task: details, dependencies, relationships, comments, files, commits, time logs, and watchers.", {
-      task_id: exports_external2.string().describe("Task ID")
-    }, async ({ task_id }) => {
+    server.tool("task_context", "Get compact context for a task by default: details, dependencies, relationships, comments, files, commits, and watchers. Pass detail=full for all data.", {
+      task_id: exports_external2.string().describe("Task ID"),
+      detail: exports_external2.enum(["compact", "full"]).optional().describe("Response detail (default: compact)"),
+      comment_limit: exports_external2.number().optional().describe("Max recent comments in compact mode (default: 5)"),
+      file_limit: exports_external2.number().optional().describe("Max files in compact mode (default: 10)"),
+      commit_limit: exports_external2.number().optional().describe("Max commits in compact mode (default: 10)"),
+      max_description_chars: exports_external2.number().optional().describe("Max description chars in compact mode (default: 240)")
+    }, async ({ task_id, detail, comment_limit, file_limit, commit_limit, max_description_chars }) => {
       try {
         const resolvedId = resolveId(task_id);
         const { getTask: getTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
         const task = getTask2(resolvedId);
         if (!task)
           throw new Error(`Task not found: ${task_id}`);
-        const { getTaskDependencies: getTaskDependencies3 } = (init_tasks(), __toCommonJS(exports_tasks));
         const { getTaskRelationships: getTaskRelationships2 } = (init_task_relationships(), __toCommonJS(exports_task_relationships));
         const { listComments: listComments2 } = (init_comments(), __toCommonJS(exports_comments));
         const { listTaskFiles: listTaskFiles2 } = (init_task_files(), __toCommonJS(exports_task_files));
         const { getTaskCommits: getTaskCommits2 } = (init_task_commits(), __toCommonJS(exports_task_commits));
         const { getTaskWatchers: getTaskWatchers2 } = (init_tasks(), __toCommonJS(exports_tasks));
         const [deps, rels, comments, files, commits, watchers] = await Promise.all([
-          Promise.resolve(getTaskDependencies3(resolvedId, "both")),
+          Promise.resolve(getDependencyContext(resolvedId)),
           Promise.resolve(getTaskRelationships2(resolvedId)),
           Promise.resolve(listComments2(resolvedId)),
           Promise.resolve(listTaskFiles2(resolvedId)),
           Promise.resolve(getTaskCommits2(resolvedId)),
           Promise.resolve(getTaskWatchers2(resolvedId))
         ]);
+        if (detail !== "full") {
+          const commentsShown = comments.slice(-(comment_limit || 5));
+          const filesShown = files.slice(0, file_limit || 10);
+          const commitsShown = commits.slice(0, commit_limit || 10);
+          return {
+            content: [{
+              type: "text",
+              text: compactJson({
+                task: compactTask(task, max_description_chars || 240),
+                dependencies: {
+                  count: deps.length,
+                  items: deps.slice(0, 10).map((d) => ({ direction: d.direction, task_id: d.task_id, status: d.status })),
+                  omitted: Math.max(0, deps.length - 10)
+                },
+                relationships: {
+                  count: rels.length,
+                  items: rels.slice(0, 10).map((r) => ({
+                    source_task_id: r.source_task_id,
+                    relationship_type: r.relationship_type,
+                    target_task_id: r.target_task_id
+                  })),
+                  omitted: Math.max(0, rels.length - 10)
+                },
+                comments: {
+                  count: comments.length,
+                  recent: commentsShown.map((c) => ({
+                    agent_id: c.agent_id || null,
+                    created_at: c.created_at,
+                    content: truncateText(c.content, 160)
+                  })),
+                  omitted: Math.max(0, comments.length - commentsShown.length)
+                },
+                files: {
+                  count: files.length,
+                  items: filesShown.map((f) => ({ status: f.status, path: f.path })),
+                  omitted: Math.max(0, files.length - filesShown.length)
+                },
+                commits: {
+                  count: commits.length,
+                  items: commitsShown.map((c) => ({ sha: c.sha, message: truncateText(c.message || "(no message)", 120) })),
+                  omitted: Math.max(0, commits.length - commitsShown.length)
+                },
+                watchers: { count: watchers.length },
+                metadata_keys: task.metadata ? Object.keys(task.metadata) : []
+              })
+            }]
+          };
+        }
         const lines = [
           `== ${task.title} ====================`,
           `ID:       ${task.id}`,
@@ -28719,15 +29293,20 @@ No blocked tasks.`,
     });
   }
   if (shouldRegisterTool("get_comments")) {
-    server.tool("get_comments", "Alias for list_comments.", {
-      task_id: exports_external2.string().describe("Task ID")
-    }, async ({ task_id }) => {
+    server.tool("get_comments", "List recent comments for a task. Compact by default; pass detail=full for all comment text.", {
+      task_id: exports_external2.string().describe("Task ID"),
+      detail: exports_external2.enum(["compact", "full"]).optional().describe("Response detail (default: compact)"),
+      limit: exports_external2.number().optional().describe("Max recent comments in compact mode (default: 20)")
+    }, async ({ task_id, detail, limit }) => {
       try {
         const { listComments: listComments2 } = (init_comments(), __toCommonJS(exports_comments));
         const comments = listComments2(resolveId(task_id));
         if (comments.length === 0)
           return { content: [{ type: "text", text: "No comments." }] };
-        const lines = comments.map((c) => `[${c.agent_id || "?"}] ${c.created_at?.slice(0, 16)}: ${c.content}`);
+        const shown = detail === "full" ? comments : comments.slice(-(limit || 20));
+        const lines = shown.map((c) => `[${c.agent_id || "?"}] ${c.created_at?.slice(0, 16)}: ${detail === "full" ? c.content : truncateText(c.content, 180)}`);
+        if (shown.length < comments.length)
+          lines.unshift(`Showing ${shown.length} of ${comments.length} comments (${comments.length - shown.length} older omitted).`);
         return { content: [{ type: "text", text: lines.join(`
 
 `) }] };
@@ -28767,6 +29346,7 @@ No blocked tasks.`,
 }
 var init_task_adv_tools = __esm(() => {
   init_zod2();
+  init_token_utils();
 });
 
 // src/mcp/tools/task-meta-tools.ts
@@ -28797,7 +29377,7 @@ function registerTaskMetaTools(server, ctx) {
         const toolDocs = {
           create_task: "create_task \u2014 Create a new task. Params: title (required), description, status, priority, project_id, task_list_id, assigned_to, depends_on, short_id (null to disable), tags, estimate (minutes), confidence (0.0-1.0), deadline (ISO), retry_count",
           list_tasks: "list_tasks \u2014 List tasks with filters. Params: status, priority, project_id, task_list_id, assigned_to, tags[], created_after, created_before, limit, offset",
-          get_task: "get_task \u2014 Get full details for a task. Params: task_id",
+          get_task: "get_task \u2014 Get compact task details by default. Params: task_id, detail=compact|full, max_description_chars, include_metadata",
           update_task: "update_task \u2014 Update task fields (optimistic locking). Params: task_id (required), title, description, status, priority, assigned_to (null to unassign), project_id, task_list_id, depends_on[], tags[], estimate, actual_minutes, confidence, approved_by, completed_at, deadline, retry_count, version",
           delete_task: "delete_task \u2014 Delete a task. Params: task_id, force (skip child check)",
           start_task: "start_task \u2014 Mark task in_progress. Params: task_id, version",
@@ -28811,8 +29391,8 @@ function registerTaskMetaTools(server, ctx) {
           get_next_task: "get_next_task \u2014 Get the next available task without claiming it. Params: agent_id, project_id, task_list_id, plan_id, tags",
           claim_next_task: "claim_next_task \u2014 Atomically claim and start the next available task. Params: agent_id, project_id, task_list_id, plan_id, tags",
           get_tasks_changed_since: "get_tasks_changed_since \u2014 List tasks changed since an ISO timestamp. Params: since, project_id, task_list_id, limit",
-          get_context: "get_context \u2014 Get session start context. Params: agent_id, project_id, task_list_id, explain_blocked",
-          bootstrap: "bootstrap \u2014 Bootstrap an agent session with queue context. Params: agent_id, project_id, task_list_id, explain_blocked",
+          get_context: "get_context \u2014 Get compact session start context by default. Params: agent_id, project_id, task_list_id, explain_blocked, detail=compact|full, max_description_chars",
+          bootstrap: "bootstrap \u2014 Bootstrap an agent session with compact queue context by default. Params: agent_id, project_id, task_list_id, explain_blocked, detail=compact|full, max_description_chars",
           standup: "standup \u2014 Get standup report. Params: agent_id, project_id",
           patrol_tasks: "patrol_tasks \u2014 Scan for task issues. Params: stuck_minutes, confidence_threshold, project_id",
           get_review_queue: "get_review_queue \u2014 Get tasks needing review. Params: project_id, limit",
@@ -28849,6 +29429,7 @@ function registerTaskMetaTools(server, ctx) {
           get_task_relationships: "get_task_relationships \u2014 Get all relationships. Params: task_id, relationship_type",
           create_comment: "create_comment \u2014 Add comment. Params: task_id, body, author",
           list_comments: "list_comments \u2014 List comments. Params: task_id",
+          get_comments: "get_comments \u2014 List recent comments by default. Params: task_id, detail=compact|full, limit",
           update_comment: "update_comment \u2014 Edit comment. Params: comment_id, body",
           delete_comment: "delete_comment \u2014 Delete comment. Params: comment_id",
           lock_task: "lock_task \u2014 Acquire exclusive lock. Params: task_id, agent_id, ttl_seconds",
@@ -31694,30 +32275,14 @@ __export(exports_mcp, {
 });
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
-import { join as join12, dirname as dirname6 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
 function getMcpVersion() {
-  try {
-    let dir = dirname6(fileURLToPath3(import.meta.url));
-    for (let i = 0;i < 4; i++) {
-      const pkgPath = join12(dir, "package.json");
-      if (existsSync9(pkgPath)) {
-        return JSON.parse(readFileSync7(pkgPath, "utf-8")).version || "0.0.0";
-      }
-      dir = dirname6(dir);
-    }
-  } catch {
-    return "0.0.0";
-  }
-  return "0.0.0";
+  return getPackageVersion(import.meta.url);
+}
+function hasVersionFlag() {
+  return process.argv.includes("--version") || process.argv.includes("-V");
 }
 function shouldRegisterTool(name) {
-  if (TODOS_PROFILE === "minimal")
-    return MINIMAL_TOOLS.has(name);
-  if (TODOS_PROFILE === "standard")
-    return !STANDARD_EXCLUDED.has(name);
-  return true;
+  return shouldRegisterToolForProfile(name);
 }
 function getAgentFocus(agentId) {
   const sessionFocus = agentFocusMap.get(agentId);
@@ -31854,7 +32419,7 @@ async function main() {
   const transport = new StdioServerTransport;
   await server.connect(transport);
 }
-var server, TODOS_PROFILE, MINIMAL_TOOLS, STANDARD_EXCLUDED, agentFocusMap, toolContext;
+var server, agentFocusMap, toolContext;
 var init_mcp = __esm(() => {
   init_cloud();
   init_agents();
@@ -31872,46 +32437,17 @@ var init_mcp = __esm(() => {
   init_code_tools();
   init_machines2();
   init_agents2();
+  init_package_version();
+  init_token_utils();
+  if (hasVersionFlag()) {
+    console.log(getMcpVersion());
+    process.exit(0);
+  }
   server = new McpServer({
     name: "todos",
     version: getMcpVersion()
   });
-  TODOS_PROFILE = (process.env["TODOS_PROFILE"] || "full").toLowerCase();
-  MINIMAL_TOOLS = new Set([
-    "claim_next_task",
-    "complete_task",
-    "fail_task",
-    "get_status",
-    "get_context",
-    "get_task",
-    "start_task",
-    "add_comment",
-    "get_next_task",
-    "bootstrap",
-    "get_tasks_changed_since",
-    "get_health",
-    "heartbeat",
-    "release_agent"
-  ]);
-  STANDARD_EXCLUDED = new Set([
-    "rename_agent",
-    "delete_agent",
-    "unarchive_agent",
-    "create_webhook",
-    "list_webhooks",
-    "delete_webhook",
-    "create_template",
-    "list_templates",
-    "create_task_from_template",
-    "delete_template",
-    "update_template",
-    "init_templates",
-    "preview_template",
-    "export_template",
-    "import_template",
-    "template_history",
-    "approve_task"
-  ]);
+  installMcpTokenTelemetry(server);
   agentFocusMap = new Map;
   toolContext = {
     shouldRegisterTool,
@@ -33034,7 +33570,7 @@ import { basename as basename2, resolve as resolve4 } from "path";
 init_tasks();
 init_config();
 init_sync_utils();
-import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync3, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
 import { join as join5 } from "path";
 function getTaskListDir(taskListId) {
   return join5(HOME, ".claude", "tasks", taskListId);
@@ -33056,7 +33592,7 @@ function toSqliteStatus(status) {
 }
 function readPrefixCounter(dir) {
   const path = join5(dir, ".prefix-counter");
-  if (!existsSync4(path))
+  if (!existsSync5(path))
     return 0;
   const val = parseInt(readFileSync3(path, "utf-8").trim(), 10);
   return isNaN(val) ? 0 : val;
@@ -33089,7 +33625,7 @@ function taskToClaudeTask(task, claudeTaskId, existingMeta) {
 }
 function pushToClaudeTaskList(taskListId, projectId, options = {}) {
   const dir = getTaskListDir(taskListId);
-  if (!existsSync4(dir))
+  if (!existsSync5(dir))
     ensureDir2(dir);
   const filter = {};
   if (projectId)
@@ -33185,7 +33721,7 @@ function pushToClaudeTaskList(taskListId, projectId, options = {}) {
 }
 function pullFromClaudeTaskList(taskListId, projectId, options = {}) {
   const dir = getTaskListDir(taskListId);
-  if (!existsSync4(dir)) {
+  if (!existsSync5(dir)) {
     return { pushed: 0, pulled: 0, errors: [`Task list directory not found: ${dir}`] };
   }
   const files = readdirSync2(dir).filter((f) => f.endsWith(".json"));
@@ -33276,12 +33812,12 @@ function syncClaudeTaskList(taskListId, projectId, options = {}) {
 init_tasks();
 init_sync_utils();
 init_config();
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { join as join6 } from "path";
 function getTodosGlobalDir2() {
   const newDir = join6(HOME, ".hasna", "todos");
   const legacyDir = join6(HOME, ".todos");
-  if (!existsSync5(newDir) && existsSync5(legacyDir))
+  if (!existsSync6(newDir) && existsSync6(legacyDir))
     return legacyDir;
   return newDir;
 }
@@ -33321,7 +33857,7 @@ function metadataKey(agent) {
 }
 function pushToAgentTaskList(agent, taskListId, projectId, options = {}) {
   const dir = getTaskListDir2(agent, taskListId);
-  if (!existsSync5(dir))
+  if (!existsSync6(dir))
     ensureDir2(dir);
   const filter = {};
   if (projectId)
@@ -33404,7 +33940,7 @@ function pushToAgentTaskList(agent, taskListId, projectId, options = {}) {
 }
 function pullFromAgentTaskList(agent, taskListId, projectId, options = {}) {
   const dir = getTaskListDir2(agent, taskListId);
-  if (!existsSync5(dir)) {
+  if (!existsSync6(dir)) {
     return { pushed: 0, pulled: 0, errors: [`Task list directory not found: ${dir}`] };
   }
   const files = listJsonFiles(dir);
@@ -34298,7 +34834,7 @@ init_tasks();
 init_config();
 init_helpers();
 import chalk6 from "chalk";
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname4, join as join10 } from "path";
 function registerConfigServeCommands(program2) {
   program2.command("config").description("View or update configuration").option("--get <key>", "Get a config value").option("--set <key=value>", "Set a config value (e.g. completion_guard.enabled=true)").action((opts) => {
@@ -34306,7 +34842,7 @@ function registerConfigServeCommands(program2) {
     const home = process.env["HOME"] || "~";
     const newPath = join10(home, ".hasna", "todos", "config.json");
     const legacyPath = join10(home, ".todos", "config.json");
-    const configPath = !existsSync7(newPath) && existsSync7(legacyPath) ? legacyPath : newPath;
+    const configPath = !existsSync8(newPath) && existsSync8(legacyPath) ? legacyPath : newPath;
     if (opts.get) {
       const config2 = loadConfig();
       const keys = opts.get.split(".");
@@ -34343,7 +34879,7 @@ function registerConfigServeCommands(program2) {
       }
       obj[keys[keys.length - 1]] = parsedValue;
       const dir = dirname4(configPath);
-      if (!existsSync7(dir))
+      if (!existsSync8(dir))
         mkdirSync3(dir, { recursive: true });
       writeFileSync3(configPath, JSON.stringify(config2, null, 2));
       if (globalOpts.json) {
@@ -36056,8 +36592,8 @@ init_tasks();
 init_helpers();
 import chalk9 from "chalk";
 import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, chmodSync } from "fs";
-import { dirname as dirname7, join as join13 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync7, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, chmodSync } from "fs";
+import { dirname as dirname6, join as join12 } from "path";
 var HOME2 = process.env["HOME"] || process.env["USERPROFILE"] || "~";
 function getMcpBinaryPath() {
   try {
@@ -36065,7 +36601,7 @@ function getMcpBinaryPath() {
     if (p)
       return p;
   } catch {}
-  const bunBin = join13(HOME2, ".bun", "bin", "todos-mcp");
+  const bunBin = join12(HOME2, ".bun", "bin", "todos-mcp");
   if (existsSync10(bunBin))
     return bunBin;
   return "todos-mcp";
@@ -36074,13 +36610,13 @@ function readJsonFile2(path) {
   if (!existsSync10(path))
     return {};
   try {
-    return JSON.parse(readFileSync8(path, "utf-8"));
+    return JSON.parse(readFileSync7(path, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeJsonFile2(path, data) {
-  const dir = dirname7(path);
+  const dir = dirname6(path);
   if (!existsSync10(dir))
     mkdirSync5(dir, { recursive: true });
   writeFileSync5(path, JSON.stringify(data, null, 2) + `
@@ -36089,10 +36625,10 @@ function writeJsonFile2(path, data) {
 function readTomlFile(path) {
   if (!existsSync10(path))
     return "";
-  return readFileSync8(path, "utf-8");
+  return readFileSync7(path, "utf-8");
 }
 function writeTomlFile(path, content) {
-  const dir = dirname7(path);
+  const dir = dirname6(path);
   if (!existsSync10(dir))
     mkdirSync5(dir, { recursive: true });
   writeFileSync5(path, content);
@@ -36139,7 +36675,7 @@ function unregisterClaude(_global) {
   }
 }
 function registerCodex(binPath) {
-  const configPath = join13(HOME2, ".codex", "config.toml");
+  const configPath = join12(HOME2, ".codex", "config.toml");
   let content = readTomlFile(configPath);
   content = removeTomlBlock(content, "mcp_servers.todos");
   const block = `
@@ -36153,7 +36689,7 @@ args = []
   console.log(chalk9.green(`Codex CLI: registered in ${configPath}`));
 }
 function unregisterCodex() {
-  const configPath = join13(HOME2, ".codex", "config.toml");
+  const configPath = join12(HOME2, ".codex", "config.toml");
   let content = readTomlFile(configPath);
   if (!content.includes("[mcp_servers.todos]")) {
     console.log(chalk9.dim(`Codex CLI: todos not found in ${configPath}`));
@@ -36165,7 +36701,7 @@ function unregisterCodex() {
   console.log(chalk9.green(`Codex CLI: unregistered from ${configPath}`));
 }
 function registerGemini(binPath) {
-  const configPath = join13(HOME2, ".gemini", "settings.json");
+  const configPath = join12(HOME2, ".gemini", "settings.json");
   const config = readJsonFile2(configPath);
   if (!config["mcpServers"]) {
     config["mcpServers"] = {};
@@ -36179,7 +36715,7 @@ function registerGemini(binPath) {
   console.log(chalk9.green(`Gemini CLI: registered in ${configPath}`));
 }
 function unregisterGemini() {
-  const configPath = join13(HOME2, ".gemini", "settings.json");
+  const configPath = join12(HOME2, ".gemini", "settings.json");
   const config = readJsonFile2(configPath);
   const servers = config["mcpServers"];
   if (!servers || !("todos" in servers)) {
@@ -36236,7 +36772,7 @@ function registerMcpHooksCommands(program2) {
       if (p)
         todosBin = p;
     } catch {}
-    const hooksDir = join13(process.cwd(), ".claude", "hooks");
+    const hooksDir = join12(process.cwd(), ".claude", "hooks");
     if (!existsSync10(hooksDir))
       mkdirSync5(hooksDir, { recursive: true });
     const hookScript = `#!/usr/bin/env bash
@@ -36262,11 +36798,11 @@ esac
 
 exit 0
 `;
-    const hookPath = join13(hooksDir, "todos-sync.sh");
+    const hookPath = join12(hooksDir, "todos-sync.sh");
     writeFileSync5(hookPath, hookScript);
     execSync3(`chmod +x "${hookPath}"`);
     console.log(chalk9.green(`Hook script created: ${hookPath}`));
-    const settingsPath = join13(process.cwd(), ".claude", "settings.json");
+    const settingsPath = join12(process.cwd(), ".claude", "settings.json");
     const settings = readJsonFile2(settingsPath);
     if (!settings["hooks"]) {
       settings["hooks"] = {};
@@ -36360,7 +36896,7 @@ exit 0
       const hookPath = `${gitDir}/hooks/post-commit`;
       const marker = "# todos-auto-link";
       if (existsSync10(hookPath)) {
-        const existing = readFileSync8(hookPath, "utf-8");
+        const existing = readFileSync7(hookPath, "utf-8");
         if (existing.includes(marker)) {
           console.log(chalk9.yellow("Hook already installed."));
           return;
@@ -36391,7 +36927,7 @@ $(dirname "$0")/../../scripts/post-commit-hook.sh
         console.log(chalk9.dim("No post-commit hook found."));
         return;
       }
-      const content = readFileSync8(hookPath, "utf-8");
+      const content = readFileSync7(hookPath, "utf-8");
       if (!content.includes(marker)) {
         console.log(chalk9.dim("Hook not managed by todos."));
         return;
@@ -36555,7 +37091,7 @@ import chalk11 from "chalk";
 import { execSync as execSync4 } from "child_process";
 import { writeFileSync as writeFileSync6 } from "fs";
 import { tmpdir } from "os";
-import { join as join14 } from "path";
+import { join as join13 } from "path";
 function getOrCreateLocalMachineName() {
   return process.env["TODOS_MACHINE_NAME"] || __require("os").hostname() || "unknown";
 }
@@ -36749,7 +37285,7 @@ Warning: No primary machine set.`));
       if (opts.push) {
         try {
           const localTasks = listTasks3();
-          const tmpFile = join14(tmpdir(), `todos-export-${uuid()}.json`);
+          const tmpFile = join13(tmpdir(), `todos-export-${uuid()}.json`);
           writeFileSync6(tmpFile, JSON.stringify(localTasks, null, 2));
           execSync4(`scp ${tmpFile} ${ssh}:/tmp/todos-import.json`, { timeout: 15000 });
           const importCmd = `ssh ${ssh} 'node -e "const fs=require(\\'fs\\');const tasks=JSON.parse(fs.readFileSync(\\'/tmp/todos-import.json\\',\\'utf-8\\'));console.log(JSON.stringify(tasks.length))"'`;