@staff0rd/assist 0.367.2 → 0.369.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.367.2",
+  version: "0.369.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -963,7 +963,7 @@ function createPool() {
   return pool;
 }
 async function initSchema(pool) {
-  await ensureSchema((sql10) => pool.query(sql10));
+  await ensureSchema((sql11) => pool.query(sql11));
   const orm = makeOrmFromPool(pool);
   await seedNewsFeeds(orm);
   await runUsagePeakCleanup(orm);
@@ -3881,8 +3881,8 @@ async function buildDump(tables, copyOut) {
 // src/commands/backlog/dump/copyTableOut.ts
 import { to as copyTo } from "pg-copy-streams";
 async function copyTableOut(client, table) {
-  const sql10 = `COPY ${table.name} (${table.columns.join(", ")}) TO STDOUT`;
-  const stream = client.query(copyTo(sql10));
+  const sql11 = `COPY ${table.name} (${table.columns.join(", ")}) TO STDOUT`;
+  const stream = client.query(copyTo(sql11));
   const chunks = [];
   for await (const chunk of stream) {
     chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
@@ -5234,6 +5234,7 @@ function buildAuthoredPhasePrompt(item, phaseNumber, phase) {
   const confirmSuffix = needsConfirmation ? " and the user confirms" : "";
   return [
     ...buildContextLines(item, phaseNumber, phase),
+    ...buildJiraStartedLines(item, phaseNumber),
     "",
     "Focus ONLY on this phase. Do not work on other phases.",
     "If you need to modify backlog items, run `assist backlog --help` to discover available commands.",
@@ -5262,6 +5263,15 @@ function buildContextLines(item, phaseNumber, phase) {
     formatTasks(phase)
   ];
 }
+function buildJiraStartedLines(item, phaseNumber) {
+  if (phaseNumber !== 1 || !item.jiraKey) {
+    return [];
+  }
+  return [
+    "",
+    `As your first step, before any implementation, run \`/jira started ${item.jiraKey}\` to assign the issue to yourself and transition it to In Progress.`
+  ];
+}
 function buildManualCheckLines(manualChecks) {
   if (manualChecks.length > 0) {
     return [
@@ -6311,8 +6321,12 @@ function createFallbackHandler(routes3, htmlHandler2, extra) {
 import { eq as eq12 } from "drizzle-orm";
 
 // src/commands/backlog/loadItemSummaries.ts
-import { asc as asc5, eq as eq11 } from "drizzle-orm";
+import { asc as asc5, eq as eq11, ne, sql as sql5 } from "drizzle-orm";
 async function loadItemSummaries(orm, origin) {
+  const incompleteCounts = orm.select({
+    itemId: itemSubtasks.itemId,
+    count: sql5`count(*)::int`.as("incomplete_subtasks")
+  }).from(itemSubtasks).where(ne(itemSubtasks.status, "done")).groupBy(itemSubtasks.itemId).as("incomplete_counts");
   const rows = await orm.select({
     id: items.id,
     origin: items.origin,
@@ -6320,8 +6334,9 @@ async function loadItemSummaries(orm, origin) {
     name: items.name,
     status: items.status,
     starred: items.starred,
-    jiraKey: items.jiraKey
-  }).from(items).where(origin === void 0 ? void 0 : eq11(items.origin, origin)).orderBy(asc5(items.id));
+    jiraKey: items.jiraKey,
+    incompleteSubtasks: incompleteCounts.count
+  }).from(items).leftJoin(incompleteCounts, eq11(incompleteCounts.itemId, items.id)).where(origin === void 0 ? void 0 : eq11(items.origin, origin)).orderBy(asc5(items.id));
   return rows.map((row) => ({
     id: row.id,
     origin: row.origin,
@@ -6329,7 +6344,8 @@ async function loadItemSummaries(orm, origin) {
     name: row.name,
     status: row.status,
     starred: row.starred,
-    jiraKey: row.jiraKey ?? void 0
+    jiraKey: row.jiraKey ?? void 0,
+    incompleteSubtasks: row.incompleteSubtasks ?? 0
   }));
 }
 
@@ -6484,6 +6500,17 @@ async function parseStarBody(req) {
   return JSON.parse(await readBody(req));
 }
 
+// src/commands/backlog/resolveRewindPlan.ts
+function resolveRewindPlan(item) {
+  return [...resolvePlan(item), buildReviewPhase()];
+}
+
+// src/commands/backlog/web/withReviewPhase.ts
+function withReviewPhase(item) {
+  if (!item.plan || item.plan.length === 0) return item;
+  return { ...item, plan: resolveRewindPlan(item) };
+}
+
 // src/commands/backlog/web/shared.ts
 async function listItems(req, res) {
   applyCwdFromReq(req);
@@ -6501,7 +6528,7 @@ async function findItemOr404(res, id2) {
 }
 async function getItemById(res, id2) {
   const result = await findItemOr404(res, id2);
-  if (result) respondJson(res, 200, result.item);
+  if (result) respondJson(res, 200, withReviewPhase(result.item));
 }
 async function deleteItem2(res, id2) {
   const result = await findItemOr404(res, id2);
@@ -6575,12 +6602,33 @@ async function patchSubtaskStatus(req, res, id2, idx) {
   respondJson(res, 200, await loadItem(orm, id2));
 }
 
-// src/commands/backlog/web/rewindItemPhase.ts
-import { eq as eq16 } from "drizzle-orm";
-
-// src/commands/backlog/resolveRewindPlan.ts
-function resolveRewindPlan(item) {
-  return [...resolvePlan(item), buildReviewPhase()];
+// src/commands/backlog/rewindItemToPhase.ts
+async function rewindItemToPhase(orm, item, phaseNumber, reason) {
+  const plan2 = resolveRewindPlan(item);
+  if (phaseNumber < 1 || phaseNumber > plan2.length) {
+    return {
+      ok: false,
+      error: `Phase ${phaseNumber} does not exist. Valid range: 1\u2013${plan2.length}.`
+    };
+  }
+  const currentPhase = item.currentPhase ?? 1;
+  if (phaseNumber >= currentPhase) {
+    return {
+      ok: false,
+      error: `Phase ${phaseNumber} is not earlier than the current phase (${currentPhase}).`
+    };
+  }
+  const phaseName = plan2[phaseNumber - 1].name;
+  await appendComment(
+    orm,
+    item.id,
+    `Rewound to phase ${phaseNumber} (${phaseName}): ${reason}`,
+    { phase: phaseNumber }
+  );
+  await updateCurrentPhase(orm, item.id, phaseNumber);
+  await updateStatus(orm, item.id, "in-progress");
+  writeSignal("rewind", { itemId: item.id, targetPhase: phaseNumber - 1 });
+  return { ok: true, phaseName };
 }
 
 // src/commands/backlog/web/rewindItemPhase.ts
@@ -6589,32 +6637,13 @@ async function rewindItemPhase(req, res, id2) {
   const result = await findItemOr404(res, id2);
   if (!result) return;
   const { orm, item } = result;
-  const plan2 = resolveRewindPlan(item);
-  const error = validateRewind(item, plan2, phase);
-  if (error) {
-    respondJson(res, 400, { error });
+  const outcome = await rewindItemToPhase(orm, item, phase, reason);
+  if (!outcome.ok) {
+    respondJson(res, 400, { error: outcome.error });
     return;
   }
-  const phaseName = plan2[phase - 1].name;
-  await appendComment(
-    orm,
-    id2,
-    `Rewound to phase ${phase} (${phaseName}): ${reason}`,
-    { phase }
-  );
-  await orm.update(items).set({ currentPhase: phase, status: "in-progress" }).where(eq16(items.id, id2));
   respondJson(res, 200, await loadItem(orm, id2));
 }
-function validateRewind(item, plan2, phase) {
-  if (phase < 1 || phase > plan2.length) {
-    return `Phase ${phase} does not exist. Valid range: 1\u2013${plan2.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/handleItemRoute.ts
 var id = (match, group = 1) => Number.parseInt(match[group], 10);
@@ -7725,7 +7754,7 @@ async function web2(options2) {
 
 // src/commands/backlog/associate-jira/index.ts
 import chalk61 from "chalk";
-import { eq as eq17 } from "drizzle-orm";
+import { eq as eq16 } from "drizzle-orm";
 
 // src/commands/jira/fetchIssue.ts
 import { execSync as execSync25 } from "child_process";
@@ -7767,7 +7796,7 @@ async function associateJira(id2, key, options2) {
   const { orm } = found;
   const itemId = found.item.id;
   if (options2.clear) {
-    await orm.update(items).set({ jiraKey: null }).where(eq17(items.id, itemId));
+    await orm.update(items).set({ jiraKey: null }).where(eq16(items.id, itemId));
     console.log(chalk61.green(`Cleared Jira association on item #${itemId}.`));
     return;
   }
@@ -7786,7 +7815,7 @@ async function associateJira(id2, key, options2) {
   const parsed = fetchIssue(key, "summary");
   const fields = parsed?.fields;
   const summary = fields?.summary;
-  await orm.update(items).set({ jiraKey: key }).where(eq17(items.id, itemId));
+  await orm.update(items).set({ jiraKey: key }).where(eq16(items.id, itemId));
   console.log(
     chalk61.green(`Associated ${key} with item #${itemId}.`),
     summary ? chalk61.dim(`(${summary})`) : ""
@@ -7986,8 +8015,8 @@ async function readStdinBuffer() {
 import { finished } from "stream/promises";
 import { from as copyFrom } from "pg-copy-streams";
 async function copyTableIn(client, table, data) {
-  const sql10 = `COPY ${table.name} (${table.columns.join(", ")}) FROM STDIN`;
-  const stream = client.query(copyFrom(sql10));
+  const sql11 = `COPY ${table.name} (${table.columns.join(", ")}) FROM STDIN`;
+  const stream = client.query(copyFrom(sql11));
   stream.end(data);
   await finished(stream);
 }
@@ -8084,22 +8113,22 @@ function registerImportCommand(cmd) {
 import chalk68 from "chalk";
 
 // src/commands/backlog/insertPhaseAt.ts
-import { count as count2, eq as eq19 } from "drizzle-orm";
+import { count as count2, eq as eq18 } from "drizzle-orm";
 
 // src/commands/backlog/shiftPhasesUp.ts
-import { and as and6, desc as desc3, eq as eq18, gte } from "drizzle-orm";
+import { and as and6, desc as desc3, eq as eq17, gte } from "drizzle-orm";
 async function shiftPhasesUp(db, itemId, fromIdx) {
-  const toShift = await db.select({ idx: planPhases.idx }).from(planPhases).where(and6(eq18(planPhases.itemId, itemId), gte(planPhases.idx, fromIdx))).orderBy(desc3(planPhases.idx));
+  const toShift = await db.select({ idx: planPhases.idx }).from(planPhases).where(and6(eq17(planPhases.itemId, itemId), gte(planPhases.idx, fromIdx))).orderBy(desc3(planPhases.idx));
   for (const p of toShift) {
-    await db.update(planTasks).set({ phaseIdx: p.idx + 1 }).where(and6(eq18(planTasks.itemId, itemId), eq18(planTasks.phaseIdx, p.idx)));
-    await db.update(planPhases).set({ idx: p.idx + 1 }).where(and6(eq18(planPhases.itemId, itemId), eq18(planPhases.idx, p.idx)));
+    await db.update(planTasks).set({ phaseIdx: p.idx + 1 }).where(and6(eq17(planTasks.itemId, itemId), eq17(planTasks.phaseIdx, p.idx)));
+    await db.update(planPhases).set({ idx: p.idx + 1 }).where(and6(eq17(planPhases.itemId, itemId), eq17(planPhases.idx, p.idx)));
   }
 }
 
 // src/commands/backlog/insertPhaseAt.ts
 async function insertPhaseAt(orm, itemId, phaseIdx, name, tasks, manualChecks, currentPhase) {
   await orm.transaction(async (tx) => {
-    const [row] = await tx.select({ cnt: count2() }).from(planPhases).where(eq19(planPhases.itemId, itemId));
+    const [row] = await tx.select({ cnt: count2() }).from(planPhases).where(eq18(planPhases.itemId, itemId));
     const phaseCount = row?.cnt ?? 0;
     await shiftPhasesUp(tx, itemId, phaseIdx);
     await tx.insert(planPhases).values({ itemId, idx: phaseIdx, name, manualChecks });
@@ -8108,17 +8137,17 @@ async function insertPhaseAt(orm, itemId, phaseIdx, name, tasks, manualChecks, c
     }
     if (currentPhase !== void 0 && currentPhase - 1 >= phaseIdx) {
       const atReviewSlot = currentPhase - 1 >= phaseCount;
-      await tx.update(items).set({ currentPhase: atReviewSlot ? phaseIdx + 1 : currentPhase + 1 }).where(eq19(items.id, itemId));
+      await tx.update(items).set({ currentPhase: atReviewSlot ? phaseIdx + 1 : currentPhase + 1 }).where(eq18(items.id, itemId));
     }
   });
 }
 
 // src/commands/backlog/insertSubtask.ts
-import { sql as sql5 } from "drizzle-orm";
+import { sql as sql6 } from "drizzle-orm";
 async function insertSubtask(orm, itemId, title, description) {
   await orm.insert(itemSubtasks).values({
     itemId,
-    idx: sql5`(SELECT COALESCE(MAX(${itemSubtasks.idx}) + 1, 0) FROM ${itemSubtasks} WHERE ${itemSubtasks.itemId} = ${itemId})`,
+    idx: sql6`(SELECT COALESCE(MAX(${itemSubtasks.idx}) + 1, 0) FROM ${itemSubtasks} WHERE ${itemSubtasks.itemId} = ${itemId})`,
     title,
     description: description ?? null,
     status: "todo"
@@ -8242,9 +8271,9 @@ import chalk70 from "chalk";
 
 // src/commands/backlog/resolveInsertPosition.ts
 import chalk69 from "chalk";
-import { count as count3, eq as eq20 } from "drizzle-orm";
+import { count as count3, eq as eq19 } from "drizzle-orm";
 async function resolveInsertPosition(orm, itemId, position) {
-  const [row] = await orm.select({ cnt: count3() }).from(planPhases).where(eq20(planPhases.itemId, itemId));
+  const [row] = await orm.select({ cnt: count3() }).from(planPhases).where(eq19(planPhases.itemId, itemId));
   const phaseCount = row?.cnt ?? 0;
   if (position === void 0) return phaseCount;
   const pos = Number.parseInt(position, 10);
@@ -8368,9 +8397,9 @@ function hasCycle(adjacency, fromId, toId) {
 }
 
 // src/commands/backlog/loadDependencyGraph.ts
-import { eq as eq21 } from "drizzle-orm";
+import { eq as eq20 } from "drizzle-orm";
 async function loadDependencyGraph(orm) {
-  const rows = await orm.select({ itemId: links.itemId, targetId: links.targetId }).from(links).where(eq21(links.type, "depends-on"));
+  const rows = await orm.select({ itemId: links.itemId, targetId: links.targetId }).from(links).where(eq20(links.type, "depends-on"));
   const graph = /* @__PURE__ */ new Map();
   for (const { itemId, targetId } of rows) {
     const bucket = graph.get(itemId);
@@ -8433,7 +8462,7 @@ async function link(fromId, toId, opts) {
 
 // src/commands/backlog/unlink.ts
 import chalk74 from "chalk";
-import { and as and7, eq as eq22 } from "drizzle-orm";
+import { and as and7, eq as eq21 } from "drizzle-orm";
 async function unlink(fromId, toId) {
   const fromNum = Number.parseInt(fromId, 10);
   const toNum = Number.parseInt(toId, 10);
@@ -8451,7 +8480,7 @@ async function unlink(fromId, toId) {
     console.log(chalk74.yellow(`No link from #${fromId} to #${toId} found.`));
     return;
   }
-  await orm.delete(links).where(and7(eq22(links.itemId, fromNum), eq22(links.targetId, toNum)));
+  await orm.delete(links).where(and7(eq21(links.itemId, fromNum), eq21(links.targetId, toNum)));
   console.log(chalk74.green(`Removed link from #${fromId} to #${toId}.`));
 }
 
@@ -8467,7 +8496,7 @@ function registerLinkCommands(cmd) {
 
 // src/commands/backlog/move-repo/index.ts
 import chalk76 from "chalk";
-import { eq as eq24 } from "drizzle-orm";
+import { eq as eq23 } from "drizzle-orm";
 
 // src/commands/backlog/move-repo/confirmMove.ts
 import chalk75 from "chalk";
@@ -8482,9 +8511,9 @@ async function confirmMove(cnt, oldOrigin, newOrigin) {
 }
 
 // src/commands/backlog/move-repo/countByOrigin.ts
-import { count as count4, eq as eq23 } from "drizzle-orm";
+import { count as count4, eq as eq22 } from "drizzle-orm";
 async function countByOrigin(orm, origin) {
-  const [{ cnt }] = await orm.select({ cnt: count4() }).from(items).where(eq23(items.origin, origin));
+  const [{ cnt }] = await orm.select({ cnt: count4() }).from(items).where(eq22(items.origin, origin));
   return cnt;
 }
 
@@ -8527,7 +8556,7 @@ async function moveRepo(oldOriginRaw, newOriginRaw, options2 = {}) {
     console.log(chalk76.yellow("Move cancelled; no changes made."));
     return;
   }
-  await orm.update(items).set({ origin: newOrigin }).where(eq24(items.origin, oldOrigin));
+  await orm.update(items).set({ origin: newOrigin }).where(eq23(items.origin, oldOrigin));
   console.log(
     chalk76.green(
       `Moved ${pluralItems(cnt)} from "${oldOrigin}" to "${newOrigin}".`
@@ -8707,47 +8736,24 @@ function registerRefineCommand(cmd) {
 
 // src/commands/backlog/rewindPhase.ts
 import chalk80 from "chalk";
-function validateRewind2(item, plan2, phaseNumber) {
-  if (phaseNumber < 1 || phaseNumber > plan2.length) {
-    return `Phase ${phaseNumber} does not exist. Valid range: 1\u2013${plan2.length}.`;
-  }
-  const currentPhase = item.currentPhase ?? 1;
-  if (phaseNumber >= currentPhase) {
-    return `Phase ${phaseNumber} is not earlier than the current phase (${currentPhase}).`;
-  }
-  return void 0;
-}
 async function rewindPhase(id2, phase, opts) {
   const phaseNumber = Number.parseInt(phase, 10);
-  const phaseIndex = phaseNumber - 1;
   const { orm } = await getReady();
   const item = await loadItem(orm, Number.parseInt(id2, 10));
   if (!item) {
     console.log(chalk80.red(`Item #${id2} not found.`));
     return;
   }
-  const plan2 = resolveRewindPlan(item);
-  const error = validateRewind2(item, plan2, phaseNumber);
-  if (error) {
-    console.log(chalk80.red(error));
+  const result = await rewindItemToPhase(orm, item, phaseNumber, opts.reason);
+  if (!result.ok) {
+    console.log(chalk80.red(result.error));
     process.exitCode = 1;
     return;
   }
-  const phaseName = plan2[phaseIndex].name;
-  await appendComment(
-    orm,
-    item.id,
-    `Rewound to phase ${phaseNumber} (${phaseName}): ${opts.reason}`,
-    { phase: phaseNumber }
-  );
-  await setCurrentPhase(id2, phaseNumber);
-  await setStatus(id2, "in-progress");
-  writeSignal("rewind", {
-    itemId: Number.parseInt(id2, 10),
-    targetPhase: phaseIndex
-  });
   console.log(
-    chalk80.green(`Rewound item #${id2} to phase ${phaseNumber} (${phaseName}).`)
+    chalk80.green(
+      `Rewound item #${id2} to phase ${phaseNumber} (${result.phaseName}).`
+    )
   );
 }
 
@@ -8896,10 +8902,10 @@ async function start(id2) {
 
 // src/commands/backlog/stop/index.ts
 import chalk88 from "chalk";
-import { and as and8, eq as eq25 } from "drizzle-orm";
+import { and as and8, eq as eq24 } from "drizzle-orm";
 async function stop() {
   const { orm } = await getReady();
-  const stopped = await orm.update(items).set({ status: "todo", currentPhase: 1 }).where(and8(eq25(items.status, "in-progress"), eq25(items.origin, getOrigin()))).returning({ id: items.id, name: items.name });
+  const stopped = await orm.update(items).set({ status: "todo", currentPhase: 1 }).where(and8(eq24(items.status, "in-progress"), eq24(items.origin, getOrigin()))).returning({ id: items.id, name: items.name });
   if (stopped.length === 0) {
     console.log(chalk88.yellow("No in-progress items to stop."));
     return;
@@ -9008,13 +9014,13 @@ async function findSubtask(id2, index3) {
 }
 
 // src/commands/backlog/updateSubtask.ts
-import { and as and9, eq as eq26 } from "drizzle-orm";
+import { and as and9, eq as eq25 } from "drizzle-orm";
 async function updateSubtask(orm, itemId, idx, fields) {
   const set = {};
   if (fields.title !== void 0) set.title = fields.title;
   if (fields.description !== void 0) set.description = fields.description;
   if (fields.status !== void 0) set.status = fields.status;
-  const [row] = await orm.update(itemSubtasks).set(set).where(and9(eq26(itemSubtasks.itemId, itemId), eq26(itemSubtasks.idx, idx))).returning({ title: itemSubtasks.title });
+  const [row] = await orm.update(itemSubtasks).set(set).where(and9(eq25(itemSubtasks.itemId, itemId), eq25(itemSubtasks.idx, idx))).returning({ title: itemSubtasks.title });
   return row?.title;
 }
 
@@ -9067,16 +9073,16 @@ async function editSubtask(id2, index3, options2) {
 import chalk94 from "chalk";
 
 // src/commands/backlog/deleteSubtask.ts
-import { and as and10, asc as asc6, eq as eq27 } from "drizzle-orm";
+import { and as and10, asc as asc6, eq as eq26 } from "drizzle-orm";
 async function deleteSubtask(orm, itemId, idx) {
-  const [row] = await orm.delete(itemSubtasks).where(and10(eq27(itemSubtasks.itemId, itemId), eq27(itemSubtasks.idx, idx))).returning({ title: itemSubtasks.title });
+  const [row] = await orm.delete(itemSubtasks).where(and10(eq26(itemSubtasks.itemId, itemId), eq26(itemSubtasks.idx, idx))).returning({ title: itemSubtasks.title });
   if (!row) return void 0;
-  const remaining = await orm.select({ idx: itemSubtasks.idx }).from(itemSubtasks).where(eq27(itemSubtasks.itemId, itemId)).orderBy(asc6(itemSubtasks.idx));
+  const remaining = await orm.select({ idx: itemSubtasks.idx }).from(itemSubtasks).where(eq26(itemSubtasks.itemId, itemId)).orderBy(asc6(itemSubtasks.idx));
   for (let i = 0; i < remaining.length; i++) {
     const oldIdx = remaining[i].idx;
     if (oldIdx === i) continue;
     await orm.update(itemSubtasks).set({ idx: i }).where(
-      and10(eq27(itemSubtasks.itemId, itemId), eq27(itemSubtasks.idx, oldIdx))
+      and10(eq26(itemSubtasks.itemId, itemId), eq26(itemSubtasks.idx, oldIdx))
     );
   }
   return row.title;
@@ -9143,20 +9149,20 @@ function registerSubtaskCommands(cmd) {
 
 // src/commands/backlog/movePhase.ts
 import chalk96 from "chalk";
-import { count as count6, eq as eq30 } from "drizzle-orm";
+import { count as count6, eq as eq29 } from "drizzle-orm";
 
 // src/commands/backlog/reorderPhaseRows.ts
-import { and as and12, asc as asc8, eq as eq29 } from "drizzle-orm";
+import { and as and12, asc as asc8, eq as eq28 } from "drizzle-orm";
 
 // src/commands/backlog/reindexPhases.ts
-import { and as and11, asc as asc7, count as count5, eq as eq28 } from "drizzle-orm";
+import { and as and11, asc as asc7, count as count5, eq as eq27 } from "drizzle-orm";
 async function reindexPhases(db, itemId) {
-  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq28(planPhases.itemId, itemId)).orderBy(asc7(planPhases.idx));
+  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq27(planPhases.itemId, itemId)).orderBy(asc7(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(and11(eq28(planTasks.itemId, itemId), eq28(planTasks.phaseIdx, oldIdx)));
-    await db.update(planPhases).set({ idx: i }).where(and11(eq28(planPhases.itemId, itemId), eq28(planPhases.idx, oldIdx)));
+    await db.update(planTasks).set({ phaseIdx: i }).where(and11(eq27(planTasks.itemId, itemId), eq27(planTasks.phaseIdx, oldIdx)));
+    await db.update(planPhases).set({ idx: i }).where(and11(eq27(planPhases.itemId, itemId), eq27(planPhases.idx, oldIdx)));
   }
 }
 async function adjustCurrentPhase(db, item, removedIdx) {
@@ -9164,24 +9170,24 @@ 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(eq28(items.id, item.id));
+    await db.update(items).set({ currentPhase: currentPhase - 1 }).where(eq27(items.id, item.id));
     return;
   }
   if (removedIdx !== currentIdx) return;
-  const [row] = await db.select({ cnt: count5() }).from(planPhases).where(eq28(planPhases.itemId, item.id));
+  const [row] = await db.select({ cnt: count5() }).from(planPhases).where(eq27(planPhases.itemId, item.id));
   const cnt = row?.cnt ?? 0;
-  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq28(items.id, item.id));
+  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq27(items.id, item.id));
 }
 
 // src/commands/backlog/reorderPhaseRows.ts
 async function reorderPhaseRows(orm, itemId, fromIdx, toIdx) {
   await orm.transaction(async (tx) => {
-    const [phaseRow] = await tx.select({ name: planPhases.name, manualChecks: planPhases.manualChecks }).from(planPhases).where(and12(eq29(planPhases.itemId, itemId), eq29(planPhases.idx, fromIdx)));
-    const tasks = await tx.select({ idx: planTasks.idx, task: planTasks.task }).from(planTasks).where(and12(eq29(planTasks.itemId, itemId), eq29(planTasks.phaseIdx, fromIdx))).orderBy(asc8(planTasks.idx));
+    const [phaseRow] = await tx.select({ name: planPhases.name, manualChecks: planPhases.manualChecks }).from(planPhases).where(and12(eq28(planPhases.itemId, itemId), eq28(planPhases.idx, fromIdx)));
+    const tasks = await tx.select({ idx: planTasks.idx, task: planTasks.task }).from(planTasks).where(and12(eq28(planTasks.itemId, itemId), eq28(planTasks.phaseIdx, fromIdx))).orderBy(asc8(planTasks.idx));
     await tx.delete(planTasks).where(
-      and12(eq29(planTasks.itemId, itemId), eq29(planTasks.phaseIdx, fromIdx))
+      and12(eq28(planTasks.itemId, itemId), eq28(planTasks.phaseIdx, fromIdx))
     );
-    await tx.delete(planPhases).where(and12(eq29(planPhases.itemId, itemId), eq29(planPhases.idx, fromIdx)));
+    await tx.delete(planPhases).where(and12(eq28(planPhases.itemId, itemId), eq28(planPhases.idx, fromIdx)));
     await reindexPhases(tx, itemId);
     await shiftPhasesUp(tx, itemId, toIdx);
     await tx.insert(planPhases).values({
@@ -9222,7 +9228,7 @@ async function movePhase(id2, from, to) {
   if (!found) return;
   const { orm, item } = found;
   const itemId = item.id;
-  const [row] = await orm.select({ cnt: count6() }).from(planPhases).where(eq30(planPhases.itemId, itemId));
+  const [row] = await orm.select({ cnt: count6() }).from(planPhases).where(eq29(planPhases.itemId, itemId));
   const phaseCount = row?.cnt ?? 0;
   const fromIdx = toIndex(from, phaseCount);
   if (fromIdx === void 0) return;
@@ -9238,22 +9244,22 @@ async function movePhase(id2, from, to) {
 import chalk98 from "chalk";
 
 // src/commands/backlog/applyPhaseUpdate.ts
-import { and as and13, eq as eq31 } from "drizzle-orm";
+import { and as and13, eq as eq30 } 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(
-        and13(eq31(planPhases.itemId, itemId), eq31(planPhases.idx, phaseIdx))
+        and13(eq30(planPhases.itemId, itemId), eq30(planPhases.idx, phaseIdx))
       );
     }
     if (fields.manualCheck) {
       await tx.update(planPhases).set({ manualChecks: JSON.stringify(fields.manualCheck) }).where(
-        and13(eq31(planPhases.itemId, itemId), eq31(planPhases.idx, phaseIdx))
+        and13(eq30(planPhases.itemId, itemId), eq30(planPhases.idx, phaseIdx))
       );
     }
     if (fields.task) {
       await tx.delete(planTasks).where(
-        and13(eq31(planTasks.itemId, itemId), eq31(planTasks.phaseIdx, phaseIdx))
+        and13(eq30(planTasks.itemId, itemId), eq30(planTasks.phaseIdx, phaseIdx))
       );
       if (fields.task.length) {
         await tx.insert(planTasks).values(
@@ -9271,14 +9277,14 @@ async function applyPhaseUpdate(orm, itemId, phaseIdx, fields) {
 
 // src/commands/backlog/findPhase.ts
 import chalk97 from "chalk";
-import { and as and14, count as count7, eq as eq32 } from "drizzle-orm";
+import { and as and14, count as count7, eq as eq31 } from "drizzle-orm";
 async function findPhase(id2, phase) {
   const found = await findOneItem(id2);
   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: count7() }).from(planPhases).where(and14(eq32(planPhases.itemId, itemId), eq32(planPhases.idx, phaseIdx)));
+  const [row] = await orm.select({ cnt: count7() }).from(planPhases).where(and14(eq31(planPhases.itemId, itemId), eq31(planPhases.idx, phaseIdx)));
   if (!row || row.cnt === 0) {
     console.log(
       chalk97.red(`Phase ${phaseIdx + 1} not found on item #${itemId}.`)
@@ -9449,16 +9455,16 @@ function registerUpdatePhaseCommand(cmd) {
 
 // src/commands/backlog/removePhase.ts
 import chalk99 from "chalk";
-import { and as and15, eq as eq33 } from "drizzle-orm";
+import { and as and15, eq as eq32 } from "drizzle-orm";
 async function removePhase(id2, phase) {
   const found = await findPhase(id2, phase);
   if (!found) return;
   const { item, orm, itemId, phaseIdx } = found;
   await orm.transaction(async (tx) => {
     await tx.delete(planTasks).where(
-      and15(eq33(planTasks.itemId, itemId), eq33(planTasks.phaseIdx, phaseIdx))
+      and15(eq32(planTasks.itemId, itemId), eq32(planTasks.phaseIdx, phaseIdx))
     );
-    await tx.delete(planPhases).where(and15(eq33(planPhases.itemId, itemId), eq33(planPhases.idx, phaseIdx)));
+    await tx.delete(planPhases).where(and15(eq32(planPhases.itemId, itemId), eq32(planPhases.idx, phaseIdx)));
     await reindexPhases(tx, itemId);
     await adjustCurrentPhase(tx, item, phaseIdx);
   });
@@ -9469,7 +9475,7 @@ async function removePhase(id2, phase) {
 
 // src/commands/backlog/update/index.ts
 import chalk101 from "chalk";
-import { eq as eq34 } from "drizzle-orm";
+import { eq as eq33 } from "drizzle-orm";
 
 // src/commands/backlog/update/applyAcMutations.ts
 function hasAcMutations(options2) {
@@ -9549,7 +9555,7 @@ async function update(id2, options2) {
   if (!built) return;
   const { orm } = found;
   const itemId = found.item.id;
-  await orm.update(items).set(built.set).where(eq34(items.id, itemId));
+  await orm.update(items).set(built.set).where(eq33(items.id, itemId));
   console.log(chalk101.green(`Updated ${built.fields} on item #${itemId}.`));
 }
 
@@ -13259,9 +13265,9 @@ function registerGithub(program2) {
 }
 
 // src/commands/handover/countPendingHandovers.ts
-import { and as and16, eq as eq35, isNull, sql as sql6 } from "drizzle-orm";
+import { and as and16, eq as eq34, isNull, sql as sql7 } from "drizzle-orm";
 async function countPendingHandovers(orm, origin) {
-  const [row] = await orm.select({ count: sql6`count(*)::int` }).from(handovers).where(and16(eq35(handovers.origin, origin), isNull(handovers.recalledAt)));
+  const [row] = await orm.select({ count: sql7`count(*)::int` }).from(handovers).where(and16(eq34(handovers.origin, origin), isNull(handovers.recalledAt)));
   return row?.count ?? 0;
 }
 
@@ -13401,13 +13407,13 @@ async function load2(options2 = {}) {
 }
 
 // src/commands/handover/listPendingHandovers.ts
-import { and as and17, desc as desc4, eq as eq36, isNull as isNull2 } from "drizzle-orm";
+import { and as and17, desc as desc4, eq as eq35, isNull as isNull2 } from "drizzle-orm";
 async function listPendingHandovers(orm, origin) {
   return orm.select({
     id: handovers.id,
     summary: handovers.summary,
     createdAt: handovers.createdAt
-  }).from(handovers).where(and17(eq36(handovers.origin, origin), isNull2(handovers.recalledAt))).orderBy(desc4(handovers.createdAt), desc4(handovers.id));
+  }).from(handovers).where(and17(eq35(handovers.origin, origin), isNull2(handovers.recalledAt))).orderBy(desc4(handovers.createdAt), desc4(handovers.id));
 }
 
 // src/commands/handover/printPendingHandovers.ts
@@ -13420,17 +13426,17 @@ async function printPendingHandovers() {
 }
 
 // src/commands/handover/recallHandover.ts
-import { and as and18, desc as desc5, eq as eq37, isNull as isNull3 } from "drizzle-orm";
+import { and as and18, desc as desc5, eq as eq36, isNull as isNull3 } from "drizzle-orm";
 async function recallHandover(orm, origin, id2) {
   const [row] = await orm.select().from(handovers).where(
     and18(
-      eq37(handovers.origin, origin),
+      eq36(handovers.origin, origin),
       isNull3(handovers.recalledAt),
-      ...id2 === void 0 ? [] : [eq37(handovers.id, id2)]
+      ...id2 === void 0 ? [] : [eq36(handovers.id, id2)]
     )
   ).orderBy(desc5(handovers.createdAt), desc5(handovers.id)).limit(1);
   if (!row) return void 0;
-  await orm.update(handovers).set({ recalledAt: /* @__PURE__ */ new Date() }).where(eq37(handovers.id, row.id));
+  await orm.update(handovers).set({ recalledAt: /* @__PURE__ */ new Date() }).where(eq36(handovers.id, row.id));
   return row.content;
 }
 
@@ -19458,8 +19464,8 @@ function filterToSql(filter) {
 // src/commands/seq/fetchSeqData.ts
 function buildDataParams(filter, count8, from, to) {
   const sqlFilter = filterToSql(filter);
-  const sql10 = `select @Timestamp, @Level, @Exception, @Message from stream where ${sqlFilter} order by @Timestamp desc limit ${count8}`;
-  const params = new URLSearchParams({ q: sql10 });
+  const sql11 = `select @Timestamp, @Level, @Exception, @Message from stream where ${sqlFilter} order by @Timestamp desc limit ${count8}`;
+  const params = new URLSearchParams({ q: sql11 });
   if (from) params.set("rangeStartUtc", from);
   if (to) params.set("rangeEndUtc", to);
   return params;
@@ -19719,26 +19725,26 @@ import chalk186 from "chalk";
 // src/commands/sql/loadConnections.ts
 function loadConnections3() {
   const raw = loadGlobalConfigRaw();
-  const sql10 = raw.sql;
-  return sql10?.connections ?? [];
+  const sql11 = raw.sql;
+  return sql11?.connections ?? [];
 }
 function saveConnections3(connections) {
   const raw = loadGlobalConfigRaw();
-  const sql10 = raw.sql ?? {};
-  sql10.connections = connections;
-  raw.sql = sql10;
+  const sql11 = raw.sql ?? {};
+  sql11.connections = connections;
+  raw.sql = sql11;
   saveGlobalConfig(raw);
 }
 function getDefaultConnection2() {
   const raw = loadGlobalConfigRaw();
-  const sql10 = raw.sql;
-  return sql10?.defaultConnection;
+  const sql11 = raw.sql;
+  return sql11?.defaultConnection;
 }
 function setDefaultConnection2(name) {
   const raw = loadGlobalConfigRaw();
-  const sql10 = raw.sql ?? {};
-  sql10.defaultConnection = name;
-  raw.sql = sql10;
+  const sql11 = raw.sql ?? {};
+  sql11.defaultConnection = name;
+  raw.sql = sql11;
   saveGlobalConfig(raw);
 }
 
@@ -19809,9 +19815,9 @@ function resolveConnection3(name) {
 }
 
 // src/commands/sql/sqlConnect.ts
-import sql7 from "mssql";
+import sql8 from "mssql";
 async function sqlConnect(conn) {
-  return await sql7.connect({
+  return await sql8.connect({
     server: conn.server,
     port: conn.port,
     user: conn.user,
@@ -19874,11 +19880,11 @@ var MUTATION_PATTERN = new RegExp(
   `\\b(${MUTATION_KEYWORDS.join("|")})\\b`,
   "i"
 );
-function stripComments(sql10) {
-  return sql10.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/--[^\n]*/g, " ");
+function stripComments(sql11) {
+  return sql11.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/--[^\n]*/g, " ");
 }
-function isMutation(sql10) {
-  const stripped = stripComments(sql10);
+function isMutation(sql11) {
+  const stripped = stripComments(sql11);
   if (MUTATION_PATTERN.test(stripped)) return true;
   return /\bSELECT\b[\s\S]+\bINTO\s+\w/i.test(stripped);
 }
@@ -21992,13 +21998,13 @@ function logSpawnedSession(session) {
 }
 
 // src/shared/db/recordPhaseActiveMs.ts
-import { sql as sql8 } from "drizzle-orm";
+import { sql as sql9 } from "drizzle-orm";
 async function recordPhaseActiveMs(db, itemId, phaseIdx, activeMs) {
   if (activeMs <= 0) return;
   await db.insert(phaseUsage).values({ itemId, phaseIdx, activeMs }).onConflictDoUpdate({
     target: [phaseUsage.itemId, phaseUsage.phaseIdx],
     set: {
-      activeMs: sql8`${phaseUsage.activeMs} + excluded.active_ms`
+      activeMs: sql9`${phaseUsage.activeMs} + excluded.active_ms`
     }
   });
 }
@@ -22141,15 +22147,15 @@ function makeStatusChangeHandler(dismiss, notify2, reuseForRun) {
 }
 
 // src/shared/db/recordPhaseTokens.ts
-import { sql as sql9 } from "drizzle-orm";
+import { sql as sql10 } from "drizzle-orm";
 async function recordPhaseTokens(db, itemId, phaseIdx, totalIn, totalOut) {
   await db.insert(phaseUsage).values({ itemId, phaseIdx, lastTotalIn: totalIn, lastTotalOut: totalOut }).onConflictDoUpdate({
     target: [phaseUsage.itemId, phaseUsage.phaseIdx],
     set: {
-      tokensDown: sql9`${phaseUsage.tokensDown} + CASE WHEN ${phaseUsage.lastTotalIn} IS NULL THEN 0 ELSE GREATEST(excluded.last_total_in - ${phaseUsage.lastTotalIn}, 0) END`,
-      tokensUp: sql9`${phaseUsage.tokensUp} + CASE WHEN ${phaseUsage.lastTotalOut} IS NULL THEN 0 ELSE GREATEST(excluded.last_total_out - ${phaseUsage.lastTotalOut}, 0) END`,
-      lastTotalIn: sql9`excluded.last_total_in`,
-      lastTotalOut: sql9`excluded.last_total_out`
+      tokensDown: sql10`${phaseUsage.tokensDown} + CASE WHEN ${phaseUsage.lastTotalIn} IS NULL THEN 0 ELSE GREATEST(excluded.last_total_in - ${phaseUsage.lastTotalIn}, 0) END`,
+      tokensUp: sql10`${phaseUsage.tokensUp} + CASE WHEN ${phaseUsage.lastTotalOut} IS NULL THEN 0 ELSE GREATEST(excluded.last_total_out - ${phaseUsage.lastTotalOut}, 0) END`,
+      lastTotalIn: sql10`excluded.last_total_in`,
+      lastTotalOut: sql10`excluded.last_total_out`
     }
   });
 }
@@ -22191,10 +22197,10 @@ function applyReviewPause(session, activity2) {
 }
 
 // src/shared/db/getPhaseActiveMs.ts
-import { and as and19, eq as eq38 } from "drizzle-orm";
+import { and as and19, eq as eq37 } from "drizzle-orm";
 async function getPhaseActiveMs(db, itemId, phaseIdx) {
   const [row] = await db.select({ activeMs: phaseUsage.activeMs }).from(phaseUsage).where(
-    and19(eq38(phaseUsage.itemId, itemId), eq38(phaseUsage.phaseIdx, phaseIdx))
+    and19(eq37(phaseUsage.itemId, itemId), eq37(phaseUsage.phaseIdx, phaseIdx))
   );
   return row?.activeMs ?? 0;
 }