@wrongstack/tools 0.310.1 → 0.313.1

package/dist/chunk-IXMNTNW5.js

@@ -0,0 +1,238 @@
+import {
+  ALLOW_PRIVATE,
+  assertNotPrivate,
+  guardedFetch
+} from "./chunk-NBDZMMG2.js";
+import {
+  truncateMiddle
+} from "./chunk-D33S4RQG.js";
+
+// src/fetch.ts
+import { FetchError, ToolError, ToolValidationError } from "@wrongstack/core/types";
+import TurndownService from "turndown";
+var TD = new TurndownService({
+  // Use `# Title` for headings, not setext underline style (`Title\n=====`).
+  headingStyle: "atx",
+  // Don't wrap code blocks in <pre> — render them as triple-backtick blocks.
+  codeBlockStyle: "fenced"
+});
+TD.addRule("stripDangerousElements", {
+  filter: ["script", "style", "noscript"],
+  replacement: () => ""
+});
+var PRUNED_BOILERPLATE_TAGS = /* @__PURE__ */ new Set(["nav", "header", "footer", "aside", "svg", "iframe"]);
+TD.remove((node) => PRUNED_BOILERPLATE_TAGS.has(node.nodeName.toLowerCase()));
+var MAX_BYTES = 131072;
+var TIMEOUT_MS = 2e4;
+var combineSignals = (signals) => AbortSignal.any(signals);
+var fetchTool = {
+  name: "fetch",
+  category: "Network",
+  description: "Fetch a URL and return its content. HTML pages are automatically converted to clean markdown. This tool has strong SSRF protections (private IPs, localhost, and cloud metadata endpoints are blocked by default).",
+  usageHint: "Use this when you need external information (documentation, API responses, web pages, etc.).\n\nSecurity notes:\n- Only HTTPS is allowed by default.\n- Internal/private networks are blocked unless explicitly enabled via environment variable.\n- Redirects are followed but re-validated at each hop.\n- Output is capped (128KB by default) to avoid flooding context.\nPrefer this over raw `bash curl` or `bash wget`.",
+  permission: "auto",
+  mutating: false,
+  capabilities: ["net.outbound"],
+  icon: "web",
+  // Trust rules for fetch match on the literal URL — declare it explicitly
+  // so a user can trust `https://api.example.com/*` without accidentally
+  // matching that pattern on any other tool that happens to have a `url`
+  // input field.
+  subjectKey: "url",
+  timeoutMs: TIMEOUT_MS,
+  maxOutputBytes: MAX_BYTES,
+  inputSchema: {
+    type: "object",
+    properties: {
+      url: {
+        type: "string",
+        description: "The target URL (must use https://)."
+      },
+      format: {
+        type: "string",
+        enum: ["markdown", "text", "raw"],
+        description: 'Output format. "markdown" is recommended for HTML pages; for non-HTML content types it falls back to plain text (JSON is pretty-printed).'
+      }
+    },
+    required: ["url"]
+  },
+  async execute(input, ctx, opts) {
+    let final;
+    const executeStream = fetchTool.executeStream;
+    if (!executeStream) {
+      throw new ToolError({
+        message: "fetchTool: stream execution unavailable",
+        code: "TOOL_EXECUTION_FAILED",
+        toolName: "fetch"
+      });
+    }
+    for await (const ev of executeStream(input, ctx, opts)) {
+      if (ev.type === "final") final = ev.output;
+    }
+    if (!final) {
+      throw new ToolError({
+        message: "fetch: stream ended without final event",
+        code: "TOOL_EXECUTION_FAILED",
+        toolName: "fetch"
+      });
+    }
+    return final;
+  },
+  async *executeStream(input, ctx, opts) {
+    if (!input?.url) {
+      throw new ToolValidationError({
+        message: "fetch: url is required",
+        field: "url"
+      });
+    }
+    const u = new URL(input.url);
+    if (u.username || u.password) {
+      throw new ToolValidationError({
+        message: "fetch: URLs with embedded credentials (user:pass@host) are not allowed",
+        field: "url"
+      });
+    }
+    if (u.protocol !== "https:" && u.protocol !== "http:") {
+      throw new ToolValidationError({
+        message: `fetch: unsupported protocol "${u.protocol}"`,
+        field: "url"
+      });
+    }
+    if (u.protocol === "http:" && !ALLOW_PRIVATE) {
+      throw new ToolValidationError({
+        message: "fetch: http:// blocked (HTTPS required by default)",
+        field: "url"
+      });
+    }
+    await assertNotPrivate(u.hostname);
+    yield { type: "log", text: `GET ${input.url}` };
+    const ctrl = new AbortController();
+    const timer = setTimeout(
+      () => ctrl.abort(
+        new ToolError({
+          message: "fetch timeout",
+          code: "TOOL_TIMEOUT",
+          toolName: "fetch"
+        })
+      ),
+      TIMEOUT_MS
+    );
+    const combined = combineSignals([opts.signal, ctrl.signal]);
+    try {
+      let res;
+      try {
+        res = await guardedFetch(input.url, 5, combined);
+      } catch (err) {
+        if (opts.signal.aborted) throw err;
+        throw describeFetchError(err, input.url, ctrl.signal.aborted);
+      }
+      const ct = res.headers.get("content-type") ?? "application/octet-stream";
+      if (/^image\/|^audio\/|^video\/|application\/octet-stream/.test(ct)) {
+        throw new FetchError({
+          message: `fetch: refusing to read binary content-type "${ct}"`,
+          status: res.status,
+          context: { url: res.url, contentType: ct }
+        });
+      }
+      yield {
+        type: "log",
+        text: `HTTP ${res.status} ${ct}`,
+        data: { status: res.status, contentType: ct }
+      };
+      const reader = res.body?.getReader();
+      let received = 0;
+      const chunks = [];
+      let pendingBytes = 0;
+      const FLUSH_AT = 4 * 1024;
+      if (reader) {
+        for (; ; ) {
+          const { value, done } = await reader.read();
+          if (done) break;
+          if (!value) continue;
+          received += value.byteLength;
+          pendingBytes += value.byteLength;
+          chunks.push(value);
+          if (pendingBytes >= FLUSH_AT) {
+            const recent = Buffer.from(value).toString("utf-8");
+            yield {
+              type: "partial_output",
+              text: recent,
+              data: { received }
+            };
+            pendingBytes = 0;
+          }
+          if (received > MAX_BYTES) break;
+        }
+      }
+      const text = Buffer.concat(chunks.map((c) => Buffer.from(c))).toString("utf8");
+      const format = input.format ?? (ct.includes("text/html") ? "markdown" : "text");
+      let content;
+      if (format === "raw") content = text;
+      else if (format === "markdown" && ct.includes("text/html")) content = TD.turndown(text);
+      else if (ct.includes("application/json")) content = prettyJson(text);
+      else content = text;
+      yield {
+        type: "final",
+        output: {
+          content: truncateMiddle(content, MAX_BYTES),
+          status: res.status,
+          content_type: ct,
+          url: res.url
+        }
+      };
+      ctx.recordSideEffect?.({
+        toolUseId: `fetch-${Date.now()}`,
+        toolName: "fetch",
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        input: { url: input.url, format: input.format },
+        outcome: `HTTP ${res.status} (${ct})`,
+        risk: "network"
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+function describeFetchError(err, url, timedOut) {
+  if (timedOut) {
+    return new ToolError({
+      message: `fetch: GET ${url} timed out after ${TIMEOUT_MS}ms`,
+      code: "TOOL_TIMEOUT",
+      toolName: "fetch",
+      context: { url, timedOut: true, timeoutMs: TIMEOUT_MS },
+      cause: err
+    });
+  }
+  const parts = [];
+  const seen = /* @__PURE__ */ new Set();
+  let cur = err;
+  while (cur instanceof Error && !seen.has(cur)) {
+    seen.add(cur);
+    const code = cur.code;
+    const label = code ? `${code}: ${cur.message}` : cur.message;
+    if (label && label !== "fetch failed" && !parts.includes(label)) parts.push(label);
+    cur = cur.cause;
+  }
+  const detail = parts.length > 0 ? parts.join(" \u2192 ") : "fetch failed";
+  return new FetchError({
+    message: `fetch: GET ${url} failed \u2014 ${detail}`,
+    status: 502,
+    context: { url, timedOut: false, transportErrors: parts },
+    // Preserve the original undici / DNS / TLS chain so callers can inspect
+    // it via `err.cause` and structured `instanceof` checks. The flattened
+    // text version stays in the message for human readability.
+    cause: err
+  });
+}
+function prettyJson(s) {
+  try {
+    return JSON.stringify(JSON.parse(s), null, 2);
+  } catch {
+    return s;
+  }
+}
+
+export {
+  fetchTool
+};
+//# sourceMappingURL=chunk-IXMNTNW5.js.map

package/dist/chunk-J4SRJKBW.js

@@ -0,0 +1,428 @@
+import {
+  kanbanTool
+} from "./chunk-55KF77OK.js";
+import {
+  applyManagedKanbanBoardToTodos,
+  blockingTitles,
+  mirrorSessionTodosToKanban,
+  takeSessionMirrorFailure
+} from "./chunk-QNJ7AQ4B.js";
+
+// src/todo.ts
+import {
+  loadPlan,
+  loadTasks,
+  savePlan,
+  saveTasks,
+  setPlanItemStatus
+} from "@wrongstack/core/storage";
+import { addTask, getBoard } from "@wrongstack/kanban";
+function normalizedTitle(value) {
+  return value.trim().toLocaleLowerCase().replace(/\s+/g, " ");
+}
+function activeBoardId(items, ctx) {
+  const metaKanban = ctx.meta?.["kanban"];
+  const metaBoardId = metaKanban && typeof metaKanban === "object" ? metaKanban["boardId"] : void 0;
+  return ctx.currentKanbanBoardId ?? (typeof metaBoardId === "string" ? metaBoardId : void 0) ?? items.find((item) => item.kanbanBoardId)?.kanbanBoardId ?? "";
+}
+function bindTodosToBoard(items, previous, board) {
+  const previousById = new Map(previous.map((item) => [item.id, item]));
+  const available = board.tasks.filter(
+    (task) => task.status !== "archived" && task.mergedIntoTaskId === void 0 && (!task.childTaskIds || task.childTaskIds.length === 0)
+  ).sort(
+    (left, right) => left.createdAt.localeCompare(right.createdAt) || left.order - right.order
+  );
+  const used = /* @__PURE__ */ new Set();
+  return items.map((item) => {
+    const previousItem = previousById.get(item.id);
+    const requestedTaskId = item.kanbanBoardId === board.id ? item.kanbanTaskId : previousItem?.kanbanBoardId === board.id ? previousItem.kanbanTaskId : void 0;
+    const title = normalizedTitle(item.content);
+    const candidates = [
+      requestedTaskId ? board.tasks.find((task2) => task2.id === requestedTaskId) : void 0,
+      board.tasks.find((task2) => task2.id === item.id),
+      board.tasks.find((task2) => task2.origin?.taskId === item.id),
+      available.find((task2) => !used.has(task2.id) && normalizedTitle(task2.title) === title)
+    ];
+    const task = candidates.find((candidate) => candidate && !used.has(candidate.id));
+    if (!task) {
+      const { blockedBy: _discarded, ...rest } = item;
+      return { ...rest };
+    }
+    used.add(task.id);
+    const blockedBy = blockingTitles(board, task);
+    return {
+      ...item,
+      kanbanBoardId: board.id,
+      kanbanTaskId: task.id,
+      ...blockedBy.length ? { blockedBy } : { blockedBy: void 0 }
+    };
+  });
+}
+function demoteBlockedInProgress(items, warnings) {
+  return items.map((item) => {
+    if (item.status !== "in_progress" || !item.blockedBy?.length) return item;
+    warnings.push(
+      `"${item.content}" cannot start yet \u2014 it waits on: ${item.blockedBy.join("; ")}. Kept as pending; complete the blocking work first.`
+    );
+    return { ...item, status: "pending" };
+  });
+}
+async function createMissingManagedCards(items, board, ctx, warnings) {
+  const created = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (item.kanbanBoardId === board.id && item.kanbanTaskId) continue;
+    try {
+      const result = await addTask(ctx.projectRoot, board.id, {
+        title: item.content,
+        description: item.activeForm?.trim() || `Added from the session todo list: ${item.content}`
+      });
+      if (!result) {
+        warnings.push(`Could not open a Kanban card for "${item.content}": board not found.`);
+        continue;
+      }
+      created.set(item.id, result.task.id);
+    } catch (error) {
+      warnings.push(
+        `Could not open a Kanban card for "${item.content}": ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return created;
+}
+async function synchronizeManagedKanban(items, board, ctx, signal) {
+  let synced = 0;
+  const warnings = [];
+  const actor = ctx.agentId?.trim() || ctx.agentName?.trim() || "kanban-agent";
+  const execute = async (input) => {
+    const result = await kanbanTool.execute(input, ctx, { signal });
+    if (!result.ok) warnings.push(result.message);
+    else {
+      synced++;
+      if (result.message.includes("Warning:")) warnings.push(result.message);
+    }
+    return result;
+  };
+  for (const item of items) {
+    if (item.status !== "pending" || item.kanbanBoardId !== board.id || !item.kanbanTaskId) {
+      continue;
+    }
+    const task = board.tasks.find((candidate) => candidate.id === item.kanbanTaskId);
+    if (task?.lifecycle?.currentStage !== "running") continue;
+    const released = await execute({
+      action: "mark_assignment",
+      boardId: board.id,
+      taskId: task.id,
+      assignmentStatus: "assigned",
+      agentId: actor,
+      lastResult: `Todo returned to queue: ${item.content}`
+    });
+    if (!released.ok) continue;
+    await execute({
+      action: "transition_task",
+      boardId: board.id,
+      taskId: task.id,
+      lifecycleStage: "todo",
+      author: actor,
+      transitionComment: `Todo returned to queue: ${item.content}`
+    });
+  }
+  for (const item of items) {
+    if (item.status === "completed" || item.kanbanBoardId !== board.id || !item.kanbanTaskId) {
+      continue;
+    }
+    const task = board.tasks.find((candidate) => candidate.id === item.kanbanTaskId);
+    if (task?.status !== "completed") continue;
+    warnings.push(
+      `"${item.content}" is already Done on the Kanban board and a completed card cannot be reopened; the row stays completed. Create a follow-up card for any remaining work.`
+    );
+  }
+  for (const item of items) {
+    if (item.status !== "completed" || item.kanbanBoardId !== board.id || !item.kanbanTaskId) {
+      continue;
+    }
+    const task = board.tasks.find((candidate) => candidate.id === item.kanbanTaskId);
+    if (!task || task.status === "completed") continue;
+    const stage = task.lifecycle?.currentStage;
+    if (stage === "backlog" || stage === "todo") {
+      const started = await execute({
+        action: "start_task",
+        boardId: board.id,
+        taskId: task.id,
+        author: actor,
+        agentId: actor,
+        transitionComment: `Auto-started for completion: ${item.content}`
+      });
+      if (!started.ok) {
+        continue;
+      }
+    }
+    await execute({
+      action: "mark_assignment",
+      boardId: board.id,
+      taskId: task.id,
+      assignmentStatus: "completed",
+      agentId: actor,
+      lastResult: `Todo completed: ${item.content}`
+    });
+  }
+  const attemptedParents = /* @__PURE__ */ new Set();
+  let afterCompletions = await getBoard(ctx.projectRoot, board.id);
+  while (afterCompletions) {
+    const parent = afterCompletions.tasks.find(
+      (task) => task.atomic === true && task.status !== "completed" && Boolean(task.childTaskIds?.length) && !attemptedParents.has(task.id) && task.childTaskIds?.every(
+        (childId) => afterCompletions?.tasks.find((candidate) => candidate.id === childId)?.status === "completed"
+      )
+    );
+    if (!parent) break;
+    attemptedParents.add(parent.id);
+    const started = await execute({
+      action: "start_task",
+      boardId: board.id,
+      taskId: parent.id,
+      author: actor,
+      agentId: actor,
+      transitionComment: "All child tasks completed; validating composite parent."
+    });
+    if (started.ok) {
+      await execute({
+        action: "mark_assignment",
+        boardId: board.id,
+        taskId: parent.id,
+        assignmentStatus: "completed",
+        agentId: actor,
+        lastResult: "All child tasks completed; composite result ready for verification."
+      });
+    }
+    afterCompletions = await getBoard(ctx.projectRoot, board.id);
+  }
+  const completionPending = items.some(
+    (item) => item.status === "completed" && item.kanbanBoardId === board.id && Boolean(item.kanbanTaskId) && afterCompletions?.tasks.find((task) => task.id === item.kanbanTaskId)?.status !== "completed"
+  );
+  const active = items.find(
+    (item) => item.status === "in_progress" && item.kanbanBoardId === board.id && Boolean(item.kanbanTaskId)
+  );
+  const activeStage = active?.kanbanTaskId ? afterCompletions?.tasks.find((task) => task.id === active.kanbanTaskId)?.lifecycle?.currentStage : void 0;
+  if (active?.kanbanTaskId) {
+    if (activeStage === "review" || activeStage === "done") {
+      warnings.push(
+        `"${active.content}" is in ${activeStage === "review" ? "Review" : "Done"} awaiting acceptance; not re-activating it from the todo list. ` + (activeStage === "review" ? "Call kanban start_task explicitly to reopen it as a repair." : "Done is terminal; reopen only by creating a follow-up card.")
+      );
+    } else {
+      await execute({
+        action: "start_task",
+        boardId: board.id,
+        taskId: active.kanbanTaskId,
+        author: actor,
+        agentId: actor,
+        transitionComment: `Todo activated: ${active.content}`
+      });
+    }
+  }
+  if (active?.kanbanTaskId && activeStage === "review") {
+  } else if (active?.kanbanTaskId && completionPending) {
+    warnings.push(
+      "A completed todo is still awaiting acceptance; the next independent Kanban task was started."
+    );
+  } else if (!active && ctx.currentKanbanBoardId === board.id) {
+    ctx.setCurrentKanbanTask(void 0, board.id);
+  }
+  return { synced, warnings };
+}
+var todoTool = {
+  name: "todo",
+  category: "Session",
+  description: "Manage the compact active-work list. With a managed Kanban binding, every row resolves to a real card and status changes advance that card; without Kanban it remains session-only state. Each call replaces ordering and supplied fields, but unfinished omitted rows are retained until completed.",
+  usageHint: "BEST PRACTICE for complex tasks:\n- At the beginning of a non-trivial task, create a clear todo list with specific, actionable items.\n- Only **one** item should be `in_progress` at any time.\n- Update the list frequently as work progresses (mark items done, add new ones, change status).\n- **Re-order items** to reflect current priorities. Omission is not cancellation: unfinished rows are retained until completed.\n- When all items are completed the board auto-clears \u2014 you do NOT need to send an empty list.\n- The system and user can see this list, so keep it honest and up-to-date.\nThis tool is extremely valuable for maintaining focus and giving the user visibility into your plan.",
+  permission: "confirm",
+  mutating: true,
+  timeoutMs: 3e4,
+  capabilities: ["session.todo", "fs.write"],
+  subjectKey: "todos",
+  icon: "todo",
+  inputSchema: {
+    type: "object",
+    properties: {
+      todos: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: 'Unique identifier for the todo item (e.g. "1", "auth-flow").'
+            },
+            content: {
+              type: "string",
+              description: "Clear, actionable description of the task."
+            },
+            status: {
+              type: "string",
+              enum: ["pending", "in_progress", "completed"],
+              description: 'Current status. Only one item should be "in_progress" at a time.'
+            },
+            activeForm: {
+              type: "string",
+              description: 'Optional present-tense form shown while the task is active (e.g. "Fixing auth bug").'
+            },
+            kanbanBoardId: {
+              type: "string",
+              description: "Kanban board that owns this UI row when Kanban is active."
+            },
+            kanbanTaskId: {
+              type: "string",
+              description: "Real Kanban task represented by this UI row."
+            }
+          },
+          required: ["id", "content", "status"]
+        },
+        description: "The desired todo list. Supplied rows are replaced/reordered; unfinished omitted rows are retained."
+      }
+    },
+    required: ["todos"]
+  },
+  async execute(input, ctx, call) {
+    if (!Array.isArray(input?.todos)) {
+      throw new Error("todo: todos must be an array");
+    }
+    const items = input.todos.filter((t) => Boolean(t?.id && t.content));
+    const todoIdentity = (item) => item.kanbanBoardId && item.kanbanTaskId ? `kanban:${item.kanbanBoardId}:${item.kanbanTaskId}` : item.promotedFromTask ? `task:${item.promotedFromTask}` : item.promotedFromPlan ? `plan:${item.promotedFromPlan}` : `todo:${item.id}`;
+    const requestedIdentities = new Set(items.map(todoIdentity));
+    for (const previous of ctx.todos ?? []) {
+      const identity = todoIdentity(previous);
+      if (previous.status === "completed" || requestedIdentities.has(identity)) {
+        continue;
+      }
+      items.push({ ...previous });
+      requestedIdentities.add(identity);
+    }
+    const inProgress = items.filter((t) => t.status === "in_progress");
+    if (inProgress.length > 1) {
+      let seenInProgress = false;
+      for (const item of items) {
+        if (item.status === "in_progress") {
+          if (seenInProgress) item.status = "pending";
+          seenInProgress = true;
+        }
+      }
+    }
+    const boardId = activeBoardId(items, ctx);
+    let board = boardId ? await getBoard(ctx.projectRoot, boardId) : null;
+    const managed = board?.lifecycle?.mode === "managed";
+    let boundItems = managed && board ? bindTodosToBoard(items, ctx.todos ?? [], board) : items;
+    const creationWarnings = [];
+    if (managed && board) {
+      const managedBoardId = board.id;
+      const created = await createMissingManagedCards(boundItems, board, ctx, creationWarnings);
+      if (created.size > 0) {
+        boundItems = boundItems.map((item) => {
+          const taskId = created.get(item.id);
+          return taskId ? { ...item, kanbanBoardId: managedBoardId, kanbanTaskId: taskId } : item;
+        });
+        board = await getBoard(ctx.projectRoot, managedBoardId) ?? board;
+        boundItems = bindTodosToBoard(boundItems, ctx.todos ?? [], board);
+      }
+      boundItems = demoteBlockedInProgress(boundItems, creationWarnings);
+    }
+    ctx.state.replaceTodos(boundItems);
+    const kanbanSync = managed && board ? await synchronizeManagedKanban(boundItems, board, ctx, call.signal) : { synced: 0, warnings: [] };
+    kanbanSync.warnings.unshift(...creationWarnings);
+    if (managed && board) {
+      const unresolved = boundItems.filter(
+        (item) => item.kanbanBoardId !== board.id || !item.kanbanTaskId
+      );
+      if (unresolved.length > 0) {
+        kanbanSync.warnings.push(
+          `${unresolved.length} Todo row(s) could not be bound to a Kanban task and were not applied. Preserve kanbanBoardId/kanbanTaskId when updating the projection.`
+        );
+      }
+    }
+    const mirrorFailure = takeSessionMirrorFailure(ctx.projectRoot, ctx.session?.id ?? "");
+    if (mirrorFailure) kanbanSync.warnings.push(mirrorFailure);
+    let projectedBoard = board;
+    if (managed && board) {
+      const refreshed = await getBoard(ctx.projectRoot, board.id);
+      if (refreshed) {
+        projectedBoard = refreshed;
+        applyManagedKanbanBoardToTodos(ctx, refreshed);
+      }
+    }
+    if (!managed) {
+      mirrorSessionTodosToKanban(ctx.projectRoot, items, ctx.session?.id ?? "session");
+    }
+    const completedPlanIds = /* @__PURE__ */ new Set();
+    const completedTaskIds = /* @__PURE__ */ new Set();
+    const pendingPlanIds = /* @__PURE__ */ new Set();
+    const pendingTaskIds = /* @__PURE__ */ new Set();
+    for (const item of items) {
+      if (item.promotedFromPlan) {
+        (item.status === "completed" ? completedPlanIds : pendingPlanIds).add(
+          item.promotedFromPlan
+        );
+      }
+      if (item.promotedFromTask) {
+        (item.status === "completed" ? completedTaskIds : pendingTaskIds).add(
+          item.promotedFromTask
+        );
+      }
+    }
+    for (const planId of completedPlanIds) {
+      if (pendingPlanIds.has(planId)) continue;
+      const meta = ctx.meta;
+      const planPath = meta["plan.path.resolved"] ?? meta["plan.path"];
+      if (typeof planPath !== "string" || !planPath) continue;
+      try {
+        const plan = await loadPlan(planPath);
+        if (plan) {
+          const updated = setPlanItemStatus(plan, planId, "done");
+          await savePlan(planPath, updated);
+        }
+      } catch {
+      }
+    }
+    for (const taskId of completedTaskIds) {
+      if (pendingTaskIds.has(taskId)) continue;
+      const meta = ctx.meta;
+      const taskPath = meta["task.path.resolved"] ?? meta["task.path"];
+      if (typeof taskPath !== "string" || !taskPath) continue;
+      try {
+        const file = await loadTasks(taskPath);
+        if (file) {
+          const task = file.tasks.find((t) => t.id === taskId);
+          if (task && task.status !== "completed") {
+            task.status = "completed";
+            task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+            await saveTasks(taskPath, file);
+          }
+        }
+      } catch {
+      }
+    }
+    return {
+      count: items.length,
+      in_progress: (ctx.todos ?? boundItems).filter((t) => t.status === "in_progress").length,
+      ...kanbanSync.synced > 0 ? { kanban_synced: kanbanSync.synced } : {},
+      ...kanbanSync.warnings.length > 0 ? { kanban_warnings: kanbanSync.warnings } : {},
+      ...projectedBoard?.lifecycle?.mode === "managed" ? {
+        kanban_bindings: boundItems.flatMap((item) => {
+          if (item.kanbanBoardId !== projectedBoard.id || !item.kanbanTaskId) return [];
+          const task = projectedBoard.tasks.find(
+            (candidate) => candidate.id === item.kanbanTaskId
+          );
+          return task ? [
+            {
+              todoId: item.id,
+              boardId: projectedBoard.id,
+              taskId: task.id,
+              taskStatus: task.status
+            }
+          ] : [];
+        })
+      } : {}
+    };
+  }
+};
+
+export {
+  todoTool
+};
+//# sourceMappingURL=chunk-J4SRJKBW.js.map