@hasna/todos 0.11.82 → 0.11.84

package/dist/index.js

@@ -23525,7 +23525,19 @@ function createPostgresTodosStorageAdapter(options) {
       claimNext: (agentId, filters) => claimNextTask2(agentId, filters, store),
       getNext: (_agentId, filters) => getNextTask2(filters, store),
       getActiveWork: (filters) => getActiveWork2(filters, store),
-      getChangedSince: (since, filters) => getChangedSince(since, filters, store)
+      getChangedSince: (since, filters) => getChangedSince(since, filters, store),
+      lock: (id, agentId) => lockTask2(id, agentId, store),
+      unlock: (id, agentId) => unlockTask2(id, agentId, store)
+    },
+    dependencies: {
+      add: (taskId, dependsOn, context) => addDependency2(taskId, dependsOn, store, context),
+      remove: (taskId, dependsOn) => removeDependency2(taskId, dependsOn, store),
+      list: (taskId) => listDependencies(taskId, store),
+      listAll: () => store.list("dependencies")
+    },
+    verifications: {
+      add: (input, context) => addVerification(input, store, context),
+      list: (taskId) => listVerifications(taskId, store)
     },
     projects: {
       create: (input, context) => createProject2(input, store, context),
@@ -23980,6 +23992,104 @@ async function patchTask(task2, patch, store) {
   await store.upsert("tasks", updated);
   return updated;
 }
+var CLOUD_LOCK_EXPIRY_MINUTES = 30;
+function cloudLockExpired(lockedAt) {
+  if (!lockedAt)
+    return true;
+  return new Date(lockedAt).getTime() + CLOUD_LOCK_EXPIRY_MINUTES * 60 * 1000 < Date.now();
+}
+function cloudLockExpiresAt(lockedAt) {
+  return new Date(new Date(lockedAt).getTime() + CLOUD_LOCK_EXPIRY_MINUTES * 60 * 1000).toISOString();
+}
+async function lockTask2(id, agentId, store) {
+  const task2 = await requireRecord("tasks", id, store);
+  if (task2.status === "completed" || task2.status === "cancelled") {
+    return { success: false, error: `Task is ${task2.status} and cannot be locked` };
+  }
+  if (task2.locked_by && task2.locked_by !== agentId && !cloudLockExpired(task2.locked_at)) {
+    return { success: false, locked_by: task2.locked_by, locked_at: task2.locked_at ?? undefined, error: `Task is locked by ${task2.locked_by}` };
+  }
+  const timestamp2 = new Date().toISOString();
+  await patchTask(task2, { locked_by: agentId, locked_at: timestamp2 }, store);
+  return { success: true, locked_by: agentId, locked_at: timestamp2, expires_at: cloudLockExpiresAt(timestamp2) };
+}
+async function unlockTask2(id, agentId, store) {
+  const task2 = await requireRecord("tasks", id, store);
+  if (agentId && task2.locked_by && task2.locked_by !== agentId) {
+    throw new Error(`Task ${id} is locked by ${task2.locked_by}, not ${agentId}`);
+  }
+  await patchTask(task2, { locked_by: null, locked_at: null }, store);
+  return true;
+}
+function dependencyId(taskId, dependsOn) {
+  return `${taskId}::${dependsOn}`;
+}
+async function addDependency2(taskId, dependsOn, store, context) {
+  if (taskId === dependsOn)
+    throw new Error("A task cannot depend on itself");
+  if (!await store.get("tasks", taskId))
+    throw new Error(`Task not found: ${taskId}`);
+  if (!await store.get("tasks", dependsOn))
+    throw new Error(`Task not found: ${dependsOn}`);
+  const edges = await store.list("dependencies");
+  const adjacency = new Map;
+  for (const edge of edges) {
+    if (!adjacency.has(edge.task_id))
+      adjacency.set(edge.task_id, []);
+    adjacency.get(edge.task_id).push(edge.depends_on);
+  }
+  const queue = [dependsOn];
+  const seen = new Set;
+  while (queue.length) {
+    const node = queue.shift();
+    if (node === taskId)
+      throw new Error(`Adding dependency ${taskId} -> ${dependsOn} would create a cycle`);
+    if (seen.has(node))
+      continue;
+    seen.add(node);
+    for (const next of adjacency.get(node) ?? [])
+      queue.push(next);
+  }
+  const timestamp2 = new Date().toISOString();
+  const record = { id: dependencyId(taskId, dependsOn), task_id: taskId, depends_on: dependsOn, created_at: timestamp2, updated_at: timestamp2 };
+  await store.upsert("dependencies", record, context);
+  return { task_id: taskId, depends_on: dependsOn };
+}
+async function removeDependency2(taskId, dependsOn, store) {
+  const existing = await store.get("dependencies", dependencyId(taskId, dependsOn));
+  if (!existing)
+    return false;
+  await store.delete("dependencies", dependencyId(taskId, dependsOn));
+  return true;
+}
+async function listDependencies(taskId, store) {
+  const edges = await store.list("dependencies");
+  return {
+    dependencies: edges.filter((edge) => edge.task_id === taskId).map((edge) => ({ task_id: edge.task_id, depends_on: edge.depends_on })),
+    blocked_by: edges.filter((edge) => edge.depends_on === taskId).map((edge) => ({ task_id: edge.task_id, depends_on: edge.depends_on }))
+  };
+}
+async function addVerification(input, store, context) {
+  if (!await store.get("tasks", input.task_id))
+    throw new Error(`Task not found: ${input.task_id}`);
+  const timestamp2 = new Date().toISOString();
+  const verification = {
+    id: randomUUID3(),
+    task_id: input.task_id,
+    command: input.command,
+    status: input.status ?? "unknown",
+    output_summary: input.output_summary ?? null,
+    artifact_path: input.artifact_path ?? null,
+    agent_id: input.agent_id ?? context?.agentId ?? null,
+    run_at: timestamp2,
+    created_at: timestamp2
+  };
+  await store.upsert("verifications", { ...verification, updated_at: timestamp2 }, context);
+  return verification;
+}
+async function listVerifications(taskId, store) {
+  return (await store.list("verifications")).filter((verification) => verification.task_id === taskId).sort((a, b) => b.run_at.localeCompare(a.run_at));
+}
 var TASK_ORDER_BY = "ORDER BY CASE payload->>'priority' WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 ELSE 4 END ASC, payload->>'created_at' ASC, payload->>'id' ASC";
 function toFilterArray(value) {
   return Array.isArray(value) ? value : [value];
@@ -31783,13 +31893,13 @@ function importTodosMarkdown(markdown, options = {}, db) {
     if (!taskId)
       continue;
     for (const dependencyTitle of item.depends_on_titles) {
-      const dependencyId = taskByTitle.get(dependencyTitle);
-      if (!dependencyId) {
+      const dependencyId2 = taskByTitle.get(dependencyTitle);
+      if (!dependencyId2) {
         skipped.task_dependencies++;
         issues.push(`missing dependency task: ${dependencyTitle}`);
         continue;
       }
-      addDependency(taskId, dependencyId, d);
+      addDependency(taskId, dependencyId2, d);
       inserted.task_dependencies++;
     }
   }

package/dist/mcp/index.js

@@ -22863,6 +22863,13 @@ async function cloudCountTasks(client, filter = {}) {
   const tasks = await cloudListTasks(client, rest);
   return tasks.length;
 }
+async function cloudRegisterAgent(client, input) {
+  const raw = await client.transport.post("/agents", input);
+  if (raw && typeof raw === "object" && "agent" in raw) {
+    return raw.agent;
+  }
+  return raw;
+}
 var _cache;
 var init_cloud_router = __esm(() => {
   init_storage();
@@ -44195,6 +44202,33 @@ function registerAgentTools(server, { shouldRegisterTool, resolveId, formatError
       force: exports_external.boolean().optional().describe("Force takeover of an active agent's name. Use with caution \u2014 only when you know the previous session is dead.")
     }, async ({ name, description, role, title, level, permissions, capabilities, session_id, working_dir, force }) => {
       try {
+        const cloud = getTodosCloudClient();
+        if (cloud) {
+          const agent2 = await cloudRegisterAgent(cloud, {
+            name,
+            description,
+            role,
+            title,
+            level,
+            permissions,
+            capabilities,
+            session_id,
+            working_dir,
+            force
+          });
+          return {
+            content: [{
+              type: "text",
+              text: `Agent registered:
+ID: ${agent2.id}
+Name: ${agent2.name}${agent2.description ? `
+Description: ${agent2.description}` : ""}
+Session: ${agent2.session_id ?? "unbound"}
+Created: ${agent2.created_at}
+Last seen: ${agent2.last_seen_at}`
+            }]
+          };
+        }
         const pool = getAgentPoolForProject(working_dir);
         const result = registerAgent({ name, description, role, title, level, permissions, capabilities, session_id, working_dir, force, pool: pool || undefined });
         if (isAgentConflict(result)) {
@@ -48094,7 +48128,19 @@ function createPostgresTodosStorageAdapter(options) {
       claimNext: (agentId, filters) => claimNextTask2(agentId, filters, store),
       getNext: (_agentId, filters) => getNextTask2(filters, store),
       getActiveWork: (filters) => getActiveWork2(filters, store),
-      getChangedSince: (since, filters) => getChangedSince(since, filters, store)
+      getChangedSince: (since, filters) => getChangedSince(since, filters, store),
+      lock: (id, agentId) => lockTask2(id, agentId, store),
+      unlock: (id, agentId) => unlockTask2(id, agentId, store)
+    },
+    dependencies: {
+      add: (taskId, dependsOn, context) => addDependency2(taskId, dependsOn, store, context),
+      remove: (taskId, dependsOn) => removeDependency2(taskId, dependsOn, store),
+      list: (taskId) => listDependencies(taskId, store),
+      listAll: () => store.list("dependencies")
+    },
+    verifications: {
+      add: (input, context) => addVerification(input, store, context),
+      list: (taskId) => listVerifications(taskId, store)
     },
     projects: {
       create: (input, context) => createProject2(input, store, context),
@@ -48549,6 +48595,103 @@ async function patchTask(task2, patch, store) {
   await store.upsert("tasks", updated);
   return updated;
 }
+function cloudLockExpired(lockedAt) {
+  if (!lockedAt)
+    return true;
+  return new Date(lockedAt).getTime() + CLOUD_LOCK_EXPIRY_MINUTES * 60 * 1000 < Date.now();
+}
+function cloudLockExpiresAt(lockedAt) {
+  return new Date(new Date(lockedAt).getTime() + CLOUD_LOCK_EXPIRY_MINUTES * 60 * 1000).toISOString();
+}
+async function lockTask2(id, agentId, store) {
+  const task2 = await requireRecord("tasks", id, store);
+  if (task2.status === "completed" || task2.status === "cancelled") {
+    return { success: false, error: `Task is ${task2.status} and cannot be locked` };
+  }
+  if (task2.locked_by && task2.locked_by !== agentId && !cloudLockExpired(task2.locked_at)) {
+    return { success: false, locked_by: task2.locked_by, locked_at: task2.locked_at ?? undefined, error: `Task is locked by ${task2.locked_by}` };
+  }
+  const timestamp3 = new Date().toISOString();
+  await patchTask(task2, { locked_by: agentId, locked_at: timestamp3 }, store);
+  return { success: true, locked_by: agentId, locked_at: timestamp3, expires_at: cloudLockExpiresAt(timestamp3) };
+}
+async function unlockTask2(id, agentId, store) {
+  const task2 = await requireRecord("tasks", id, store);
+  if (agentId && task2.locked_by && task2.locked_by !== agentId) {
+    throw new Error(`Task ${id} is locked by ${task2.locked_by}, not ${agentId}`);
+  }
+  await patchTask(task2, { locked_by: null, locked_at: null }, store);
+  return true;
+}
+function dependencyId(taskId, dependsOn) {
+  return `${taskId}::${dependsOn}`;
+}
+async function addDependency2(taskId, dependsOn, store, context) {
+  if (taskId === dependsOn)
+    throw new Error("A task cannot depend on itself");
+  if (!await store.get("tasks", taskId))
+    throw new Error(`Task not found: ${taskId}`);
+  if (!await store.get("tasks", dependsOn))
+    throw new Error(`Task not found: ${dependsOn}`);
+  const edges = await store.list("dependencies");
+  const adjacency = new Map;
+  for (const edge of edges) {
+    if (!adjacency.has(edge.task_id))
+      adjacency.set(edge.task_id, []);
+    adjacency.get(edge.task_id).push(edge.depends_on);
+  }
+  const queue = [dependsOn];
+  const seen = new Set;
+  while (queue.length) {
+    const node = queue.shift();
+    if (node === taskId)
+      throw new Error(`Adding dependency ${taskId} -> ${dependsOn} would create a cycle`);
+    if (seen.has(node))
+      continue;
+    seen.add(node);
+    for (const next of adjacency.get(node) ?? [])
+      queue.push(next);
+  }
+  const timestamp3 = new Date().toISOString();
+  const record = { id: dependencyId(taskId, dependsOn), task_id: taskId, depends_on: dependsOn, created_at: timestamp3, updated_at: timestamp3 };
+  await store.upsert("dependencies", record, context);
+  return { task_id: taskId, depends_on: dependsOn };
+}
+async function removeDependency2(taskId, dependsOn, store) {
+  const existing = await store.get("dependencies", dependencyId(taskId, dependsOn));
+  if (!existing)
+    return false;
+  await store.delete("dependencies", dependencyId(taskId, dependsOn));
+  return true;
+}
+async function listDependencies(taskId, store) {
+  const edges = await store.list("dependencies");
+  return {
+    dependencies: edges.filter((edge) => edge.task_id === taskId).map((edge) => ({ task_id: edge.task_id, depends_on: edge.depends_on })),
+    blocked_by: edges.filter((edge) => edge.depends_on === taskId).map((edge) => ({ task_id: edge.task_id, depends_on: edge.depends_on }))
+  };
+}
+async function addVerification(input, store, context) {
+  if (!await store.get("tasks", input.task_id))
+    throw new Error(`Task not found: ${input.task_id}`);
+  const timestamp3 = new Date().toISOString();
+  const verification = {
+    id: randomUUID3(),
+    task_id: input.task_id,
+    command: input.command,
+    status: input.status ?? "unknown",
+    output_summary: input.output_summary ?? null,
+    artifact_path: input.artifact_path ?? null,
+    agent_id: input.agent_id ?? context?.agentId ?? null,
+    run_at: timestamp3,
+    created_at: timestamp3
+  };
+  await store.upsert("verifications", { ...verification, updated_at: timestamp3 }, context);
+  return verification;
+}
+async function listVerifications(taskId, store) {
+  return (await store.list("verifications")).filter((verification) => verification.task_id === taskId).sort((a, b) => b.run_at.localeCompare(a.run_at));
+}
 function toFilterArray(value) {
   return Array.isArray(value) ? value : [value];
 }
@@ -48922,7 +49065,7 @@ function compareClock(left, right) {
 function numberValue3(value) {
   return typeof value === "number" && Number.isSafeInteger(value) ? value : null;
 }
-var TASK_ORDER_BY = "ORDER BY CASE payload->>'priority' WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 ELSE 4 END ASC, payload->>'created_at' ASC, payload->>'id' ASC";
+var CLOUD_LOCK_EXPIRY_MINUTES = 30, TASK_ORDER_BY = "ORDER BY CASE payload->>'priority' WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 ELSE 4 END ASC, payload->>'created_at' ASC, payload->>'id' ASC";
 var init_postgres_adapter = () => {};
 
 // src/server/cloud.ts
@@ -49420,6 +49563,7 @@ async function handleV1Request(req, url) {
   const resource = segments[1];
   const id = segments[2];
   const action = segments[3];
+  const subId = segments[4];
   try {
     if (resource === "tasks") {
       if (id === "exists" && !action) {
@@ -49495,6 +49639,89 @@ async function handleV1Request(req, url) {
           }
           return error(405, `method ${method} not allowed on /v1/tasks/:id/comments`);
         }
+        if (action === "lock" || action === "unlock") {
+          if (method !== "POST")
+            return error(405, `method ${method} not allowed on /v1/tasks/:id/${action}`);
+          if (typeof store.tasks.lock !== "function" || typeof store.tasks.unlock !== "function") {
+            return error(501, "task locking is not supported by this storage backend");
+          }
+          const body2 = await readJson(req) ?? {};
+          if (!await store.tasks.get(id))
+            return error(404, "task not found");
+          if (action === "lock") {
+            const agentId2 = body2.agent_id || principal.agent || "todos-serve";
+            return json2({ result: await store.tasks.lock(id, agentId2) });
+          }
+          const released = await store.tasks.unlock(id, body2.agent_id || principal.agent || undefined);
+          return json2({ success: released });
+        }
+        if (action === "dependencies") {
+          if (!store.dependencies)
+            return error(501, "dependencies are not supported by this storage backend");
+          if (method === "GET") {
+            if (!await store.tasks.get(id))
+              return error(404, "task not found");
+            const edges = await store.dependencies.list(id);
+            return json2(edges);
+          }
+          if (method === "POST") {
+            const body2 = await readJson(req) ?? {};
+            if (typeof body2.depends_on !== "string" || !body2.depends_on.trim()) {
+              return error(400, "depends_on is required");
+            }
+            try {
+              const dependency = await store.dependencies.add(id, body2.depends_on, contextFromPrincipal(principal));
+              return json2({ dependency }, 201);
+            } catch (e) {
+              const msg = e.message || "";
+              if (msg.includes("not found"))
+                return error(404, msg);
+              if (msg.includes("cycle") || msg.includes("itself"))
+                return error(409, msg);
+              throw e;
+            }
+          }
+          if (method === "DELETE") {
+            if (!subId)
+              return error(400, "dependency target id is required (/v1/tasks/:id/dependencies/:dep)");
+            const removed = await store.dependencies.remove(id, subId);
+            return json2({ removed });
+          }
+          return error(405, `method ${method} not allowed on /v1/tasks/:id/dependencies`);
+        }
+        if (action === "verifications") {
+          if (!store.verifications)
+            return error(501, "verifications are not supported by this storage backend");
+          if (method === "GET") {
+            if (!await store.tasks.get(id))
+              return error(404, "task not found");
+            const verifications = await store.verifications.list(id);
+            return json2({ verifications, count: verifications.length });
+          }
+          if (method === "POST") {
+            const body2 = await readJson(req) ?? {};
+            if (typeof body2.command !== "string" || !body2.command.trim()) {
+              return error(400, "command is required");
+            }
+            try {
+              const verification = await store.verifications.add({
+                task_id: id,
+                command: body2.command,
+                status: body2.status,
+                output_summary: body2.output_summary,
+                artifact_path: body2.artifact_path,
+                agent_id: body2.agent_id
+              }, contextFromPrincipal(principal, body2));
+              return json2({ verification }, 201);
+            } catch (e) {
+              const msg = e.message || "";
+              if (msg.includes("not found"))
+                return error(404, msg);
+              throw e;
+            }
+          }
+          return error(405, `method ${method} not allowed on /v1/tasks/:id/verifications`);
+        }
         const body = await readJson(req) ?? {};
         const agentId = body.agent_id || principal.agent || "todos-serve";
         if (action === "start" && method === "POST") {
@@ -49599,16 +49826,55 @@ async function handleV1Request(req, url) {
       }
       if (!id && method === "POST") {
         const body = await readJson(req);
-        if (!body || typeof body.name !== "string")
+        if (!body || typeof body.name !== "string" || !body.name.trim())
           return error(400, "name is required");
-        const agent = await store.agents.register(body, contextFromPrincipal(principal));
-        return json2({ agent }, 201);
+        const result = await store.agents.register(body, contextFromPrincipal(principal));
+        if (result && typeof result === "object" && "conflict" in result) {
+          return error(409, result.message ?? "agent name conflict", { conflict: true });
+        }
+        return json2({ agent: result }, 201);
       }
       if (id && method === "GET") {
         const agent = await store.agents.get(id);
         return agent ? json2({ agent }) : error(404, "agent not found");
       }
     }
+    if (resource === "activity" && !id) {
+      if (method !== "GET")
+        return error(405, `method ${method} not allowed on /v1/activity`);
+      const limitParam = url.searchParams.get("limit");
+      const limit = limitParam ? Math.max(1, Math.min(1e4, Number(limitParam) || 50)) : 50;
+      const activity = await store.audit.getRecentActivity(limit);
+      return json2({ activity, count: activity.length });
+    }
+    if (resource === "task-lists" && !id) {
+      if (method !== "GET")
+        return error(405, `method ${method} not allowed on /v1/task-lists`);
+      const projectId = url.searchParams.get("project_id") ?? undefined;
+      const taskLists = await store.taskLists.list(projectId);
+      return json2({ task_lists: taskLists, count: taskLists.length });
+    }
+    if (resource === "dependencies" && !id) {
+      if (method !== "GET")
+        return error(405, `method ${method} not allowed on /v1/dependencies`);
+      if (typeof store.dependencies?.listAll !== "function") {
+        return error(501, "dependency edge listing is not supported by this storage backend");
+      }
+      const dependencies = await store.dependencies.listAll();
+      return json2({ dependencies, count: dependencies.length });
+    }
+    if (resource === "next" && !id) {
+      if (method !== "GET")
+        return error(405, `method ${method} not allowed on /v1/next`);
+      const agent = url.searchParams.get("agent") ?? undefined;
+      const filters = {
+        ...url.searchParams.get("project_id") ? { project_id: url.searchParams.get("project_id") } : {},
+        ...url.searchParams.get("task_list_id") ? { task_list_id: url.searchParams.get("task_list_id") } : {},
+        ...url.searchParams.get("plan_id") ? { plan_id: url.searchParams.get("plan_id") } : {}
+      };
+      const task2 = await store.tasks.getNext(agent, filters);
+      return json2({ task: task2 ?? null });
+    }
     if (resource === "stats" && method === "GET") {
       const [tasks, tasksAll, projects] = await Promise.all([
         store.tasks.count(),

package/dist/mcp/tools/agents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../../src/mcp/tools/agents.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAOzE,UAAU,UAAU;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,KAAK,OAAO,GAAG;IACb,kBAAkB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IAC9C,SAAS,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAClD,WAAW,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,MAAM,CAAC;IACpC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACvC,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,UAAU,GAAG,SAAS,CAAC;CAC5D,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,kBAAkB,EAAE,SAAS,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,EAAE,OAAO,GAAG,IAAI,CA6bjJ"}
+{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../../src/mcp/tools/agents.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAOzE,UAAU,UAAU;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,KAAK,OAAO,GAAG;IACb,kBAAkB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IAC9C,SAAS,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAClD,WAAW,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,MAAM,CAAC;IACpC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACvC,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,UAAU,GAAG,SAAS,CAAC;CAC5D,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,kBAAkB,EAAE,SAAS,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,EAAE,OAAO,GAAG,IAAI,CA6cjJ"}

package/dist/release-provenance.json

@@ -1,7 +1,7 @@
 {
   "packageName": "@hasna/todos",
-  "packageVersion": "0.11.82",
+  "packageVersion": "0.11.84",
   "repository": "https://github.com/hasna/todos.git",
-  "gitCommit": "c6e5695eeb5700d03c6c7f70b722fdb18dc60e32",
-  "generatedAt": "2026-07-08T13:21:23.262Z"
+  "gitCommit": "f7fcea3d57bf87853fcc48b009019733b2206ca7",
+  "generatedAt": "2026-07-08T15:23:54.541Z"
 }