@hasna/todos 0.11.37 → 0.11.38

package/dist/cli/index.js

@@ -8290,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;
@@ -8402,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,
@@ -8504,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);
   }
@@ -8523,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);
   }
@@ -8535,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);
   }
@@ -8545,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`);
@@ -8574,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);
@@ -8582,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 {
@@ -8597,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 {
@@ -8864,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());
@@ -9260,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;
       }
@@ -9268,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);
@@ -9359,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);
@@ -26879,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;
@@ -26969,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)"}`,
@@ -27076,6 +27502,7 @@ var init_task_crud2 = __esm(() => {
   init_zod2();
   init_tasks();
   init_types();
+  init_token_utils();
 });
 
 // src/mcp/tools/task-project-tools.ts
@@ -27227,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})`);
@@ -28025,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));
@@ -28039,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) {
@@ -28112,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
@@ -28491,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));
@@ -28508,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",
@@ -28546,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}`,
@@ -28734,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(`
 
 `) }] };
@@ -28782,6 +29346,7 @@ No blocked tasks.`,
 }
 var init_task_adv_tools = __esm(() => {
   init_zod2();
+  init_token_utils();
 });
 
 // src/mcp/tools/task-meta-tools.ts
@@ -28812,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",
@@ -28826,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",
@@ -28864,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",
@@ -31716,11 +32282,7 @@ 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);
@@ -31857,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();
@@ -31876,6 +32438,7 @@ var init_mcp = __esm(() => {
   init_machines2();
   init_agents2();
   init_package_version();
+  init_token_utils();
   if (hasVersionFlag()) {
     console.log(getMcpVersion());
     process.exit(0);
@@ -31884,42 +32447,7 @@ var init_mcp = __esm(() => {
     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,