@hasna/todos 0.11.38 → 0.11.39

package/dist/registry.js

@@ -0,0 +1,1382 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/types/index.ts
+var TASK_STATUSES, TASK_PRIORITIES, PLAN_STATUSES, VersionConflictError, TaskNotFoundError, ProjectNotFoundError, PlanNotFoundError, LockError, AgentNotFoundError, TaskListNotFoundError, DependencyCycleError, CompletionGuardError, DISPATCH_STATUSES, DispatchNotFoundError;
+var init_types = __esm(() => {
+  TASK_STATUSES = [
+    "pending",
+    "in_progress",
+    "completed",
+    "failed",
+    "cancelled"
+  ];
+  TASK_PRIORITIES = [
+    "low",
+    "medium",
+    "high",
+    "critical"
+  ];
+  PLAN_STATUSES = ["active", "completed", "archived"];
+  VersionConflictError = class VersionConflictError extends Error {
+    taskId;
+    expectedVersion;
+    actualVersion;
+    static code = "VERSION_CONFLICT";
+    static suggestion = "Fetch the task with get_task to get the current version before updating.";
+    constructor(taskId, expectedVersion, actualVersion) {
+      super(`Version conflict for task ${taskId}: expected ${expectedVersion}, got ${actualVersion}`);
+      this.taskId = taskId;
+      this.expectedVersion = expectedVersion;
+      this.actualVersion = actualVersion;
+      this.name = "VersionConflictError";
+    }
+  };
+  TaskNotFoundError = class TaskNotFoundError extends Error {
+    taskId;
+    static code = "TASK_NOT_FOUND";
+    static suggestion = "Verify the task ID. Use list_tasks or search_tasks to find the correct ID.";
+    constructor(taskId) {
+      super(`Task not found: ${taskId}`);
+      this.taskId = taskId;
+      this.name = "TaskNotFoundError";
+    }
+  };
+  ProjectNotFoundError = class ProjectNotFoundError extends Error {
+    projectId;
+    static code = "PROJECT_NOT_FOUND";
+    static suggestion = "Use list_projects to see available projects.";
+    constructor(projectId) {
+      super(`Project not found: ${projectId}`);
+      this.projectId = projectId;
+      this.name = "ProjectNotFoundError";
+    }
+  };
+  PlanNotFoundError = class PlanNotFoundError extends Error {
+    planId;
+    static code = "PLAN_NOT_FOUND";
+    static suggestion = "Use list_plans to see available plans.";
+    constructor(planId) {
+      super(`Plan not found: ${planId}`);
+      this.planId = planId;
+      this.name = "PlanNotFoundError";
+    }
+  };
+  LockError = class LockError extends Error {
+    taskId;
+    lockedBy;
+    static code = "LOCK_ERROR";
+    static suggestion = "Wait for the lock to expire (30 min) or contact the lock holder.";
+    constructor(taskId, lockedBy) {
+      super(`Task ${taskId} is locked by ${lockedBy}`);
+      this.taskId = taskId;
+      this.lockedBy = lockedBy;
+      this.name = "LockError";
+    }
+  };
+  AgentNotFoundError = class AgentNotFoundError extends Error {
+    agentId;
+    static code = "AGENT_NOT_FOUND";
+    static suggestion = "Use register_agent to create the agent first, or list_agents to find existing ones.";
+    constructor(agentId) {
+      super(`Agent not found: ${agentId}`);
+      this.agentId = agentId;
+      this.name = "AgentNotFoundError";
+    }
+  };
+  TaskListNotFoundError = class TaskListNotFoundError extends Error {
+    taskListId;
+    static code = "TASK_LIST_NOT_FOUND";
+    static suggestion = "Use list_task_lists to see available lists.";
+    constructor(taskListId) {
+      super(`Task list not found: ${taskListId}`);
+      this.taskListId = taskListId;
+      this.name = "TaskListNotFoundError";
+    }
+  };
+  DependencyCycleError = class DependencyCycleError extends Error {
+    taskId;
+    dependsOn;
+    static code = "DEPENDENCY_CYCLE";
+    static suggestion = "Check the dependency chain with get_task to avoid circular references.";
+    constructor(taskId, dependsOn) {
+      super(`Adding dependency ${taskId} -> ${dependsOn} would create a cycle`);
+      this.taskId = taskId;
+      this.dependsOn = dependsOn;
+      this.name = "DependencyCycleError";
+    }
+  };
+  CompletionGuardError = class CompletionGuardError extends Error {
+    reason;
+    retryAfterSeconds;
+    static code = "COMPLETION_BLOCKED";
+    static suggestion = "Wait for the cooldown period, then retry.";
+    constructor(reason, retryAfterSeconds) {
+      super(reason);
+      this.reason = reason;
+      this.retryAfterSeconds = retryAfterSeconds;
+      this.name = "CompletionGuardError";
+    }
+  };
+  DISPATCH_STATUSES = ["pending", "sent", "failed", "cancelled"];
+  DispatchNotFoundError = class DispatchNotFoundError extends Error {
+    dispatchId;
+    static code = "DISPATCH_NOT_FOUND";
+    static suggestion = "Check the dispatch ID with list_dispatches.";
+    constructor(dispatchId) {
+      super(`Dispatch not found: ${dispatchId}`);
+      this.dispatchId = dispatchId;
+      this.name = "DispatchNotFoundError";
+    }
+  };
+});
+
+// src/lib/package-version.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+function getPackageVersion(fromUrl = import.meta.url) {
+  try {
+    let dir = dirname(fileURLToPath(fromUrl));
+    for (let i = 0;i < 5; i++) {
+      const pkgPath = join(dir, "package.json");
+      if (existsSync(pkgPath)) {
+        return JSON.parse(readFileSync(pkgPath, "utf-8")).version || "0.0.0";
+      }
+      const parent = dirname(dir);
+      if (parent === dir)
+        break;
+      dir = parent;
+    }
+  } catch {
+    return "0.0.0";
+  }
+  return "0.0.0";
+}
+
+// src/json-contracts.ts
+function source(version) {
+  return {
+    packageName: "@hasna/todos",
+    repository: "hasna/todos",
+    version
+  };
+}
+function field(type, description, nullable = false) {
+  return { type, description, nullable };
+}
+function contract(input) {
+  return {
+    ...input,
+    additionalProperties: true,
+    evolution: {
+      additionalFields: "allowed",
+      removingRequiredFields: "breaking",
+      changingRequiredFieldTypes: "breaking",
+      nullableToNonNullable: "breaking"
+    }
+  };
+}
+var idField = field("string", "Stable UUID or short identifier.");
+var nullableIdField = field(["string", "null"], "Stable identifier when attached to another object.", true);
+var isoDateField = field("string", "ISO-8601 timestamp string.");
+var nullableIsoDateField = field(["string", "null"], "ISO-8601 timestamp string, or null when not set.", true);
+var metadataField = field("object", "JSON object metadata. Unknown keys are extension data.");
+var tagsField = field("array", "Array of string tags.");
+var TODOS_JSON_CONTRACTS = [
+  contract({
+    id: "task",
+    name: "Task",
+    description: "Canonical task object returned by CLI JSON, SDK, API summaries, and MCP task tools.",
+    surfaces: ["cli", "api", "mcp", "sdk"],
+    stability: "stable",
+    required: {
+      id: idField,
+      short_id: nullableIdField,
+      title: field("string", "Human-readable task title."),
+      description: field(["string", "null"], "Optional task description.", true),
+      status: field("string", "Task lifecycle status."),
+      priority: field("string", "Task priority."),
+      project_id: nullableIdField,
+      plan_id: nullableIdField,
+      task_list_id: nullableIdField,
+      agent_id: nullableIdField,
+      assigned_to: field(["string", "null"], "Assigned agent name or id.", true),
+      tags: tagsField,
+      metadata: metadataField,
+      version: field("integer", "Optimistic locking version."),
+      created_at: isoDateField,
+      updated_at: isoDateField
+    },
+    optional: {
+      locked_by: field(["string", "null"], "Agent currently holding the task lock.", true),
+      locked_at: nullableIsoDateField,
+      started_at: nullableIsoDateField,
+      completed_at: nullableIsoDateField,
+      due_at: nullableIsoDateField
+    }
+  }),
+  contract({
+    id: "project",
+    name: "Project",
+    description: "Project object used to scope tasks to a local repository or workspace.",
+    surfaces: ["cli", "api", "mcp", "sdk"],
+    stability: "stable",
+    required: {
+      id: idField,
+      name: field("string", "Project display name."),
+      path: field("string", "Canonical project path."),
+      description: field(["string", "null"], "Optional project description.", true),
+      task_list_id: nullableIdField,
+      task_prefix: field(["string", "null"], "Optional task prefix.", true),
+      task_counter: field("integer", "Monotonic project task counter."),
+      created_at: isoDateField,
+      updated_at: isoDateField
+    },
+    optional: {
+      sources: field("array", "Optional project source records.")
+    }
+  }),
+  contract({
+    id: "agent",
+    name: "Agent",
+    description: "Registered agent identity and coordination metadata.",
+    surfaces: ["cli", "api", "mcp", "sdk"],
+    stability: "stable",
+    required: {
+      id: idField,
+      name: field("string", "Normalized agent name."),
+      description: field(["string", "null"], "Optional agent description.", true),
+      role: field(["string", "null"], "Agent role.", true),
+      permissions: field("array", "Permission labels."),
+      capabilities: field("array", "Capability labels."),
+      status: field("string", "Agent lifecycle status."),
+      created_at: isoDateField,
+      last_seen_at: isoDateField
+    },
+    optional: {
+      session_id: nullableIdField,
+      working_dir: field(["string", "null"], "Current working directory.", true),
+      active_project_id: nullableIdField
+    }
+  }),
+  contract({
+    id: "template",
+    name: "Task Template",
+    description: "Task template object used to create repeatable task plans.",
+    surfaces: ["cli", "api", "mcp", "sdk"],
+    stability: "stable",
+    required: {
+      id: idField,
+      name: field("string", "Template name."),
+      title_pattern: field("string", "Task title pattern."),
+      description: field(["string", "null"], "Optional template description.", true),
+      priority: field("string", "Default task priority."),
+      tags: tagsField,
+      variables: field("array", "Template variable definitions."),
+      version: field("integer", "Template version."),
+      project_id: nullableIdField,
+      plan_id: nullableIdField,
+      metadata: metadataField,
+      created_at: isoDateField
+    },
+    optional: {
+      tasks: field("array", "Expanded template task steps.")
+    }
+  }),
+  contract({
+    id: "task_list",
+    name: "Task List",
+    description: "Named task list, optionally scoped to a project.",
+    surfaces: ["cli", "api", "mcp", "sdk"],
+    stability: "stable",
+    required: {
+      id: idField,
+      project_id: nullableIdField,
+      slug: field("string", "Stable URL/CLI-safe list slug."),
+      name: field("string", "Task list display name."),
+      description: field(["string", "null"], "Optional list description.", true),
+      metadata: metadataField,
+      created_at: isoDateField,
+      updated_at: isoDateField
+    },
+    optional: {}
+  }),
+  contract({
+    id: "comment",
+    name: "Task Comment",
+    description: "Comment, progress update, or note attached to a task.",
+    surfaces: ["cli", "api", "mcp", "sdk"],
+    stability: "stable",
+    required: {
+      id: idField,
+      task_id: idField,
+      agent_id: nullableIdField,
+      session_id: nullableIdField,
+      content: field("string", "Comment body."),
+      type: field("string", "Comment type: comment, progress, or note."),
+      progress_pct: field(["integer", "number", "null"], "Progress percentage for progress entries.", true),
+      created_at: isoDateField
+    },
+    optional: {}
+  }),
+  contract({
+    id: "checkpoint",
+    name: "Task Run Checkpoint",
+    description: "Task runner checkpoint for a named execution step.",
+    surfaces: ["api", "mcp", "sdk"],
+    stability: "stable",
+    required: {
+      id: idField,
+      task_id: idField,
+      agent_id: nullableIdField,
+      step: field("string", "Runner step name."),
+      status: field("string", "Checkpoint execution status."),
+      data: metadataField,
+      error: field(["string", "null"], "Step error message when failed.", true),
+      attempt: field("integer", "Current attempt number."),
+      max_attempts: field("integer", "Maximum allowed attempts."),
+      started_at: nullableIsoDateField,
+      completed_at: nullableIsoDateField,
+      created_at: isoDateField,
+      updated_at: isoDateField
+    },
+    optional: {}
+  }),
+  contract({
+    id: "dispatch",
+    name: "Dispatch",
+    description: "Queued or completed tmux dispatch/run request.",
+    surfaces: ["cli", "mcp", "sdk"],
+    stability: "stable",
+    required: {
+      id: idField,
+      title: field(["string", "null"], "Optional dispatch title.", true),
+      target_window: field("string", "tmux target window."),
+      task_ids: field("array", "Task IDs included in the dispatch."),
+      task_list_id: nullableIdField,
+      message: field(["string", "null"], "Preformatted message, or null when generated from tasks.", true),
+      delay_ms: field(["integer", "null"], "Delay between send and Enter.", true),
+      scheduled_at: nullableIsoDateField,
+      status: field("string", "Dispatch status."),
+      error: field(["string", "null"], "Dispatch error when failed.", true),
+      created_at: isoDateField,
+      sent_at: nullableIsoDateField
+    },
+    optional: {}
+  }),
+  contract({
+    id: "audit_history",
+    name: "Audit History",
+    description: "Audit log entry for a task mutation.",
+    surfaces: ["cli", "api", "mcp", "sdk"],
+    stability: "stable",
+    required: {
+      id: idField,
+      task_id: idField,
+      action: field("string", "Mutation action name."),
+      field: field(["string", "null"], "Changed field name.", true),
+      old_value: field(["string", "null"], "Previous value serialized as a string.", true),
+      new_value: field(["string", "null"], "New value serialized as a string.", true),
+      agent_id: nullableIdField,
+      created_at: isoDateField
+    },
+    optional: {}
+  }),
+  contract({
+    id: "status_summary",
+    name: "Status Summary",
+    description: "Queue status counts and lightweight next/active work summary.",
+    surfaces: ["cli", "api", "mcp", "sdk"],
+    stability: "stable",
+    required: {
+      pending: field("integer", "Pending task count."),
+      in_progress: field("integer", "In-progress task count."),
+      completed: field("integer", "Completed task count."),
+      total: field("integer", "Total task count for the selected scope."),
+      active_work: field("array", "Lightweight active work items."),
+      next_task: field(["object", "null"], "Next available task, or null when none is available.", true),
+      stale_count: field("integer", "Count of stale in-progress tasks."),
+      overdue_recurring: field("integer", "Count of overdue recurring tasks.")
+    },
+    optional: {
+      blocked_tasks: field("array", "Optional blocked task explanation list.")
+    }
+  }),
+  contract({
+    id: "structured_error",
+    name: "Structured Error",
+    description: "Structured MCP/SDK-style error response with a stable machine code.",
+    surfaces: ["mcp", "sdk"],
+    stability: "stable",
+    required: {
+      code: field("string", "Stable machine-readable error code."),
+      message: field("string", "Human-readable error message.")
+    },
+    optional: {
+      suggestion: field("string", "Optional recovery suggestion."),
+      retryAfterSeconds: field("integer", "Optional retry delay for cooldown errors.")
+    }
+  }),
+  contract({
+    id: "api_error",
+    name: "API Error",
+    description: "HTTP API and CLI JSON error object for simple error responses.",
+    surfaces: ["cli", "api"],
+    stability: "stable",
+    required: {
+      error: field("string", "Human-readable error message.")
+    },
+    optional: {
+      code: field("string", "Optional machine-readable error code."),
+      conflict: field("boolean", "Optional conflict flag for registration errors."),
+      suggestions: field("array", "Optional recovery suggestions."),
+      retry_after: field("integer", "Optional retry delay for rate-limited responses.")
+    }
+  })
+];
+function expectedTypes(contract2) {
+  const types = Array.isArray(contract2.type) ? [...contract2.type] : [contract2.type];
+  if (contract2.nullable && !types.includes("null"))
+    return [...types, "null"];
+  return types;
+}
+function actualType(value) {
+  if (value === null)
+    return "null";
+  if (Array.isArray(value))
+    return "array";
+  if (typeof value === "number" && Number.isInteger(value))
+    return "integer";
+  if (typeof value === "number")
+    return "number";
+  if (typeof value === "boolean")
+    return "boolean";
+  if (typeof value === "string")
+    return "string";
+  if (typeof value === "object")
+    return "object";
+  return "string";
+}
+function matchesType(value, expected) {
+  const actual = actualType(value);
+  if (expected.includes(actual))
+    return true;
+  return actual === "integer" && expected.includes("number");
+}
+function getJsonContract(contractId) {
+  return TODOS_JSON_CONTRACTS.find((contractItem) => contractItem.id === contractId) ?? null;
+}
+function validateJsonContract(contractId, value) {
+  const contractItem = getJsonContract(contractId);
+  if (!contractItem) {
+    throw new Error(`Unknown JSON contract: ${contractId}`);
+  }
+  const record = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  const missingRequired = [];
+  const typeMismatches = [];
+  for (const [fieldName, fieldContract] of Object.entries(contractItem.required)) {
+    if (!(fieldName in record)) {
+      missingRequired.push(fieldName);
+      continue;
+    }
+    const expected = expectedTypes(fieldContract);
+    const valueType = actualType(record[fieldName]);
+    if (!matchesType(record[fieldName], expected)) {
+      typeMismatches.push({ field: fieldName, expected, actual: valueType });
+    }
+  }
+  return {
+    ok: missingRequired.length === 0 && typeMismatches.length === 0,
+    contractId,
+    missingRequired,
+    typeMismatches
+  };
+}
+function createJsonContractsManifest(options = {}) {
+  const version = options.version ?? getPackageVersion(import.meta.url);
+  return {
+    schemaVersion: 1,
+    generatedAt: options.generatedAt ?? new Date().toISOString(),
+    package: source(version),
+    contracts: TODOS_JSON_CONTRACTS
+  };
+}
+var TODOS_JSON_CONTRACTS_MANIFEST = createJsonContractsManifest({
+  generatedAt: "1970-01-01T00:00:00.000Z"
+});
+
+// src/contracts.ts
+init_types();
+var objectSchema = {
+  type: "object",
+  additionalProperties: true
+};
+var taskSchema = {
+  type: "object",
+  properties: {
+    id: { type: "string" },
+    title: { type: "string" },
+    status: { type: "string", enum: TASK_STATUSES },
+    priority: { type: "string", enum: TASK_PRIORITIES }
+  },
+  required: ["id", "title", "status", "priority"],
+  additionalProperties: true
+};
+var taskArraySchema = {
+  type: "array",
+  items: taskSchema
+};
+var TODOS_API_ROUTES = [
+  {
+    id: "health.read",
+    method: "GET",
+    path: "/api/health",
+    description: "Read local server health and stale task counts.",
+    auth: "optional-api-key",
+    requestSchema: null,
+    responseSchema: objectSchema,
+    tags: ["server", "health"],
+    stability: "stable"
+  },
+  {
+    id: "tasks.list",
+    method: "GET",
+    path: "/api/tasks",
+    description: "List tasks with query filters for status, project, session, agent, limit, and offset.",
+    auth: "optional-api-key",
+    requestSchema: null,
+    responseSchema: taskArraySchema,
+    tags: ["tasks", "query"],
+    stability: "stable"
+  },
+  {
+    id: "tasks.create",
+    method: "POST",
+    path: "/api/tasks",
+    description: "Create a task with a title, optional description, priority, and project.",
+    auth: "optional-api-key",
+    requestSchema: {
+      type: "object",
+      properties: {
+        title: { type: "string" },
+        description: { type: "string" },
+        priority: { type: "string", enum: TASK_PRIORITIES },
+        project_id: { type: "string" }
+      },
+      required: ["title"],
+      additionalProperties: false
+    },
+    responseSchema: taskSchema,
+    tags: ["tasks", "mutation"],
+    stability: "stable"
+  },
+  {
+    id: "tasks.read",
+    method: "GET",
+    path: "/api/tasks/:id",
+    description: "Read a single task by full or partial id.",
+    auth: "optional-api-key",
+    requestSchema: null,
+    responseSchema: taskSchema,
+    tags: ["tasks", "query"],
+    stability: "stable"
+  },
+  {
+    id: "tasks.update",
+    method: "PATCH",
+    path: "/api/tasks/:id",
+    description: "Update a task with optimistic locking through the current version.",
+    auth: "optional-api-key",
+    requestSchema: objectSchema,
+    responseSchema: taskSchema,
+    tags: ["tasks", "mutation"],
+    stability: "stable"
+  },
+  {
+    id: "tasks.complete",
+    method: "POST",
+    path: "/api/tasks/:id/complete",
+    description: "Mark a task complete and return its updated summary.",
+    auth: "optional-api-key",
+    requestSchema: null,
+    responseSchema: taskSchema,
+    tags: ["tasks", "workflow"],
+    stability: "stable"
+  },
+  {
+    id: "tasks.claim",
+    method: "POST",
+    path: "/api/tasks/claim",
+    description: "Atomically claim the next available task for an agent.",
+    auth: "optional-api-key",
+    requestSchema: {
+      type: "object",
+      properties: {
+        agent_id: { type: "string" },
+        project_id: { type: "string" }
+      },
+      additionalProperties: false
+    },
+    responseSchema: objectSchema,
+    tags: ["tasks", "agents", "workflow"],
+    stability: "stable"
+  },
+  {
+    id: "agents.register",
+    method: "POST",
+    path: "/api/agents",
+    description: "Register an agent for local task coordination.",
+    auth: "optional-api-key",
+    requestSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string" },
+        description: { type: "string" }
+      },
+      required: ["name"],
+      additionalProperties: true
+    },
+    responseSchema: objectSchema,
+    tags: ["agents"],
+    stability: "stable"
+  },
+  {
+    id: "plans.create",
+    method: "POST",
+    path: "/api/plans",
+    description: "Create a plan for grouping related task work.",
+    auth: "optional-api-key",
+    requestSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string" },
+        description: { type: "string" },
+        project_id: { type: "string" },
+        task_list_id: { type: "string" },
+        agent_id: { type: "string" },
+        status: { type: "string", enum: PLAN_STATUSES }
+      },
+      required: ["name"],
+      additionalProperties: false
+    },
+    responseSchema: objectSchema,
+    tags: ["plans"],
+    stability: "stable"
+  },
+  {
+    id: "streams.tasks",
+    method: "GET",
+    path: "/api/tasks/stream",
+    description: "Subscribe to server-sent task events with optional agent, project, and event filters.",
+    auth: "optional-api-key",
+    requestSchema: null,
+    responseSchema: {
+      type: "object",
+      properties: {
+        type: { type: "string" },
+        timestamp: { type: "string" }
+      },
+      additionalProperties: true
+    },
+    tags: ["tasks", "events"],
+    stability: "experimental"
+  }
+];
+var TODOS_ERROR_CODES = [
+  {
+    code: VersionConflictError.code,
+    name: "VersionConflictError",
+    suggestion: VersionConflictError.suggestion,
+    httpStatus: 409
+  },
+  {
+    code: TaskNotFoundError.code,
+    name: "TaskNotFoundError",
+    suggestion: TaskNotFoundError.suggestion,
+    httpStatus: 404
+  },
+  {
+    code: ProjectNotFoundError.code,
+    name: "ProjectNotFoundError",
+    suggestion: ProjectNotFoundError.suggestion,
+    httpStatus: 404
+  },
+  {
+    code: PlanNotFoundError.code,
+    name: "PlanNotFoundError",
+    suggestion: PlanNotFoundError.suggestion,
+    httpStatus: 404
+  },
+  {
+    code: LockError.code,
+    name: "LockError",
+    suggestion: LockError.suggestion,
+    httpStatus: 409
+  },
+  {
+    code: AgentNotFoundError.code,
+    name: "AgentNotFoundError",
+    suggestion: AgentNotFoundError.suggestion,
+    httpStatus: 404
+  },
+  {
+    code: TaskListNotFoundError.code,
+    name: "TaskListNotFoundError",
+    suggestion: TaskListNotFoundError.suggestion,
+    httpStatus: 404
+  },
+  {
+    code: DependencyCycleError.code,
+    name: "DependencyCycleError",
+    suggestion: DependencyCycleError.suggestion,
+    httpStatus: 409
+  },
+  {
+    code: CompletionGuardError.code,
+    name: "CompletionGuardError",
+    suggestion: CompletionGuardError.suggestion,
+    httpStatus: 409
+  },
+  {
+    code: DispatchNotFoundError.code,
+    name: "DispatchNotFoundError",
+    suggestion: DispatchNotFoundError.suggestion,
+    httpStatus: 404
+  }
+];
+function source2(version) {
+  return {
+    packageName: "@hasna/todos",
+    repository: "hasna/todos",
+    version
+  };
+}
+function createContractsManifest(options = {}) {
+  const version = options.version ?? getPackageVersion(import.meta.url);
+  const generatedAt = options.generatedAt ?? new Date().toISOString();
+  return {
+    schemaVersion: 1,
+    generatedAt,
+    package: source2(version),
+    values: {
+      taskStatuses: TASK_STATUSES,
+      taskPriorities: TASK_PRIORITIES,
+      planStatuses: PLAN_STATUSES,
+      dispatchStatuses: DISPATCH_STATUSES
+    },
+    apiRoutes: TODOS_API_ROUTES,
+    errorCodes: TODOS_ERROR_CODES,
+    jsonOutputs: createJsonContractsManifest({ version, generatedAt })
+  };
+}
+var TODOS_CONTRACTS = createContractsManifest({
+  generatedAt: "1970-01-01T00:00:00.000Z"
+});
+
+// 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"
+  ],
+  maintenance: ["extract_todos", "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);
+}
+
+// src/mcp.ts
+function source3(version) {
+  return {
+    packageName: "@hasna/todos",
+    repository: "hasna/todos",
+    version
+  };
+}
+function uniqueSorted(values) {
+  return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+function getAllMcpToolNames() {
+  return uniqueSorted(Object.values(MCP_TOOL_GROUPS).flatMap((tools) => [...tools]));
+}
+function groupsForTool(toolName) {
+  return Object.entries(MCP_TOOL_GROUPS).filter(([, tools]) => tools.includes(toolName)).map(([group]) => group).sort((left, right) => left.localeCompare(right));
+}
+function profilesForTool(toolName) {
+  return Object.entries(MCP_PROFILE_GROUPS).filter(([, groups]) => groups.some((group) => MCP_TOOL_GROUPS[group]?.includes(toolName))).map(([profile]) => profile).sort((left, right) => left.localeCompare(right));
+}
+function getMcpToolNames(options = {}) {
+  const profile = options.profile ?? "minimal";
+  const groups = options.groups ?? "";
+  return getAllMcpToolNames().filter((toolName) => shouldRegisterToolForProfile(toolName, profile, groups));
+}
+function createMcpManifest(options = {}) {
+  const version = options.version ?? getPackageVersion(import.meta.url);
+  return {
+    schemaVersion: 1,
+    generatedAt: options.generatedAt ?? new Date().toISOString(),
+    package: source3(version),
+    server: {
+      name: "todos",
+      binary: "todos-mcp",
+      transport: "stdio",
+      profileEnvironmentVariable: "TODOS_PROFILE",
+      groupEnvironmentVariable: "TODOS_TOOL_GROUPS"
+    },
+    groups: MCP_TOOL_GROUPS,
+    profiles: MCP_PROFILE_GROUPS,
+    tools: getAllMcpToolNames().map((toolName) => ({
+      name: toolName,
+      groups: groupsForTool(toolName),
+      profiles: profilesForTool(toolName),
+      core: CORE_MCP_TOOLS.has(toolName),
+      stability: CORE_MCP_TOOLS.has(toolName) ? "stable" : "experimental"
+    }))
+  };
+}
+var TODOS_MCP_MANIFEST = createMcpManifest({
+  generatedAt: "1970-01-01T00:00:00.000Z"
+});
+
+// src/capabilities.ts
+var packageName = "@hasna/todos";
+var repository = "hasna/todos";
+var objectSchema2 = {
+  type: "object",
+  additionalProperties: true
+};
+var taskSchema2 = {
+  type: "object",
+  properties: {
+    id: { type: "string" },
+    title: { type: "string" },
+    status: { type: "string" },
+    priority: { type: "string" }
+  },
+  required: ["id", "title", "status", "priority"],
+  additionalProperties: true
+};
+function source4(version) {
+  return { packageName, repository, version };
+}
+function capability(version, input) {
+  return {
+    ...input,
+    source: source4(version)
+  };
+}
+function buildCapabilities(version) {
+  return [
+    capability(version, {
+      id: "cli.add-task",
+      kind: "cli",
+      name: "todos add",
+      description: "Create a local task from the command line.",
+      tags: ["tasks", "cli", "local"],
+      docsPath: "README.md#cli",
+      stability: "stable",
+      inputSchema: {
+        type: "object",
+        properties: {
+          title: { type: "string" },
+          description: { type: "string" },
+          priority: { type: "string", enum: ["low", "medium", "high", "critical"] },
+          tags: { type: "array", items: { type: "string" } }
+        },
+        required: ["title"],
+        additionalProperties: false
+      },
+      outputSchema: taskSchema2
+    }),
+    capability(version, {
+      id: "cli.list-tasks",
+      kind: "cli",
+      name: "todos list",
+      description: "List local tasks with filters for status, priority, assignment, tags, and task lists.",
+      tags: ["tasks", "cli", "query"],
+      docsPath: "README.md#cli",
+      stability: "stable",
+      inputSchema: {
+        type: "object",
+        properties: {
+          status: { type: "string" },
+          priority: { type: "string" },
+          tags: { type: "array", items: { type: "string" } },
+          limit: { type: "number" }
+        },
+        additionalProperties: false
+      },
+      outputSchema: {
+        type: "array",
+        items: taskSchema2
+      }
+    }),
+    capability(version, {
+      id: "cli.show-task",
+      kind: "cli",
+      name: "todos show",
+      description: "Show full local task details by id or partial id.",
+      tags: ["tasks", "cli", "query"],
+      docsPath: "README.md#cli",
+      stability: "stable",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: { type: "string" }
+        },
+        required: ["id"],
+        additionalProperties: false
+      },
+      outputSchema: taskSchema2
+    }),
+    capability(version, {
+      id: "sdk.client",
+      kind: "sdk",
+      name: "createClient",
+      description: "Create a REST SDK client for cross-process and cross-machine task operations.",
+      tags: ["sdk", "api", "client"],
+      docsPath: "sdk/README.md",
+      stability: "stable",
+      inputSchema: {
+        type: "object",
+        properties: {
+          baseUrl: { type: "string" },
+          apiKey: { type: "string" }
+        },
+        required: ["baseUrl"],
+        additionalProperties: true
+      },
+      outputSchema: objectSchema2
+    }),
+    capability(version, {
+      id: "mcp.create-task",
+      kind: "mcp",
+      name: "create_task",
+      description: "Create a task through the MCP server.",
+      tags: ["mcp", "tasks", "create"],
+      docsPath: "README.md#mcp",
+      stability: "stable",
+      inputSchema: {
+        type: "object",
+        properties: {
+          title: { type: "string" },
+          description: { type: "string" },
+          priority: { type: "string", enum: ["low", "medium", "high", "critical"] },
+          project_id: { type: "string" },
+          tags: { type: "array", items: { type: "string" } }
+        },
+        required: ["title"],
+        additionalProperties: false
+      },
+      outputSchema: taskSchema2
+    }),
+    capability(version, {
+      id: "mcp.claim-next-task",
+      kind: "mcp",
+      name: "claim_next_task",
+      description: "Atomically claim and start the best available pending task for an agent.",
+      tags: ["mcp", "tasks", "agents", "workflow"],
+      docsPath: "README.md#mcp",
+      stability: "stable",
+      inputSchema: {
+        type: "object",
+        properties: {
+          agent_id: { type: "string" },
+          project_id: { type: "string" },
+          task_list_id: { type: "string" },
+          plan_id: { type: "string" },
+          tags: { type: "array", items: { type: "string" } }
+        },
+        required: ["agent_id"],
+        additionalProperties: false
+      },
+      outputSchema: taskSchema2
+    }),
+    capability(version, {
+      id: "mcp.get-status",
+      kind: "mcp",
+      name: "get_status",
+      description: "Read queue status or task-specific status through the MCP server.",
+      tags: ["mcp", "tasks", "status"],
+      docsPath: "README.md#mcp",
+      stability: "stable",
+      inputSchema: {
+        type: "object",
+        properties: {
+          task_id: { type: "string" },
+          project_id: { type: "string" },
+          task_list_id: { type: "string" },
+          agent_id: { type: "string" }
+        },
+        additionalProperties: false
+      },
+      outputSchema: objectSchema2
+    }),
+    capability(version, {
+      id: "server.local-api",
+      kind: "server",
+      name: "todos-serve",
+      description: "Start the local HTTP server for task APIs and dashboard support.",
+      tags: ["server", "api", "local"],
+      docsPath: "README.md#server",
+      stability: "experimental",
+      inputSchema: {
+        type: "object",
+        properties: {
+          port: { type: "number" },
+          host: { type: "string" }
+        },
+        additionalProperties: true
+      },
+      outputSchema: objectSchema2
+    })
+  ];
+}
+function createCapabilityManifest(options = {}) {
+  const version = options.version ?? getPackageVersion(import.meta.url);
+  return {
+    schemaVersion: 1,
+    generatedAt: options.generatedAt ?? new Date().toISOString(),
+    package: source4(version),
+    capabilities: buildCapabilities(version)
+  };
+}
+var TODOS_CAPABILITIES = createCapabilityManifest({
+  generatedAt: "1970-01-01T00:00:00.000Z"
+}).capabilities;
+
+// src/registry.ts
+var TODOS_PACKAGE_EXPORTS = [
+  {
+    subpath: ".",
+    import: "./dist/index.js",
+    types: "./dist/index.d.ts",
+    description: "Root SDK and local database exports kept for backward compatibility.",
+    stability: "stable"
+  },
+  {
+    subpath: "./sdk",
+    import: "./dist/sdk/index.js",
+    types: "./dist/sdk/index.d.ts",
+    description: "REST SDK client and SDK response/error types.",
+    stability: "stable"
+  },
+  {
+    subpath: "./mcp",
+    import: "./dist/mcp.js",
+    types: "./dist/mcp.d.ts",
+    description: "Side-effect-free MCP manifest, profile, and tool group contracts.",
+    stability: "stable"
+  },
+  {
+    subpath: "./registry",
+    import: "./dist/registry.js",
+    types: "./dist/registry.d.ts",
+    description: "Package registry manifest combining exports, capabilities, contracts, and MCP metadata.",
+    stability: "stable"
+  },
+  {
+    subpath: "./contracts",
+    import: "./dist/contracts.js",
+    types: "./dist/contracts.d.ts",
+    description: "Stable API, enum, and error contracts for integrations.",
+    stability: "stable"
+  },
+  {
+    subpath: "./storage",
+    import: "./dist/storage.js",
+    types: "./dist/storage.d.ts",
+    description: "Storage and service adapter contracts for local SQLite implementations.",
+    stability: "stable"
+  }
+];
+function source5(version) {
+  return {
+    packageName: "@hasna/todos",
+    repository: "hasna/todos",
+    version
+  };
+}
+function createTodosRegistry(options = {}) {
+  const version = options.version ?? getPackageVersion(import.meta.url);
+  const generatedAt = options.generatedAt ?? new Date().toISOString();
+  return {
+    schemaVersion: 1,
+    generatedAt,
+    package: source5(version),
+    exports: TODOS_PACKAGE_EXPORTS,
+    jsonContractDocsPath: "docs/json-contracts.md",
+    capabilities: createCapabilityManifest({ version, generatedAt }),
+    contracts: createContractsManifest({ version, generatedAt }),
+    mcp: createMcpManifest({ version, generatedAt })
+  };
+}
+var TODOS_REGISTRY = createTodosRegistry({
+  generatedAt: "1970-01-01T00:00:00.000Z"
+});
+export {
+  createTodosRegistry,
+  TODOS_REGISTRY,
+  TODOS_PACKAGE_EXPORTS
+};