@hasna/todos 0.11.37 → 0.11.38

package/dist/mcp/index.js

@@ -22624,6 +22624,383 @@ ${lines.join(`
 // src/mcp/tools/task-crud.ts
 init_tasks();
 init_types2();
+
+// src/mcp/token-utils.ts
+var 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"
+]);
+var 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"]
+};
+var 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"]
+};
+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);
+  };
+}
+
+// src/mcp/tools/task-crud.ts
 function registerTaskCrudTools(server, ctx) {
   const { shouldRegisterTool, resolveId, formatError, formatTask } = ctx;
   function versionFor(taskId, version) {
@@ -22713,15 +23090,31 @@ function registerTaskCrudTools(server, ctx) {
     });
   }
   if (shouldRegisterTool("get_task")) {
-    server.tool("get_task", "Get full details for a task.", {
-      task_id: exports_external.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_external.string().describe("Task ID (full or short)"),
+      detail: exports_external.enum(["compact", "full"]).optional().describe("Response detail (default: compact)"),
+      max_description_chars: exports_external.number().optional().describe("Max description chars in compact mode (default: 240)"),
+      include_metadata: exports_external.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)"}`,
@@ -23042,8 +23435,17 @@ function registerTaskProjectTools(server, ctx) {
       direction: exports_external.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})`);
@@ -23832,8 +24234,10 @@ function registerTaskWorkflowTools(server, ctx) {
       agent_id: exports_external.string().optional().describe("Agent ID or name"),
       project_id: exports_external.string().optional().describe("Filter by project"),
       task_list_id: exports_external.string().optional().describe("Filter by task list"),
-      explain_blocked: exports_external.boolean().optional().describe("Include blocked task details")
-    }, async ({ agent_id, project_id, task_list_id, explain_blocked }) => {
+      explain_blocked: exports_external.boolean().optional().describe("Include blocked task details"),
+      detail: exports_external.enum(["compact", "full"]).optional().describe("Response detail (default: compact)"),
+      max_description_chars: exports_external.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));
@@ -23846,16 +24250,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) {
@@ -24165,14 +24584,37 @@ ${lines.join(`
 // 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_external.string().optional().describe("Task ID for task-specific status"),
       project_id: exports_external.string().optional().describe("Filter summary by project"),
       task_list_id: exports_external.string().optional().describe("Filter summary by task list"),
       agent_id: exports_external.string().optional().describe("Agent for next-task affinity"),
-      explain_blocked: exports_external.boolean().optional().describe("Include blocked task explanations in summary")
-    }, async ({ task_id, project_id, task_list_id, agent_id, explain_blocked }) => {
+      explain_blocked: exports_external.boolean().optional().describe("Include blocked task explanations in summary"),
+      detail: exports_external.enum(["compact", "full"]).optional().describe("Response detail (default: compact)"),
+      comment_limit: exports_external.number().optional().describe("Max recent comments for task status (default: 5)"),
+      file_limit: exports_external.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));
@@ -24182,21 +24624,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",
@@ -24220,29 +24692,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_external.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_external.string().describe("Task ID"),
+      detail: exports_external.enum(["compact", "full"]).optional().describe("Response detail (default: compact)"),
+      comment_limit: exports_external.number().optional().describe("Max recent comments in compact mode (default: 5)"),
+      file_limit: exports_external.number().optional().describe("Max files in compact mode (default: 10)"),
+      commit_limit: exports_external.number().optional().describe("Max commits in compact mode (default: 10)"),
+      max_description_chars: exports_external.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}`,
@@ -24408,15 +24932,20 @@ No blocked tasks.`,
     });
   }
   if (shouldRegisterTool("get_comments")) {
-    server.tool("get_comments", "Alias for list_comments.", {
-      task_id: exports_external.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_external.string().describe("Task ID"),
+      detail: exports_external.enum(["compact", "full"]).optional().describe("Response detail (default: compact)"),
+      limit: exports_external.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(`
 
 `) }] };
@@ -24483,7 +25012,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",
@@ -24497,8 +25026,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",
@@ -24535,6 +25064,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",
@@ -26097,48 +26627,9 @@ var server = new McpServer({
   name: "todos",
   version: getMcpVersion()
 });
-var TODOS_PROFILE = (process.env["TODOS_PROFILE"] || "full").toLowerCase();
-var 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"
-]);
-var 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);
 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);
 }
 var agentFocusMap = new Map;
 function getAgentFocus(agentId) {