@wrongstack/core 0.282.1 → 0.283.0

package/dist/defaults/index.js

@@ -6689,6 +6689,16 @@ function getKanbanPath(projectRoot, boardId) {
   }
   return resolved;
 }
+function getKanbanEventsPath(projectRoot, boardId) {
+  assertValidBoardId(boardId);
+  const dir = path4.resolve(getKanbanDir(projectRoot));
+  const resolved = path4.resolve(dir, `${boardId}.events.jsonl`);
+  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("..");
 }
@@ -6741,6 +6751,14 @@ async function readBoard(projectRoot, boardRef) {
     throw err;
   }
 }
+async function appendKanbanEvent(projectRoot, boardId, event) {
+  const filePath = getKanbanEventsPath(projectRoot, boardId);
+  await withFileLock(filePath, async () => {
+    await fsp7.mkdir(path4.dirname(filePath), { recursive: true });
+    await fsp7.appendFile(filePath, `${JSON.stringify(event)}
+`, "utf8");
+  });
+}
 async function mutateBoard(projectRoot, boardRef, mutator) {
   const boardId = await resolveBoardRef(projectRoot, boardRef);
   if (!boardId) return null;
@@ -6839,9 +6857,12 @@ async function listBoards(projectRoot) {
   return listBoardSummaries(projectRoot);
 }
 async function updateTaskAssignment(projectRoot, boardId, taskId, patch) {
+  let event;
   const updated = await mutateBoard(projectRoot, boardId, (board) => {
     const task = findTask(board, taskId);
     if (!task) return null;
+    const previousColumnId = task.columnId;
+    const beforeAssignment = task.assignment ? { ...task.assignment } : void 0;
     const nextAssignment = {
       ...task.assignment ?? { status: "assigned" }
     };
@@ -6879,10 +6900,17 @@ async function updateTaskAssignment(projectRoot, boardId, taskId, patch) {
       }
       delete task.completedAt;
     }
+    syncTaskColumnForStatus(board, task, previousColumnId);
     task.updatedAt = nowIso();
     board.updatedAt = task.updatedAt;
+    event = createKanbanEvent(board.id, task, assignmentEventType(task.assignment.status), {
+      before: beforeAssignment,
+      after: { ...task.assignment },
+      note: patch.error ?? patch.lastResult
+    });
     return task;
   });
+  if (updated && event) await emitKanbanEvent(projectRoot, event);
   return updated?.result ? updated.board : null;
 }
 async function claimReadyTask(projectRoot, input = {}) {
@@ -6929,14 +6957,25 @@ function buildAssignment(input) {
     ...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.allowedCapabilities !== void 0 ? { allowedCapabilities: input.allowedCapabilities } : {},
+    ...input.leaseId !== void 0 ? { leaseId: input.leaseId } : {},
+    ...input.claimedAt !== void 0 ? { claimedAt: input.claimedAt } : {},
+    ...input.heartbeatAt !== void 0 ? { heartbeatAt: input.heartbeatAt } : {},
+    ...input.leaseExpiresAt !== void 0 ? { leaseExpiresAt: input.leaseExpiresAt } : {},
+    ...input.attempt !== void 0 ? { attempt: input.attempt } : {},
+    ...input.maxAttempts !== void 0 ? { maxAttempts: input.maxAttempts } : {},
+    ...input.costCeilingUsd !== void 0 ? { costCeilingUsd: input.costCeilingUsd } : {},
+    ...input.retryPolicy !== void 0 ? { retryPolicy: input.retryPolicy } : {},
+    ...input.lastFailureKind !== void 0 ? { lastFailureKind: input.lastFailureKind } : {}
   };
 }
 async function claimReadyTaskOnBoard(projectRoot, boardId, input) {
+  let event;
   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 previousColumnId = task.columnId;
     const current = task.assignment;
     const assignment = buildAssignment({
       ...current?.agentId !== void 0 ? { agentId: current.agentId } : {},
@@ -6948,6 +6987,15 @@ async function claimReadyTaskOnBoard(projectRoot, boardId, input) {
       ...current?.fallbackModels !== void 0 ? { fallbackModels: current.fallbackModels } : {},
       ...current?.tools !== void 0 ? { tools: current.tools } : {},
       ...current?.allowedCapabilities !== void 0 ? { allowedCapabilities: current.allowedCapabilities } : {},
+      ...current?.leaseId !== void 0 ? { leaseId: current.leaseId } : {},
+      ...current?.claimedAt !== void 0 ? { claimedAt: current.claimedAt } : {},
+      ...current?.heartbeatAt !== void 0 ? { heartbeatAt: current.heartbeatAt } : {},
+      ...current?.leaseExpiresAt !== void 0 ? { leaseExpiresAt: current.leaseExpiresAt } : {},
+      ...current?.attempt !== void 0 ? { attempt: current.attempt } : {},
+      ...current?.maxAttempts !== void 0 ? { maxAttempts: current.maxAttempts } : {},
+      ...current?.costCeilingUsd !== void 0 ? { costCeilingUsd: current.costCeilingUsd } : {},
+      ...current?.retryPolicy !== void 0 ? { retryPolicy: current.retryPolicy } : {},
+      ...current?.lastFailureKind !== void 0 ? { lastFailureKind: current.lastFailureKind } : {},
       ...input.agentId !== void 0 ? { agentId: input.agentId } : {},
       ...input.name !== void 0 ? { name: input.name } : {},
       ...input.role !== void 0 ? { role: input.role } : {},
@@ -6957,10 +7005,20 @@ async function claimReadyTaskOnBoard(projectRoot, boardId, input) {
       ...input.fallbackModels !== void 0 ? { fallbackModels: input.fallbackModels } : {},
       ...input.tools !== void 0 ? { tools: input.tools } : {},
       ...input.allowedCapabilities !== void 0 ? { allowedCapabilities: input.allowedCapabilities } : {},
+      ...input.leaseId !== void 0 ? { leaseId: input.leaseId } : {},
+      ...input.claimedAt !== void 0 ? { claimedAt: input.claimedAt } : {},
+      ...input.heartbeatAt !== void 0 ? { heartbeatAt: input.heartbeatAt } : {},
+      ...input.leaseExpiresAt !== void 0 ? { leaseExpiresAt: input.leaseExpiresAt } : {},
+      ...input.attempt !== void 0 ? { attempt: input.attempt } : {},
+      ...input.maxAttempts !== void 0 ? { maxAttempts: input.maxAttempts } : {},
+      ...input.costCeilingUsd !== void 0 ? { costCeilingUsd: input.costCeilingUsd } : {},
+      ...input.retryPolicy !== void 0 ? { retryPolicy: input.retryPolicy } : {},
+      ...input.lastFailureKind !== void 0 ? { lastFailureKind: input.lastFailureKind } : {},
       ...input.assignee !== void 0 ? { assignee: input.assignee } : {},
       status: input.status ?? "queued"
     });
-    assignment.dispatchedAt = assignment.dispatchedAt ?? nowIso();
+    assignment.claimedAt = assignment.claimedAt ?? nowIso();
+    assignment.dispatchedAt = assignment.dispatchedAt ?? assignment.claimedAt;
     task.assignment = assignment;
     if (assignment.agentId ?? assignment.role ?? assignment.name) {
       task.assignedAgent = assignment.agentId ?? assignment.role ?? assignment.name;
@@ -6970,10 +7028,16 @@ async function claimReadyTaskOnBoard(projectRoot, boardId, input) {
     }
     task.status = assignment.status === "running" ? "in_progress" : "ready";
     delete task.completedAt;
+    syncTaskColumnForStatus(board, task, previousColumnId);
     task.updatedAt = nowIso();
     board.updatedAt = task.updatedAt;
+    event = createKanbanEvent(board.id, task, "task.claimed", {
+      before: current ? { ...current } : void 0,
+      after: { ...assignment }
+    });
     return task;
   });
+  if (updated && event) await emitKanbanEvent(projectRoot, event);
   return updated?.result ? { board: updated.board, task: updated.result } : null;
 }
 function compareTasksForWork(a, b) {
@@ -7007,6 +7071,18 @@ function findTask(board, taskId) {
   }
   return matches[0];
 }
+function existingColumnId(board, columnId) {
+  if (!columnId) return void 0;
+  const exact = board.columns.find((column) => column.id === columnId);
+  if (exact) return exact.id;
+  const matches = board.columns.filter((column) => column.id.startsWith(columnId));
+  if (matches.length > 1) {
+    throw new Error(
+      `Ambiguous kanban column id "${columnId}": ${matches.slice(0, 5).map((column) => column.id).join(", ")}`
+    );
+  }
+  return matches[0]?.id;
+}
 function isTaskReadyForWork(board, task) {
   if (!["pending", "ready"].includes(task.status)) return false;
   if (task.assignment && ["queued", "running"].includes(task.assignment.status)) return false;
@@ -7014,6 +7090,60 @@ function isTaskReadyForWork(board, task) {
   if (!areDependenciesMet(board, task.id)) return false;
   return true;
 }
+function createKanbanEvent(boardId, task, type, details = {}) {
+  return {
+    id: randomUUID(),
+    boardId,
+    taskId: task.id,
+    type,
+    ts: nowIso(),
+    ...task.assignment?.agentId !== void 0 ? { actor: task.assignment.agentId } : {},
+    ...task.assignment?.subagentId !== void 0 ? { subagentId: task.assignment.subagentId } : {},
+    ...task.assignment?.runTaskId !== void 0 ? { runTaskId: task.assignment.runTaskId } : {},
+    ...details
+  };
+}
+async function emitKanbanEvent(projectRoot, event) {
+  try {
+    await appendKanbanEvent(projectRoot, event.boardId, event);
+  } catch {
+  }
+}
+function assignmentEventType(status) {
+  return status === "completed" ? "task.assignment.completed" : status === "failed" ? "task.assignment.failed" : status === "running" ? "task.assignment.running" : status === "cancelled" ? "task.assignment.cancelled" : "task.assignment.updated";
+}
+function columnIdForKanbanStatus(board, status) {
+  const preferred = status === "completed" ? ["done", "completed"] : status === "in_progress" ? ["in-progress", "progress", "doing"] : status === "review" || status === "failed" ? ["review"] : status === "blocked" ? ["blocked", "backlog"] : status === "ready" ? ["todo", "ready", "backlog"] : status === "archived" ? ["done", "archive", "backlog"] : ["todo", "backlog"];
+  for (const columnRef of preferred) {
+    const columnId = existingColumnId(board, columnRef);
+    if (columnId) return columnId;
+  }
+  return board.columns[0]?.id;
+}
+function normalizeColumnTaskOrders(board, columnId) {
+  board.tasks.filter((task) => task.columnId === columnId).sort((a, b) => a.order - b.order || a.createdAt.localeCompare(b.createdAt)).forEach((task, index) => {
+    task.order = index;
+  });
+}
+function syncTaskColumnForStatus(board, task, previousColumnId) {
+  const nextColumnId = columnIdForKanbanStatus(board, task.status);
+  if (!nextColumnId || nextColumnId === task.columnId) return;
+  task.columnId = nextColumnId;
+  normalizeColumnTaskOrders(board, previousColumnId);
+  placeTaskInColumn(board, task, nextColumnId, void 0);
+}
+function placeTaskInColumn(board, task, columnId, targetOrder) {
+  const tasks = board.tasks.filter((candidate) => candidate.columnId === columnId && candidate.id !== task.id).sort((a, b) => a.order - b.order || a.createdAt.localeCompare(b.createdAt));
+  const index = clampOrder(targetOrder, tasks.length);
+  tasks.splice(index, 0, task);
+  tasks.forEach((candidate, order) => {
+    candidate.order = order;
+  });
+}
+function clampOrder(order, max) {
+  if (!Number.isFinite(order)) return max;
+  return Math.max(0, Math.min(Math.trunc(order), max));
+}
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -7145,6 +7275,9 @@ function makeLLMClassifier(complete) {
 }
 
 // src/coordination/director-tools.ts
+function nowIso2() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
 function makeSpawnTool(director, roster) {
   const inputSchema = {
     type: "object",
@@ -7702,8 +7835,8 @@ 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.',
+    description: "Claim dependency-ready Kanban tasks and dispatch them into the Director fleet. Preserves per-task provider/model/role/tool routing metadata, seeds lease metadata (claimedAt, leaseExpiresAt, heartbeatAt), assigns each claimed task to a spawned subagent, instructs workers to call kanban heartbeat_assignment periodically, and can await results while writing completion back to Kanban.",
+    usageHint: 'Use action:"dispatch_ready" with optional boardId/taskId/maxTasks. Set heartbeatIntervalMs (default 60s) and leaseTtlMs (default 5m) to size stale-recovery windows. 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],
@@ -7734,6 +7867,16 @@ function makeKanbanQueueTool(director, roster) {
           minimum: 1,
           description: "Optional per-assigned-task tool-call cap."
         },
+        heartbeatIntervalMs: {
+          type: "number",
+          minimum: 1e3,
+          description: "Suggested heartbeat interval for the worker. Default 60000 (60s). Workers are instructed to call kanban heartbeat_assignment at this cadence."
+        },
+        leaseTtlMs: {
+          type: "number",
+          minimum: 1e3,
+          description: "Lease time-to-live seeded on dispatch. Default 300000 (5m). Workers should refresh via heartbeat_assignment before expiry."
+        },
         agentId: { type: "string" },
         name: { type: "string" },
         role: { type: "string" },
@@ -7756,6 +7899,14 @@ function makeKanbanQueueTool(director, roster) {
       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 leaseTtlMs = Math.max(1e3, Math.floor(i.leaseTtlMs ?? 5 * 60 * 1e3));
+      const claimedAt = nowIso2();
+      const leaseSeeding = {
+        leaseId: randomUUID(),
+        claimedAt,
+        heartbeatAt: claimedAt,
+        leaseExpiresAt: new Date(Date.now() + leaseTtlMs).toISOString()
+      };
       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;
@@ -7776,6 +7927,7 @@ function makeKanbanQueueTool(director, roster) {
           ...i.fallbackModels !== void 0 ? { fallbackModels: i.fallbackModels } : {},
           ...i.tools !== void 0 ? { tools: i.tools } : {},
           ...i.allowedCapabilities !== void 0 ? { allowedCapabilities: i.allowedCapabilities } : {},
+          ...leaseSeeding !== void 0 ? leaseSeeding : {},
           status: "queued"
         });
         if (!claim) {
@@ -7784,13 +7936,34 @@ function makeKanbanQueueTool(director, roster) {
         }
         let subagentId;
         let runTaskId;
+        const costCeiling = claim.task.assignment?.costCeilingUsd;
+        if (costCeiling !== void 0) {
+          const remaining = director.getRemainingBudgetUsd();
+          if (remaining !== void 0 && remaining < costCeiling) {
+            await updateTaskAssignment(projectRoot, claim.board.id, claim.task.id, {
+              status: "failed",
+              error: `Cost ceiling ${costCeiling} exceeds remaining budget ${remaining.toFixed(4)}`,
+              lastResult: "Skipped by kanban_queue cost gate (Sprint 3)"
+            });
+            errors.push({
+              taskId: claim.task.id,
+              error: `Cost ceiling ${costCeiling} exceeds remaining budget ${remaining.toFixed(4)}`
+            });
+            continue;
+          }
+        }
         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),
+            description: buildKanbanFleetTaskPrompt(claim.board, claim.task, {
+              heartbeatIntervalMs: i.heartbeatIntervalMs ?? 6e4,
+              leaseTtlMs,
+              leaseId: leaseSeeding.leaseId,
+              leaseExpiresAt: leaseSeeding.leaseExpiresAt
+            }),
             ...i.maxToolCalls !== void 0 ? { maxToolCalls: i.maxToolCalls } : {},
             ...i.timeoutMs !== void 0 ? { timeoutMs: i.timeoutMs } : {},
             context: {
@@ -7888,7 +8061,9 @@ function normalizeKanbanQueueInput(input) {
     fallbackModels: stringArray(raw.fallbackModels),
     tools: stringArray(raw.tools),
     allowedCapabilities: stringArray(raw.allowedCapabilities),
-    worktree: normalizeWorktreeOverride(raw.worktree)
+    worktree: normalizeWorktreeOverride(raw.worktree),
+    heartbeatIntervalMs: typeof raw.heartbeatIntervalMs === "number" ? raw.heartbeatIntervalMs : void 0,
+    leaseTtlMs: typeof raw.leaseTtlMs === "number" ? raw.leaseTtlMs : void 0
   };
 }
 function buildKanbanSubagentConfig(task, input, roster) {
@@ -7906,7 +8081,8 @@ function buildKanbanSubagentConfig(task, input, roster) {
     ...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 } : {}
+    ...input.worktree !== void 0 ? { worktree: input.worktree } : {},
+    ...assignment?.costCeilingUsd !== void 0 ? { maxCostUsd: assignment.costCeilingUsd } : {}
   };
 }
 function ensureKanbanTool(tools) {
@@ -7926,7 +8102,7 @@ function matchesKanbanQueueQuery(task, query) {
     ...task.labels ?? []
   ].filter(Boolean).some((value) => String(value).toLowerCase().includes(normalized));
 }
-function buildKanbanFleetTaskPrompt(board, task) {
+function buildKanbanFleetTaskPrompt(board, task, lease) {
   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(
@@ -7973,9 +8149,24 @@ ${checks}` : "",
     metrics ? `Goal metrics:
 ${metrics}` : "",
     task.labels?.length ? `Labels: ${task.labels.join(", ")}` : "",
+    "Lease contract (Sprint 1):",
+    `- leaseId: ${lease.leaseId}`,
+    `- claimedAt: ${task.assignment?.claimedAt ?? "<unknown>"}`,
+    `- leaseExpiresAt: ${lease.leaseExpiresAt}`,
+    `- expected heartbeatIntervalMs: ${lease.heartbeatIntervalMs}`,
+    `- expected leaseTtlMs: ${lease.leaseTtlMs}`,
+    "",
+    "Retry policy:",
+    `- retryPolicy: ${task.assignment?.retryPolicy ?? task.retryPolicy ?? "<unset>"}`,
+    `- maxAttempts: ${task.assignment?.maxAttempts ?? "<unset>"}`,
+    `- costCeilingUsd: ${task.assignment?.costCeilingUsd ?? task.costCeilingUsd ?? "<unset>"}`,
     "",
     "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 you start, call kanban with action "mark_assignment", boardId "${board.id}", taskId "${task.id}", and assignmentStatus "running". Include subagentId and runTaskId when you have them.`,
+    `To stay alive in the queue, call kanban with action "heartbeat_assignment", boardId "${board.id}", taskId "${task.id}", and heartbeatAt set to the current time. Cadence must be <= heartbeatIntervalMs and well before leaseExpiresAt.`,
+    `When you finish, call kanban with action "mark_assignment", boardId "${board.id}", taskId "${task.id}", and assignmentStatus "completed" or "failed". Include lastResult or error.`,
+    `If you cannot finish in time, call kanban with action "heartbeat_assignment" to extend the lease, or with action "release_task" to release so another worker can claim. Do NOT silently abandon the assignment.`,
+    'On failure the host may call kanban with action "recover_stale" (mode: retry/release/fail); respect its decisions and do not duplicate work in parallel.',
     "When finished, report what changed, what you verified, and any remaining blockers."
   ].filter(Boolean).join("\n");
 }
@@ -10018,6 +10209,15 @@ var Director = class _Director {
   getLeaderContextPressure() {
     return this.leaderContextPressure;
   }
+  /**
+   * Remaining USD budget for the entire fleet (when a cap is configured).
+   * Returns `undefined` when no cap was set (Infinity).
+   */
+  getRemainingBudgetUsd() {
+    if (this.maxFleetCostUsd === Number.POSITIVE_INFINITY) return void 0;
+    const totalCost = this.usage.snapshot().total?.cost ?? 0;
+    return Math.max(0, this.maxFleetCostUsd - totalCost);
+  }
   resolveMaxContext() {
     const resolved = typeof this.maxContext === "function" ? this.maxContext() : this.maxContext;
     return resolved && resolved > 0 ? resolved : 128e3;
@@ -19889,107 +20089,170 @@ var DEFAULT_MODES = [
   {
     id: "default",
     name: "Default",
-    description: "General-purpose coding assistant",
+    description: "Balanced general-purpose mode; use when no special token/coverage trade-off is needed",
     prompt: "",
-    tags: ["general"]
+    tags: ["general", "balanced"]
+  },
+  {
+    id: "brief",
+    name: "Brief",
+    description: "Ultra-compact responses for low-context, high-speed work",
+    prompt: modePrompt("brief"),
+    tags: ["lite", "fast", "concise", "token-saving"],
+    toolPreferences: ["read", "edit", "bash"],
+    suggestedSkills: []
+  },
+  {
+    id: "review-lite",
+    name: "Review Lite",
+    description: "Token-saving code review: changed files only, top correctness/security risks",
+    prompt: modePrompt("review-lite"),
+    tags: ["lite", "review", "quality", "token-saving"],
+    toolPreferences: ["git", "diff", "read", "grep"],
+    suggestedSkills: ["bug-hunter", "typescript-strict"]
+  },
+  {
+    id: "audit-lite",
+    name: "Audit Lite",
+    description: "Token-saving security triage for a small diff or named file",
+    prompt: modePrompt("audit-lite"),
+    tags: ["lite", "security", "audit", "token-saving"],
+    toolPreferences: ["grep", "read", "git"],
+    suggestedSkills: ["security-scanner"]
+  },
+  {
+    id: "plan-lite",
+    name: "Plan Lite",
+    description: "Token-saving planning: 3-6 actionable steps, minimal design debate",
+    prompt: modePrompt("plan-lite"),
+    tags: ["lite", "planning", "architecture", "token-saving"],
+    toolPreferences: ["tree", "glob", "read", "grep"],
+    suggestedSkills: ["refactor-planner"]
+  },
+  {
+    id: "debug-lite",
+    name: "Debug Lite",
+    description: "Token-saving bug triage: one hypothesis, nearest evidence, narrow check",
+    prompt: modePrompt("debug-lite"),
+    tags: ["lite", "debug", "triage", "token-saving"],
+    toolPreferences: ["read", "grep", "test", "logs"],
+    suggestedSkills: ["bug-hunter"]
+  },
+  {
+    id: "test-lite",
+    name: "Test Lite",
+    description: "Token-saving tests: one focused regression or narrow verification target",
+    prompt: modePrompt("test-lite"),
+    tags: ["lite", "testing", "qa", "token-saving"],
+    toolPreferences: ["test", "read", "grep"],
+    suggestedSkills: ["testing"]
+  },
+  {
+    id: "refactor-lite",
+    name: "Refactor Lite",
+    description: "Token-saving cleanup: small scoped behavior-preserving changes",
+    prompt: modePrompt("refactor-lite"),
+    tags: ["lite", "refactor", "token-saving"],
+    toolPreferences: ["read", "edit", "test"],
+    suggestedSkills: ["typescript-strict"]
+  },
+  {
+    id: "research-lite",
+    name: "Research Lite",
+    description: "Token-saving web research: one search, one authoritative fetch, short answer",
+    prompt: modePrompt("research-lite"),
+    tags: ["lite", "research", "web", "token-saving"],
+    toolPreferences: ["search", "fetch"],
+    suggestedSkills: ["research-web"]
   },
   {
     id: "code-reviewer",
-    name: "Code Reviewer",
-    description: "Focus on code quality, best practices, and potential bugs",
+    name: "Review Deep",
+    description: "Comprehensive code review across contracts, edge cases, lifecycle, errors, concurrency",
     prompt: modePrompt("code-reviewer"),
-    tags: ["review", "quality", "security"],
+    tags: ["deep", "review", "quality", "security"],
     toolPreferences: ["read", "grep", "git", "diff", "test"],
     suggestedSkills: ["bug-hunter", "security-scanner", "typescript-strict", "testing"]
   },
   {
     id: "code-auditor",
-    name: "Code Auditor",
-    description: "Security-focused code analysis",
+    name: "Audit Deep",
+    description: "Comprehensive security audit with category coverage and exploitability notes",
     prompt: modePrompt("code-auditor"),
-    tags: ["security", "audit", "compliance"],
+    tags: ["deep", "security", "audit", "compliance"],
     toolPreferences: ["grep", "read", "audit", "bash"],
     suggestedSkills: ["security-scanner", "bug-hunter", "audit-log"]
   },
   {
     id: "architect",
-    name: "Software Architect",
-    description: "Design patterns, scalability, and system design",
+    name: "Architecture Deep",
+    description: "Comprehensive architecture and cross-module contract analysis",
     prompt: modePrompt("architect"),
-    tags: ["architecture", "design", "scalability"],
+    tags: ["deep", "architecture", "design", "scalability"],
     toolPreferences: ["read", "glob", "tree", "diff"],
     suggestedSkills: ["api-design", "refactor-planner", "node-modern", "docker-deploy"]
   },
   {
     id: "debugger",
-    name: "Debugger",
-    description: "Root cause analysis and error investigation",
+    name: "Debug Deep",
+    description: "Comprehensive root-cause analysis with traces, logs, assumptions, and verification",
     prompt: modePrompt("debugger"),
-    tags: ["debug", "investigation", "error-resolution"],
+    tags: ["deep", "debug", "investigation", "error-resolution"],
     toolPreferences: ["read", "grep", "bash", "logs", "test"],
     suggestedSkills: ["bug-hunter", "audit-log", "observability"]
   },
   {
     id: "tester",
-    name: "QA Engineer",
-    description: "Test coverage, edge cases, and quality assurance",
+    name: "Test Deep",
+    description: "Comprehensive QA mode for coverage, boundaries, isolation, and integration gaps",
     prompt: modePrompt("tester"),
-    tags: ["testing", "qa", "quality"],
+    tags: ["deep", "testing", "qa", "quality"],
     toolPreferences: ["read", "grep", "test", "bash"],
     suggestedSkills: ["testing", "bug-hunter", "typescript-strict"]
   },
   {
     id: "devops",
-    name: "DevOps Engineer",
-    description: "Infrastructure, deployment, and operations",
+    name: "DevOps Deep",
+    description: "Comprehensive infrastructure, deployment, observability, and operations review",
     prompt: modePrompt("devops"),
-    tags: ["devops", "infrastructure", "operations"],
+    tags: ["deep", "devops", "infrastructure", "operations"],
     toolPreferences: ["read", "bash", "grep", "logs", "git"],
     suggestedSkills: ["docker-deploy", "observability", "security-scanner"]
   },
   {
     id: "refactorer",
-    name: "Refactorer",
-    description: "Code improvement and modernization",
+    name: "Refactor Deep",
+    description: "Comprehensive modernization/refactor mode with contracts and verification discipline",
     prompt: modePrompt("refactorer"),
-    tags: ["refactor", "modernization", "improvement"],
+    tags: ["deep", "refactor", "modernization", "improvement"],
     toolPreferences: ["read", "edit", "test", "git", "grep"],
     suggestedSkills: ["refactor-planner", "typescript-strict", "node-modern", "testing"]
   },
   {
     id: "ui-design",
-    name: "UI Design",
-    description: "Design-first frontend & mobile UI work (Design Studio)",
+    name: "UI Design Deep",
+    description: "Comprehensive design-first frontend/mobile UI work with kit, tokens, and accessibility",
     prompt: modePrompt("ui-design"),
-    tags: ["ui", "frontend", "mobile", "design"],
+    tags: ["deep", "ui", "frontend", "mobile", "design"],
     toolPreferences: ["design", "write", "edit", "read", "scaffold"],
     suggestedSkills: ["react-modern"]
   },
-  {
-    id: "brief",
-    name: "Brief",
-    description: "Fast, no-nonsense \u2014 get to the point",
-    prompt: modePrompt("brief"),
-    tags: ["fast", "concise", "direct"],
-    toolPreferences: ["read", "edit", "bash"],
-    suggestedSkills: []
-  },
   {
     id: "teach",
-    name: "Teach",
-    description: "Mentor mode \u2014 explains why, not just what",
+    name: "Teach Deep",
+    description: "Mentor mode with explanations, mental models, trade-offs, and takeaways",
     prompt: modePrompt("teach"),
-    tags: ["teaching", "mentor", "learning"],
+    tags: ["deep", "teaching", "mentor", "learning"],
     toolPreferences: ["read", "edit", "explain"],
     suggestedSkills: ["prompt-engineering", "skill-creator", "node-modern", "typescript-strict"]
   },
   {
     id: "research-web",
-    name: "Research Web",
-    description: "Current-data research \u2014 search web, verify, inject findings into context",
+    name: "Research Deep",
+    description: "Comprehensive current-data research with cross-checking and reusable findings",
     prompt: modePrompt("research-web"),
-    tags: ["research", "web", "current-data", "up-to-date"],
-    toolPreferences: ["search/fetch", "search/fetch", "search", "fetch", "context_manager"],
+    tags: ["deep", "research", "web", "current-data", "up-to-date"],
+    toolPreferences: ["search", "fetch", "context_manager"],
     suggestedSkills: ["research-web", "tech-stack", "node-modern", "security-scanner", "react-modern"]
   }
 ];
@@ -29930,8 +30193,8 @@ ${body.trim()}`);
     if (!this.persistBackup || scope === "project-agents") return;
     try {
       const content = await this.backend.readAll(scope, this.files[scope]);
-      const { writeFile: writeFile9, mkdir: mkdir10 } = await import('fs/promises');
-      await mkdir10(this.backupDir, { recursive: true });
+      const { writeFile: writeFile9, mkdir: mkdir11 } = await import('fs/promises');
+      await mkdir11(this.backupDir, { recursive: true });
       await writeFile9(`${this.backupDir}/${scope}.md`, content, "utf8");
     } catch {
     }