@wrongstack/core 0.282.0 → 0.282.2

package/dist/defaults/index.js

@@ -6,7 +6,7 @@ import * as path4 from 'path';
 import { isAbsolute, join, resolve, sep } from 'path';
 import * as os from 'os';
 import { hostname } from 'os';
-import * as fs12 from 'fs';
+import * as fs13 from 'fs';
 import { readFileSync, statSync, createReadStream, existsSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { EventEmitter } from 'events';
@@ -70,8 +70,8 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat11 = await fsp7.stat(targetPath);
-      mode = stat11.mode & 511;
+      const stat12 = await fsp7.stat(targetPath);
+      mode = stat12.mode & 511;
     } catch {
       mode = opts.mode;
     }
@@ -117,8 +117,8 @@ async function withFileLock(targetPath, fn, opts = {}) {
       }
       if (code !== "EEXIST") throw err;
       try {
-        const stat11 = await fsp7.stat(lockPath);
-        if (Date.now() - stat11.mtimeMs > staleMs) {
+        const stat12 = await fsp7.stat(lockPath);
+        if (Date.now() - stat12.mtimeMs > staleMs) {
           await fsp7.unlink(lockPath);
           continue;
         }
@@ -133,7 +133,7 @@ async function withFileLock(targetPath, fn, opts = {}) {
           context: { timeoutMs }
         });
       }
-      await new Promise((resolve12) => setTimeout(resolve12, 25));
+      await new Promise((resolve13) => setTimeout(resolve13, 25));
     }
   }
   try {
@@ -166,7 +166,7 @@ async function renameWithRetry(from, to) {
       if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
         throw err;
       }
-      await new Promise((resolve12) => setTimeout(resolve12, delays[i]));
+      await new Promise((resolve13) => setTimeout(resolve13, delays[i]));
     }
   }
   throw lastErr;
@@ -629,8 +629,8 @@ async function expandGlob(pattern) {
       for (const e of entries) {
         const full = `${dir}${SEP}${e}`;
         try {
-          const stat11 = await fsp7.stat(full);
-          if (stat11.isDirectory()) await walk3(full, rest);
+          const stat12 = await fsp7.stat(full);
+          if (stat12.isDirectory()) await walk3(full, rest);
         } catch {
         }
       }
@@ -647,8 +647,8 @@ async function expandGlob(pattern) {
       if (entries.includes(seg)) {
         const full = `${dir}${SEP}${seg}`;
         try {
-          const stat11 = await fsp7.stat(full);
-          if (stat11.isDirectory()) await walk3(full, rest);
+          const stat12 = await fsp7.stat(full);
+          if (stat12.isDirectory()) await walk3(full, rest);
         } catch {
         }
       }
@@ -859,10 +859,10 @@ function validateAgainstSchema(value, schema) {
   walk(value, schema, "", errors, 0);
   return { ok: errors.length === 0, errors };
 }
-function walk(value, schema, path32, errors, depth) {
+function walk(value, schema, path33, errors, depth) {
   if (depth > MAX_SCHEMA_DEPTH) {
     errors.push({
-      path: path32 || "<root>",
+      path: path33 || "<root>",
       message: `schema nesting exceeds maximum depth (${MAX_SCHEMA_DEPTH})`
     });
     return;
@@ -870,7 +870,7 @@ function walk(value, schema, path32, errors, depth) {
   if (schema.enum !== void 0) {
     if (!enumIncludes(schema.enum, value)) {
       errors.push({
-        path: path32 || "<root>",
+        path: path33 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -879,7 +879,7 @@ function walk(value, schema, path32, errors, depth) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path32 || "<root>",
+        path: path33 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)}`
       });
       return;
@@ -889,20 +889,20 @@ function walk(value, schema, path32, errors, depth) {
     const obj = value;
     for (const req of schema.required ?? []) {
       if (!(req in obj)) {
-        errors.push({ path: joinPath(path32, req), message: "required property missing" });
+        errors.push({ path: joinPath(path33, req), message: "required property missing" });
       }
     }
     if (schema.properties) {
       for (const [key, subSchema] of Object.entries(schema.properties)) {
         if (key in obj) {
-          walk(obj[key], subSchema, joinPath(path32, key), errors, depth + 1);
+          walk(obj[key], subSchema, joinPath(path33, key), errors, depth + 1);
         }
       }
     }
   }
   if (schema.type === "array" && Array.isArray(value) && schema.items) {
     for (let i = 0; i < value.length; i++) {
-      walk(value[i], schema.items, `${path32}[${i}]`, errors, depth + 1);
+      walk(value[i], schema.items, `${path33}[${i}]`, errors, depth + 1);
     }
   }
 }
@@ -1283,7 +1283,7 @@ var init_ulid = __esm({
 
 // src/utils/sleep.ts
 function sleep(ms) {
-  return new Promise((resolve12) => setTimeout(resolve12, ms));
+  return new Promise((resolve13) => setTimeout(resolve13, ms));
 }
 var init_sleep = __esm({
   "src/utils/sleep.ts"() {
@@ -2697,7 +2697,7 @@ var InMemoryAgentBridge = class {
       });
     }
     this.inflightGuards.add(correlationId);
-    return new Promise((resolve12, reject) => {
+    return new Promise((resolve13, reject) => {
       const timer = setTimeout(() => {
         this.inflightGuards.delete(correlationId);
         this.pendingRequests.delete(correlationId);
@@ -2716,7 +2716,7 @@ var InMemoryAgentBridge = class {
         return;
       }
       this.pendingRequests.set(correlationId, {
-        resolve: resolve12,
+        resolve: resolve13,
         reject,
         timer
       });
@@ -3068,13 +3068,13 @@ var SubagentBudget = class _SubagentBudget {
     if (!bus?.hasListenerFor("budget.threshold_reached")) {
       return Promise.resolve("stop");
     }
-    return new Promise((resolve12) => {
+    return new Promise((resolve13) => {
       let resolved = false;
       const respond = (d) => {
         if (resolved) return;
         resolved = true;
         clearTimeout(fallback);
-        resolve12(d);
+        resolve13(d);
       };
       const fallback = setTimeout(() => respond("stop"), _SubagentBudget.DECISION_TIMEOUT_MS);
       const sessionId = this.currentSessionId();
@@ -5448,7 +5448,7 @@ function createDelegateTool(opts) {
           subagentId
         });
         const dir = director;
-        const result = await new Promise((resolve12) => {
+        const result = await new Promise((resolve13) => {
           let settled = false;
           let timer;
           const finish = (value) => {
@@ -5458,7 +5458,7 @@ function createDelegateTool(opts) {
             offTool();
             offIter();
             offProgress();
-            resolve12(value);
+            resolve13(value);
           };
           const arm = () => {
             if (timer) clearTimeout(timer);
@@ -5902,7 +5902,14 @@ var DirectorStateCheckpoint = class {
         mode: 384
       });
     } catch (err) {
-      console.warn("[director-state] checkpoint write failed:", toErrorMessage(err));
+      console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "director_state.checkpoint_write_failed",
+          message: toErrorMessage(err),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
     } finally {
       this.writing = false;
       if (this.rewriteRequested) {
@@ -6008,7 +6015,7 @@ var CollabSession = class extends EventEmitter {
     }
     for (const filePath of allFiles) {
       try {
-        const [content, stat11] = await Promise.all([
+        const [content, stat12] = await Promise.all([
           fsp7.readFile(filePath, "utf8"),
           fsp7.stat(filePath)
         ]);
@@ -6018,8 +6025,8 @@ var CollabSession = class extends EventEmitter {
           path: filePath,
           content,
           language,
-          snapshotMtimeMs: stat11.mtimeMs,
-          snapshotSizeBytes: stat11.size
+          snapshotMtimeMs: stat12.mtimeMs,
+          snapshotSizeBytes: stat12.size
         });
       } catch {
         this.snapshot.files.push({ path: filePath, content: "", language: void 0 });
@@ -6432,9 +6439,9 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
     for (const file of this.snapshot.files) {
       if (file.snapshotMtimeMs === void 0 && file.snapshotSizeBytes === void 0) continue;
       try {
-        const stat11 = await fsp7.stat(file.path);
-        const mtimeChanged = file.snapshotMtimeMs !== void 0 && stat11.mtimeMs > file.snapshotMtimeMs + 1;
-        const sizeChanged = file.snapshotSizeBytes !== void 0 && stat11.size !== file.snapshotSizeBytes;
+        const stat12 = await fsp7.stat(file.path);
+        const mtimeChanged = file.snapshotMtimeMs !== void 0 && stat12.mtimeMs > file.snapshotMtimeMs + 1;
+        const sizeChanged = file.snapshotSizeBytes !== void 0 && stat12.size !== file.snapshotSizeBytes;
         if (mtimeChanged || sizeChanged) {
           warnings.push(`${file.path} changed after the collab snapshot was captured.`);
         }
@@ -6652,6 +6659,366 @@ function rosterSummaryFromConfigs(roster) {
   }
   return lines.join("\n");
 }
+
+// src/kanban/storage.ts
+init_atomic_write();
+
+// src/kanban/types.ts
+var DEFAULT_COLUMNS = [
+  { id: "backlog", title: "Backlog", order: 0, wipLimit: 0, color: "#64748b" },
+  { id: "todo", title: "To Do", order: 1, wipLimit: 0, color: "#2563eb" },
+  { id: "in-progress", title: "In Progress", order: 2, wipLimit: 5, color: "#d97706" },
+  { id: "review", title: "Review", order: 3, wipLimit: 0, color: "#7c3aed" },
+  { id: "done", title: "Done", order: 4, wipLimit: 0, color: "#16a34a" }
+];
+var CURRENT_KANBAN_VERSION = 1;
+
+// src/kanban/storage.ts
+var KANBANS_DIR = "kanbans";
+var BOARD_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+function getKanbanDir(projectRoot) {
+  return path4.join(projectRoot, ".wrongstack", KANBANS_DIR);
+}
+function getKanbanPath(projectRoot, boardId) {
+  assertValidBoardId(boardId);
+  const dir = path4.resolve(getKanbanDir(projectRoot));
+  const resolved = path4.resolve(dir, `${boardId}.json`);
+  const rel = path4.relative(dir, resolved);
+  if (rel.startsWith("..") || path4.isAbsolute(rel)) {
+    throw invalidBoardId(boardId);
+  }
+  return resolved;
+}
+function isValidBoardId(boardId) {
+  return BOARD_ID_RE.test(boardId) && !boardId.includes("..");
+}
+function assertValidBoardId(boardId) {
+  if (!isValidBoardId(boardId)) throw invalidBoardId(boardId);
+}
+function invalidBoardId(boardId) {
+  return new Error(`Invalid kanban board id: ${boardId}`);
+}
+function isEnoent(err) {
+  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
+}
+async function pathExists(filePath) {
+  try {
+    await fsp7.stat(filePath);
+    return true;
+  } catch (err) {
+    if (isEnoent(err)) return false;
+    throw err;
+  }
+}
+async function listBoardIds(projectRoot) {
+  const dir = getKanbanDir(projectRoot);
+  try {
+    const entries = await fsp7.readdir(dir, { withFileTypes: true });
+    return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -5)).filter(isValidBoardId).sort();
+  } catch (err) {
+    if (isEnoent(err)) return [];
+    throw err;
+  }
+}
+async function resolveBoardRef(projectRoot, boardRef) {
+  assertValidBoardId(boardRef);
+  if (await pathExists(getKanbanPath(projectRoot, boardRef))) return boardRef;
+  const matches = (await listBoardIds(projectRoot)).filter((id) => id.startsWith(boardRef));
+  if (matches.length === 0) return null;
+  if (matches.length > 1) {
+    throw new Error(`Ambiguous kanban board id "${boardRef}": ${matches.slice(0, 5).join(", ")}`);
+  }
+  return matches[0] ?? null;
+}
+async function readBoard(projectRoot, boardRef) {
+  const boardId = await resolveBoardRef(projectRoot, boardRef);
+  if (!boardId) return null;
+  try {
+    const raw = await fsp7.readFile(getKanbanPath(projectRoot, boardId), "utf8");
+    return normalizeBoard(JSON.parse(raw));
+  } catch (err) {
+    if (isEnoent(err)) return null;
+    throw err;
+  }
+}
+async function mutateBoard(projectRoot, boardRef, mutator) {
+  const boardId = await resolveBoardRef(projectRoot, boardRef);
+  if (!boardId) return null;
+  const filePath = getKanbanPath(projectRoot, boardId);
+  return withFileLock(filePath, async () => {
+    let board;
+    try {
+      const raw = await fsp7.readFile(filePath, "utf8");
+      board = normalizeBoard(JSON.parse(raw));
+    } catch (err) {
+      if (isEnoent(err)) return null;
+      throw err;
+    }
+    const result = await mutator(board);
+    await writeBoardUnlocked(filePath, normalizeBoard(board));
+    return { board, result };
+  });
+}
+function summarizeBoard(board) {
+  const total = board.tasks.length;
+  const completed = board.tasks.filter((task) => task.status === "completed").length;
+  const lastActivity = latestActivity(board);
+  return {
+    id: board.id,
+    title: board.title,
+    createdAt: board.createdAt,
+    updatedAt: board.updatedAt,
+    columnCount: board.columns.length,
+    taskCount: total,
+    completedTaskCount: completed,
+    ...board.description !== void 0 ? { description: board.description } : {},
+    ...board.tags !== void 0 ? { tags: board.tags } : {},
+    ...lastActivity !== void 0 ? { lastActivity } : {}
+  };
+}
+async function listBoardSummaries(projectRoot) {
+  const summaries = [];
+  for (const id of await listBoardIds(projectRoot)) {
+    const board = await readBoard(projectRoot, id);
+    if (board) summaries.push(summarizeBoard(board));
+  }
+  return summaries.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+function normalizeBoard(board) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const columns = [...board.columns?.length ? board.columns : DEFAULT_COLUMNS].map((column, index) => ({
+    ...column,
+    order: column.order ?? index
+  })).sort((a, b) => a.order - b.order).map((column, index) => ({ ...column, order: index }));
+  const columnIds = new Set(columns.map((column) => column.id));
+  const fallbackColumnId = columns[0]?.id ?? "backlog";
+  const tasks = normalizeTaskOrders(
+    (board.tasks ?? []).map((task, index) => ({
+      ...task,
+      columnId: columnIds.has(task.columnId) ? task.columnId : fallbackColumnId,
+      order: task.order ?? index,
+      priority: task.priority ?? "medium",
+      status: task.status ?? "pending",
+      createdAt: task.createdAt ?? now,
+      updatedAt: task.updatedAt ?? now
+    }))
+  );
+  return {
+    ...board,
+    version: board.version ?? CURRENT_KANBAN_VERSION,
+    createdAt: board.createdAt ?? now,
+    updatedAt: board.updatedAt ?? now,
+    columns,
+    tasks
+  };
+}
+function latestActivity(board) {
+  return [board.updatedAt, ...board.tasks.map((task) => task.updatedAt)].filter(Boolean).sort().reverse()[0];
+}
+async function writeBoardUnlocked(filePath, board) {
+  await atomicWrite(filePath, `${JSON.stringify(board, null, 2)}
+`, { encoding: "utf8" });
+}
+function normalizeTaskOrders(tasks) {
+  const byColumn = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    const columnTasks = byColumn.get(task.columnId) ?? [];
+    columnTasks.push(task);
+    byColumn.set(task.columnId, columnTasks);
+  }
+  for (const columnTasks of byColumn.values()) {
+    columnTasks.sort((a, b) => a.order - b.order || a.createdAt.localeCompare(b.createdAt)).forEach((task, index) => {
+      task.order = index;
+    });
+  }
+  return tasks;
+}
+
+// src/kanban/manager.ts
+async function listBoards(projectRoot) {
+  return listBoardSummaries(projectRoot);
+}
+async function updateTaskAssignment(projectRoot, boardId, taskId, patch) {
+  const updated = await mutateBoard(projectRoot, boardId, (board) => {
+    const task = findTask(board, taskId);
+    if (!task) return null;
+    const nextAssignment = {
+      ...task.assignment ?? { status: "assigned" }
+    };
+    for (const [key, value] of Object.entries(patch)) {
+      if (value !== void 0) {
+        nextAssignment[key] = value;
+      }
+    }
+    task.assignment = nextAssignment;
+    if (task.assignment.agentId) task.assignedAgent = task.assignment.agentId;
+    if (task.assignment.status === "completed") {
+      task.assignment.completedAt = task.assignment.completedAt ?? nowIso();
+      task.status = "completed";
+      task.completedAt = task.assignment.completedAt;
+      if (patch.error === void 0) delete task.assignment.error;
+    } else if (task.assignment.status === "running") {
+      delete task.assignment.completedAt;
+      if (patch.error === void 0) delete task.assignment.error;
+      task.status = "in_progress";
+      delete task.completedAt;
+    } else if (task.assignment.status === "failed") {
+      delete task.assignment.completedAt;
+      task.status = "failed";
+      delete task.completedAt;
+    } else if (task.assignment.status === "cancelled") {
+      delete task.assignment.completedAt;
+      if (patch.error === void 0) delete task.assignment.error;
+      task.status = "blocked";
+      delete task.completedAt;
+    } else if (task.assignment.status === "queued" || task.assignment.status === "assigned") {
+      delete task.assignment.completedAt;
+      if (patch.error === void 0) delete task.assignment.error;
+      if (task.status === "completed" || task.status === "failed") {
+        task.status = task.assignment.status === "queued" ? "ready" : "pending";
+      }
+      delete task.completedAt;
+    }
+    task.updatedAt = nowIso();
+    board.updatedAt = task.updatedAt;
+    return task;
+  });
+  return updated?.result ? updated.board : null;
+}
+async function claimReadyTask(projectRoot, input = {}) {
+  if (input.boardId) return claimReadyTaskOnBoard(projectRoot, input.boardId, input);
+  for (const board of await listBoards(projectRoot)) {
+    const claimed = await claimReadyTaskOnBoard(projectRoot, board.id, input);
+    if (claimed) return claimed;
+  }
+  return null;
+}
+async function searchKanban(projectRoot, input = {}) {
+  const boardIds = input.boardId ? [input.boardId] : (await listBoards(projectRoot)).map((b) => b.id);
+  const results = [];
+  for (const boardId of boardIds) {
+    const board = await readBoard(projectRoot, boardId);
+    if (!board) continue;
+    for (const task of board.tasks) {
+      if (!matchesKanbanSearch(board, task, input)) continue;
+      results.push({ board: summarizeBoard(board), task });
+    }
+  }
+  return results;
+}
+async function listReadyTasks(projectRoot, input = {}) {
+  const results = await searchKanban(projectRoot, { ...input, readyOnly: true });
+  return input.limit && input.limit > 0 ? results.slice(0, input.limit) : results;
+}
+function areDependenciesMet(board, taskId) {
+  const task = findTask(board, taskId);
+  if (!task?.dependsOn?.length) return true;
+  return task.dependsOn.every((depId) => {
+    const depTask = board.tasks.find((candidate) => candidate.id === depId);
+    return depTask?.status === "completed";
+  });
+}
+function buildAssignment(input) {
+  return {
+    status: input.status ?? "assigned",
+    ...input.agentId !== void 0 ? { agentId: input.agentId } : {},
+    ...input.name !== void 0 ? { name: input.name } : {},
+    ...input.role !== void 0 ? { role: input.role } : {},
+    ...input.provider !== void 0 ? { provider: input.provider } : {},
+    ...input.model !== void 0 ? { model: input.model } : {},
+    ...input.fallbackProfile !== void 0 ? { fallbackProfile: input.fallbackProfile } : {},
+    ...input.fallbackModels !== void 0 ? { fallbackModels: input.fallbackModels } : {},
+    ...input.tools !== void 0 ? { tools: input.tools } : {},
+    ...input.allowedCapabilities !== void 0 ? { allowedCapabilities: input.allowedCapabilities } : {}
+  };
+}
+async function claimReadyTaskOnBoard(projectRoot, boardId, input) {
+  const updated = await mutateBoard(projectRoot, boardId, (board) => {
+    const candidates = input.taskId ? [findTask(board, input.taskId)].filter((task2) => Boolean(task2)) : board.tasks.filter((task2) => isTaskReadyForWork(board, task2)).sort(compareTasksForWork);
+    const task = candidates.find((candidate) => isTaskReadyForWork(board, candidate));
+    if (!task) return null;
+    const current = task.assignment;
+    const assignment = buildAssignment({
+      ...current?.agentId !== void 0 ? { agentId: current.agentId } : {},
+      ...current?.name !== void 0 ? { name: current.name } : {},
+      ...current?.role !== void 0 ? { role: current.role } : {},
+      ...current?.provider !== void 0 ? { provider: current.provider } : {},
+      ...current?.model !== void 0 ? { model: current.model } : {},
+      ...current?.fallbackProfile !== void 0 ? { fallbackProfile: current.fallbackProfile } : {},
+      ...current?.fallbackModels !== void 0 ? { fallbackModels: current.fallbackModels } : {},
+      ...current?.tools !== void 0 ? { tools: current.tools } : {},
+      ...current?.allowedCapabilities !== void 0 ? { allowedCapabilities: current.allowedCapabilities } : {},
+      ...input.agentId !== void 0 ? { agentId: input.agentId } : {},
+      ...input.name !== void 0 ? { name: input.name } : {},
+      ...input.role !== void 0 ? { role: input.role } : {},
+      ...input.provider !== void 0 ? { provider: input.provider } : {},
+      ...input.model !== void 0 ? { model: input.model } : {},
+      ...input.fallbackProfile !== void 0 ? { fallbackProfile: input.fallbackProfile } : {},
+      ...input.fallbackModels !== void 0 ? { fallbackModels: input.fallbackModels } : {},
+      ...input.tools !== void 0 ? { tools: input.tools } : {},
+      ...input.allowedCapabilities !== void 0 ? { allowedCapabilities: input.allowedCapabilities } : {},
+      ...input.assignee !== void 0 ? { assignee: input.assignee } : {},
+      status: input.status ?? "queued"
+    });
+    assignment.dispatchedAt = assignment.dispatchedAt ?? nowIso();
+    task.assignment = assignment;
+    if (assignment.agentId ?? assignment.role ?? assignment.name) {
+      task.assignedAgent = assignment.agentId ?? assignment.role ?? assignment.name;
+    }
+    if (input.assignee ?? assignment.name ?? assignment.agentId) {
+      task.assignee = input.assignee ?? assignment.name ?? assignment.agentId;
+    }
+    task.status = assignment.status === "running" ? "in_progress" : "ready";
+    delete task.completedAt;
+    task.updatedAt = nowIso();
+    board.updatedAt = task.updatedAt;
+    return task;
+  });
+  return updated?.result ? { board: updated.board, task: updated.result } : null;
+}
+function compareTasksForWork(a, b) {
+  const priorityRank = {
+    critical: 0,
+    high: 1,
+    medium: 2,
+    low: 3
+  };
+  return priorityRank[a.priority] - priorityRank[b.priority] || a.columnId.localeCompare(b.columnId) || a.order - b.order || a.createdAt.localeCompare(b.createdAt);
+}
+function matchesKanbanSearch(board, task, input) {
+  const query = input.query?.trim().toLowerCase();
+  if (input.assignedAgent && task.assignedAgent !== input.assignedAgent) return false;
+  if (input.status && task.status !== input.status) return false;
+  if (input.priority && task.priority !== input.priority) return false;
+  if (input.label && !task.labels?.includes(input.label)) return false;
+  if (input.chainId && task.chain?.chainId !== input.chainId) return false;
+  if (input.readyOnly && !isTaskReadyForWork(board, task)) return false;
+  if (!query) return true;
+  return [task.title, task.description, task.assignedAgent, task.assignee, ...task.labels ?? []].filter(Boolean).some((value) => String(value).toLowerCase().includes(query));
+}
+function findTask(board, taskId) {
+  const exact = board.tasks.find((task) => task.id === taskId);
+  if (exact) return exact;
+  const matches = board.tasks.filter((task) => task.id.startsWith(taskId));
+  if (matches.length > 1) {
+    throw new Error(
+      `Ambiguous kanban task id "${taskId}": ${matches.slice(0, 5).map((task) => task.id).join(", ")}`
+    );
+  }
+  return matches[0];
+}
+function isTaskReadyForWork(board, task) {
+  if (!["pending", "ready"].includes(task.status)) return false;
+  if (task.assignment && ["queued", "running"].includes(task.assignment.status)) return false;
+  if (task.mergedIntoTaskId) return false;
+  if (!areDependenciesMet(board, task.id)) return false;
+  return true;
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+
+// src/coordination/director-tools.ts
 init_error();
 
 // src/coordination/dispatcher.ts
@@ -7332,6 +7699,298 @@ function makeAssignTool(director) {
     }
   };
 }
+function makeKanbanQueueTool(director, roster) {
+  return {
+    name: "kanban_queue",
+    description: "Claim dependency-ready Kanban tasks and dispatch them into the Director fleet. Preserves per-task provider/model/role/tool routing metadata, assigns each claimed task to a spawned subagent, and can await results while writing completion back to Kanban.",
+    usageHint: 'Use action:"dispatch_ready" with optional boardId/taskId/maxTasks. Set awaitCompletion:true when you want this call to update Kanban to completed/failed before returning; otherwise use await_tasks and kanban mark_assignment later.',
+    permission: "auto",
+    mutating: true,
+    capabilities: [ToolCapabilities.SUBAGENT_SPAWN, ToolCapabilities.FS_WRITE],
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["dispatch_ready"] },
+        boardId: { type: "string", description: "Optional board id/prefix to claim from." },
+        taskId: { type: "string", description: "Optional exact task id/prefix to claim." },
+        query: { type: "string", description: "Optional natural-language filter for ready tasks." },
+        maxTasks: {
+          type: "number",
+          minimum: 1,
+          maximum: 20,
+          description: "Maximum number of ready tasks to claim and dispatch. Default 1."
+        },
+        awaitCompletion: {
+          type: "boolean",
+          description: "When true, waits for assigned fleet task results and writes completed/failed back to Kanban."
+        },
+        timeoutMs: {
+          type: "number",
+          minimum: 1,
+          description: "Optional per-assigned-task timeout in ms."
+        },
+        maxToolCalls: {
+          type: "number",
+          minimum: 1,
+          description: "Optional per-assigned-task tool-call cap."
+        },
+        agentId: { type: "string" },
+        name: { type: "string" },
+        role: { type: "string" },
+        provider: { type: "string" },
+        model: { type: "string" },
+        fallbackModels: { type: "array", items: { type: "string" } },
+        tools: { type: "array", items: { type: "string" } },
+        allowedCapabilities: { type: "array", items: { type: "string" } },
+        worktree: {
+          anyOf: [{ type: "boolean" }, { type: "string", enum: ["auto", "required", "off"] }]
+        }
+      }
+    },
+    async execute(input, ctx) {
+      const i = normalizeKanbanQueueInput(input);
+      const rawAction = input?.action;
+      if (rawAction !== void 0 && rawAction !== "dispatch_ready") {
+        return { error: `Unknown kanban_queue action: ${String(rawAction)}` };
+      }
+      const projectRoot = ctx.projectRoot;
+      if (!projectRoot) return { error: "kanban_queue requires ctx.projectRoot." };
+      const maxTasks = Math.max(1, Math.min(20, Math.floor(i.maxTasks ?? 1)));
+      const candidateTaskIds = i.taskId !== void 0 ? [i.taskId] : i.query ? (await listReadyTasks(projectRoot, {
+        ...i.boardId !== void 0 ? { boardId: i.boardId } : {}
+      })).filter((candidate) => matchesKanbanQueueQuery(candidate.task, i.query ?? "")).slice(0, maxTasks).map((candidate) => candidate.task.id) : void 0;
+      const dispatches = [];
+      const errors = [];
+      const resultFailures = [];
+      for (let index = 0; index < maxTasks; index++) {
+        const candidateTaskId = candidateTaskIds?.[index];
+        if (candidateTaskIds && !candidateTaskId) break;
+        const claim = await claimReadyTask(projectRoot, {
+          ...i.boardId !== void 0 ? { boardId: i.boardId } : {},
+          ...candidateTaskId !== void 0 ? { taskId: candidateTaskId } : {},
+          ...i.agentId !== void 0 ? { agentId: i.agentId } : {},
+          ...i.name !== void 0 ? { name: i.name } : {},
+          ...i.role !== void 0 ? { role: i.role } : {},
+          ...i.provider !== void 0 ? { provider: i.provider } : {},
+          ...i.model !== void 0 ? { model: i.model } : {},
+          ...i.fallbackModels !== void 0 ? { fallbackModels: i.fallbackModels } : {},
+          ...i.tools !== void 0 ? { tools: i.tools } : {},
+          ...i.allowedCapabilities !== void 0 ? { allowedCapabilities: i.allowedCapabilities } : {},
+          status: "queued"
+        });
+        if (!claim) {
+          if (candidateTaskIds) continue;
+          break;
+        }
+        let subagentId;
+        let runTaskId;
+        try {
+          const config = buildKanbanSubagentConfig(claim.task, i, roster);
+          subagentId = await director.spawn(config);
+          runTaskId = await director.assign({
+            id: randomUUID(),
+            subagentId,
+            description: buildKanbanFleetTaskPrompt(claim.board, claim.task),
+            ...i.maxToolCalls !== void 0 ? { maxToolCalls: i.maxToolCalls } : {},
+            ...i.timeoutMs !== void 0 ? { timeoutMs: i.timeoutMs } : {},
+            context: {
+              kanban: {
+                boardId: claim.board.id,
+                taskId: claim.task.id,
+                origin: claim.task.origin
+              }
+            }
+          });
+          await updateTaskAssignment(projectRoot, claim.board.id, claim.task.id, {
+            ...claim.task.assignment ?? {},
+            status: "running",
+            subagentId,
+            runTaskId
+          });
+          dispatches.push({
+            boardId: claim.board.id,
+            taskId: claim.task.id,
+            title: claim.task.title,
+            subagentId,
+            runTaskId,
+            ...config.provider !== void 0 ? { provider: config.provider } : {},
+            ...config.model !== void 0 ? { model: config.model } : {}
+          });
+        } catch (err) {
+          let message = toErrorMessage(err);
+          if (subagentId && !runTaskId) {
+            try {
+              await director.terminate(subagentId);
+            } catch (cleanupErr) {
+              message = `${message}; cleanup failed for spawned subagent ${subagentId}: ${toErrorMessage(cleanupErr)}`;
+            }
+          }
+          await updateTaskAssignment(projectRoot, claim.board.id, claim.task.id, {
+            ...claim.task.assignment ?? {},
+            status: "failed",
+            ...subagentId !== void 0 ? { subagentId } : {},
+            ...runTaskId !== void 0 ? { runTaskId } : {},
+            error: message
+          });
+          errors.push({ taskId: claim.task.id, error: message });
+        }
+      }
+      let results;
+      if (i.awaitCompletion && dispatches.length > 0) {
+        results = await director.awaitTasks(dispatches.map((dispatch) => dispatch.runTaskId));
+        for (const result of results) {
+          const dispatch = dispatches.find((candidate) => candidate.runTaskId === result.taskId);
+          if (!dispatch) continue;
+          await updateTaskAssignment(projectRoot, dispatch.boardId, dispatch.taskId, {
+            status: result.status === "success" ? "completed" : "failed",
+            subagentId: result.subagentId,
+            runTaskId: result.taskId,
+            ...result.status === "success" ? { lastResult: resultToText(result) } : { error: resultErrorText(result) }
+          });
+          if (result.status !== "success") {
+            resultFailures.push({
+              taskId: dispatch.taskId,
+              runTaskId: result.taskId,
+              status: result.status,
+              error: resultErrorText(result)
+            });
+          }
+        }
+      }
+      return {
+        ok: errors.length === 0 && resultFailures.length === 0,
+        dispatched: dispatches,
+        count: dispatches.length,
+        ...results !== void 0 ? { results } : {},
+        ...errors.length > 0 ? { errors } : {},
+        ...resultFailures.length > 0 ? { resultFailures } : {},
+        message: dispatches.length > 0 ? `Dispatched ${dispatches.length} kanban task(s).` : "No ready kanban task matched."
+      };
+    }
+  };
+}
+function normalizeKanbanQueueInput(input) {
+  const raw = input ?? {};
+  return {
+    action: raw.action === "dispatch_ready" ? "dispatch_ready" : void 0,
+    boardId: typeof raw.boardId === "string" ? raw.boardId : void 0,
+    taskId: typeof raw.taskId === "string" ? raw.taskId : void 0,
+    query: typeof raw.query === "string" ? raw.query : void 0,
+    maxTasks: typeof raw.maxTasks === "number" ? raw.maxTasks : void 0,
+    awaitCompletion: typeof raw.awaitCompletion === "boolean" ? raw.awaitCompletion : void 0,
+    timeoutMs: typeof raw.timeoutMs === "number" ? raw.timeoutMs : void 0,
+    maxToolCalls: typeof raw.maxToolCalls === "number" ? raw.maxToolCalls : void 0,
+    agentId: typeof raw.agentId === "string" ? raw.agentId : void 0,
+    name: typeof raw.name === "string" ? raw.name : void 0,
+    role: typeof raw.role === "string" ? raw.role : void 0,
+    provider: typeof raw.provider === "string" ? raw.provider : void 0,
+    model: typeof raw.model === "string" ? raw.model : void 0,
+    fallbackModels: stringArray(raw.fallbackModels),
+    tools: stringArray(raw.tools),
+    allowedCapabilities: stringArray(raw.allowedCapabilities),
+    worktree: normalizeWorktreeOverride(raw.worktree)
+  };
+}
+function buildKanbanSubagentConfig(task, input, roster) {
+  const assignment = task.assignment;
+  const role = input.role ?? assignment?.role;
+  const base = role && roster?.[role] ? instantiateRosterConfig2(role, roster[role] ?? {}) : void 0;
+  const tools = input.tools ?? assignment?.tools ?? base?.tools;
+  const name = input.name ?? assignment?.name ?? input.agentId ?? assignment?.agentId ?? task.assignedAgent ?? role ?? "kanban-agent";
+  return {
+    ...base ?? { name },
+    name: base?.name ?? name,
+    ...role !== void 0 ? { role } : {},
+    ...input.provider ?? assignment?.provider ? { provider: input.provider ?? assignment?.provider } : {},
+    ...input.model ?? assignment?.model ? { model: input.model ?? assignment?.model } : {},
+    ...input.fallbackModels ?? assignment?.fallbackModels ? { fallbackModels: input.fallbackModels ?? assignment?.fallbackModels } : {},
+    ...tools ? { tools: ensureKanbanTool(tools) } : {},
+    ...input.allowedCapabilities ?? assignment?.allowedCapabilities ? { allowedCapabilities: input.allowedCapabilities ?? assignment?.allowedCapabilities } : {},
+    ...input.worktree !== void 0 ? { worktree: input.worktree } : {}
+  };
+}
+function ensureKanbanTool(tools) {
+  return tools.includes("kanban") ? [...tools] : [...tools, "kanban"];
+}
+function matchesKanbanQueueQuery(task, query) {
+  const normalized = query.trim().toLowerCase();
+  if (!normalized) return true;
+  return [
+    task.title,
+    task.description,
+    task.assignedAgent,
+    task.assignee,
+    task.origin?.system,
+    task.origin?.graphId,
+    task.origin?.phaseId,
+    ...task.labels ?? []
+  ].filter(Boolean).some((value) => String(value).toLowerCase().includes(normalized));
+}
+function buildKanbanFleetTaskPrompt(board, task) {
+  const dependencyLines = (task.dependsOn ?? []).map((depId) => board.tasks.find((candidate) => candidate.id === depId)).filter((dep) => Boolean(dep)).map((dep) => `- ${dep.title} [${dep.status}] (${dep.id})`);
+  const checks = task.successCriteria?.map((check) => `- ${check.description}`).join("\n");
+  const metrics = task.goalMetrics?.map(
+    (metric) => `- ${metric.name}: ${metric.current ?? "n/a"}${metric.target !== void 0 ? ` / ${metric.target}` : ""}${metric.unit ? ` ${metric.unit}` : ""} [${metric.status}]`
+  ).join("\n");
+  const chain = task.chain ? [
+    `chainId: ${task.chain.chainId}`,
+    `order: ${task.chain.order}`,
+    task.chain.previousTaskId ? `previous: ${task.chain.previousTaskId}` : "",
+    task.chain.nextTaskId ? `next: ${task.chain.nextTaskId}` : ""
+  ].filter(Boolean).join("\n") : "";
+  const routing = [
+    task.assignment?.role ? `role: ${task.assignment.role}` : "",
+    task.assignment?.provider ? `provider: ${task.assignment.provider}` : "",
+    task.assignment?.model ? `model: ${task.assignment.model}` : "",
+    task.assignment?.fallbackProfile ? `fallbackProfile: ${task.assignment.fallbackProfile}` : "",
+    task.assignment?.fallbackModels?.length ? `fallbackModels: ${task.assignment.fallbackModels.join(", ")}` : ""
+  ].filter(Boolean);
+  const origin = task.origin ? [
+    `system: ${task.origin.system}`,
+    task.origin.graphId ? `graphId: ${task.origin.graphId}` : "",
+    task.origin.phaseId ? `phaseId: ${task.origin.phaseId}` : "",
+    task.origin.taskId ? `sourceTaskId: ${task.origin.taskId}` : ""
+  ].filter(Boolean).join("\n") : "";
+  return [
+    "You are processing a claimed WrongStack Kanban task.",
+    "",
+    `Board: ${board.title} (${board.id})`,
+    `Task: ${task.title} (${task.id})`,
+    `Status: ${task.status}`,
+    `Priority: ${task.priority}`,
+    task.description ? `Description:
+${task.description}` : "",
+    origin ? `Origin:
+${origin}` : "",
+    routing.length ? `Routing hints:
+${routing.join("\n")}` : "",
+    chain ? `Task chain:
+${chain}` : "",
+    dependencyLines.length ? `Dependencies:
+${dependencyLines.join("\n")}` : "",
+    checks ? `Success criteria:
+${checks}` : "",
+    metrics ? `Goal metrics:
+${metrics}` : "",
+    task.labels?.length ? `Labels: ${task.labels.join(", ")}` : "",
+    "",
+    "Work this task end-to-end. If scope is too broad or too small, use the kanban tool to split_task or merge_tasks instead of losing traceability.",
+    `When you start or finish, call kanban with action "mark_assignment", boardId "${board.id}", taskId "${task.id}", and assignmentStatus "running", "completed", or "failed". Include lastResult or error when you finish.`,
+    "When finished, report what changed, what you verified, and any remaining blockers."
+  ].filter(Boolean).join("\n");
+}
+function resultToText(result) {
+  if (typeof result.result === "string") return result.result;
+  if (result.result === void 0) return "";
+  try {
+    return JSON.stringify(result.result);
+  } catch {
+    return String(result.result);
+  }
+}
+function resultErrorText(result) {
+  return result.error ? `${result.error.kind}: ${result.error.message}` : result.status;
+}
 function makeAwaitTasksTool(director) {
   return {
     name: "await_tasks",
@@ -8557,7 +9216,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       taskIds.map((id) => {
         const cached = this.completedResults.find((r) => r.taskId === id);
         if (cached) return cached;
-        return new Promise((resolve12, reject) => {
+        return new Promise((resolve13, reject) => {
           const timeout = setTimeout(() => {
             this.off("task.completed", handler);
             reject(new Error(`awaitTasks timed out waiting for task "${id}"`));
@@ -8566,7 +9225,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
             if (result.taskId === id) {
               clearTimeout(timeout);
               this.off("task.completed", handler);
-              resolve12(result);
+              resolve13(result);
             }
           };
           this.on("task.completed", handler);
@@ -8591,13 +9250,13 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       const done = new Set(completed.map((r) => r.taskId));
       return { completed, pending: taskIds.filter((id) => !done.has(id)) };
     }
-    return new Promise((resolve12) => {
+    return new Promise((resolve13) => {
       let timer;
       const handler = ({ result }) => {
         if (!ids.has(result.taskId)) return;
         if (timer) clearTimeout(timer);
         this.off("task.completed", handler);
-        resolve12({
+        resolve13({
           completed: [result],
           pending: taskIds.filter((id) => id !== result.taskId)
         });
@@ -8605,7 +9264,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       if (opts?.timeoutMs !== void 0) {
         timer = setTimeout(() => {
           this.off("task.completed", handler);
-          resolve12({ completed: [], pending: [...taskIds], timedOut: true });
+          resolve13({ completed: [], pending: [...taskIds], timedOut: true });
         }, opts.timeoutMs);
       }
       this.on("task.completed", handler);
@@ -8875,12 +9534,12 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
             }
             return new Promise((resolveDecision) => {
               let settled = false;
-              const resolve12 = (d) => {
+              const resolve13 = (d) => {
                 if (settled) return;
                 settled = true;
                 resolveDecision(d);
               };
-              const fallback = setTimeout(() => resolve12("stop"), DECISION_TIMEOUT_MS);
+              const fallback = setTimeout(() => resolve13("stop"), DECISION_TIMEOUT_MS);
               const sessionId = this.currentSessionId();
               budget._events?.emit("budget.threshold_reached", {
                 ...sessionId ? { sessionId } : {},
@@ -8898,11 +9557,11 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
                 // disagreeing, resolves as a stop). Async grants still resolve.
                 extend: (extra) => {
                   clearTimeout(fallback);
-                  queueMicrotask(() => resolve12({ extend: extra }));
+                  queueMicrotask(() => resolve13({ extend: extra }));
                 },
                 deny: () => {
                   clearTimeout(fallback);
-                  resolve12("stop");
+                  resolve13("stop");
                 }
               });
             });
@@ -10367,11 +11026,11 @@ var Director = class _Director {
         if (cached) return cached;
         const existing = this.taskWaiters.get(id);
         if (existing) return existing.promise;
-        let resolve12;
+        let resolve13;
         const promise = new Promise((res) => {
-          resolve12 = res;
+          resolve13 = res;
         });
-        this.taskWaiters.set(id, { promise, resolve: resolve12 });
+        this.taskWaiters.set(id, { promise, resolve: resolve13 });
         return promise;
       })
     );
@@ -10400,10 +11059,10 @@ var Director = class _Director {
         pending: taskIds.filter((id) => !done.has(id))
       });
     }
-    return new Promise((resolve12) => {
+    return new Promise((resolve13) => {
       const entry = {
         ids: new Set(taskIds),
-        resolve: (r) => resolve12({
+        resolve: (r) => resolve13({
           completed: [r],
           pending: taskIds.filter((id) => id !== r.taskId)
         })
@@ -10411,7 +11070,7 @@ var Director = class _Director {
       if (opts?.timeoutMs !== void 0) {
         entry.timer = setTimeout(() => {
           this.anyWaiters.delete(entry);
-          resolve12({ completed: [], pending: [...taskIds], timedOut: true });
+          resolve13({ completed: [], pending: [...taskIds], timedOut: true });
         }, opts.timeoutMs);
       }
       this.anyWaiters.add(entry);
@@ -10643,6 +11302,7 @@ var Director = class _Director {
     const t = [
       makeSpawnTool(this, effectiveRoster),
       makeAssignTool(this),
+      makeKanbanQueueTool(this, effectiveRoster),
       makeAwaitTasksTool(this),
       makeAskTool(this),
       makeAskResultTool(this),
@@ -11600,9 +12260,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
     let cacheHit = false;
     try {
       const s = await fsp7.stat(file);
-      const stat11 = { mtimeMs: s.mtimeMs, size: s.size };
+      const stat12 = { mtimeMs: s.mtimeMs, size: s.size };
       const cached = this._loadCache.get(id);
-      if (cached && cached.mtimeMs === stat11.mtimeMs && cached.size === stat11.size) {
+      if (cached && cached.mtimeMs === stat12.mtimeMs && cached.size === stat12.size) {
         cacheHit = true;
         this._loadCache.delete(id);
         this._loadCache.set(id, cached);
@@ -11725,7 +12385,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
             this._loadCache.delete(oldest);
           }
         }
-        this._loadCache.set(id, { mtimeMs: stat11.mtimeMs, size: stat11.size, data });
+        this._loadCache.set(id, { mtimeMs: stat12.mtimeMs, size: stat12.size, data });
       }
       return data;
     } catch (err) {
@@ -11767,14 +12427,14 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const limit = opts?.limit;
     const signal = opts?.signal;
     const out = [];
-    let stat11;
+    let stat12;
     try {
-      stat11 = await fsp7.stat(file);
+      stat12 = await fsp7.stat(file);
     } catch (err) {
       if (err.code === "ENOENT") return [];
       throw err;
     }
-    if (stat11.size === 0) return [];
+    if (stat12.size === 0) return [];
     let fh;
     try {
       fh = await fsp7.open(file, "r");
@@ -11957,15 +12617,15 @@ var DefaultSessionStore = class _DefaultSessionStore {
    * Returns empty array when the index doesn't exist or is corrupt.
    */
   async readIndex() {
-    let stat11;
+    let stat12;
     try {
       const s = await fsp7.stat(this.indexFile);
-      stat11 = { mtimeMs: s.mtimeMs, size: s.size };
+      stat12 = { mtimeMs: s.mtimeMs, size: s.size };
     } catch {
       this._indexCache = null;
       return [];
     }
-    if (this._indexCache !== null && this._indexCache.mtimeMs === stat11.mtimeMs && this._indexCache.size === stat11.size) {
+    if (this._indexCache !== null && this._indexCache.mtimeMs === stat12.mtimeMs && this._indexCache.size === stat12.size) {
       return [...this._indexCache.summaries];
     }
     let raw;
@@ -11998,7 +12658,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       if (a.startedAt > b.startedAt) return -1;
       return a.id.localeCompare(b.id);
     });
-    this._indexCache = { ...stat11, summaries };
+    this._indexCache = { ...stat12, summaries };
     return [...summaries];
   }
   /**
@@ -12165,8 +12825,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
     if (fromManifest) return fromManifest;
     try {
       const full = this.sessionPath(id, ".jsonl");
-      const stat11 = await fsp7.stat(full);
-      const summary = await this.summarize(id, stat11.mtime.toISOString());
+      const stat12 = await fsp7.stat(full);
+      const summary = await this.summarize(id, stat12.mtime.toISOString());
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         const msg = toErrorMessage(err);
         this.emitError(id, manifest, "summary_fallback", msg, true);
@@ -12209,18 +12869,18 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async summaryHeaderFor(ref) {
     let mtime = (/* @__PURE__ */ new Date(0)).toISOString();
     try {
-      const stat11 = await fsp7.stat(ref.filePath);
-      if (!stat11.isFile()) {
+      const stat12 = await fsp7.stat(ref.filePath);
+      if (!stat12.isFile()) {
         return {
           id: ref.id,
           title: "(damaged)",
-          startedAt: stat11.mtime.toISOString(),
+          startedAt: stat12.mtime.toISOString(),
           model: "unknown",
           provider: "unknown",
           tokenTotal: 0
         };
       }
-      mtime = stat11.mtime.toISOString();
+      mtime = stat12.mtime.toISOString();
     } catch {
       return null;
     }
@@ -12376,8 +13036,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const pruneFile = async (dir, name, prefix) => {
       const jsonlPath = path4.join(dir, name);
       try {
-        const stat11 = await fsp7.stat(jsonlPath);
-        if (stat11.mtimeMs >= cutoff) return;
+        const stat12 = await fsp7.stat(jsonlPath);
+        if (stat12.mtimeMs >= cutoff) return;
       } catch {
         return;
       }
@@ -13712,6 +14372,7 @@ var DEFAULT_TOOLS_CONFIG = Object.freeze({
   defaultExecutionStrategy: "smart",
   maxIterations: 100,
   iterationTimeoutMs: 3e5,
+  maxToolTimeoutMs: 3e5,
   sessionTimeoutMs: 18e5,
   perIterationOutputCapBytes: 1e5,
   descriptionMode: Object.freeze({}),
@@ -14355,12 +15016,12 @@ function verifyFiles(tokens, files) {
   const violations = [];
   let onPalette = 0;
   let offPalette = 0;
-  for (const { path: path32, text } of files) {
+  for (const { path: path33, text } of files) {
     const lines = text.split("\n");
     lines.forEach((lineText, i) => {
       const lineNo = i + 1;
       const flag = (snippet, reason) => {
-        violations.push({ file: path32, line: lineNo, snippet: snippet.slice(0, 80), reason });
+        violations.push({ file: path33, line: lineNo, snippet: snippet.slice(0, 80), reason });
       };
       for (const re of [HEX_RE, FUNC_COLOR_RE]) {
         re.lastIndex = 0;
@@ -14412,14 +15073,14 @@ var SKIP_DIR = /* @__PURE__ */ new Set([
   ".design"
 ]);
 async function walkUiFiles(root, max = 200) {
-  const { default: fs16 } = await import('fs/promises');
+  const { default: fs17 } = await import('fs/promises');
   const { default: nodePath } = await import('path');
   const found = [];
   async function rec(dir, depth) {
     if (found.length >= max || depth > 8) return;
     let entries;
     try {
-      entries = await fs16.readdir(dir, { withFileTypes: true });
+      entries = await fs17.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -14437,13 +15098,13 @@ async function walkUiFiles(root, max = 200) {
   return found;
 }
 async function runDesignVerify(projectRoot, tokens, explicitFiles) {
-  const { default: fs16 } = await import('fs/promises');
+  const { default: fs17 } = await import('fs/promises');
   const { default: nodePath } = await import('path');
   const abs = explicitFiles && explicitFiles.length > 0 ? explicitFiles.map((f) => nodePath.isAbsolute(f) ? f : nodePath.join(projectRoot, f)) : await walkUiFiles(projectRoot);
   const files = [];
   for (const a of abs) {
     try {
-      files.push({ path: nodePath.relative(projectRoot, a), text: await fs16.readFile(a, "utf8") });
+      files.push({ path: nodePath.relative(projectRoot, a), text: await fs17.readFile(a, "utf8") });
     } catch {
     }
   }
@@ -14574,10 +15235,10 @@ function makeDesignVerifyToolCallMiddleware() {
         const p = typeof input?.path === "string" ? input.path : "";
         if (!p || !detectFrontendFile(p)) return out;
         const ctx = out.ctx;
-        const { default: fs16 } = await import('fs/promises');
+        const { default: fs17 } = await import('fs/promises');
         const { default: nodePath } = await import('path');
         const abs = nodePath.isAbsolute(p) ? p : nodePath.join(ctx.projectRoot, p);
-        const text = await fs16.readFile(abs, "utf8").catch(() => "");
+        const text = await fs17.readFile(abs, "utf8").catch(() => "");
         if (!text) return out;
         const loader = getDesignKitLoader(ctx.projectRoot);
         const rawTokens = await loader.readTokens(state.activeKit);
@@ -15529,8 +16190,8 @@ ${recentJournal}` : "No prior iterations.",
       await saveGoal(this.goalPath, abandoned, this.opts.events);
     }
     try {
-      const { unlink: unlink15 } = await import('fs/promises');
-      await unlink15(this.goalPath);
+      const { unlink: unlink16 } = await import('fs/promises');
+      await unlink16(this.goalPath);
     } catch {
     }
     this.opts.onEternalStop?.();
@@ -16472,8 +17133,8 @@ async function streamProviderToResponse(provider, req, signal, ctx, events, logg
         });
         await Promise.race([
           drainPromise,
-          new Promise((resolve12) => {
-            drainTimer = setTimeout(resolve12, STREAM_DRAIN_TIMEOUT_MS);
+          new Promise((resolve13) => {
+            drainTimer = setTimeout(resolve13, STREAM_DRAIN_TIMEOUT_MS);
           })
         ]);
       } finally {
@@ -16584,7 +17245,7 @@ async function runProviderWithRetry(opts) {
           description
         });
       }
-      await new Promise((resolve12, reject) => {
+      await new Promise((resolve13, reject) => {
         let settled = false;
         const cleanup = () => {
           clearTimeout(t);
@@ -16600,7 +17261,7 @@ async function runProviderWithRetry(opts) {
           if (settled) return;
           settled = true;
           cleanup();
-          resolve12();
+          resolve13();
         }, delay);
         if (signal.aborted) {
           onAbort();
@@ -16750,7 +17411,14 @@ IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiv
       raw = textBlocks.map((b) => b.text).join("\n").trim();
     } catch (err) {
       if (err instanceof Error) {
-        console.warn("[LLMSelector] selector call failed, using recency fallback:", err.message);
+        console.warn(
+          JSON.stringify({
+            level: "warn",
+            event: "llm_selector.call_failed",
+            message: `selector call failed, using recency fallback: ${err.message}`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
       }
       return this.fallbackSelect(messages, effectiveBudget);
     } finally {
@@ -19017,6 +19685,7 @@ var githubServer = () => ({
   transport: "stdio",
   command: "npx",
   args: ["-y", "@modelcontextprotocol/server-github"],
+  passthroughEnv: ["GITHUB_PERSONAL_ACCESS_TOKEN", "GITHUB_TOKEN"],
   permission: "confirm"
 });
 var context7Server = () => ({
@@ -19032,6 +19701,7 @@ var braveSearchServer = () => ({
   transport: "stdio",
   command: "npx",
   args: ["-y", "@modelcontextprotocol/server-brave-search"],
+  passthroughEnv: ["BRAVE_SEARCH_API_KEY"],
   permission: "confirm"
 });
 var blockServer = () => ({
@@ -19048,6 +19718,7 @@ var everArtServer = () => ({
   transport: "stdio",
   command: "npx",
   args: ["-y", "@modelcontextprotocol/server-everart"],
+  passthroughEnv: ["EVERART_API_KEY"],
   permission: "confirm"
 });
 var slackServer = () => ({
@@ -19056,6 +19727,7 @@ var slackServer = () => ({
   transport: "stdio",
   command: "npx",
   args: ["-y", "@modelcontextprotocol/server-slack"],
+  passthroughEnv: ["SLACK_BOT_TOKEN", "SLACK_TEAM_ID"],
   permission: "confirm"
 });
 var awsServer = () => ({
@@ -19064,6 +19736,7 @@ var awsServer = () => ({
   transport: "stdio",
   command: "npx",
   args: ["-y", "@modelcontextprotocol/server-aws"],
+  passthroughEnv: ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_REGION", "AWS_SESSION_TOKEN"],
   permission: "confirm"
 });
 var googleMapsServer = () => ({
@@ -19072,6 +19745,7 @@ var googleMapsServer = () => ({
   transport: "stdio",
   command: "npx",
   args: ["-y", "@modelcontextprotocol/server-google-maps"],
+  passthroughEnv: ["GOOGLE_MAPS_API_KEY"],
   permission: "confirm"
 });
 var sentinelServer = () => ({
@@ -19089,6 +19763,7 @@ var zaiVisionServer = () => ({
   command: "npx",
   args: ["-y", "@z_ai/mcp-server@latest"],
   env: { Z_AI_MODE: "ZAI" },
+  passthroughEnv: ["Z_AI_API_KEY"],
   allowedTools: [
     "image_analysis",
     "extract_text_from_screenshot",
@@ -19118,6 +19793,7 @@ var miniMaxVisionServer = () => ({
     MINIMAX_API_HOST: "https://api.minimax.io",
     MINIMAX_API_RESOURCE_MODE: "url"
   },
+  passthroughEnv: ["MINIMAX_API_KEY"],
   allowedTools: ["understand_image"],
   permission: "auto"
 });
@@ -19392,8 +20068,8 @@ async function loadProjectModes(modesDir) {
     for (const entry of entries) {
       if (!entry.endsWith(".md") && !entry.endsWith(".txt")) continue;
       const filePath = path4.join(modesDir, entry);
-      const stat11 = await fsp7.stat(filePath);
-      if (!stat11.isFile()) continue;
+      const stat12 = await fsp7.stat(filePath);
+      if (!stat12.isFile()) continue;
       const content = await fsp7.readFile(filePath, "utf8");
       const id = path4.basename(entry, path4.extname(entry));
       modes.push({
@@ -19452,10 +20128,19 @@ var FAMILY_BY_NPM = {
   "@ai-sdk/deepseek": "openai-compatible",
   "@ai-sdk/google": "google"
 };
+var FAMILY_BY_PROVIDER_ID = {
+  "anthropic-oauth": "anthropic-oauth",
+  "github-copilot": "github-copilot",
+  "openai-codex": "openai-codex"
+};
 function classifyFamily(npm) {
   if (!npm) return "unsupported";
   return FAMILY_BY_NPM[npm] ?? "unsupported";
 }
+function classifyProviderFamily(p) {
+  const byNpm = classifyFamily(p.npm);
+  return byNpm !== "unsupported" ? byNpm : FAMILY_BY_PROVIDER_ID[p.id] ?? "unsupported";
+}
 var DefaultModelsRegistry = class {
   /** Merged (base + overlay) payload — what every reader sees. */
   payload;
@@ -19721,7 +20406,7 @@ var DefaultModelsRegistry = class {
     return {
       id: p.id,
       name: p.name,
-      family: classifyFamily(p.npm),
+      family: classifyProviderFamily(p),
       apiBase: p.api,
       envVars: p.env ?? [],
       doc: p.doc,
@@ -19968,9 +20653,9 @@ var DefaultHealthRegistry = class {
   }
   async runOne(check) {
     let timer = null;
-    const timeout = new Promise((resolve12) => {
+    const timeout = new Promise((resolve13) => {
       timer = setTimeout(
-        () => resolve12({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
+        () => resolve13({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
         this.timeoutMs
       );
     });
@@ -20154,7 +20839,7 @@ async function startMetricsServer(opts) {
   const tls = opts.tls;
   const useHttps = !!(tls?.cert && tls?.key);
   const host = opts.host ?? "127.0.0.1";
-  const path32 = opts.path ?? "/metrics";
+  const path33 = opts.path ?? "/metrics";
   const healthPath = opts.healthPath ?? "/healthz";
   const healthRegistry = opts.healthRegistry;
   const listener = (req, res) => {
@@ -20164,7 +20849,7 @@ async function startMetricsServer(opts) {
       return;
     }
     const url = req.url.split("?")[0];
-    if (url === path32) {
+    if (url === path33) {
       let body;
       try {
         body = renderPrometheus(opts.sink.snapshot());
@@ -20210,14 +20895,14 @@ async function startMetricsServer(opts) {
     const { createServer } = await import('http');
     server = createServer(listener);
   }
-  await new Promise((resolve12, reject) => {
+  await new Promise((resolve13, reject) => {
     const onError = (err) => {
       server.off("listening", onListening);
       reject(err);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve12();
+      resolve13();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -20228,9 +20913,9 @@ async function startMetricsServer(opts) {
   const protocol = useHttps ? "https" : "http";
   return {
     port: boundPort,
-    url: `${protocol}://${host}:${boundPort}${path32}`,
-    close: () => new Promise((resolve12, reject) => {
-      server.close((err) => err ? reject(err) : resolve12());
+    url: `${protocol}://${host}:${boundPort}${path33}`,
+    close: () => new Promise((resolve13, reject) => {
+      server.close((err) => err ? reject(err) : resolve13());
     })
   };
 }
@@ -20699,15 +21384,15 @@ function computeCriticalPath(graph, _topoOrder, blockedByMap) {
       maxId = id;
     }
   }
-  const path32 = [];
+  const path33 = [];
   let current = maxId;
   const visited = /* @__PURE__ */ new Set();
   while (current && !visited.has(current)) {
     visited.add(current);
-    path32.unshift(current);
+    path33.unshift(current);
     current = prev.get(current) ?? null;
   }
-  return path32;
+  return path33;
 }
 function computeParallelGroups(graph, blockedByMap) {
   const groups = [];
@@ -21773,9 +22458,9 @@ var AISpecBuilder = class {
     if (!this.sessionPath) return;
     try {
       const fsp20 = await import('fs/promises');
-      const path32 = await import('path');
+      const path33 = await import('path');
       const { atomicWrite: atomicWrite2 } = await Promise.resolve().then(() => (init_atomic_write(), atomic_write_exports));
-      await fsp20.mkdir(path32.dirname(this.sessionPath), { recursive: true });
+      await fsp20.mkdir(path33.dirname(this.sessionPath), { recursive: true });
       await atomicWrite2(this.sessionPath, JSON.stringify(this.session, null, 2));
     } catch {
     }
@@ -25984,7 +26669,7 @@ function makeCommandVerifier(options = {}) {
   return async function verifyTask(info) {
     const cmd = info.task.metadata?.[metadataKey];
     if (typeof cmd !== "string" || !cmd.trim()) return { ok: true };
-    return await new Promise((resolve12) => {
+    return await new Promise((resolve13) => {
       const isWindows = process.platform === "win32";
       const [shell, ...shellArgs] = isWindows ? ["cmd", "/d", "/c"] : ["sh", "-c"];
       const child = spawn(shell, [...shellArgs, cmd], {
@@ -25997,19 +26682,19 @@ function makeCommandVerifier(options = {}) {
       const timer = setTimeout(() => {
         timedOut = true;
         child.kill();
-        resolve12({ ok: false, reason: `verification timed out: ${cmd}` });
+        resolve13({ ok: false, reason: `verification timed out: ${cmd}` });
       }, timeoutMs);
       child.on("exit", (code) => {
         clearTimeout(timer);
         if (timedOut) return;
-        resolve12(
+        resolve13(
           code === 0 ? { ok: true } : { ok: false, reason: `verification failed (exit ${code}): ${cmd}` }
         );
       });
       child.on("error", (err) => {
         clearTimeout(timer);
         if (timedOut) return;
-        resolve12({ ok: false, reason: `verification spawn error: ${String(err)}` });
+        resolve13({ ok: false, reason: `verification spawn error: ${String(err)}` });
       });
     });
   };
@@ -26110,8 +26795,8 @@ function pathLooksInsideProject(rawPath, projectRoot) {
   if (!projectRoot) return false;
   if (rawPath === "~" || rawPath.startsWith("~/") || rawPath.startsWith("~\\")) return false;
   const resolved = path4.resolve(projectRoot, rawPath);
-  const relative4 = path4.relative(projectRoot, resolved);
-  return !!relative4 && !relative4.startsWith("..") && !path4.isAbsolute(relative4);
+  const relative5 = path4.relative(projectRoot, resolved);
+  return !!relative5 && !relative5.startsWith("..") && !path4.isAbsolute(relative5);
 }
 function tokenizeShell(command) {
   return command.match(/"[^"]*"|'[^']*'|\S+/g)?.map((token) => token.replace(/^['"]|['"]$/g, "")) ?? [];
@@ -26427,6 +27112,12 @@ var DefaultPermissionPolicy = class {
     return false;
   }
   isDestructiveYoloCall(tool, input, ctx) {
+    if (tool.name === "mcp_control") {
+      const action = getInputString(input, "action");
+      if (action === "list" || action === "search" || action === "activate" || action === "deactivate") {
+        return false;
+      }
+    }
     if (this.isDestructiveByCapability(tool)) {
       const caps = tool.capabilities ?? [];
       if (caps.includes(ToolCapabilities.SHELL_ARBITRARY) || caps.includes(ToolCapabilities.SHELL_RESTRICTED) || caps.includes(ToolCapabilities.SHELL_EXEC)) {
@@ -26833,8 +27524,8 @@ function unwrapDataKey(buf, keyFile) {
 function checkKeyFilePermissions(keyFile) {
   if (process.platform === "win32") return;
   try {
-    const stat11 = fs12.statSync(keyFile);
-    const actualMode = stat11.mode & 511;
+    const stat12 = fs13.statSync(keyFile);
+    const actualMode = stat12.mode & 511;
     if (actualMode !== KEY_FILE_MODE) {
       console.warn(JSON.stringify({
         level: "warn",
@@ -26922,16 +27613,16 @@ var DefaultSecretVault = class {
     const oldVersion = this._keyVersion;
     const newKey = randomBytes(KEY_BYTES);
     const newVersion = oldVersion + 1;
-    fs12.mkdirSync(path4.dirname(this.keyFile), { recursive: true });
+    fs13.mkdirSync(path4.dirname(this.keyFile), { recursive: true });
     const passphrase = getVaultPassphrase();
     if (passphrase) {
-      fs12.writeFileSync(this.keyFile, wrapDataKey(newKey, newVersion, passphrase), { mode: 384 });
+      fs13.writeFileSync(this.keyFile, wrapDataKey(newKey, newVersion, passphrase), { mode: 384 });
     } else {
       const keyFileBuf = Buffer.alloc(VERSIONED_KEY_FILE_SIZE);
       KEY_FILE_MAGIC.copy(keyFileBuf, 0);
       keyFileBuf[KEY_FILE_MAGIC.length] = newVersion;
       newKey.copy(keyFileBuf, KEY_FILE_MAGIC.length + 1);
-      fs12.writeFileSync(this.keyFile, keyFileBuf, { mode: 384 });
+      fs13.writeFileSync(this.keyFile, keyFileBuf, { mode: 384 });
     }
     checkKeyFilePermissions(this.keyFile);
     this.key = newKey;
@@ -26949,7 +27640,7 @@ var DefaultSecretVault = class {
     const passphrase = getVaultPassphrase();
     if (!passphrase || !this.key) return;
     try {
-      fs12.writeFileSync(this.keyFile, wrapDataKey(this.key, this._keyVersion, passphrase), {
+      fs13.writeFileSync(this.keyFile, wrapDataKey(this.key, this._keyVersion, passphrase), {
         mode: 384
       });
       checkKeyFilePermissions(this.keyFile);
@@ -26959,7 +27650,7 @@ var DefaultSecretVault = class {
   loadOrCreateKey() {
     if (this.key) return this.key;
     try {
-      const buf = fs12.readFileSync(this.keyFile);
+      const buf = fs13.readFileSync(this.keyFile);
       if (isWrappedKeyFile(buf)) {
         const { key: key2, version } = unwrapDataKey(buf, this.keyFile);
         this.key = key2;
@@ -27006,15 +27697,15 @@ var DefaultSecretVault = class {
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
-    fs12.mkdirSync(path4.dirname(this.keyFile), { recursive: true });
+    fs13.mkdirSync(path4.dirname(this.keyFile), { recursive: true });
     const key = randomBytes(KEY_BYTES);
     const passphrase = getVaultPassphrase();
     const initialBytes = passphrase ? wrapDataKey(key, 1, passphrase) : key;
     try {
-      fs12.writeFileSync(this.keyFile, initialBytes, { mode: 384, flag: "wx" });
+      fs13.writeFileSync(this.keyFile, initialBytes, { mode: 384, flag: "wx" });
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
-      const buf = fs12.readFileSync(this.keyFile);
+      const buf = fs13.readFileSync(this.keyFile);
       if (isWrappedKeyFile(buf)) {
         const { key: winnerKey, version } = unwrapDataKey(buf, this.keyFile);
         this.key = winnerKey;
@@ -27409,6 +28100,7 @@ var BEHAVIOR_DEFAULTS = {
     defaultExecutionStrategy: DEFAULT_TOOLS_CONFIG.defaultExecutionStrategy,
     maxIterations: DEFAULT_TOOLS_CONFIG.maxIterations,
     iterationTimeoutMs: DEFAULT_TOOLS_CONFIG.iterationTimeoutMs,
+    maxToolTimeoutMs: DEFAULT_TOOLS_CONFIG.maxToolTimeoutMs,
     sessionTimeoutMs: DEFAULT_TOOLS_CONFIG.sessionTimeoutMs,
     perIterationOutputCapBytes: DEFAULT_TOOLS_CONFIG.perIterationOutputCapBytes,
     descriptionMode: DEFAULT_TOOLS_CONFIG.descriptionMode,
@@ -28057,8 +28749,8 @@ var DefaultConfigLoader = class {
     const t0 = Date.now();
     let mtimeMs = null;
     try {
-      const stat11 = await fsp7.stat(file);
-      mtimeMs = stat11.mtimeMs;
+      const stat12 = await fsp7.stat(file);
+      mtimeMs = stat12.mtimeMs;
       const cached = this.jsonCache.get(file);
       if (cached && cached.mtimeMs === mtimeMs) {
         return structuredClone(cached.value);
@@ -28501,8 +29193,8 @@ var FileMemoryBackend = class {
   }
   async getMtime(file) {
     try {
-      const stat11 = await fsp7.stat(file);
-      return stat11.mtimeMs;
+      const stat12 = await fsp7.stat(file);
+      return stat12.mtimeMs;
     } catch {
       return 0;
     }
@@ -30104,8 +30796,8 @@ var DefaultSessionReader = class _DefaultSessionReader {
     const sessionPath = sessionScopedPath(rootDir, sessionId, ".jsonl");
     let mtimeMs = null;
     try {
-      const stat11 = await fsp7.stat(sessionPath);
-      mtimeMs = stat11.mtimeMs;
+      const stat12 = await fsp7.stat(sessionPath);
+      mtimeMs = stat12.mtimeMs;
     } catch {
       this.eventCache.delete(sessionId);
       this.eventCacheMtimes.delete(sessionId);