@hasna/todos 0.11.37 → 0.11.39

package/dist/contracts.js

@@ -0,0 +1,823 @@
+// @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"
+});
+export {
+  validateJsonContract,
+  getJsonContract,
+  createJsonContractsManifest,
+  createContractsManifest,
+  TODOS_JSON_CONTRACTS_MANIFEST,
+  TODOS_JSON_CONTRACTS,
+  TODOS_ERROR_CODES,
+  TODOS_CONTRACTS,
+  TODOS_API_ROUTES
+};