@staff0rd/assist 0.633.0 → 0.634.1

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.633.0",
+  version: "0.634.1",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -11739,8 +11739,44 @@ async function countItemUsageByOrigin(db) {
   return rows.map((row) => ({ origin: row.origin, count: Number(row.count) }));
 }
 
+// src/shared/db/itemUsageWhere.ts
+import { and as and9, eq as eq21, ne as ne2 } from "drizzle-orm";
+function parseItemUsageStatus(value) {
+  return value === "done" || value === "running" ? value : void 0;
+}
+function statusClause(status3) {
+  if (status3 === "done") return eq21(items.status, "done");
+  if (status3 === "running") return ne2(items.status, "done");
+  return void 0;
+}
+function itemUsageWhere(filter) {
+  return and9(
+    filter?.origin ? eq21(items.origin, filter.origin) : void 0,
+    statusClause(filter?.status)
+  );
+}
+
+// src/shared/db/parseItemUsageSort.ts
+var sortFields = [
+  "phases",
+  "active",
+  "tokens",
+  "peakContext",
+  "lastPhase"
+];
+var defaultItemUsageSort = {
+  field: "lastPhase",
+  direction: "desc"
+};
+function parseItemUsageSort(field, direction) {
+  return {
+    field: sortFields.find((known) => known === field) ?? defaultItemUsageSort.field,
+    direction: direction === "asc" ? "asc" : "desc"
+  };
+}
+
 // src/shared/db/itemUsageStats.ts
-import { eq as eq21, sql as sql18 } from "drizzle-orm";
+import { eq as eq22, sql as sql18 } from "drizzle-orm";
 function median(value) {
   return sql18`coalesce(percentile_cont(0.5) within group (order by (${value})::double precision), 0)`;
 }
@@ -11756,7 +11792,7 @@ async function itemUsageStats(db, options2) {
     ),
     medianActiveMs: median(totals.activeMs),
     medianTokens: median(sql18`${totals.tokensUp} + ${totals.tokensDown}`)
-  }).from(items).innerJoin(totals, eq21(totals.itemId, items.id)).leftJoin(planned, eq21(planned.itemId, items.id)).where(options2?.origin ? eq21(items.origin, options2.origin) : void 0);
+  }).from(items).innerJoin(totals, eq22(totals.itemId, items.id)).leftJoin(planned, eq22(planned.itemId, items.id)).where(itemUsageWhere(options2));
   return {
     itemCount: Number(row?.itemCount ?? 0),
     doneCount: Number(row?.doneCount ?? 0),
@@ -11768,15 +11804,30 @@ async function itemUsageStats(db, options2) {
 }
 
 // src/shared/db/listItemUsageSummaries.ts
-import { desc as desc4, eq as eq22, sql as sql20 } from "drizzle-orm";
+import { eq as eq23 } from "drizzle-orm";
+
+// src/shared/db/itemUsageOrderBy.ts
+import { desc as desc4, sql as sql19 } from "drizzle-orm";
+function itemUsageOrderBy(joins, sort = defaultItemUsageSort) {
+  const { totals, planned, lastPhase } = joins;
+  const sortable = {
+    phases: sql19`coalesce(${planned.count}, ${totals.recordedPhases})`,
+    active: sql19`${totals.activeMs}`,
+    tokens: sql19`${totals.tokensUp} + ${totals.tokensDown}`,
+    peakContext: sql19`${totals.peakContextPct}`,
+    lastPhase: sql19`${lastPhase.at}`
+  };
+  const order = sort.direction === "asc" ? sql19`asc` : sql19`desc`;
+  return [sql19`${sortable[sort.field]} ${order} nulls last`, desc4(items.id)];
+}
 
 // src/shared/db/lastPhaseActivity.ts
-import { sql as sql19 } from "drizzle-orm";
+import { sql as sql20 } from "drizzle-orm";
 function lastPhaseActivity(db) {
   return db.select({
     itemId: phaseSessions.itemId,
-    at: sql19`max(${phaseSessions.createdAt})`.as("last_phase_at"),
-    atIso: sql19`to_char(max(${phaseSessions.createdAt}) at time zone 'utc', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')`.as(
+    at: sql20`max(${phaseSessions.createdAt})`.as("last_phase_at"),
+    atIso: sql20`to_char(max(${phaseSessions.createdAt}) at time zone 'utc', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')`.as(
       "last_phase_at_iso"
     )
   }).from(phaseSessions).groupBy(phaseSessions.itemId).as("last_phase_activity");
@@ -11814,7 +11865,9 @@ async function listItemUsageSummaries(db, options2) {
     activeMs: totals.activeMs,
     peakContextPct: totals.peakContextPct,
     lastPhaseAt: lastPhase.atIso
-  }).from(items).innerJoin(totals, eq22(totals.itemId, items.id)).leftJoin(planned, eq22(planned.itemId, items.id)).leftJoin(lastPhase, eq22(lastPhase.itemId, items.id)).where(options2?.origin ? eq22(items.origin, options2.origin) : void 0).orderBy(sql20`${lastPhase.at} desc nulls last`, desc4(items.id));
+  }).from(items).innerJoin(totals, eq23(totals.itemId, items.id)).leftJoin(planned, eq23(planned.itemId, items.id)).leftJoin(lastPhase, eq23(lastPhase.itemId, items.id)).where(itemUsageWhere(options2)).orderBy(
+    ...itemUsageOrderBy({ totals, planned, lastPhase }, options2?.sort)
+  );
   const rows = options2?.limit === void 0 ? await query : await query.limit(options2.limit).offset(options2.offset ?? 0);
   return rows.map(toItemUsageSummary);
 }
@@ -11823,10 +11876,15 @@ async function listItemUsageSummaries(db, options2) {
 function listUsageItems(req, res) {
   return respondPagedRows(req, res, async (range, params) => {
     const origin = params.get("origin") || void 0;
+    const status3 = parseItemUsageStatus(params.get("status"));
+    const sort = parseItemUsageSort(
+      params.get("sort"),
+      params.get("direction")
+    );
     const db = await getDb();
     const [rows, summary, origins] = await Promise.all([
-      listItemUsageSummaries(db, { ...range, origin }),
-      itemUsageStats(db, { origin }),
+      listItemUsageSummaries(db, { ...range, origin, status: status3, sort }),
+      itemUsageStats(db, { origin, status: status3 }),
       countItemUsageByOrigin(db)
     ]);
     return { rows, total: summary.itemCount, summary, origins };
@@ -13652,11 +13710,11 @@ function registerActivityCommands(cmd) {
 
 // src/commands/backlog/associate-github/index.ts
 import chalk66 from "chalk";
-import { eq as eq24 } from "drizzle-orm";
+import { eq as eq25 } from "drizzle-orm";
 
 // src/commands/backlog/beginAssociation.ts
 import chalk65 from "chalk";
-import { eq as eq23 } from "drizzle-orm";
+import { eq as eq24 } from "drizzle-orm";
 async function beginAssociation(id, options2, clearPatch, label2) {
   const found = await findOneItem(id);
   if (!found) {
@@ -13666,7 +13724,7 @@ async function beginAssociation(id, options2, clearPatch, label2) {
   const { orm } = found;
   const itemId2 = found.item.id;
   if (options2.clear) {
-    await orm.update(items).set(clearPatch).where(eq23(items.id, itemId2));
+    await orm.update(items).set(clearPatch).where(eq24(items.id, itemId2));
     console.log(
       chalk65.green(
         `Cleared ${label2} association on item ${formatItemId(itemId2)}.`
@@ -13734,7 +13792,7 @@ async function associateGithub(id, issue, options2) {
     return;
   }
   const title = fetchGithubIssueTitle(normalized);
-  await orm.update(items).set({ githubIssue: normalized, jiraKey: null }).where(eq24(items.id, itemId2));
+  await orm.update(items).set({ githubIssue: normalized, jiraKey: null }).where(eq25(items.id, itemId2));
   console.log(
     chalk66.green(`Associated ${normalized} with item ${formatItemId(itemId2)}.`),
     title ? chalk66.dim(`(${title})`) : ""
@@ -13748,7 +13806,7 @@ function registerAssociateGithubCommand(cmd) {
 
 // src/commands/backlog/associate-jira/index.ts
 import chalk68 from "chalk";
-import { eq as eq25 } from "drizzle-orm";
+import { eq as eq26 } from "drizzle-orm";
 
 // src/commands/jira/fetchIssue.ts
 import { execSync as execSync27 } from "child_process";
@@ -13813,7 +13871,7 @@ async function associateJira(id, key, options2) {
   const parsed = fetchIssue(normalized, "summary");
   const fields = parsed?.fields;
   const summary = fields?.summary;
-  await orm.update(items).set({ jiraKey: normalized, githubIssue: null }).where(eq25(items.id, itemId2));
+  await orm.update(items).set({ jiraKey: normalized, githubIssue: null }).where(eq26(items.id, itemId2));
   console.log(
     chalk68.green(`Associated ${normalized} with item ${formatItemId(itemId2)}.`),
     summary ? chalk68.dim(`(${summary})`) : ""
@@ -14320,15 +14378,15 @@ function isClaudeCode() {
 }
 
 // src/commands/backlog/insertPhaseAt.ts
-import { eq as eq27 } from "drizzle-orm";
+import { eq as eq28 } from "drizzle-orm";
 
 // src/commands/backlog/shiftPhasesUp.ts
-import { and as and9, desc as desc5, eq as eq26, gte } from "drizzle-orm";
+import { and as and10, desc as desc5, eq as eq27, gte } from "drizzle-orm";
 async function shiftPhasesUp(db, itemId2, fromIdx) {
-  const toShift = await db.select({ idx: planPhases.idx }).from(planPhases).where(and9(eq26(planPhases.itemId, itemId2), gte(planPhases.idx, fromIdx))).orderBy(desc5(planPhases.idx));
+  const toShift = await db.select({ idx: planPhases.idx }).from(planPhases).where(and10(eq27(planPhases.itemId, itemId2), gte(planPhases.idx, fromIdx))).orderBy(desc5(planPhases.idx));
   for (const p of toShift) {
-    await db.update(planTasks).set({ phaseIdx: p.idx + 1 }).where(and9(eq26(planTasks.itemId, itemId2), eq26(planTasks.phaseIdx, p.idx)));
-    await db.update(planPhases).set({ idx: p.idx + 1 }).where(and9(eq26(planPhases.itemId, itemId2), eq26(planPhases.idx, p.idx)));
+    await db.update(planTasks).set({ phaseIdx: p.idx + 1 }).where(and10(eq27(planTasks.itemId, itemId2), eq27(planTasks.phaseIdx, p.idx)));
+    await db.update(planPhases).set({ idx: p.idx + 1 }).where(and10(eq27(planPhases.itemId, itemId2), eq27(planPhases.idx, p.idx)));
   }
 }
 
@@ -14341,7 +14399,7 @@ async function insertPhaseAt(orm, itemId2, phaseIdx, name, tasks, manualChecks,
       await tx.insert(planTasks).values(tasks.map((task, i) => ({ itemId: itemId2, phaseIdx, idx: i, task })));
     }
     if (currentPhase !== void 0 && currentPhase - 1 >= phaseIdx) {
-      await tx.update(items).set({ currentPhase: phaseIdx + 1 }).where(eq27(items.id, itemId2));
+      await tx.update(items).set({ currentPhase: phaseIdx + 1 }).where(eq28(items.id, itemId2));
     }
   });
 }
@@ -14513,9 +14571,9 @@ import chalk78 from "chalk";
 
 // src/commands/backlog/resolveInsertPosition.ts
 import chalk77 from "chalk";
-import { count as count3, eq as eq28 } from "drizzle-orm";
+import { count as count3, eq as eq29 } from "drizzle-orm";
 async function resolveInsertPosition(orm, itemId2, position) {
-  const [row] = await orm.select({ cnt: count3() }).from(planPhases).where(eq28(planPhases.itemId, itemId2));
+  const [row] = await orm.select({ cnt: count3() }).from(planPhases).where(eq29(planPhases.itemId, itemId2));
   const phaseCount = row?.cnt ?? 0;
   if (position === void 0) return phaseCount;
   const pos = Number.parseInt(position, 10);
@@ -14810,9 +14868,9 @@ function hasCycle(adjacency, fromId, toId) {
 }
 
 // src/commands/backlog/loadDependencyGraph.ts
-import { eq as eq29 } from "drizzle-orm";
+import { eq as eq30 } from "drizzle-orm";
 async function loadDependencyGraph(orm) {
-  const rows = await orm.select({ itemId: links.itemId, targetId: links.targetId }).from(links).where(eq29(links.type, "depends-on"));
+  const rows = await orm.select({ itemId: links.itemId, targetId: links.targetId }).from(links).where(eq30(links.type, "depends-on"));
   const graph = /* @__PURE__ */ new Map();
   for (const { itemId: itemId2, targetId } of rows) {
     const bucket = graph.get(itemId2);
@@ -14879,7 +14937,7 @@ async function link(fromId, toId, opts) {
 
 // src/commands/backlog/unlink.ts
 import chalk85 from "chalk";
-import { and as and10, eq as eq30 } from "drizzle-orm";
+import { and as and11, eq as eq31 } from "drizzle-orm";
 async function unlink(fromId, toId) {
   const fromNum = parseItemId(fromId);
   const toNum = parseItemId(toId);
@@ -14903,7 +14961,7 @@ async function unlink(fromId, toId) {
     );
     return;
   }
-  await orm.delete(links).where(and10(eq30(links.itemId, fromNum), eq30(links.targetId, toNum)));
+  await orm.delete(links).where(and11(eq31(links.itemId, fromNum), eq31(links.targetId, toNum)));
   console.log(
     chalk85.green(
       `Removed link from ${formatItemId(fromNum)} to ${formatItemId(toNum)}.`
@@ -14923,7 +14981,7 @@ function registerLinkCommands(cmd) {
 
 // src/commands/backlog/move-repo/index.ts
 import chalk87 from "chalk";
-import { eq as eq32 } from "drizzle-orm";
+import { eq as eq33 } from "drizzle-orm";
 
 // src/commands/backlog/move-repo/confirmMove.ts
 import chalk86 from "chalk";
@@ -14938,9 +14996,9 @@ async function confirmMove(cnt, oldOrigin, newOrigin) {
 }
 
 // src/commands/backlog/move-repo/countByOrigin.ts
-import { count as count4, eq as eq31 } from "drizzle-orm";
+import { count as count4, eq as eq32 } from "drizzle-orm";
 async function countByOrigin(orm, origin) {
-  const [{ cnt }] = await orm.select({ cnt: count4() }).from(items).where(eq31(items.origin, origin));
+  const [{ cnt }] = await orm.select({ cnt: count4() }).from(items).where(eq32(items.origin, origin));
   return cnt;
 }
 
@@ -14983,7 +15041,7 @@ async function moveRepo(oldOriginRaw, newOriginRaw, options2 = {}) {
     console.log(chalk87.yellow("Move cancelled; no changes made."));
     return;
   }
-  await orm.update(items).set({ origin: newOrigin }).where(eq32(items.origin, oldOrigin));
+  await orm.update(items).set({ origin: newOrigin }).where(eq33(items.origin, oldOrigin));
   console.log(
     chalk87.green(
       `Moved ${pluralItems(cnt)} from "${oldOrigin}" to "${newOrigin}".`
@@ -15383,10 +15441,10 @@ async function start(id) {
 
 // src/commands/backlog/stop/index.ts
 import chalk99 from "chalk";
-import { and as and11, eq as eq33 } from "drizzle-orm";
+import { and as and12, eq as eq34 } from "drizzle-orm";
 async function stop() {
   const { orm } = await getReady();
-  const stopped = await orm.update(items).set({ status: "todo", currentPhase: 1 }).where(and11(eq33(items.status, "in-progress"), eq33(items.origin, getOrigin()))).returning({ id: items.id, name: items.name });
+  const stopped = await orm.update(items).set({ status: "todo", currentPhase: 1 }).where(and12(eq34(items.status, "in-progress"), eq34(items.origin, getOrigin()))).returning({ id: items.id, name: items.name });
   if (stopped.length === 0) {
     console.log(chalk99.yellow("No in-progress items to stop."));
     return;
@@ -15503,13 +15561,13 @@ async function findSubtask(id, index3) {
 }
 
 // src/commands/backlog/updateSubtask.ts
-import { and as and12, eq as eq34 } from "drizzle-orm";
+import { and as and13, eq as eq35 } from "drizzle-orm";
 async function updateSubtask(orm, itemId2, 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(and12(eq34(itemSubtasks.itemId, itemId2), eq34(itemSubtasks.idx, idx))).returning({ title: itemSubtasks.title });
+  const [row] = await orm.update(itemSubtasks).set(set).where(and13(eq35(itemSubtasks.itemId, itemId2), eq35(itemSubtasks.idx, idx))).returning({ title: itemSubtasks.title });
   return row?.title;
 }
 
@@ -15564,16 +15622,16 @@ async function editSubtask(id, index3, options2) {
 import chalk105 from "chalk";
 
 // src/commands/backlog/deleteSubtask.ts
-import { and as and13, asc as asc9, eq as eq35 } from "drizzle-orm";
+import { and as and14, asc as asc9, eq as eq36 } from "drizzle-orm";
 async function deleteSubtask(orm, itemId2, idx) {
-  const [row] = await orm.delete(itemSubtasks).where(and13(eq35(itemSubtasks.itemId, itemId2), eq35(itemSubtasks.idx, idx))).returning({ title: itemSubtasks.title });
+  const [row] = await orm.delete(itemSubtasks).where(and14(eq36(itemSubtasks.itemId, itemId2), eq36(itemSubtasks.idx, idx))).returning({ title: itemSubtasks.title });
   if (!row) return void 0;
-  const remaining = await orm.select({ idx: itemSubtasks.idx }).from(itemSubtasks).where(eq35(itemSubtasks.itemId, itemId2)).orderBy(asc9(itemSubtasks.idx));
+  const remaining = await orm.select({ idx: itemSubtasks.idx }).from(itemSubtasks).where(eq36(itemSubtasks.itemId, itemId2)).orderBy(asc9(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(
-      and13(eq35(itemSubtasks.itemId, itemId2), eq35(itemSubtasks.idx, oldIdx))
+      and14(eq36(itemSubtasks.itemId, itemId2), eq36(itemSubtasks.idx, oldIdx))
     );
   }
   return row.title;
@@ -15642,20 +15700,20 @@ function registerSubtaskCommands(cmd) {
 
 // src/commands/backlog/movePhase.ts
 import chalk107 from "chalk";
-import { count as count6, eq as eq38 } from "drizzle-orm";
+import { count as count6, eq as eq39 } from "drizzle-orm";
 
 // src/commands/backlog/reorderPhaseRows.ts
-import { and as and15, asc as asc11, eq as eq37 } from "drizzle-orm";
+import { and as and16, asc as asc11, eq as eq38 } from "drizzle-orm";
 
 // src/commands/backlog/reindexPhases.ts
-import { and as and14, asc as asc10, count as count5, eq as eq36 } from "drizzle-orm";
+import { and as and15, asc as asc10, count as count5, eq as eq37 } from "drizzle-orm";
 async function reindexPhases(db, itemId2) {
-  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq36(planPhases.itemId, itemId2)).orderBy(asc10(planPhases.idx));
+  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq37(planPhases.itemId, itemId2)).orderBy(asc10(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(and14(eq36(planTasks.itemId, itemId2), eq36(planTasks.phaseIdx, oldIdx)));
-    await db.update(planPhases).set({ idx: i }).where(and14(eq36(planPhases.itemId, itemId2), eq36(planPhases.idx, oldIdx)));
+    await db.update(planTasks).set({ phaseIdx: i }).where(and15(eq37(planTasks.itemId, itemId2), eq37(planTasks.phaseIdx, oldIdx)));
+    await db.update(planPhases).set({ idx: i }).where(and15(eq37(planPhases.itemId, itemId2), eq37(planPhases.idx, oldIdx)));
   }
 }
 async function adjustCurrentPhase(db, item, removedIdx) {
@@ -15663,24 +15721,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(eq36(items.id, item.id));
+    await db.update(items).set({ currentPhase: currentPhase - 1 }).where(eq37(items.id, item.id));
     return;
   }
   if (removedIdx !== currentIdx) return;
-  const [row] = await db.select({ cnt: count5() }).from(planPhases).where(eq36(planPhases.itemId, item.id));
+  const [row] = await db.select({ cnt: count5() }).from(planPhases).where(eq37(planPhases.itemId, item.id));
   const cnt = row?.cnt ?? 0;
-  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq36(items.id, item.id));
+  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq37(items.id, item.id));
 }
 
 // src/commands/backlog/reorderPhaseRows.ts
 async function reorderPhaseRows(orm, itemId2, fromIdx, toIdx) {
   await orm.transaction(async (tx) => {
-    const [phaseRow] = await tx.select({ name: planPhases.name, manualChecks: planPhases.manualChecks }).from(planPhases).where(and15(eq37(planPhases.itemId, itemId2), eq37(planPhases.idx, fromIdx)));
-    const tasks = await tx.select({ idx: planTasks.idx, task: planTasks.task }).from(planTasks).where(and15(eq37(planTasks.itemId, itemId2), eq37(planTasks.phaseIdx, fromIdx))).orderBy(asc11(planTasks.idx));
+    const [phaseRow] = await tx.select({ name: planPhases.name, manualChecks: planPhases.manualChecks }).from(planPhases).where(and16(eq38(planPhases.itemId, itemId2), eq38(planPhases.idx, fromIdx)));
+    const tasks = await tx.select({ idx: planTasks.idx, task: planTasks.task }).from(planTasks).where(and16(eq38(planTasks.itemId, itemId2), eq38(planTasks.phaseIdx, fromIdx))).orderBy(asc11(planTasks.idx));
     await tx.delete(planTasks).where(
-      and15(eq37(planTasks.itemId, itemId2), eq37(planTasks.phaseIdx, fromIdx))
+      and16(eq38(planTasks.itemId, itemId2), eq38(planTasks.phaseIdx, fromIdx))
     );
-    await tx.delete(planPhases).where(and15(eq37(planPhases.itemId, itemId2), eq37(planPhases.idx, fromIdx)));
+    await tx.delete(planPhases).where(and16(eq38(planPhases.itemId, itemId2), eq38(planPhases.idx, fromIdx)));
     await reindexPhases(tx, itemId2);
     await shiftPhasesUp(tx, itemId2, toIdx);
     await tx.insert(planPhases).values({
@@ -15721,7 +15779,7 @@ async function movePhase(id, from, to) {
   if (!found) return;
   const { orm, item } = found;
   const itemId2 = item.id;
-  const [row] = await orm.select({ cnt: count6() }).from(planPhases).where(eq38(planPhases.itemId, itemId2));
+  const [row] = await orm.select({ cnt: count6() }).from(planPhases).where(eq39(planPhases.itemId, itemId2));
   const phaseCount = row?.cnt ?? 0;
   const fromIdx = toIndex2(from, phaseCount);
   if (fromIdx === void 0) return;
@@ -15737,22 +15795,22 @@ async function movePhase(id, from, to) {
 import chalk109 from "chalk";
 
 // src/commands/backlog/applyPhaseUpdate.ts
-import { and as and16, eq as eq39 } from "drizzle-orm";
+import { and as and17, eq as eq40 } from "drizzle-orm";
 async function applyPhaseUpdate(orm, itemId2, phaseIdx, fields) {
   await orm.transaction(async (tx) => {
     if (fields.name) {
       await tx.update(planPhases).set({ name: fields.name }).where(
-        and16(eq39(planPhases.itemId, itemId2), eq39(planPhases.idx, phaseIdx))
+        and17(eq40(planPhases.itemId, itemId2), eq40(planPhases.idx, phaseIdx))
       );
     }
     if (fields.manualCheck) {
       await tx.update(planPhases).set({ manualChecks: JSON.stringify(fields.manualCheck) }).where(
-        and16(eq39(planPhases.itemId, itemId2), eq39(planPhases.idx, phaseIdx))
+        and17(eq40(planPhases.itemId, itemId2), eq40(planPhases.idx, phaseIdx))
       );
     }
     if (fields.task) {
       await tx.delete(planTasks).where(
-        and16(eq39(planTasks.itemId, itemId2), eq39(planTasks.phaseIdx, phaseIdx))
+        and17(eq40(planTasks.itemId, itemId2), eq40(planTasks.phaseIdx, phaseIdx))
       );
       if (fields.task.length) {
         await tx.insert(planTasks).values(
@@ -15770,14 +15828,14 @@ async function applyPhaseUpdate(orm, itemId2, phaseIdx, fields) {
 
 // src/commands/backlog/findPhase.ts
 import chalk108 from "chalk";
-import { and as and17, count as count7, eq as eq40 } from "drizzle-orm";
+import { and as and18, count as count7, eq as eq41 } from "drizzle-orm";
 async function findPhase(id, phase) {
   const found = await findOneItem(id);
   if (!found) return void 0;
   const { orm, item } = found;
   const itemId2 = item.id;
   const phaseIdx = Number.parseInt(phase, 10) - 1;
-  const [row] = await orm.select({ cnt: count7() }).from(planPhases).where(and17(eq40(planPhases.itemId, itemId2), eq40(planPhases.idx, phaseIdx)));
+  const [row] = await orm.select({ cnt: count7() }).from(planPhases).where(and18(eq41(planPhases.itemId, itemId2), eq41(planPhases.idx, phaseIdx)));
   if (!row || row.cnt === 0) {
     console.log(
       chalk108.red(
@@ -15950,16 +16008,16 @@ function registerUpdatePhaseCommand(cmd) {
 
 // src/commands/backlog/removePhase.ts
 import chalk110 from "chalk";
-import { and as and18, eq as eq41 } from "drizzle-orm";
+import { and as and19, eq as eq42 } from "drizzle-orm";
 async function removePhase(id, phase) {
   const found = await findPhase(id, phase);
   if (!found) return;
   const { item, orm, itemId: itemId2, phaseIdx } = found;
   await orm.transaction(async (tx) => {
     await tx.delete(planTasks).where(
-      and18(eq41(planTasks.itemId, itemId2), eq41(planTasks.phaseIdx, phaseIdx))
+      and19(eq42(planTasks.itemId, itemId2), eq42(planTasks.phaseIdx, phaseIdx))
     );
-    await tx.delete(planPhases).where(and18(eq41(planPhases.itemId, itemId2), eq41(planPhases.idx, phaseIdx)));
+    await tx.delete(planPhases).where(and19(eq42(planPhases.itemId, itemId2), eq42(planPhases.idx, phaseIdx)));
     await reindexPhases(tx, itemId2);
     await adjustCurrentPhase(tx, item, phaseIdx);
   });
@@ -15972,7 +16030,7 @@ async function removePhase(id, phase) {
 
 // src/commands/backlog/update/update.ts
 import chalk114 from "chalk";
-import { eq as eq42 } from "drizzle-orm";
+import { eq as eq43 } from "drizzle-orm";
 
 // src/commands/backlog/update/buildUpdateValues.ts
 import chalk111 from "chalk";
@@ -16083,7 +16141,7 @@ async function update(id, options2) {
   if (!built) return;
   const { orm } = found;
   const itemId2 = found.item.id;
-  await orm.update(items).set(built.set).where(eq42(items.id, itemId2));
+  await orm.update(items).set(built.set).where(eq43(items.id, itemId2));
   console.log(
     chalk114.green(`Updated ${built.fields} on item ${formatItemId(itemId2)}.`)
   );
@@ -16104,7 +16162,7 @@ function readPlanUpdate(source) {
 }
 
 // src/commands/backlog/updatePlan/replacePlan.ts
-import { eq as eq43 } from "drizzle-orm";
+import { eq as eq44 } from "drizzle-orm";
 
 // src/commands/backlog/updatePlan/clampCurrentPhase.ts
 function clampCurrentPhase(currentPhase, phaseCount) {
@@ -16115,8 +16173,8 @@ function clampCurrentPhase(currentPhase, phaseCount) {
 // src/commands/backlog/updatePlan/replacePlan.ts
 async function replacePlan(orm, itemId2, phases, currentPhase) {
   await orm.transaction(async (tx) => {
-    await tx.delete(planTasks).where(eq43(planTasks.itemId, itemId2));
-    await tx.delete(planPhases).where(eq43(planPhases.itemId, itemId2));
+    await tx.delete(planTasks).where(eq44(planTasks.itemId, itemId2));
+    await tx.delete(planPhases).where(eq44(planPhases.itemId, itemId2));
     if (phases.length > 0) {
       await tx.insert(planPhases).values(
         phases.map((phase, idx) => ({
@@ -16134,7 +16192,7 @@ async function replacePlan(orm, itemId2, phases, currentPhase) {
     if (currentPhase === void 0) return;
     const clamped = clampCurrentPhase(currentPhase, phases.length);
     if (clamped === currentPhase) return;
-    await tx.update(items).set({ currentPhase: clamped }).where(eq43(items.id, itemId2));
+    await tx.update(items).set({ currentPhase: clamped }).where(eq44(items.id, itemId2));
   });
 }
 
@@ -22899,9 +22957,9 @@ function registerGithub(program2) {
 }
 
 // src/commands/handover/countPendingHandovers.ts
-import { and as and19, eq as eq44, isNull, sql as sql22 } from "drizzle-orm";
+import { and as and20, eq as eq45, isNull, sql as sql22 } from "drizzle-orm";
 async function countPendingHandovers(orm, origin) {
-  const [row] = await orm.select({ count: sql22`count(*)::int` }).from(handovers).where(and19(eq44(handovers.origin, origin), isNull(handovers.recalledAt)));
+  const [row] = await orm.select({ count: sql22`count(*)::int` }).from(handovers).where(and20(eq45(handovers.origin, origin), isNull(handovers.recalledAt)));
   return row?.count ?? 0;
 }
 
@@ -23041,13 +23099,13 @@ async function load2(options2 = {}) {
 }
 
 // src/commands/handover/listPendingHandovers.ts
-import { and as and20, desc as desc6, eq as eq45, isNull as isNull2 } from "drizzle-orm";
+import { and as and21, desc as desc6, eq as eq46, 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(and20(eq45(handovers.origin, origin), isNull2(handovers.recalledAt))).orderBy(desc6(handovers.createdAt), desc6(handovers.id));
+  }).from(handovers).where(and21(eq46(handovers.origin, origin), isNull2(handovers.recalledAt))).orderBy(desc6(handovers.createdAt), desc6(handovers.id));
 }
 
 // src/commands/handover/printPendingHandovers.ts
@@ -23060,17 +23118,17 @@ async function printPendingHandovers() {
 }
 
 // src/commands/handover/recallHandover.ts
-import { and as and21, desc as desc7, eq as eq46, isNull as isNull3 } from "drizzle-orm";
+import { and as and22, desc as desc7, eq as eq47, isNull as isNull3 } from "drizzle-orm";
 async function recallHandover(orm, origin, id) {
   const [row] = await orm.select().from(handovers).where(
-    and21(
-      eq46(handovers.origin, origin),
+    and22(
+      eq47(handovers.origin, origin),
       isNull3(handovers.recalledAt),
-      ...id === void 0 ? [] : [eq46(handovers.id, id)]
+      ...id === void 0 ? [] : [eq47(handovers.id, id)]
     )
   ).orderBy(desc7(handovers.createdAt), desc7(handovers.id)).limit(1);
   if (!row) return void 0;
-  await orm.update(handovers).set({ recalledAt: /* @__PURE__ */ new Date() }).where(eq46(handovers.id, row.id));
+  await orm.update(handovers).set({ recalledAt: /* @__PURE__ */ new Date() }).where(eq47(handovers.id, row.id));
   return row.content;
 }
 
@@ -36569,10 +36627,10 @@ function applyReviewPause(session, activity2) {
 }
 
 // src/shared/db/getPhaseActiveMs.ts
-import { and as and22, eq as eq47 } from "drizzle-orm";
+import { and as and23, eq as eq48 } from "drizzle-orm";
 async function getPhaseActiveMs(db, itemId2, phaseIdx) {
   const [row] = await db.select({ activeMs: phaseUsage.activeMs }).from(phaseUsage).where(
-    and22(eq47(phaseUsage.itemId, itemId2), eq47(phaseUsage.phaseIdx, phaseIdx))
+    and23(eq48(phaseUsage.itemId, itemId2), eq48(phaseUsage.phaseIdx, phaseIdx))
   );
   return row?.activeMs ?? 0;
 }
@@ -37398,17 +37456,17 @@ async function recordPhaseTranscriptUsage(db, itemId2, phaseIdx, responses) {
 }
 
 // src/shared/db/recordWindowTokens.ts
-import { and as and23, eq as eq48, sql as sql28 } from "drizzle-orm";
+import { and as and24, eq as eq49, sql as sql28 } from "drizzle-orm";
 async function recordWindowTokens(db, window, resetsAt, tokensUp, tokensDown) {
   if (tokensUp <= 0 && tokensDown <= 0) return;
   await db.update(usagePeaks).set({
     tokensUp: sql28`${usagePeaks.tokensUp} + ${tokensUp}`,
     tokensDown: sql28`${usagePeaks.tokensDown} + ${tokensDown}`
   }).where(
-    and23(
-      eq48(usagePeaks.window, window),
-      eq48(usagePeaks.resetsAt, resetsAt),
-      eq48(usagePeaks.segment, 0)
+    and24(
+      eq49(usagePeaks.window, window),
+      eq49(usagePeaks.resetsAt, resetsAt),
+      eq49(usagePeaks.segment, 0)
     )
   );
 }

package/package.json

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