@staff0rd/assist 0.230.0 → 0.231.0

package/README.md

@@ -235,7 +235,7 @@ The first backlog command in a repository that still has a local `.assist/backlo
 - `assist sessions` - Start the web dashboard (same as `sessions web`)
 - `assist sessions web [-p, --port <number>]` - Start the web dashboard with Sessions and Backlog tabs, xterm.js terminals (default port 3100)
 - `assist sessions summarise [-f, --force] [-n, --limit <count>]` - Generate one-line summaries for unsummarised Claude sessions (force re-generates all; limit caps how many to process)
-- `assist next` - Alias for `backlog next -w`
+- `assist next` - Alias for `backlog next`
 - `assist draft` (alias: `feat`) - Launch Claude in `/draft` mode, chain into next on `/next` signal
 - `assist bug` - Launch Claude in `/bug` mode, chain into next on `/next` signal
 - `assist refine [id]` - Launch Claude in `/refine` mode to refine a backlog item; prompts for selection when no id given

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.230.0",
+  version: "0.231.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -1058,57 +1058,28 @@ function getCurrentOrigin(cwd) {
   return `local:${root ?? cwd}`;
 }
 
-// src/commands/backlog/saveAllItems.ts
-import { eq as eq4, sql } from "drizzle-orm";
-
-// src/commands/backlog/deleteItemRelations.ts
+// src/commands/backlog/loadItem.ts
 import { eq as eq3 } from "drizzle-orm";
-async function deleteItemRelations(db, itemId) {
-  await db.delete(planTasks).where(eq3(planTasks.itemId, itemId));
-  await db.delete(planPhases).where(eq3(planPhases.itemId, itemId));
-  await db.delete(comments).where(eq3(comments.itemId, itemId));
-  await db.delete(links).where(eq3(links.itemId, itemId));
+async function loadItem(orm, id) {
+  const [row] = await orm.select().from(items).where(eq3(items.id, id));
+  if (!row) return void 0;
+  const rel = await loadRelations(orm, [id]);
+  return rowToItem(row, rel);
 }
 
 // src/commands/backlog/saveAllItems.ts
-async function upsertItem(db, item, origin) {
-  const values = itemColumns(item, origin);
-  await db.insert(items).values({ id: item.id, ...values }).onConflictDoUpdate({ target: items.id, set: values });
-  await deleteItemRelations(db, item.id);
-  await insertItemRelations(db, item);
-}
-async function resyncSequences(db) {
-  await db.execute(
-    sql`SELECT setval(pg_get_serial_sequence('items', 'id'), COALESCE((SELECT MAX(id) FROM items), 0) + 1, false)`
-  );
-  await db.execute(
-    sql`SELECT setval(pg_get_serial_sequence('comments', 'id'), COALESCE((SELECT MAX(id) FROM comments), 0) + 1, false)`
-  );
-}
-async function saveAllItems(orm, file, origin) {
-  await orm.transaction(async (tx) => {
-    const existingIds = await tx.select({ id: items.id }).from(items).where(eq4(items.origin, origin));
-    const newIds = new Set(file.map((i) => i.id));
-    for (const { id } of existingIds) {
-      if (!newIds.has(id)) {
-        await deleteItemRelations(tx, id);
-        await tx.delete(items).where(eq4(items.id, id));
-      }
-    }
-    for (const item of file) {
-      await upsertItem(tx, item, origin);
-    }
-    await resyncSequences(tx);
-  });
-}
+import { eq as eq5, sql } from "drizzle-orm";
+
+// src/commands/backlog/deleteItemRelations.ts
+import { eq as eq4 } from "drizzle-orm";
 
 // src/commands/backlog/searchItemIds.ts
-import { and, asc as asc3, eq as eq5, ilike, or } from "drizzle-orm";
+import { and, asc as asc3, eq as eq6, ilike, or } from "drizzle-orm";
 async function searchItemIds(orm, query, origin) {
   const pattern2 = `%${query}%`;
-  const rows = await orm.selectDistinct({ id: items.id }).from(items).leftJoin(comments, eq5(comments.itemId, items.id)).leftJoin(planPhases, eq5(planPhases.itemId, items.id)).where(
+  const rows = await orm.selectDistinct({ id: items.id }).from(items).leftJoin(comments, eq6(comments.itemId, items.id)).leftJoin(planPhases, eq6(planPhases.itemId, items.id)).where(
     and(
-      origin ? eq5(items.origin, origin) : void 0,
+      origin ? eq6(items.origin, origin) : void 0,
       or(
         ilike(items.name, pattern2),
         ilike(items.description, pattern2),
@@ -1122,15 +1093,15 @@ async function searchItemIds(orm, query, origin) {
 }
 
 // src/commands/backlog/updateCurrentPhase.ts
-import { eq as eq6 } from "drizzle-orm";
+import { eq as eq7 } from "drizzle-orm";
 async function updateCurrentPhase(orm, id, phase) {
-  await orm.update(items).set({ currentPhase: phase }).where(eq6(items.id, id));
+  await orm.update(items).set({ currentPhase: phase }).where(eq7(items.id, id));
 }
 
 // src/commands/backlog/updateStatus.ts
-import { eq as eq7 } from "drizzle-orm";
+import { eq as eq8 } from "drizzle-orm";
 async function updateStatus(orm, id, status2) {
-  const [row] = await orm.update(items).set({ status: status2 }).where(eq7(items.id, id)).returning({ name: items.name });
+  const [row] = await orm.update(items).set({ status: status2 }).where(eq8(items.id, id)).returning({ name: items.name });
   return row?.name;
 }
 
@@ -1162,21 +1133,15 @@ async function searchBacklog(query) {
   const allItems = await loadAllItems(orm, origin);
   return allItems.filter((item) => ids.includes(item.id));
 }
-async function saveBacklog(items2) {
+async function findOneItem(id) {
+  const numId = Number.parseInt(id, 10);
   const { orm } = await getReady();
-  await saveAllItems(orm, items2, getOrigin());
-}
-function findItem(items2, id) {
-  return items2.find((item) => item.id === id);
-}
-async function loadAndFindItem(id) {
-  const items2 = await loadBacklog();
-  const item = findItem(items2, Number.parseInt(id, 10));
+  const item = Number.isNaN(numId) ? void 0 : await loadItem(orm, numId);
   if (!item) {
     console.log(chalk6.red(`Item #${id} not found.`));
     return void 0;
   }
-  return { items: items2, item };
+  return { orm, item };
 }
 async function setStatus(id, status2) {
   const { orm } = await getReady();
@@ -1330,9 +1295,9 @@ function resolvePlan(item) {
 
 // src/commands/backlog/prepareRun.ts
 async function prepareRun(id) {
-  const result = await loadAndFindItem(id);
-  if (!result) return void 0;
-  const { item } = result;
+  const found = await findOneItem(id);
+  if (!found) return void 0;
+  const { item } = found;
   const plan2 = resolvePlan(item);
   const startPhase = (item.currentPhase ?? 1) - 1;
   if (item.status === "done") {
@@ -1596,9 +1561,9 @@ async function executePhase(item, phaseIndex, phases, spawnOptions) {
 
 // src/commands/backlog/reloadPlan.ts
 async function reloadPlan(id) {
-  const result = await loadAndFindItem(String(id));
-  if (!result) return void 0;
-  return resolvePlan(result.item);
+  const found = await findOneItem(String(id));
+  if (!found) return void 0;
+  return resolvePlan(found.item);
 }
 
 // src/commands/backlog/runPhases.ts
@@ -1750,9 +1715,9 @@ async function appendComment(orm, itemId, text2, opts = {}) {
 }
 
 // src/commands/backlog/getItemStatus.ts
-import { eq as eq8 } from "drizzle-orm";
+import { eq as eq9 } from "drizzle-orm";
 async function getItemStatus(orm, id) {
-  const [row] = await orm.select({ status: items.status }).from(items).where(eq8(items.id, id));
+  const [row] = await orm.select({ status: items.status }).from(items).where(eq9(items.id, id));
   return row?.status;
 }
 
@@ -1789,9 +1754,9 @@ async function phaseDone(id, phase, summary) {
 // src/commands/backlog/plan.ts
 import chalk15 from "chalk";
 async function plan(id) {
-  const result = await loadAndFindItem(id);
-  if (!result) return;
-  const { item } = result;
+  const found = await findOneItem(id);
+  if (!found) return;
+  const { item } = found;
   if (!item.plan || item.plan.length === 0) {
     console.log(chalk15.dim("No plan defined for this item."));
     return;
@@ -1823,12 +1788,30 @@ function formatComment(entry) {
 
 // src/commands/backlog/show/printLinks.ts
 import chalk17 from "chalk";
-function printLinks(item, items2) {
+
+// src/commands/backlog/show/loadLinkTargets.ts
+import { inArray as inArray2 } from "drizzle-orm";
+async function loadLinkTargets(orm, ids) {
+  if (ids.length === 0) return [];
+  const rows = await orm.select({ id: items.id, name: items.name, status: items.status }).from(items).where(inArray2(items.id, ids));
+  return rows.map((r) => ({
+    id: r.id,
+    name: r.name,
+    status: r.status
+  }));
+}
+
+// src/commands/backlog/show/printLinks.ts
+async function printLinks(orm, item) {
   const links2 = item.links ?? [];
   if (links2.length === 0) return;
+  const targets = await loadLinkTargets(
+    orm,
+    links2.map((l) => l.targetId)
+  );
   console.log(chalk17.bold("Links"));
   for (const link3 of links2) {
-    const target = items2.find((i) => i.id === link3.targetId);
+    const target = targets.find((i) => i.id === link3.targetId);
     const typeLabel2 = link3.type === "depends-on" ? chalk17.red("depends-on") : chalk17.blue("relates-to");
     if (target) {
       console.log(
@@ -1893,9 +1876,9 @@ function printAcceptanceCriteria(criteria) {
   console.log();
 }
 async function show(id) {
-  const result = await loadAndFindItem(id);
-  if (!result) process.exit(1);
-  const { item, items: items2 } = result;
+  const found = await findOneItem(id);
+  if (!found) process.exit(1);
+  const { orm, item } = found;
   printHeader(item);
   if (item.description) {
     console.log(chalk19.bold("Description"));
@@ -1903,7 +1886,7 @@ async function show(id) {
     console.log();
   }
   printAcceptanceCriteria(item.acceptanceCriteria);
-  printLinks(item, items2);
+  await printLinks(orm, item);
   printPlan(item);
   printComments(item);
 }
@@ -2051,66 +2034,8 @@ async function createItem(req, res) {
   respondJson(res, 201, { id, ...newItem });
 }
 
-// src/commands/backlog/addComment.ts
-function addComment(item, text2, phase) {
-  const entry = {
-    text: text2,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    type: "comment",
-    ...phase !== void 0 && { phase }
-  };
-  if (!item.comments) item.comments = [];
-  item.comments.push(entry);
-}
-function addPhaseSummary(item, text2, phase) {
-  const entry = {
-    text: text2,
-    phase,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    type: "summary"
-  };
-  if (!item.comments) item.comments = [];
-  item.comments.push(entry);
-}
-
 // src/commands/backlog/web/rewindItemPhase.ts
-async function rewindItemPhase(req, res, id) {
-  const { phase, reason } = await parseRewindBody(req);
-  const items2 = await loadBacklog();
-  const item = items2.find((i) => i.id === id);
-  if (!item) {
-    respondJson(res, 404, { error: "Not found" });
-    return;
-  }
-  const error = validateRewind(item, phase);
-  if (error) {
-    respondJson(res, 400, { error });
-    return;
-  }
-  const phaseName = item.plan?.[phase - 1].name;
-  addComment(
-    item,
-    `Rewound to phase ${phase} (${phaseName}): ${reason}`,
-    phase
-  );
-  item.currentPhase = phase;
-  item.status = "in-progress";
-  await saveBacklog(items2);
-  respondJson(res, 200, item);
-}
-function validateRewind(item, phase) {
-  if (!item.plan || item.plan.length === 0) {
-    return "Item has no plan phases.";
-  }
-  if (phase < 1 || phase > item.plan.length) {
-    return `Phase ${phase} does not exist. Valid range: 1\u2013${item.plan.length}.`;
-  }
-  const currentPhase = item.currentPhase ?? 1;
-  if (phase >= currentPhase) {
-    return `Phase ${phase} is not earlier than the current phase (${currentPhase}).`;
-  }
-  return void 0;
-}
+import { eq as eq10 } from "drizzle-orm";
 
 // src/commands/backlog/web/shared.ts
 async function listItems(req, res) {
@@ -2119,13 +2044,13 @@ async function listItems(req, res) {
   respondJson(res, 200, q ? await searchBacklog(q) : await loadBacklog());
 }
 async function findItemOr404(res, id) {
-  const items2 = await loadBacklog();
-  const item = items2.find((i) => i.id === id);
+  const { orm } = await getReady();
+  const item = await loadItem(orm, id);
   if (!item) {
     respondJson(res, 404, { error: "Not found" });
     return void 0;
   }
-  return { items: items2, item };
+  return { orm, item };
 }
 async function getItemById(res, id) {
   const result = await findItemOr404(res, id);
@@ -2134,31 +2059,67 @@ async function getItemById(res, id) {
 async function deleteItem2(res, id) {
   const result = await findItemOr404(res, id);
   if (!result) return;
-  await saveBacklog(result.items.filter((i) => i.id !== id));
+  await deleteItem(result.orm, id);
   respondJson(res, 200, result.item);
 }
 async function patchItemStatus(req, res, id) {
   const { status: status2 } = await parseStatusBody(req);
   const result = await findItemOr404(res, id);
   if (!result) return;
-  result.item.status = status2;
-  await saveBacklog(result.items);
-  respondJson(res, 200, result.item);
+  await updateStatus(result.orm, id, status2);
+  const updated = { ...result.item, status: status2 };
+  respondJson(res, 200, updated);
+}
+
+// src/commands/backlog/web/rewindItemPhase.ts
+async function rewindItemPhase(req, res, id) {
+  const { phase, reason } = await parseRewindBody(req);
+  const result = await findItemOr404(res, id);
+  if (!result) return;
+  const { orm, item } = result;
+  const error = validateRewind(item, phase);
+  if (error) {
+    respondJson(res, 400, { error });
+    return;
+  }
+  const phaseName = item.plan?.[phase - 1].name;
+  await appendComment(
+    orm,
+    id,
+    `Rewound to phase ${phase} (${phaseName}): ${reason}`,
+    { phase }
+  );
+  await orm.update(items).set({ currentPhase: phase, status: "in-progress" }).where(eq10(items.id, id));
+  respondJson(res, 200, await loadItem(orm, id));
+}
+function validateRewind(item, phase) {
+  if (!item.plan || item.plan.length === 0) {
+    return "Item has no plan phases.";
+  }
+  if (phase < 1 || phase > item.plan.length) {
+    return `Phase ${phase} does not exist. Valid range: 1\u2013${item.plan.length}.`;
+  }
+  const currentPhase = item.currentPhase ?? 1;
+  if (phase >= currentPhase) {
+    return `Phase ${phase} is not earlier than the current phase (${currentPhase}).`;
+  }
+  return void 0;
 }
 
 // src/commands/backlog/web/updateItem.ts
+import { eq as eq11 } from "drizzle-orm";
 async function updateItem(req, res, id) {
   const body = await parseItemBody(req);
   const result = await findItemOr404(res, id);
   if (!result) return;
-  Object.assign(result.item, {
+  const { orm } = result;
+  await orm.update(items).set({
     type: body.type ?? result.item.type,
     name: body.name,
-    description: body.description,
-    acceptanceCriteria: body.acceptanceCriteria ?? []
-  });
-  await saveBacklog(result.items);
-  respondJson(res, 200, result.item);
+    description: body.description ?? null,
+    acceptanceCriteria: JSON.stringify(body.acceptanceCriteria ?? [])
+  }).where(eq11(items.id, id));
+  respondJson(res, 200, await loadItem(orm, id));
 }
 
 // src/commands/backlog/web/handleItemRoute.ts
@@ -4974,19 +4935,18 @@ function registerActivity(program2) {
 // src/commands/backlog/comment/index.ts
 import chalk46 from "chalk";
 async function comment(id, text2) {
-  const result = await loadAndFindItem(id);
-  if (!result) process.exit(1);
-  addComment(result.item, text2);
-  await saveBacklog(result.items);
+  const found = await findOneItem(id);
+  if (!found) process.exit(1);
+  await appendComment(found.orm, found.item.id, text2);
   console.log(chalk46.green(`Comment added to item #${id}.`));
 }
 
 // src/commands/backlog/comments/index.ts
 import chalk47 from "chalk";
 async function comments2(id) {
-  const result = await loadAndFindItem(id);
-  if (!result) process.exit(1);
-  const { item } = result;
+  const found = await findOneItem(id);
+  if (!found) process.exit(1);
+  const { item } = found;
   const entries = item.comments ?? [];
   if (entries.length === 0) {
     console.log(chalk47.dim(`No comments on item #${id}.`));
@@ -5004,23 +4964,22 @@ async function comments2(id) {
 import chalk48 from "chalk";
 
 // src/commands/backlog/deleteComment.ts
-import { and as and2, eq as eq9 } from "drizzle-orm";
+import { and as and2, eq as eq12 } from "drizzle-orm";
 async function deleteComment(orm, itemId, commentId) {
-  const [row] = await orm.select({ type: comments.type }).from(comments).where(and2(eq9(comments.id, commentId), eq9(comments.itemId, itemId)));
+  const [row] = await orm.select({ type: comments.type }).from(comments).where(and2(eq12(comments.id, commentId), eq12(comments.itemId, itemId)));
   if (!row) return "not-found";
   if (row.type === "summary") return "is-summary";
-  await orm.delete(comments).where(and2(eq9(comments.id, commentId), eq9(comments.itemId, itemId)));
+  await orm.delete(comments).where(and2(eq12(comments.id, commentId), eq12(comments.itemId, itemId)));
   return "deleted";
 }
 
 // src/commands/backlog/delete-comment/index.ts
 async function deleteCommentCmd(id, commentId) {
-  const result = await loadAndFindItem(id);
-  if (!result) process.exit(1);
-  const orm = await getBacklogOrm();
+  const found = await findOneItem(id);
+  if (!found) process.exit(1);
   const outcome = await deleteComment(
-    orm,
-    result.item.id,
+    found.orm,
+    found.item.id,
     Number.parseInt(commentId, 10)
   );
   switch (outcome) {
@@ -5420,15 +5379,15 @@ async function add(options2) {
 import chalk54 from "chalk";
 
 // src/commands/backlog/insertPhaseAt.ts
-import { eq as eq11 } from "drizzle-orm";
+import { eq as eq14 } from "drizzle-orm";
 
 // src/commands/backlog/shiftPhasesUp.ts
-import { and as and3, desc, eq as eq10, gte } from "drizzle-orm";
+import { and as and3, desc, eq as eq13, gte } from "drizzle-orm";
 async function shiftPhasesUp(db, itemId, fromIdx) {
-  const toShift = await db.select({ idx: planPhases.idx }).from(planPhases).where(and3(eq10(planPhases.itemId, itemId), gte(planPhases.idx, fromIdx))).orderBy(desc(planPhases.idx));
+  const toShift = await db.select({ idx: planPhases.idx }).from(planPhases).where(and3(eq13(planPhases.itemId, itemId), gte(planPhases.idx, fromIdx))).orderBy(desc(planPhases.idx));
   for (const p of toShift) {
-    await db.update(planTasks).set({ phaseIdx: p.idx + 1 }).where(and3(eq10(planTasks.itemId, itemId), eq10(planTasks.phaseIdx, p.idx)));
-    await db.update(planPhases).set({ idx: p.idx + 1 }).where(and3(eq10(planPhases.itemId, itemId), eq10(planPhases.idx, p.idx)));
+    await db.update(planTasks).set({ phaseIdx: p.idx + 1 }).where(and3(eq13(planTasks.itemId, itemId), eq13(planTasks.phaseIdx, p.idx)));
+    await db.update(planPhases).set({ idx: p.idx + 1 }).where(and3(eq13(planPhases.itemId, itemId), eq13(planPhases.idx, p.idx)));
   }
 }
 
@@ -5441,16 +5400,16 @@ async function insertPhaseAt(orm, itemId, phaseIdx, name, tasks, manualChecks, c
       await tx.insert(planTasks).values(tasks.map((task, i) => ({ itemId, phaseIdx, idx: i, task })));
     }
     if (currentPhase !== void 0 && currentPhase - 1 >= phaseIdx) {
-      await tx.update(items).set({ currentPhase: currentPhase + 1 }).where(eq11(items.id, itemId));
+      await tx.update(items).set({ currentPhase: currentPhase + 1 }).where(eq14(items.id, itemId));
     }
   });
 }
 
 // src/commands/backlog/resolveInsertPosition.ts
 import chalk53 from "chalk";
-import { count, eq as eq12 } from "drizzle-orm";
+import { count, eq as eq15 } from "drizzle-orm";
 async function resolveInsertPosition(orm, itemId, position) {
-  const [row] = await orm.select({ cnt: count() }).from(planPhases).where(eq12(planPhases.itemId, itemId));
+  const [row] = await orm.select({ cnt: count() }).from(planPhases).where(eq15(planPhases.itemId, itemId));
   const phaseCount = row?.cnt ?? 0;
   if (position === void 0) return phaseCount;
   const pos = Number.parseInt(position, 10);
@@ -5473,16 +5432,16 @@ function serializeManualChecks(manualCheck) {
 
 // src/commands/backlog/addPhase.ts
 async function addPhase(id, name, options2) {
-  const result = await loadAndFindItem(id);
-  if (!result) return;
+  const found = await findOneItem(id);
+  if (!found) return;
   const tasks = options2.task ?? [];
   if (tasks.length === 0) {
     console.log(chalk54.red("At least one --task is required."));
     process.exitCode = 1;
     return;
   }
-  const orm = await getBacklogOrm();
-  const itemId = result.item.id;
+  const { orm } = found;
+  const itemId = found.item.id;
   const phaseIdx = await resolveInsertPosition(orm, itemId, options2.position);
   if (phaseIdx === void 0) return;
   await insertPhaseAt(
@@ -5492,7 +5451,7 @@ async function addPhase(id, name, options2) {
     name,
     tasks,
     serializeManualChecks(options2.manualCheck),
-    result.item.currentPhase
+    found.item.currentPhase
   );
   const verb = options2.position !== void 0 ? "Inserted" : "Added";
   console.log(
@@ -5622,9 +5581,9 @@ function hasCycle(adjacency, fromId, toId) {
 }
 
 // src/commands/backlog/loadDependencyGraph.ts
-import { eq as eq13 } from "drizzle-orm";
+import { eq as eq16 } from "drizzle-orm";
 async function loadDependencyGraph(orm) {
-  const rows = await orm.select({ itemId: links.itemId, targetId: links.targetId }).from(links).where(eq13(links.type, "depends-on"));
+  const rows = await orm.select({ itemId: links.itemId, targetId: links.targetId }).from(links).where(eq16(links.type, "depends-on"));
   const graph = /* @__PURE__ */ new Map();
   for (const { itemId, targetId } of rows) {
     const bucket = graph.get(itemId);
@@ -5634,15 +5593,6 @@ async function loadDependencyGraph(orm) {
   return graph;
 }
 
-// src/commands/backlog/loadItem.ts
-import { eq as eq14 } from "drizzle-orm";
-async function loadItem(orm, id) {
-  const [row] = await orm.select().from(items).where(eq14(items.id, id));
-  if (!row) return void 0;
-  const rel = await loadRelations(orm, [id]);
-  return rowToItem(row, rel);
-}
-
 // src/commands/backlog/validateLinkTarget.ts
 import chalk57 from "chalk";
 function validateLinkTarget(fromItem, fromNum, toNum, linkType) {
@@ -5696,7 +5646,7 @@ async function link(fromId, toId, opts) {
 
 // src/commands/backlog/unlink.ts
 import chalk59 from "chalk";
-import { and as and4, eq as eq15 } from "drizzle-orm";
+import { and as and4, eq as eq17 } from "drizzle-orm";
 async function unlink(fromId, toId) {
   const fromNum = Number.parseInt(fromId, 10);
   const toNum = Number.parseInt(toId, 10);
@@ -5714,7 +5664,7 @@ async function unlink(fromId, toId) {
     console.log(chalk59.yellow(`No link from #${fromId} to #${toId} found.`));
     return;
   }
-  await orm.delete(links).where(and4(eq15(links.itemId, fromNum), eq15(links.targetId, toNum)));
+  await orm.delete(links).where(and4(eq17(links.itemId, fromNum), eq17(links.targetId, toNum)));
   console.log(chalk59.green(`Removed link from #${fromId} to #${toId}.`));
 }
 
@@ -5789,8 +5739,8 @@ function registerRewindCommand(cmd) {
 
 // src/commands/backlog/registerRunCommand.ts
 function registerRunCommand(cmd) {
-  cmd.command("run <id>").description("Run a backlog item's plan phase-by-phase with Claude").option("-w, --write", "Run Claude with auto permission mode").action(async (id, opts) => {
-    await run(id, { allowEdits: opts.write });
+  cmd.command("run <id>").description("Run a backlog item's plan phase-by-phase with Claude").option("-w, --write", "Run Claude with auto permission mode (default)").option("--no-write", "Run Claude without auto permission mode").action(async (id, opts) => {
+    await run(id, { allowEdits: opts.write !== false });
   });
 }
 
@@ -5832,9 +5782,9 @@ async function del(id) {
 // src/commands/backlog/done/index.ts
 import chalk63 from "chalk";
 async function done(id, summary) {
-  const result = await loadAndFindItem(id);
-  if (!result) return;
-  const { item } = result;
+  const found = await findOneItem(id);
+  if (!found) return;
+  const { orm, item } = found;
   if (item.plan && item.plan.length > 0) {
     const completedCount = (item.currentPhase ?? 1) - 1;
     const pending = item.plan.slice(completedCount);
@@ -5851,12 +5801,11 @@ async function done(id, summary) {
       return;
     }
   }
-  item.status = "done";
+  await updateStatus(orm, item.id, "done");
   if (summary) {
     const phase = item.currentPhase ?? 1;
-    addPhaseSummary(item, summary, phase);
+    await appendComment(orm, item.id, summary, { phase, type: "summary" });
   }
-  await saveBacklog(result.items);
   console.log(chalk63.green(`Completed item #${id}: ${item.name}`));
 }
 
@@ -5871,19 +5820,15 @@ async function start(id) {
 
 // src/commands/backlog/stop/index.ts
 import chalk65 from "chalk";
+import { and as and5, eq as eq18 } from "drizzle-orm";
 async function stop() {
-  const items2 = await loadBacklog();
-  const inProgress = items2.filter((item) => item.status === "in-progress");
-  if (inProgress.length === 0) {
+  const { orm } = await getReady();
+  const stopped = await orm.update(items).set({ status: "todo", currentPhase: 1 }).where(and5(eq18(items.status, "in-progress"), eq18(items.origin, getOrigin()))).returning({ id: items.id, name: items.name });
+  if (stopped.length === 0) {
     console.log(chalk65.yellow("No in-progress items to stop."));
     return;
   }
-  for (const item of inProgress) {
-    item.status = "todo";
-    item.currentPhase = 1;
-  }
-  await saveBacklog(items2);
-  for (const item of inProgress) {
+  for (const item of stopped) {
     console.log(chalk65.yellow(`Stopped item #${item.id}: ${item.name}`));
   }
 }
@@ -5891,15 +5836,15 @@ async function stop() {
 // src/commands/backlog/wontdo/index.ts
 import chalk66 from "chalk";
 async function wontdo(id, reason) {
-  const result = await loadAndFindItem(id);
-  if (!result) return;
-  result.item.status = "wontdo";
+  const found = await findOneItem(id);
+  if (!found) return;
+  const { orm, item } = found;
+  await updateStatus(orm, item.id, "wontdo");
   if (reason) {
-    const phase = result.item.currentPhase ?? 1;
-    addPhaseSummary(result.item, reason, phase);
+    const phase = item.currentPhase ?? 1;
+    await appendComment(orm, item.id, reason, { phase, type: "summary" });
   }
-  await saveBacklog(result.items);
-  console.log(chalk66.red(`Won't do item #${id}: ${result.item.name}`));
+  console.log(chalk66.red(`Won't do item #${id}: ${item.name}`));
 }
 
 // src/commands/backlog/registerStatusCommands.ts
@@ -5913,18 +5858,18 @@ function registerStatusCommands(cmd) {
 
 // src/commands/backlog/removePhase.ts
 import chalk68 from "chalk";
-import { and as and7, eq as eq18 } from "drizzle-orm";
+import { and as and8, eq as eq21 } from "drizzle-orm";
 
 // src/commands/backlog/findPhase.ts
 import chalk67 from "chalk";
-import { and as and5, count as count2, eq as eq16 } from "drizzle-orm";
+import { and as and6, count as count2, eq as eq19 } from "drizzle-orm";
 async function findPhase(id, phase) {
-  const result = await loadAndFindItem(id);
-  if (!result) return void 0;
-  const orm = await getBacklogOrm();
-  const itemId = result.item.id;
+  const found = await findOneItem(id);
+  if (!found) return void 0;
+  const { orm, item } = found;
+  const itemId = item.id;
   const phaseIdx = Number.parseInt(phase, 10) - 1;
-  const [row] = await orm.select({ cnt: count2() }).from(planPhases).where(and5(eq16(planPhases.itemId, itemId), eq16(planPhases.idx, phaseIdx)));
+  const [row] = await orm.select({ cnt: count2() }).from(planPhases).where(and6(eq19(planPhases.itemId, itemId), eq19(planPhases.idx, phaseIdx)));
   if (!row || row.cnt === 0) {
     console.log(
       chalk67.red(`Phase ${phaseIdx + 1} not found on item #${itemId}.`)
@@ -5932,18 +5877,18 @@ async function findPhase(id, phase) {
     process.exitCode = 1;
     return void 0;
   }
-  return { result, orm, itemId, phaseIdx };
+  return { item, orm, itemId, phaseIdx };
 }
 
 // src/commands/backlog/reindexPhases.ts
-import { and as and6, asc as asc4, count as count3, eq as eq17 } from "drizzle-orm";
+import { and as and7, asc as asc4, count as count3, eq as eq20 } from "drizzle-orm";
 async function reindexPhases(db, itemId) {
-  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq17(planPhases.itemId, itemId)).orderBy(asc4(planPhases.idx));
+  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq20(planPhases.itemId, itemId)).orderBy(asc4(planPhases.idx));
   for (let i = 0; i < remaining.length; i++) {
     const oldIdx = remaining[i].idx;
     if (oldIdx === i) continue;
-    await db.update(planTasks).set({ phaseIdx: i }).where(and6(eq17(planTasks.itemId, itemId), eq17(planTasks.phaseIdx, oldIdx)));
-    await db.update(planPhases).set({ idx: i }).where(and6(eq17(planPhases.itemId, itemId), eq17(planPhases.idx, oldIdx)));
+    await db.update(planTasks).set({ phaseIdx: i }).where(and7(eq20(planTasks.itemId, itemId), eq20(planTasks.phaseIdx, oldIdx)));
+    await db.update(planPhases).set({ idx: i }).where(and7(eq20(planPhases.itemId, itemId), eq20(planPhases.idx, oldIdx)));
   }
 }
 async function adjustCurrentPhase(db, item, removedIdx) {
@@ -5951,27 +5896,27 @@ async function adjustCurrentPhase(db, item, removedIdx) {
   if (currentPhase === void 0) return;
   const currentIdx = currentPhase - 1;
   if (removedIdx < currentIdx) {
-    await db.update(items).set({ currentPhase: currentPhase - 1 }).where(eq17(items.id, item.id));
+    await db.update(items).set({ currentPhase: currentPhase - 1 }).where(eq20(items.id, item.id));
     return;
   }
   if (removedIdx !== currentIdx) return;
-  const [row] = await db.select({ cnt: count3() }).from(planPhases).where(eq17(planPhases.itemId, item.id));
+  const [row] = await db.select({ cnt: count3() }).from(planPhases).where(eq20(planPhases.itemId, item.id));
   const cnt = row?.cnt ?? 0;
-  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq17(items.id, item.id));
+  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq20(items.id, item.id));
 }
 
 // src/commands/backlog/removePhase.ts
 async function removePhase(id, phase) {
   const found = await findPhase(id, phase);
   if (!found) return;
-  const { result, orm, itemId, phaseIdx } = found;
+  const { item, orm, itemId, phaseIdx } = found;
   await orm.transaction(async (tx) => {
     await tx.delete(planTasks).where(
-      and7(eq18(planTasks.itemId, itemId), eq18(planTasks.phaseIdx, phaseIdx))
+      and8(eq21(planTasks.itemId, itemId), eq21(planTasks.phaseIdx, phaseIdx))
     );
-    await tx.delete(planPhases).where(and7(eq18(planPhases.itemId, itemId), eq18(planPhases.idx, phaseIdx)));
+    await tx.delete(planPhases).where(and8(eq21(planPhases.itemId, itemId), eq21(planPhases.idx, phaseIdx)));
     await reindexPhases(tx, itemId);
-    await adjustCurrentPhase(tx, result.item, phaseIdx);
+    await adjustCurrentPhase(tx, item, phaseIdx);
   });
   console.log(
     chalk68.green(`Removed phase ${phaseIdx + 1} from item #${itemId}.`)
@@ -5980,7 +5925,7 @@ async function removePhase(id, phase) {
 
 // src/commands/backlog/update/index.ts
 import chalk70 from "chalk";
-import { eq as eq19 } from "drizzle-orm";
+import { eq as eq22 } from "drizzle-orm";
 
 // src/commands/backlog/update/parseListIndex.ts
 function parseListIndex(raw, length, label2) {
@@ -6091,8 +6036,8 @@ function buildUpdateValues(options2) {
 
 // src/commands/backlog/update/index.ts
 async function update(id, options2) {
-  const result = await loadAndFindItem(id);
-  if (!result) return;
+  const found = await findOneItem(id);
+  if (!found) return;
   let ac = options2.ac;
   if (hasAcMutations(options2)) {
     if (options2.ac) {
@@ -6102,7 +6047,7 @@ async function update(id, options2) {
       process.exitCode = 1;
       return;
     }
-    const mutation = applyAcMutations(result.item.acceptanceCriteria, options2);
+    const mutation = applyAcMutations(found.item.acceptanceCriteria, options2);
     if (!mutation.ok) {
       console.log(chalk70.red(mutation.error));
       process.exitCode = 1;
@@ -6112,9 +6057,9 @@ async function update(id, options2) {
   }
   const built = buildUpdateValues({ ...options2, ac });
   if (!built) return;
-  const orm = await getBacklogOrm();
-  const itemId = result.item.id;
-  await orm.update(items).set(built.set).where(eq19(items.id, itemId));
+  const { orm } = found;
+  const itemId = found.item.id;
+  await orm.update(items).set(built.set).where(eq22(items.id, itemId));
   console.log(chalk70.green(`Updated ${built.fields} on item #${itemId}.`));
 }
 
@@ -6122,22 +6067,22 @@ async function update(id, options2) {
 import chalk71 from "chalk";
 
 // src/commands/backlog/applyPhaseUpdate.ts
-import { and as and8, eq as eq20 } from "drizzle-orm";
+import { and as and9, eq as eq23 } from "drizzle-orm";
 async function applyPhaseUpdate(orm, itemId, phaseIdx, fields) {
   await orm.transaction(async (tx) => {
     if (fields.name) {
       await tx.update(planPhases).set({ name: fields.name }).where(
-        and8(eq20(planPhases.itemId, itemId), eq20(planPhases.idx, phaseIdx))
+        and9(eq23(planPhases.itemId, itemId), eq23(planPhases.idx, phaseIdx))
       );
     }
     if (fields.manualCheck) {
       await tx.update(planPhases).set({ manualChecks: JSON.stringify(fields.manualCheck) }).where(
-        and8(eq20(planPhases.itemId, itemId), eq20(planPhases.idx, phaseIdx))
+        and9(eq23(planPhases.itemId, itemId), eq23(planPhases.idx, phaseIdx))
       );
     }
     if (fields.task) {
       await tx.delete(planTasks).where(
-        and8(eq20(planTasks.itemId, itemId), eq20(planTasks.phaseIdx, phaseIdx))
+        and9(eq23(planTasks.itemId, itemId), eq23(planTasks.phaseIdx, phaseIdx))
       );
       if (fields.task.length) {
         await tx.insert(planTasks).values(
@@ -6220,8 +6165,8 @@ function resolvePhaseFields(options2, current) {
 async function updatePhase(id, phase, options2) {
   const found = await findPhase(id, phase);
   if (!found) return;
-  const { result, orm, itemId, phaseIdx } = found;
-  const resolved = resolvePhaseFields(options2, result.item.plan?.[phaseIdx]);
+  const { item, orm, itemId, phaseIdx } = found;
+  const resolved = resolvePhaseFields(options2, item.plan?.[phaseIdx]);
   if (!resolved.ok) {
     console.log(chalk71.red(resolved.error));
     process.exitCode = 1;
@@ -6275,8 +6220,8 @@ function registerWebCommand(cmd) {
   cmd.command("web").description("Open the backlog tab in the web dashboard").option("-p, --port <number>", "Port to listen on", "3100").action(web2);
 }
 function registerNextCommand(cmd) {
-  cmd.command("next").description("Pick and run the next backlog item, or open /draft if none").option("-w, --write", "Run Claude with auto permission mode").action(
-    (opts) => next({ allowEdits: opts.write })
+  cmd.command("next").description("Pick and run the next backlog item, or open /draft if none").option("-w, --write", "Run Claude with auto permission mode (default)").option("--no-write", "Run Claude without auto permission mode").action(
+    (opts) => next({ allowEdits: opts.write !== false })
   );
 }
 function registerBacklog(program2) {
@@ -17020,7 +16965,7 @@ registerVoice(program);
 registerSessions(program);
 registerPrompts(program);
 registerDeny(program);
-program.command("next").description("Alias for backlog next -w").action(() => next({ allowEdits: true }));
+program.command("next").description("Alias for backlog next").action(() => next({ allowEdits: true }));
 program.command("draft").alias("feat").description("Launch Claude in /draft mode, chain into next on /next signal").action(() => launchMode("draft"));
 program.command("bug").description("Launch Claude in /bug mode, chain into next on /next signal").action(() => launchMode("bug"));
 program.command("refine").argument("[id]", "Backlog item ID").description("Launch Claude in /refine mode to refine a backlog item").action((id) => refine(id));

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@staff0rd/assist",
-	"version": "0.230.0",
+	"version": "0.231.0",
 	"type": "module",
 	"main": "dist/index.js",
 	"bin": {