@staff0rd/assist 0.317.0 → 0.317.1

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.317.0",
+  version: "0.317.1",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -1132,8 +1132,8 @@ var options = [
 ];
 
 // src/commands/verify/init/getAvailableOptions/index.ts
-function resolveDescription(desc7, setup2) {
-  return typeof desc7 === "function" ? desc7(setup2) : desc7;
+function resolveDescription(desc6, setup2) {
+  return typeof desc6 === "function" ? desc6(setup2) : desc6;
 }
 function toVerifyOption(def, setup2) {
   return {
@@ -2975,6 +2975,107 @@ async function seedNewsFeeds(db) {
   }
 }
 
+// src/shared/db/cleanupFalseResetSegments.ts
+import { and as and2, eq as eq2 } from "drizzle-orm";
+
+// src/shared/db/recordWindowPeak.ts
+import { and, eq, gt, sql } from "drizzle-orm";
+var RESET_DROP_THRESHOLD = 1;
+var at = ({ window, resetsAt }, segment) => segment === void 0 ? and(eq(usagePeaks.window, window), eq(usagePeaks.resetsAt, resetsAt)) : and(
+  eq(usagePeaks.window, window),
+  eq(usagePeaks.resetsAt, resetsAt),
+  eq(usagePeaks.segment, segment)
+);
+var lock = ({ tx, window, resetsAt }) => tx.execute(
+  sql`SELECT pg_advisory_xact_lock(hashtextextended(${`${window}:${resetsAt}`}, 0))`
+);
+var load = (c) => c.tx.select().from(usagePeaks).where(at(c)).orderBy(usagePeaks.segment);
+var insertSegment = (c, segment, usedPercentage) => c.tx.insert(usagePeaks).values({
+  window: c.window,
+  resetsAt: c.resetsAt,
+  segment,
+  usedPercentage
+});
+async function collapseToReached(c, reached, usedPercentage) {
+  await c.tx.delete(usagePeaks).where(and(at(c), gt(usagePeaks.segment, reached.segment)));
+  await c.tx.update(usagePeaks).set({ usedPercentage, resetDetected: false }).where(at(c, reached.segment));
+}
+async function openReset(c, active, usedPercentage) {
+  await c.tx.update(usagePeaks).set({ resetDetected: true }).where(at(c, active.segment));
+  await insertSegment(c, active.segment + 1, usedPercentage);
+}
+async function reconcile(c, segments, usedPercentage) {
+  const reached = segments.find((s) => usedPercentage >= s.usedPercentage);
+  if (reached) {
+    await collapseToReached(c, reached, usedPercentage);
+    return;
+  }
+  const active = segments[segments.length - 1];
+  if (usedPercentage < active.usedPercentage - RESET_DROP_THRESHOLD) {
+    await openReset(c, active, usedPercentage);
+  }
+}
+async function recordWindowPeak(db, window, resetsAt, usedPercentage) {
+  await db.transaction(async (tx) => {
+    const c = { tx, window, resetsAt };
+    await lock(c);
+    const segments = await load(c);
+    if (segments.length === 0) await insertSegment(c, 0, usedPercentage);
+    else await reconcile(c, segments, usedPercentage);
+  });
+}
+
+// src/shared/db/cleanupFalseResetSegments.ts
+var MIGRATION_KEY = "usage_peaks_false_reset_cleanup";
+var climbsBack = (top, peak) => top !== void 0 && peak > top - RESET_DROP_THRESHOLD;
+function mergeDown(stack, peak) {
+  while (climbsBack(stack.at(-1), peak))
+    peak = Math.max(peak, stack.pop() ?? peak);
+  return peak;
+}
+function collapseSegments(peaks) {
+  const stack = [];
+  for (const peak of peaks) stack.push(mergeDown(stack, peak));
+  return stack.map((usedPercentage, i) => ({
+    segment: i,
+    usedPercentage,
+    resetDetected: i < stack.length - 1
+  }));
+}
+var sig = (s) => `${s.segment}:${s.usedPercentage}:${s.resetDetected}`;
+var isUnchanged = (rows, collapsed) => rows.length === collapsed.length && rows.every((r, i) => sig(r) === sig(collapsed[i]));
+var groupByCycle = (rows) => rows.reduce((cycles, r) => {
+  const key = `${r.window} ${r.resetsAt}`;
+  return cycles.set(key, [...cycles.get(key) ?? [], r]);
+}, /* @__PURE__ */ new Map());
+var earliest = (rows) => rows.reduce((a, r) => r.createdAt < a ? r.createdAt : a, rows[0].createdAt);
+async function overwrite(tx, { window, resetsAt }, createdAt, collapsed) {
+  await tx.delete(usagePeaks).where(
+    and2(eq2(usagePeaks.window, window), eq2(usagePeaks.resetsAt, resetsAt))
+  );
+  await tx.insert(usagePeaks).values(collapsed.map((c) => ({ window, resetsAt, createdAt, ...c })));
+}
+async function rewriteCycle(tx, rows) {
+  const collapsed = collapseSegments(rows.map((r) => r.usedPercentage));
+  if (isUnchanged(rows, collapsed)) return;
+  await overwrite(tx, rows[0], earliest(rows), collapsed);
+}
+var loadAll = (tx) => tx.select().from(usagePeaks).orderBy(usagePeaks.window, usagePeaks.resetsAt, usagePeaks.segment);
+var markRun = (tx) => tx.insert(metadata).values({ key: MIGRATION_KEY, value: "done" }).onConflictDoNothing();
+async function alreadyRun(tx) {
+  const done2 = await tx.select().from(metadata).where(eq2(metadata.key, MIGRATION_KEY));
+  return done2.length > 0;
+}
+async function cleanupFalseResetSegments(db) {
+  await db.transaction(async (tx) => {
+    if (await alreadyRun(tx)) return;
+    for (const rows of groupByCycle(await loadAll(tx)).values()) {
+      await rewriteCycle(tx, rows);
+    }
+    await markRun(tx);
+  });
+}
+
 // src/shared/db/Db.ts
 import {
   drizzle as drizzleNodePg
@@ -3126,6 +3227,39 @@ function getDatabaseUrl() {
   }
   return url;
 }
+async function runUsagePeakCleanup(orm) {
+  try {
+    await cleanupFalseResetSegments(orm);
+  } catch (error) {
+    console.error(
+      `${(/* @__PURE__ */ new Date()).toISOString()} usage-peaks cleanup failed: ${String(error)}`
+    );
+  }
+}
+function logPoolError(error) {
+  console.error(
+    `${(/* @__PURE__ */ new Date()).toISOString()} backlog pool error: ${error.message}`
+  );
+}
+function createPool() {
+  const pool = new Pool({
+    connectionString: getDatabaseUrl(),
+    max: 10,
+    // why: retire idle clients before managed Postgres (Supabase/Neon) drops them server-side, so we never check out a dead socket and stall on a timeout.
+    idleTimeoutMillis: 3e4,
+    // why: bound the wait for a free client so a degraded pool fails fast (500 + log line) rather than hanging for seconds.
+    connectionTimeoutMillis: 1e4
+  });
+  pool.on("error", logPoolError);
+  return pool;
+}
+async function initSchema(pool) {
+  await ensureSchema((sql6) => pool.query(sql6));
+  const orm = makeOrmFromPool(pool);
+  await seedNewsFeeds(orm);
+  await runUsagePeakCleanup(orm);
+  return orm;
+}
 var _connecting;
 var _pool;
 var _orm;
@@ -3133,23 +3267,8 @@ function getDb() {
   if (_orm) return Promise.resolve(_orm);
   if (_connecting) return _connecting;
   _connecting = (async () => {
-    const pool = new Pool({
-      connectionString: getDatabaseUrl(),
-      max: 10,
-      // why: retire idle clients before managed Postgres (Supabase/Neon) drops them server-side, so we never check out a dead socket and stall on a timeout.
-      idleTimeoutMillis: 3e4,
-      // why: bound the wait for a free client so a degraded pool fails fast (500 + log line) rather than hanging for seconds.
-      connectionTimeoutMillis: 1e4
-    });
-    pool.on("error", (err) => {
-      console.error(
-        `${(/* @__PURE__ */ new Date()).toISOString()} backlog pool error: ${err.message}`
-      );
-    });
-    _pool = pool;
-    await ensureSchema((sql6) => pool.query(sql6));
-    _orm = makeOrmFromPool(pool);
-    await seedNewsFeeds(_orm);
+    _pool = createPool();
+    _orm = await initSchema(_pool);
     return _orm;
   })();
   return _connecting;
@@ -3603,9 +3722,9 @@ function isLockedByOther(itemId) {
   const lockPath = getLockPath(itemId);
   if (!existsSync15(lockPath)) return false;
   try {
-    const lock = JSON.parse(readFileSync11(lockPath, "utf8"));
-    if (lock.pid === process.pid) return false;
-    return isProcessAlive(lock.pid);
+    const lock2 = JSON.parse(readFileSync11(lockPath, "utf8"));
+    if (lock2.pid === process.pid) return false;
+    return isProcessAlive(lock2.pid);
   } catch {
     return false;
   }
@@ -3935,7 +4054,7 @@ async function importItemsRemapped(orm, items2, origin) {
 }
 
 // src/commands/backlog/loadAllItems.ts
-import { asc as asc3, eq } from "drizzle-orm";
+import { asc as asc3, eq as eq3 } from "drizzle-orm";
 
 // src/commands/backlog/loadRelations.ts
 import { asc as asc2, inArray } from "drizzle-orm";
@@ -4045,7 +4164,7 @@ function rowToItem(row, rel) {
 
 // src/commands/backlog/loadAllItems.ts
 async function loadAllItems(orm, origin) {
-  const rows = await orm.select().from(items).where(origin === void 0 ? void 0 : eq(items.origin, origin)).orderBy(asc3(items.id));
+  const rows = await orm.select().from(items).where(origin === void 0 ? void 0 : eq3(items.origin, origin)).orderBy(asc3(items.id));
   if (rows.length === 0) return [];
   const rel = await loadRelations(
     orm,
@@ -4156,9 +4275,9 @@ async function ensureMigrated(orm, dir, origin) {
 }
 
 // src/commands/backlog/deleteItem.ts
-import { eq as eq2 } from "drizzle-orm";
+import { eq as eq4 } from "drizzle-orm";
 async function deleteItem(orm, id2) {
-  const [row] = await orm.delete(items).where(eq2(items.id, id2)).returning({ name: items.name });
+  const [row] = await orm.delete(items).where(eq4(items.id, id2)).returning({ name: items.name });
   return row?.name;
 }
 
@@ -4234,27 +4353,27 @@ function getCurrentOrigin(cwd) {
 }
 
 // src/commands/backlog/loadItem.ts
-import { eq as eq3 } from "drizzle-orm";
+import { eq as eq5 } from "drizzle-orm";
 async function loadItem(orm, id2) {
-  const [row] = await orm.select().from(items).where(eq3(items.id, id2));
+  const [row] = await orm.select().from(items).where(eq5(items.id, id2));
   if (!row) return void 0;
   const rel = await loadRelations(orm, [id2]);
   return rowToItem(row, rel);
 }
 
 // src/commands/backlog/saveAllItems.ts
-import { eq as eq5, sql } from "drizzle-orm";
+import { eq as eq7, sql as sql2 } from "drizzle-orm";
 
 // src/commands/backlog/deleteItemRelations.ts
-import { eq as eq4 } from "drizzle-orm";
+import { eq as eq6 } from "drizzle-orm";
 
 // src/commands/backlog/searchItemIds.ts
-import { and, asc as asc4, eq as eq6, ilike, or } from "drizzle-orm";
+import { and as and3, asc as asc4, eq as eq8, 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, eq6(comments.itemId, items.id)).leftJoin(planPhases, eq6(planPhases.itemId, items.id)).where(
-    and(
-      origin ? eq6(items.origin, origin) : void 0,
+  const rows = await orm.selectDistinct({ id: items.id }).from(items).leftJoin(comments, eq8(comments.itemId, items.id)).leftJoin(planPhases, eq8(planPhases.itemId, items.id)).where(
+    and3(
+      origin ? eq8(items.origin, origin) : void 0,
       or(
         ilike(items.name, pattern2),
         ilike(items.description, pattern2),
@@ -4268,15 +4387,15 @@ async function searchItemIds(orm, query, origin) {
 }
 
 // src/commands/backlog/updateCurrentPhase.ts
-import { eq as eq7 } from "drizzle-orm";
+import { eq as eq9 } from "drizzle-orm";
 async function updateCurrentPhase(orm, id2, phase) {
-  await orm.update(items).set({ currentPhase: phase }).where(eq7(items.id, id2));
+  await orm.update(items).set({ currentPhase: phase }).where(eq9(items.id, id2));
 }
 
 // src/commands/backlog/updateStatus.ts
-import { eq as eq8 } from "drizzle-orm";
+import { eq as eq10 } from "drizzle-orm";
 async function updateStatus(orm, id2, status2) {
-  const [row] = await orm.update(items).set({ status: status2 }).where(eq8(items.id, id2)).returning({ name: items.name });
+  const [row] = await orm.update(items).set({ status: status2 }).where(eq10(items.id, id2)).returning({ name: items.name });
   return row?.name;
 }
 
@@ -4902,11 +5021,11 @@ async function next(options2, startId) {
 import chalk43 from "chalk";
 
 // src/commands/backlog/appendComment.ts
-import { sql as sql2 } from "drizzle-orm";
+import { sql as sql3 } from "drizzle-orm";
 async function appendComment(orm, itemId, text6, opts = {}) {
   await orm.insert(comments).values({
     itemId,
-    idx: sql2`(SELECT COALESCE(MAX(${comments.idx}) + 1, 0) FROM ${comments} WHERE ${comments.itemId} = ${itemId})`,
+    idx: sql3`(SELECT COALESCE(MAX(${comments.idx}) + 1, 0) FROM ${comments} WHERE ${comments.itemId} = ${itemId})`,
     text: text6,
     phase: opts.phase ?? null,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -4915,9 +5034,9 @@ async function appendComment(orm, itemId, text6, opts = {}) {
 }
 
 // src/commands/backlog/getItemStatus.ts
-import { eq as eq9 } from "drizzle-orm";
+import { eq as eq11 } from "drizzle-orm";
 async function getItemStatus(orm, id2) {
-  const [row] = await orm.select({ status: items.status }).from(items).where(eq9(items.id, id2));
+  const [row] = await orm.select({ status: items.status }).from(items).where(eq11(items.id, id2));
   return row?.status;
 }
 
@@ -5401,10 +5520,10 @@ function createFallbackHandler(routes3, htmlHandler2, extra) {
 }
 
 // src/commands/backlog/loadBacklogSummaries.ts
-import { eq as eq11 } from "drizzle-orm";
+import { eq as eq13 } from "drizzle-orm";
 
 // src/commands/backlog/loadItemSummaries.ts
-import { asc as asc5, eq as eq10 } from "drizzle-orm";
+import { asc as asc5, eq as eq12 } from "drizzle-orm";
 async function loadItemSummaries(orm, origin) {
   const rows = await orm.select({
     id: items.id,
@@ -5413,7 +5532,7 @@ async function loadItemSummaries(orm, origin) {
     name: items.name,
     status: items.status,
     starred: items.starred
-  }).from(items).where(origin === void 0 ? void 0 : eq10(items.origin, origin)).orderBy(asc5(items.id));
+  }).from(items).where(origin === void 0 ? void 0 : eq12(items.origin, origin)).orderBy(asc5(items.id));
   return rows.map((row) => ({
     id: row.id,
     origin: row.origin,
@@ -5438,7 +5557,7 @@ async function searchBacklogSummaries(query) {
 }
 async function backlogHasItems() {
   const { orm } = await getReady();
-  const [row] = await orm.select({ id: items.id }).from(items).where(eq11(items.origin, getOrigin())).limit(1);
+  const [row] = await orm.select({ id: items.id }).from(items).where(eq13(items.origin, getOrigin())).limit(1);
   return row !== void 0;
 }
 
@@ -5455,19 +5574,19 @@ async function getBacklogExists(req, res) {
 }
 
 // src/commands/backlog/deleteComment.ts
-import { and as and2, eq as eq12 } from "drizzle-orm";
+import { and as and4, eq as eq14 } from "drizzle-orm";
 async function deleteComment(orm, itemId, commentId) {
-  const [row] = await orm.select({ type: comments.type }).from(comments).where(and2(eq12(comments.id, commentId), eq12(comments.itemId, itemId)));
+  const [row] = await orm.select({ type: comments.type }).from(comments).where(and4(eq14(comments.id, commentId), eq14(comments.itemId, itemId)));
   if (!row) return "not-found";
   if (row.type === "summary") return "is-summary";
-  await orm.delete(comments).where(and2(eq12(comments.id, commentId), eq12(comments.itemId, itemId)));
+  await orm.delete(comments).where(and4(eq14(comments.id, commentId), eq14(comments.itemId, itemId)));
   return "deleted";
 }
 
 // src/commands/backlog/updateStarred.ts
-import { eq as eq13 } from "drizzle-orm";
+import { eq as eq15 } from "drizzle-orm";
 async function updateStarred(orm, id2, starred) {
-  const [row] = await orm.update(items).set({ starred }).where(eq13(items.id, id2)).returning({ name: items.name });
+  const [row] = await orm.update(items).set({ starred }).where(eq15(items.id, id2)).returning({ name: items.name });
   return row?.name;
 }
 
@@ -5565,7 +5684,7 @@ async function deleteItemComment(res, itemId, commentId) {
 }
 
 // src/commands/backlog/web/rewindItemPhase.ts
-import { eq as eq14 } from "drizzle-orm";
+import { eq as eq16 } from "drizzle-orm";
 
 // src/commands/backlog/resolveRewindPlan.ts
 function resolveRewindPlan(item) {
@@ -5591,7 +5710,7 @@ async function rewindItemPhase(req, res, id2) {
     `Rewound to phase ${phase} (${phaseName}): ${reason}`,
     { phase }
   );
-  await orm.update(items).set({ currentPhase: phase, status: "in-progress" }).where(eq14(items.id, id2));
+  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) {
@@ -6933,22 +7052,22 @@ async function add(options2) {
 import chalk61 from "chalk";
 
 // src/commands/backlog/insertPhaseAt.ts
-import { count, eq as eq16 } from "drizzle-orm";
+import { count, eq as eq18 } from "drizzle-orm";
 
 // src/commands/backlog/shiftPhasesUp.ts
-import { and as and3, desc as desc3, eq as eq15, gte } from "drizzle-orm";
+import { and as and5, 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(and3(eq15(planPhases.itemId, itemId), gte(planPhases.idx, fromIdx))).orderBy(desc3(planPhases.idx));
+  const toShift = await db.select({ idx: planPhases.idx }).from(planPhases).where(and5(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(and3(eq15(planTasks.itemId, itemId), eq15(planTasks.phaseIdx, p.idx)));
-    await db.update(planPhases).set({ idx: p.idx + 1 }).where(and3(eq15(planPhases.itemId, itemId), eq15(planPhases.idx, p.idx)));
+    await db.update(planTasks).set({ phaseIdx: p.idx + 1 }).where(and5(eq17(planTasks.itemId, itemId), eq17(planTasks.phaseIdx, p.idx)));
+    await db.update(planPhases).set({ idx: p.idx + 1 }).where(and5(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: count() }).from(planPhases).where(eq16(planPhases.itemId, itemId));
+    const [row] = await tx.select({ cnt: count() }).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 });
@@ -6957,16 +7076,16 @@ 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(eq16(items.id, itemId));
+      await tx.update(items).set({ currentPhase: atReviewSlot ? phaseIdx + 1 : currentPhase + 1 }).where(eq18(items.id, itemId));
     }
   });
 }
 
 // src/commands/backlog/resolveInsertPosition.ts
 import chalk60 from "chalk";
-import { count as count2, eq as eq17 } from "drizzle-orm";
+import { count as count2, eq as eq19 } from "drizzle-orm";
 async function resolveInsertPosition(orm, itemId, position) {
-  const [row] = await orm.select({ cnt: count2() }).from(planPhases).where(eq17(planPhases.itemId, itemId));
+  const [row] = await orm.select({ cnt: count2() }).from(planPhases).where(eq19(planPhases.itemId, itemId));
   const phaseCount = row?.cnt ?? 0;
   if (position === void 0) return phaseCount;
   const pos = Number.parseInt(position, 10);
@@ -7127,9 +7246,9 @@ function hasCycle(adjacency, fromId, toId) {
 }
 
 // src/commands/backlog/loadDependencyGraph.ts
-import { eq as eq18 } 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(eq18(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);
@@ -7192,7 +7311,7 @@ async function link(fromId, toId, opts) {
 
 // src/commands/backlog/unlink.ts
 import chalk65 from "chalk";
-import { and as and4, eq as eq19 } from "drizzle-orm";
+import { and as and6, eq as eq21 } from "drizzle-orm";
 async function unlink(fromId, toId) {
   const fromNum = Number.parseInt(fromId, 10);
   const toNum = Number.parseInt(toId, 10);
@@ -7210,7 +7329,7 @@ async function unlink(fromId, toId) {
     console.log(chalk65.yellow(`No link from #${fromId} to #${toId} found.`));
     return;
   }
-  await orm.delete(links).where(and4(eq19(links.itemId, fromNum), eq19(links.targetId, toNum)));
+  await orm.delete(links).where(and6(eq21(links.itemId, fromNum), eq21(links.targetId, toNum)));
   console.log(chalk65.green(`Removed link from #${fromId} to #${toId}.`));
 }
 
@@ -7226,7 +7345,7 @@ function registerLinkCommands(cmd) {
 
 // src/commands/backlog/move-repo/index.ts
 import chalk67 from "chalk";
-import { eq as eq21 } from "drizzle-orm";
+import { eq as eq23 } from "drizzle-orm";
 
 // src/commands/backlog/move-repo/confirmMove.ts
 import chalk66 from "chalk";
@@ -7241,9 +7360,9 @@ async function confirmMove(cnt, oldOrigin, newOrigin) {
 }
 
 // src/commands/backlog/move-repo/countByOrigin.ts
-import { count as count3, eq as eq20 } from "drizzle-orm";
+import { count as count3, eq as eq22 } from "drizzle-orm";
 async function countByOrigin(orm, origin) {
-  const [{ cnt }] = await orm.select({ cnt: count3() }).from(items).where(eq20(items.origin, origin));
+  const [{ cnt }] = await orm.select({ cnt: count3() }).from(items).where(eq22(items.origin, origin));
   return cnt;
 }
 
@@ -7286,7 +7405,7 @@ async function moveRepo(oldOriginRaw, newOriginRaw, options2 = {}) {
     console.log(chalk67.yellow("Move cancelled; no changes made."));
     return;
   }
-  await orm.update(items).set({ origin: newOrigin }).where(eq21(items.origin, oldOrigin));
+  await orm.update(items).set({ origin: newOrigin }).where(eq23(items.origin, oldOrigin));
   console.log(
     chalk67.green(
       `Moved ${pluralItems(cnt)} from "${oldOrigin}" to "${newOrigin}".`
@@ -7625,10 +7744,10 @@ async function start(id2) {
 
 // src/commands/backlog/stop/index.ts
 import chalk78 from "chalk";
-import { and as and5, eq as eq22 } from "drizzle-orm";
+import { and as and7, 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(and5(eq22(items.status, "in-progress"), eq22(items.origin, getOrigin()))).returning({ id: items.id, name: items.name });
+  const stopped = await orm.update(items).set({ status: "todo", currentPhase: 1 }).where(and7(eq24(items.status, "in-progress"), eq24(items.origin, getOrigin()))).returning({ id: items.id, name: items.name });
   if (stopped.length === 0) {
     console.log(chalk78.yellow("No in-progress items to stop."));
     return;
@@ -7674,18 +7793,18 @@ function registerStatusCommands(cmd) {
 
 // src/commands/backlog/removePhase.ts
 import chalk82 from "chalk";
-import { and as and8, eq as eq25 } from "drizzle-orm";
+import { and as and10, eq as eq27 } from "drizzle-orm";
 
 // src/commands/backlog/findPhase.ts
 import chalk81 from "chalk";
-import { and as and6, count as count4, eq as eq23 } from "drizzle-orm";
+import { and as and8, count as count4, eq as eq25 } 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: count4() }).from(planPhases).where(and6(eq23(planPhases.itemId, itemId), eq23(planPhases.idx, phaseIdx)));
+  const [row] = await orm.select({ cnt: count4() }).from(planPhases).where(and8(eq25(planPhases.itemId, itemId), eq25(planPhases.idx, phaseIdx)));
   if (!row || row.cnt === 0) {
     console.log(
       chalk81.red(`Phase ${phaseIdx + 1} not found on item #${itemId}.`)
@@ -7697,14 +7816,14 @@ async function findPhase(id2, phase) {
 }
 
 // src/commands/backlog/reindexPhases.ts
-import { and as and7, asc as asc6, count as count5, eq as eq24 } from "drizzle-orm";
+import { and as and9, asc as asc6, count as count5, eq as eq26 } from "drizzle-orm";
 async function reindexPhases(db, itemId) {
-  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq24(planPhases.itemId, itemId)).orderBy(asc6(planPhases.idx));
+  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq26(planPhases.itemId, itemId)).orderBy(asc6(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(and7(eq24(planTasks.itemId, itemId), eq24(planTasks.phaseIdx, oldIdx)));
-    await db.update(planPhases).set({ idx: i }).where(and7(eq24(planPhases.itemId, itemId), eq24(planPhases.idx, oldIdx)));
+    await db.update(planTasks).set({ phaseIdx: i }).where(and9(eq26(planTasks.itemId, itemId), eq26(planTasks.phaseIdx, oldIdx)));
+    await db.update(planPhases).set({ idx: i }).where(and9(eq26(planPhases.itemId, itemId), eq26(planPhases.idx, oldIdx)));
   }
 }
 async function adjustCurrentPhase(db, item, removedIdx) {
@@ -7712,13 +7831,13 @@ 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(eq24(items.id, item.id));
+    await db.update(items).set({ currentPhase: currentPhase - 1 }).where(eq26(items.id, item.id));
     return;
   }
   if (removedIdx !== currentIdx) return;
-  const [row] = await db.select({ cnt: count5() }).from(planPhases).where(eq24(planPhases.itemId, item.id));
+  const [row] = await db.select({ cnt: count5() }).from(planPhases).where(eq26(planPhases.itemId, item.id));
   const cnt = row?.cnt ?? 0;
-  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq24(items.id, item.id));
+  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq26(items.id, item.id));
 }
 
 // src/commands/backlog/removePhase.ts
@@ -7728,9 +7847,9 @@ async function removePhase(id2, phase) {
   const { item, orm, itemId, phaseIdx } = found;
   await orm.transaction(async (tx) => {
     await tx.delete(planTasks).where(
-      and8(eq25(planTasks.itemId, itemId), eq25(planTasks.phaseIdx, phaseIdx))
+      and10(eq27(planTasks.itemId, itemId), eq27(planTasks.phaseIdx, phaseIdx))
     );
-    await tx.delete(planPhases).where(and8(eq25(planPhases.itemId, itemId), eq25(planPhases.idx, phaseIdx)));
+    await tx.delete(planPhases).where(and10(eq27(planPhases.itemId, itemId), eq27(planPhases.idx, phaseIdx)));
     await reindexPhases(tx, itemId);
     await adjustCurrentPhase(tx, item, phaseIdx);
   });
@@ -7741,7 +7860,7 @@ async function removePhase(id2, phase) {
 
 // src/commands/backlog/update/index.ts
 import chalk84 from "chalk";
-import { eq as eq26 } from "drizzle-orm";
+import { eq as eq28 } from "drizzle-orm";
 
 // src/commands/backlog/update/parseListIndex.ts
 function parseListIndex(raw, length, label2) {
@@ -7818,8 +7937,8 @@ function applyAcMutations(current, options2) {
 // src/commands/backlog/update/buildUpdateValues.ts
 import chalk83 from "chalk";
 function buildUpdateValues(options2) {
-  const { name, desc: desc7, type, ac } = options2;
-  if (!name && !desc7 && !type && !ac) {
+  const { name, desc: desc6, type, ac } = options2;
+  if (!name && !desc6 && !type && !ac) {
     console.log(chalk83.red("Nothing to update. Provide at least one flag."));
     process.exitCode = 1;
     return void 0;
@@ -7835,8 +7954,8 @@ function buildUpdateValues(options2) {
     set.name = name;
     fieldNames.push("name");
   }
-  if (desc7) {
-    set.description = desc7;
+  if (desc6) {
+    set.description = desc6;
     fieldNames.push("description");
   }
   if (type) {
@@ -7875,7 +7994,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(eq26(items.id, itemId));
+  await orm.update(items).set(built.set).where(eq28(items.id, itemId));
   console.log(chalk84.green(`Updated ${built.fields} on item #${itemId}.`));
 }
 
@@ -7883,22 +8002,22 @@ async function update(id2, options2) {
 import chalk85 from "chalk";
 
 // src/commands/backlog/applyPhaseUpdate.ts
-import { and as and9, eq as eq27 } from "drizzle-orm";
+import { and as and11, eq as eq29 } 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(
-        and9(eq27(planPhases.itemId, itemId), eq27(planPhases.idx, phaseIdx))
+        and11(eq29(planPhases.itemId, itemId), eq29(planPhases.idx, phaseIdx))
       );
     }
     if (fields.manualCheck) {
       await tx.update(planPhases).set({ manualChecks: JSON.stringify(fields.manualCheck) }).where(
-        and9(eq27(planPhases.itemId, itemId), eq27(planPhases.idx, phaseIdx))
+        and11(eq29(planPhases.itemId, itemId), eq29(planPhases.idx, phaseIdx))
       );
     }
     if (fields.task) {
       await tx.delete(planTasks).where(
-        and9(eq27(planTasks.itemId, itemId), eq27(planTasks.phaseIdx, phaseIdx))
+        and11(eq29(planTasks.itemId, itemId), eq29(planTasks.phaseIdx, phaseIdx))
       );
       if (fields.task.length) {
         await tx.insert(planTasks).values(
@@ -8241,7 +8360,7 @@ var _db;
 function getDbDir() {
   return join22(homedir8(), ".assist");
 }
-function initSchema(db) {
+function initSchema2(db) {
   db.exec(`
 		CREATE TABLE IF NOT EXISTS denied_tool_calls (
 			id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -8260,7 +8379,7 @@ function openPromptsDb(dir) {
   mkdirSync9(dbDir, { recursive: true });
   const db = new Database(join22(dbDir, "assist.db"));
   db.pragma("journal_mode = WAL");
-  initSchema(db);
+  initSchema2(db);
   _db = db;
   return db;
 }
@@ -11207,9 +11326,9 @@ function registerGithub(program2) {
 }
 
 // src/commands/handover/countPendingHandovers.ts
-import { and as and10, eq as eq28, isNull, sql as sql3 } from "drizzle-orm";
+import { and as and12, eq as eq30, isNull, sql as sql4 } from "drizzle-orm";
 async function countPendingHandovers(orm, origin) {
-  const [row] = await orm.select({ count: sql3`count(*)::int` }).from(handovers).where(and10(eq28(handovers.origin, origin), isNull(handovers.recalledAt)));
+  const [row] = await orm.select({ count: sql4`count(*)::int` }).from(handovers).where(and12(eq30(handovers.origin, origin), isNull(handovers.recalledAt)));
   return row?.count ?? 0;
 }
 
@@ -11336,7 +11455,7 @@ function emit(message) {
   console.log(json);
   return json;
 }
-async function load(options2 = {}) {
+async function load2(options2 = {}) {
   const opts = resolveLoadOptions(options2);
   const input = await parseLoadInput(opts.stdin);
   const cwd = input.cwd ?? opts.cwdFallback;
@@ -11349,13 +11468,13 @@ async function load(options2 = {}) {
 }
 
 // src/commands/handover/listPendingHandovers.ts
-import { and as and11, desc as desc4, eq as eq29, isNull as isNull2 } from "drizzle-orm";
+import { and as and13, desc as desc4, eq as eq31, 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(and11(eq29(handovers.origin, origin), isNull2(handovers.recalledAt))).orderBy(desc4(handovers.createdAt), desc4(handovers.id));
+  }).from(handovers).where(and13(eq31(handovers.origin, origin), isNull2(handovers.recalledAt))).orderBy(desc4(handovers.createdAt), desc4(handovers.id));
 }
 
 // src/commands/handover/printPendingHandovers.ts
@@ -11368,17 +11487,17 @@ async function printPendingHandovers() {
 }
 
 // src/commands/handover/recallHandover.ts
-import { and as and12, desc as desc5, eq as eq30, isNull as isNull3 } from "drizzle-orm";
+import { and as and14, desc as desc5, eq as eq32, isNull as isNull3 } from "drizzle-orm";
 async function recallHandover(orm, origin, id2) {
   const [row] = await orm.select().from(handovers).where(
-    and12(
-      eq30(handovers.origin, origin),
+    and14(
+      eq32(handovers.origin, origin),
       isNull3(handovers.recalledAt),
-      ...id2 === void 0 ? [] : [eq30(handovers.id, id2)]
+      ...id2 === void 0 ? [] : [eq32(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(eq30(handovers.id, row.id));
+  await orm.update(handovers).set({ recalledAt: /* @__PURE__ */ new Date() }).where(eq32(handovers.id, row.id));
   return row.content;
 }
 
@@ -11423,7 +11542,7 @@ function registerHandover(program2) {
   cmd.command("load").description(
     "SessionStart hook: migrate any disk handovers, then advise how many unrecalled handovers exist for this repo"
   ).action(async () => {
-    await load();
+    await load2();
   });
 }
 
@@ -17750,9 +17869,9 @@ function resolveConnection3(name) {
 }
 
 // src/commands/sql/sqlConnect.ts
-import sql4 from "mssql";
+import sql5 from "mssql";
 async function sqlConnect(conn) {
-  return await sql4.connect({
+  return await sql5.connect({
     server: conn.server,
     port: conn.port,
     user: conn.user,
@@ -18684,10 +18803,10 @@ function checkLockFile() {
   const lockFile = getLockFile();
   if (!existsSync45(lockFile)) return;
   try {
-    const lock = JSON.parse(readFileSync37(lockFile, "utf8"));
-    if (lock.pid && isProcessAlive2(lock.pid)) {
+    const lock2 = JSON.parse(readFileSync37(lockFile, "utf8"));
+    if (lock2.pid && isProcessAlive2(lock2.pid)) {
       console.error(
-        `Voice daemon already running (PID ${lock.pid}, env: ${lock.env}). Stop it first with: assist voice stop`
+        `Voice daemon already running (PID ${lock2.pid}, env: ${lock2.env}). Stop it first with: assist voice stop`
       );
       process.exit(1);
     }
@@ -19902,37 +20021,6 @@ function broadcastSessions(sessions, clients, windowsSessions = [], active) {
   });
 }
 
-// src/shared/db/recordWindowPeak.ts
-import { and as and13, desc as desc6, eq as eq31, sql as sql5 } from "drizzle-orm";
-var RESET_DROP_THRESHOLD = 1;
-async function recordWindowPeak(db, window, resetsAt, usedPercentage) {
-  const [active] = await db.select().from(usagePeaks).where(
-    and13(eq31(usagePeaks.window, window), eq31(usagePeaks.resetsAt, resetsAt))
-  ).orderBy(desc6(usagePeaks.segment)).limit(1);
-  if (!active) {
-    await db.insert(usagePeaks).values({ window, resetsAt, segment: 0, usedPercentage });
-    return;
-  }
-  const matchActive = and13(
-    eq31(usagePeaks.window, window),
-    eq31(usagePeaks.resetsAt, resetsAt),
-    eq31(usagePeaks.segment, active.segment)
-  );
-  if (usedPercentage < active.usedPercentage - RESET_DROP_THRESHOLD) {
-    await db.update(usagePeaks).set({ resetDetected: true }).where(matchActive);
-    await db.insert(usagePeaks).values({
-      window,
-      resetsAt,
-      segment: active.segment + 1,
-      usedPercentage
-    });
-    return;
-  }
-  await db.update(usagePeaks).set({
-    usedPercentage: sql5`GREATEST(${usagePeaks.usedPercentage}, ${usedPercentage})`
-  }).where(matchActive);
-}
-
 // src/shared/db/recordUsagePeak.ts
 var WINDOWS = ["five_hour", "seven_day"];
 async function recordUsagePeak(db, rateLimits) {

package/package.json

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