@staff0rd/assist 0.382.1 → 0.384.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.382.1",
+  version: "0.384.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -513,7 +513,13 @@ var itemSubtasks = pgTable5(
 );
 
 // src/shared/db/phaseUsage.ts
-import { bigint as bigint2, integer as integer6, pgTable as pgTable6, primaryKey as primaryKey3 } from "drizzle-orm/pg-core";
+import {
+  bigint as bigint2,
+  doublePrecision,
+  integer as integer6,
+  pgTable as pgTable6,
+  primaryKey as primaryKey3
+} from "drizzle-orm/pg-core";
 var phaseUsage = pgTable6(
   "phase_usage",
   {
@@ -522,6 +528,7 @@ var phaseUsage = pgTable6(
     tokensUp: bigint2("tokens_up", { mode: "number" }).notNull().default(0),
     tokensDown: bigint2("tokens_down", { mode: "number" }).notNull().default(0),
     activeMs: bigint2("active_ms", { mode: "number" }).notNull().default(0),
+    peakContextPct: doublePrecision("peak_context_pct").notNull().default(0),
     lastTotalIn: bigint2("last_total_in", { mode: "number" }),
     lastTotalOut: bigint2("last_total_out", { mode: "number" })
   },
@@ -544,7 +551,7 @@ var phaseUsageMessages = pgTable7(
 import {
   bigint as bigint3,
   boolean as boolean2,
-  doublePrecision,
+  doublePrecision as doublePrecision2,
   integer as integer8,
   pgTable as pgTable8,
   primaryKey as primaryKey5,
@@ -557,7 +564,7 @@ var usagePeaks = pgTable8(
     window: text7().$type().notNull(),
     resetsAt: bigint3("resets_at", { mode: "number" }).notNull(),
     segment: integer8().notNull().default(0),
-    usedPercentage: doublePrecision("used_percentage").notNull(),
+    usedPercentage: doublePrecision2("used_percentage").notNull(),
     resetDetected: boolean2("reset_detected").notNull().default(false),
     tokensUp: bigint3("tokens_up", { mode: "number" }).notNull().default(0),
     tokensDown: bigint3("tokens_down", { mode: "number" }).notNull().default(0),
@@ -921,6 +928,7 @@ var SCHEMA = `
 		tokens_up BIGINT NOT NULL DEFAULT 0,
 		tokens_down BIGINT NOT NULL DEFAULT 0,
 		active_ms BIGINT NOT NULL DEFAULT 0,
+		peak_context_pct DOUBLE PRECISION NOT NULL DEFAULT 0,
 		last_total_in BIGINT,
 		last_total_out BIGINT,
 		PRIMARY KEY (item_id, phase_idx)
@@ -928,6 +936,7 @@ var SCHEMA = `
 
 	ALTER TABLE phase_usage ADD COLUMN IF NOT EXISTS last_total_in BIGINT;
 	ALTER TABLE phase_usage ADD COLUMN IF NOT EXISTS last_total_out BIGINT;
+	ALTER TABLE phase_usage ADD COLUMN IF NOT EXISTS peak_context_pct DOUBLE PRECISION NOT NULL DEFAULT 0;
 
 	CREATE TABLE IF NOT EXISTS phase_usage_messages (
 		item_id INTEGER NOT NULL REFERENCES items(id) ON DELETE CASCADE,
@@ -1002,7 +1011,7 @@ function createPool() {
   return pool;
 }
 async function initSchema(pool) {
-  await ensureSchema((sql13) => pool.query(sql13));
+  await ensureSchema((sql14) => pool.query(sql14));
   const orm = makeOrmFromPool(pool);
   await seedNewsFeeds(orm);
   await runUsagePeakCleanup(orm);
@@ -4082,8 +4091,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 sql13 = `COPY ${table.name} (${table.columns.join(", ")}) TO STDOUT`;
-  const stream = client.query(copyTo(sql13));
+  const sql14 = `COPY ${table.name} (${table.columns.join(", ")}) TO STDOUT`;
+  const stream = client.query(copyTo(sql14));
   const chunks = [];
   for await (const chunk of stream) {
     chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
@@ -4972,9 +4981,10 @@ function sumPhaseUsage(usage) {
     (total, u) => ({
       tokensUp: total.tokensUp + u.tokensUp,
       tokensDown: total.tokensDown + u.tokensDown,
-      activeMs: total.activeMs + u.activeMs
+      activeMs: total.activeMs + u.activeMs,
+      peakContextPct: Math.max(total.peakContextPct, u.peakContextPct)
     }),
-    { tokensUp: 0, tokensDown: 0, activeMs: 0 }
+    { tokensUp: 0, tokensDown: 0, activeMs: 0, peakContextPct: 0 }
   );
 }
 
@@ -4984,7 +4994,8 @@ function rowToUsage(u) {
     phaseIdx: u.phaseIdx,
     tokensUp: u.tokensUp,
     tokensDown: u.tokensDown,
-    activeMs: u.activeMs
+    activeMs: u.activeMs,
+    peakContextPct: u.peakContextPct
   };
 }
 function attachUsage(item, rel, id) {
@@ -5104,12 +5115,14 @@ var phaseUsageSchema = z3.strictObject({
   phaseIdx: z3.number(),
   tokensUp: z3.number(),
   tokensDown: z3.number(),
-  activeMs: z3.number()
+  activeMs: z3.number(),
+  peakContextPct: z3.number()
 });
 var phaseUsageTotalSchema = z3.strictObject({
   tokensUp: z3.number(),
   tokensDown: z3.number(),
-  activeMs: z3.number()
+  activeMs: z3.number(),
+  peakContextPct: z3.number()
 });
 var subtaskStatusSchema = z3.enum(["todo", "in-progress", "done"]);
 var subtaskSchema = z3.strictObject({
@@ -6679,6 +6692,9 @@ function phaseUsageTotals(orm) {
     ),
     activeMs: sql6`sum(${phaseUsage.activeMs})::bigint`.as(
       "total_active_ms"
+    ),
+    peakContextPct: sql6`max(${phaseUsage.peakContextPct})`.as(
+      "max_peak_context_pct"
     )
   }).from(phaseUsage).groupBy(phaseUsage.itemId).as("usage_totals");
 }
@@ -6697,7 +6713,8 @@ function rowToItemSummary(row) {
     usageTotal: row.tokensUp == null ? void 0 : {
       tokensUp: Number(row.tokensUp),
       tokensDown: Number(row.tokensDown),
-      activeMs: Number(row.activeMs)
+      activeMs: Number(row.activeMs),
+      peakContextPct: Number(row.peakContextPct ?? 0)
     }
   };
 }
@@ -6717,7 +6734,8 @@ async function loadItemSummaries(orm, origin) {
     incompleteSubtasks: incompleteCounts.count,
     tokensUp: usageTotals.tokensUp,
     tokensDown: usageTotals.tokensDown,
-    activeMs: usageTotals.activeMs
+    activeMs: usageTotals.activeMs,
+    peakContextPct: usageTotals.peakContextPct
   }).from(items).leftJoin(incompleteCounts, eq11(incompleteCounts.itemId, items.id)).leftJoin(usageTotals, eq11(usageTotals.itemId, items.id)).where(origin === void 0 ? void 0 : eq11(items.origin, origin)).orderBy(asc5(items.id));
   return rows.map(rowToItemSummary);
 }
@@ -8459,8 +8477,8 @@ async function readStdinBuffer() {
 import { finished } from "stream/promises";
 import { from as copyFrom } from "pg-copy-streams";
 async function copyTableIn(client, table, data) {
-  const sql13 = `COPY ${table.name} (${table.columns.join(", ")}) FROM STDIN`;
-  const stream = client.query(copyFrom(sql13));
+  const sql14 = `COPY ${table.name} (${table.columns.join(", ")}) FROM STDIN`;
+  const stream = client.query(copyFrom(sql14));
   stream.end(data);
   await finished(stream);
 }
@@ -20111,8 +20129,8 @@ function filterToSql(filter) {
 // src/commands/seq/fetchSeqData.ts
 function buildDataParams(filter, count8, from, to) {
   const sqlFilter = filterToSql(filter);
-  const sql13 = `select @Timestamp, @Level, @Exception, @Message from stream where ${sqlFilter} order by @Timestamp desc limit ${count8}`;
-  const params = new URLSearchParams({ q: sql13 });
+  const sql14 = `select @Timestamp, @Level, @Exception, @Message from stream where ${sqlFilter} order by @Timestamp desc limit ${count8}`;
+  const params = new URLSearchParams({ q: sql14 });
   if (from) params.set("rangeStartUtc", from);
   if (to) params.set("rangeEndUtc", to);
   return params;
@@ -20373,26 +20391,26 @@ import chalk187 from "chalk";
 // src/commands/sql/loadConnections.ts
 function loadConnections3() {
   const raw = loadGlobalConfigRaw();
-  const sql13 = raw.sql;
-  return sql13?.connections ?? [];
+  const sql14 = raw.sql;
+  return sql14?.connections ?? [];
 }
 function saveConnections3(connections) {
   const raw = loadGlobalConfigRaw();
-  const sql13 = raw.sql ?? {};
-  sql13.connections = connections;
-  raw.sql = sql13;
+  const sql14 = raw.sql ?? {};
+  sql14.connections = connections;
+  raw.sql = sql14;
   saveGlobalConfig(raw);
 }
 function getDefaultConnection2() {
   const raw = loadGlobalConfigRaw();
-  const sql13 = raw.sql;
-  return sql13?.defaultConnection;
+  const sql14 = raw.sql;
+  return sql14?.defaultConnection;
 }
 function setDefaultConnection2(name) {
   const raw = loadGlobalConfigRaw();
-  const sql13 = raw.sql ?? {};
-  sql13.defaultConnection = name;
-  raw.sql = sql13;
+  const sql14 = raw.sql ?? {};
+  sql14.defaultConnection = name;
+  raw.sql = sql14;
   saveGlobalConfig(raw);
 }
 
@@ -20542,11 +20560,11 @@ var MUTATION_PATTERN = new RegExp(
   `\\b(${MUTATION_KEYWORDS.join("|")})\\b`,
   "i"
 );
-function stripComments(sql13) {
-  return sql13.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/--[^\n]*/g, " ");
+function stripComments(sql14) {
+  return sql14.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/--[^\n]*/g, " ");
 }
-function isMutation(sql13) {
-  const stripped = stripComments(sql13);
+function isMutation(sql14) {
+  const stripped = stripComments(sql14);
   if (MUTATION_PATTERN.test(stripped)) return true;
   return /\bSELECT\b[\s\S]+\bINTO\s+\w/i.test(stripped);
 }
@@ -22848,6 +22866,59 @@ function drainSessions(sessions, onDrained) {
   return ids.length;
 }
 
+// src/shared/db/recordPhaseActiveMs.ts
+import { sql as sql10 } from "drizzle-orm";
+async function recordPhaseActiveMs(db, itemId2, phaseIdx, activeMs) {
+  if (activeMs <= 0) return;
+  await db.insert(phaseUsage).values({ itemId: itemId2, phaseIdx, activeMs }).onConflictDoUpdate({
+    target: [phaseUsage.itemId, phaseUsage.phaseIdx],
+    set: {
+      activeMs: sql10`${phaseUsage.activeMs} + excluded.active_ms`
+    }
+  });
+}
+
+// src/commands/sessions/daemon/persistPhaseActiveMs.ts
+async function persistPhaseActiveMs(itemId2, phaseIdx, activeMs) {
+  try {
+    if (!process.env.ASSIST_DATABASE_URL && !loadConfig().database.url)
+      return true;
+    await recordPhaseActiveMs(await getDb(), itemId2, phaseIdx, activeMs);
+    return true;
+  } catch (error) {
+    daemonLog(`phase-active-ms persist failed: ${String(error)}`);
+    return false;
+  }
+}
+
+// src/commands/sessions/daemon/sessionBacklogPhase.ts
+function sessionBacklogPhase(session) {
+  const activity2 = session.activity;
+  if (activity2?.kind !== "backlog") return void 0;
+  if (activity2.itemId == null || activity2.phase == null) return void 0;
+  return { itemId: activity2.itemId, phaseIdx: activity2.phase - 1 };
+}
+
+// src/commands/sessions/daemon/flushPhaseActiveMs.ts
+function flushPhaseActiveMs(session) {
+  if (session.status !== "running" || session.runningSince == null)
+    return Promise.resolve();
+  const phase = sessionBacklogPhase(session);
+  if (!phase) return Promise.resolve();
+  const since = session.runningSince;
+  const elapsed = Date.now() - since;
+  const run4 = async () => {
+    const flushed = session.activeMsFlushedForStretch?.since === since ? session.activeMsFlushedForStretch.ms : 0;
+    const delta = elapsed - flushed;
+    if (delta <= 0) return;
+    if (await persistPhaseActiveMs(phase.itemId, phase.phaseIdx, delta))
+      session.activeMsFlushedForStretch = { since, ms: flushed + delta };
+  };
+  const chain = (session.activeMsFlushChain ?? Promise.resolve()).then(run4);
+  session.activeMsFlushChain = chain;
+  return chain;
+}
+
 // src/commands/sessions/daemon/stripReplayQueries.ts
 var ESC2 = "\x1B";
 var REPLAY_QUERY = new RegExp(
@@ -22884,36 +22955,6 @@ function logSpawnedSession(session) {
   );
 }
 
-// src/shared/db/recordPhaseActiveMs.ts
-import { sql as sql10 } from "drizzle-orm";
-async function recordPhaseActiveMs(db, itemId2, phaseIdx, activeMs) {
-  if (activeMs <= 0) return;
-  await db.insert(phaseUsage).values({ itemId: itemId2, phaseIdx, activeMs }).onConflictDoUpdate({
-    target: [phaseUsage.itemId, phaseUsage.phaseIdx],
-    set: {
-      activeMs: sql10`${phaseUsage.activeMs} + excluded.active_ms`
-    }
-  });
-}
-
-// src/commands/sessions/daemon/persistPhaseActiveMs.ts
-async function persistPhaseActiveMs(itemId2, phaseIdx, activeMs) {
-  try {
-    if (!process.env.ASSIST_DATABASE_URL && !loadConfig().database.url) return;
-    await recordPhaseActiveMs(await getDb(), itemId2, phaseIdx, activeMs);
-  } catch (error) {
-    daemonLog(`phase-active-ms persist failed: ${String(error)}`);
-  }
-}
-
-// src/commands/sessions/daemon/sessionBacklogPhase.ts
-function sessionBacklogPhase(session) {
-  const activity2 = session.activity;
-  if (activity2?.kind !== "backlog") return void 0;
-  if (activity2.itemId == null || activity2.phase == null) return void 0;
-  return { itemId: activity2.itemId, phaseIdx: activity2.phase - 1 };
-}
-
 // src/commands/sessions/daemon/setStatus.ts
 function setStatus2(session, newStatus) {
   const now = Date.now();
@@ -22997,21 +23038,11 @@ function disarmEscInterrupt(session) {
 }
 
 // src/commands/sessions/daemon/applyStatusChange.ts
-function accumulateActiveTime(session) {
-  if (session.status !== "running" || session.runningSince == null) return;
-  const phase = sessionBacklogPhase(session);
-  if (!phase) return;
-  void persistPhaseActiveMs(
-    phase.itemId,
-    phase.phaseIdx,
-    Date.now() - session.runningSince
-  );
-}
 function applyStatusChange(session, status2, exitCode, dismiss, notify2, reuseForRun) {
   disarmEscInterrupt(session);
   if (session.status === status2) return;
   daemonLog(`session ${session.id} status: ${session.status} -> ${status2}`);
-  accumulateActiveTime(session);
+  void flushPhaseActiveMs(session);
   setStatus2(session, status2);
   const autoRun = shouldAutoRun(session);
   if (autoRun.run) {
@@ -23033,8 +23064,19 @@ function makeStatusChangeHandler(dismiss, notify2, reuseForRun) {
   return (s, status2, exitCode) => applyStatusChange(s, status2, exitCode, dismiss, notify2, reuseForRun);
 }
 
-// src/shared/db/recordPhaseTranscriptUsage.ts
+// src/shared/db/recordPhasePeakContext.ts
 import { sql as sql11 } from "drizzle-orm";
+async function recordPhasePeakContext(db, itemId2, phaseIdx, pct) {
+  await db.insert(phaseUsage).values({ itemId: itemId2, phaseIdx, peakContextPct: pct }).onConflictDoUpdate({
+    target: [phaseUsage.itemId, phaseUsage.phaseIdx],
+    set: {
+      peakContextPct: sql11`GREATEST(${phaseUsage.peakContextPct}, ${pct})`
+    }
+  });
+}
+
+// src/shared/db/recordPhaseTranscriptUsage.ts
+import { sql as sql12 } from "drizzle-orm";
 async function recordPhaseTranscriptUsage(db, itemId2, phaseIdx, responses) {
   const byId = /* @__PURE__ */ new Map();
   for (const r of responses) byId.set(r.messageId, r);
@@ -23054,8 +23096,8 @@ async function recordPhaseTranscriptUsage(db, itemId2, phaseIdx, responses) {
     await tx.insert(phaseUsage).values({ itemId: itemId2, phaseIdx, tokensUp, tokensDown }).onConflictDoUpdate({
       target: [phaseUsage.itemId, phaseUsage.phaseIdx],
       set: {
-        tokensUp: sql11`${phaseUsage.tokensUp} + ${tokensUp}`,
-        tokensDown: sql11`${phaseUsage.tokensDown} + ${tokensDown}`
+        tokensUp: sql12`${phaseUsage.tokensUp} + ${tokensUp}`,
+        tokensDown: sql12`${phaseUsage.tokensDown} + ${tokensDown}`
       }
     });
     return { tokensUp, tokensDown };
@@ -23063,12 +23105,12 @@ async function recordPhaseTranscriptUsage(db, itemId2, phaseIdx, responses) {
 }
 
 // src/shared/db/recordWindowTokens.ts
-import { and as and19, eq as eq37, sql as sql12 } from "drizzle-orm";
+import { and as and19, eq as eq37, sql as sql13 } from "drizzle-orm";
 async function recordWindowTokens(db, window, resetsAt, tokensUp, tokensDown) {
   if (tokensUp <= 0 && tokensDown <= 0) return;
   await db.update(usagePeaks).set({
-    tokensUp: sql12`${usagePeaks.tokensUp} + ${tokensUp}`,
-    tokensDown: sql12`${usagePeaks.tokensDown} + ${tokensDown}`
+    tokensUp: sql13`${usagePeaks.tokensUp} + ${tokensUp}`,
+    tokensDown: sql13`${usagePeaks.tokensDown} + ${tokensDown}`
   }).where(
     and19(
       eq37(usagePeaks.window, window),
@@ -23108,12 +23150,14 @@ async function readTranscriptUsage(transcriptPath) {
 }
 
 // src/commands/sessions/daemon/persistPhaseTokens.ts
-async function persistPhaseTokens(itemId2, phaseIdx, transcriptPath, windows) {
+async function persistPhaseTokens(itemId2, phaseIdx, transcriptPath, usedPct, windows) {
   try {
     if (!process.env.ASSIST_DATABASE_URL && !loadConfig().database.url) return;
+    const db = await getDb();
+    if (usedPct !== void 0)
+      await recordPhasePeakContext(db, itemId2, phaseIdx, usedPct);
     const responses = await readTranscriptUsage(transcriptPath);
     if (responses.length === 0) return;
-    const db = await getDb();
     const { tokensUp, tokensDown } = await recordPhaseTranscriptUsage(
       db,
       itemId2,
@@ -23139,8 +23183,10 @@ function recordSessionUsage(sessions, claudeSessionId, transcriptPath, usedPct,
         phase.itemId,
         phase.phaseIdx,
         transcriptPath,
+        usedPct,
         windows
       );
+    void flushPhaseActiveMs(session);
     return true;
   }
   return false;
@@ -24355,6 +24401,11 @@ var SessionManager = class {
     this.shuttingDown = true;
     shutdownSessions(this.sessions);
   }
+  async flushActiveMs() {
+    await Promise.all(
+      [...this.sessions.values()].map((s) => flushPhaseActiveMs(s))
+    );
+  }
   restore() {
     return restoreAll(this.spawnWith, this.sessions);
   }
@@ -24755,7 +24806,8 @@ function handleFetchTranscript(client, _manager, data) {
     (messages) => sendTo(client, { type: "transcript", sessionId, messages })
   );
 }
-function handleShutdown(client, manager) {
+async function handleShutdown(client, manager) {
+  await manager.flushActiveMs();
   manager.shutdown();
   sendTo(client, { type: "shutting-down" });
   setImmediate(() => process.exit(0));
@@ -24913,8 +24965,10 @@ function onListening(manager, checkAutoExit) {
   writeFileSync40(daemonPaths.pid, String(process.pid));
   startPidFileWatchdog(() => {
     daemonLog("lost daemon.pid ownership; shutting down sessions and exiting");
-    manager.shutdown();
-    process.exit(0);
+    void manager.flushActiveMs().finally(() => {
+      manager.shutdown();
+      process.exit(0);
+    });
   });
   process.on("exit", cleanupOwnedFiles);
   const restored = manager.restore();

package/package.json

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