@staff0rd/assist 0.381.0 → 0.382.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.381.0",
+  version: "0.382.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -432,10 +432,10 @@ function getTranscriptConfig() {
 // src/shared/db/schema.ts
 import {
   foreignKey,
-  integer as integer8,
-  pgTable as pgTable8,
-  primaryKey as primaryKey5,
-  text as text7
+  integer as integer9,
+  pgTable as pgTable9,
+  primaryKey as primaryKey6,
+  text as text8
 } from "drizzle-orm/pg-core";
 
 // src/shared/db/backups.ts
@@ -536,82 +536,96 @@ var phaseUsage = pgTable6(
   (t) => [primaryKey3({ columns: [t.itemId, t.phaseIdx] })]
 );
 
+// src/shared/db/phaseUsageMessages.ts
+import { integer as integer7, pgTable as pgTable7, primaryKey as primaryKey4, text as text6 } from "drizzle-orm/pg-core";
+var phaseUsageMessages = pgTable7(
+  "phase_usage_messages",
+  {
+    itemId: integer7("item_id").notNull(),
+    phaseIdx: integer7("phase_idx").notNull(),
+    messageId: text6("message_id").notNull()
+  },
+  (t) => [primaryKey4({ columns: [t.itemId, t.phaseIdx, t.messageId] })]
+);
+
 // src/shared/db/usagePeaks.ts
 import {
   bigint as bigint3,
   boolean as boolean2,
   doublePrecision,
-  integer as integer7,
-  pgTable as pgTable7,
-  primaryKey as primaryKey4,
-  text as text6,
+  integer as integer8,
+  pgTable as pgTable8,
+  primaryKey as primaryKey5,
+  text as text7,
   timestamp as timestamp4
 } from "drizzle-orm/pg-core";
-var usagePeaks = pgTable7(
+var usagePeaks = pgTable8(
   "usage_peaks",
   {
-    window: text6().$type().notNull(),
+    window: text7().$type().notNull(),
     resetsAt: bigint3("resets_at", { mode: "number" }).notNull(),
-    segment: integer7().notNull().default(0),
+    segment: integer8().notNull().default(0),
     usedPercentage: doublePrecision("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),
     createdAt: timestamp4("created_at", { withTimezone: true }).notNull().defaultNow()
   },
-  (t) => [primaryKey4({ columns: [t.window, t.resetsAt, t.segment] })]
+  (t) => [primaryKey5({ columns: [t.window, t.resetsAt, t.segment] })]
 );
 
 // src/shared/db/schema.ts
-var comments = pgTable8("comments", {
-  id: integer8().generatedByDefaultAsIdentity().primaryKey(),
-  itemId: integer8("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
-  idx: integer8().notNull(),
-  text: text7().notNull(),
-  phase: integer8(),
-  timestamp: text7().notNull(),
-  type: text7().notNull().default("comment")
+var comments = pgTable9("comments", {
+  id: integer9().generatedByDefaultAsIdentity().primaryKey(),
+  itemId: integer9("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+  idx: integer9().notNull(),
+  text: text8().notNull(),
+  phase: integer9(),
+  timestamp: text8().notNull(),
+  type: text8().notNull().default("comment")
 });
-var links = pgTable8(
+var links = pgTable9(
   "links",
   {
-    itemId: integer8("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
-    type: text7().notNull(),
-    targetId: integer8("target_id").notNull()
+    itemId: integer9("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+    type: text8().notNull(),
+    targetId: integer9("target_id").notNull()
   },
-  (t) => [primaryKey5({ columns: [t.itemId, t.type, t.targetId] })]
+  (t) => [primaryKey6({ columns: [t.itemId, t.type, t.targetId] })]
 );
-var planPhases = pgTable8(
+var planPhases = pgTable9(
   "plan_phases",
   {
-    itemId: integer8("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
-    idx: integer8().notNull(),
-    name: text7().notNull(),
-    manualChecks: text7("manual_checks")
+    itemId: integer9("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+    idx: integer9().notNull(),
+    name: text8().notNull(),
+    manualChecks: text8("manual_checks")
   },
-  (t) => [primaryKey5({ columns: [t.itemId, t.idx] })]
+  (t) => [primaryKey6({ columns: [t.itemId, t.idx] })]
 );
-var planTasks = pgTable8(
+var planTasks = pgTable9(
   "plan_tasks",
   {
-    itemId: integer8("item_id").notNull(),
-    phaseIdx: integer8("phase_idx").notNull(),
-    idx: integer8().notNull(),
-    task: text7().notNull()
+    itemId: integer9("item_id").notNull(),
+    phaseIdx: integer9("phase_idx").notNull(),
+    idx: integer9().notNull(),
+    task: text8().notNull()
   },
   (t) => [
-    primaryKey5({ columns: [t.itemId, t.phaseIdx, t.idx] }),
+    primaryKey6({ columns: [t.itemId, t.phaseIdx, t.idx] }),
     foreignKey({
       columns: [t.itemId, t.phaseIdx],
       foreignColumns: [planPhases.itemId, planPhases.idx]
     }).onDelete("cascade")
   ]
 );
-var metadata = pgTable8("metadata", {
-  key: text7().primaryKey(),
-  value: text7().notNull()
+var metadata = pgTable9("metadata", {
+  key: text8().primaryKey(),
+  value: text8().notNull()
 });
-var feeds = pgTable8("feeds", {
-  id: integer8().generatedByDefaultAsIdentity().primaryKey(),
-  url: text7().notNull().unique()
+var feeds = pgTable9("feeds", {
+  id: integer9().generatedByDefaultAsIdentity().primaryKey(),
+  url: text8().notNull().unique()
 });
 var schema = {
   items,
@@ -626,7 +640,8 @@ var schema = {
   handovers,
   usagePeaks,
   backups,
-  phaseUsage
+  phaseUsage,
+  phaseUsageMessages
 };
 
 // src/commands/backlog/addFeed.ts
@@ -662,30 +677,27 @@ async function seedNewsFeeds(db) {
 import { and as and2, eq as eq2 } from "drizzle-orm";
 
 // src/shared/db/recordWindowPeak.ts
-import { and, eq, gt, sql } from "drizzle-orm";
+import { sql } from "drizzle-orm";
+
+// src/shared/db/applyReading.ts
+import { and, eq, gt } 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);
+var load = (c) => c.tx.select().from(usagePeaks).where(at(c)).orderBy(usagePeaks.segment);
+async function applyReading(c, usedPercentage) {
+  const segments = await load(c);
+  if (segments.length === 0) await insertSegment(c, 0, usedPercentage);
+  else await reconcile(c, segments, usedPercentage);
 }
 async function reconcile(c, segments, usedPercentage) {
   const reached = segments.find((s) => usedPercentage >= s.usedPercentage);
@@ -698,13 +710,24 @@ async function reconcile(c, segments, usedPercentage) {
     await openReset(c, active, 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);
+}
+
+// src/shared/db/recordWindowPeak.ts
+var lock = ({ tx, window, resetsAt }) => tx.execute(
+  sql`SELECT pg_advisory_xact_lock(hashtextextended(${`${window}:${resetsAt}`}, 0))`
+);
 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);
+    await applyReading(c, usedPercentage);
   });
 }
 
@@ -859,6 +882,8 @@ var SCHEMA = `
 		segment INTEGER NOT NULL DEFAULT 0,
 		used_percentage DOUBLE PRECISION NOT NULL,
 		reset_detected BOOLEAN NOT NULL DEFAULT false,
+		tokens_up BIGINT NOT NULL DEFAULT 0,
+		tokens_down BIGINT NOT NULL DEFAULT 0,
 		created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
 		PRIMARY KEY ("window", resets_at, segment)
 	);
@@ -867,6 +892,8 @@ var SCHEMA = `
 	ALTER TABLE usage_peaks ADD COLUMN IF NOT EXISTS reset_detected BOOLEAN NOT NULL DEFAULT false;
 	ALTER TABLE usage_peaks ADD COLUMN IF NOT EXISTS segment INTEGER NOT NULL DEFAULT 0;
 	ALTER TABLE usage_peaks ADD COLUMN IF NOT EXISTS created_at TIMESTAMPTZ NOT NULL DEFAULT now();
+	ALTER TABLE usage_peaks ADD COLUMN IF NOT EXISTS tokens_up BIGINT NOT NULL DEFAULT 0;
+	ALTER TABLE usage_peaks ADD COLUMN IF NOT EXISTS tokens_down BIGINT NOT NULL DEFAULT 0;
 
 	-- Widen the primary key to include segment so a cycle can hold both its
 	-- pre-reset peak and its post-reset continuation. Idempotent: only fires
@@ -907,6 +934,16 @@ var SCHEMA = `
 		PRIMARY KEY (item_id, phase_idx)
 	);
 
+	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;
+
+	CREATE TABLE IF NOT EXISTS phase_usage_messages (
+		item_id INTEGER NOT NULL REFERENCES items(id) ON DELETE CASCADE,
+		phase_idx INTEGER NOT NULL,
+		message_id TEXT NOT NULL,
+		PRIMARY KEY (item_id, phase_idx, message_id)
+	);
+
 	-- Git activity (branch/commit/PR) snapshotted for an item during a run. The
 	-- (item_id, kind, ref) primary key makes re-snapshotting the same ref a no-op
 	-- upsert rather than a duplicate row.
@@ -973,7 +1010,7 @@ function createPool() {
   return pool;
 }
 async function initSchema(pool) {
-  await ensureSchema((sql11) => pool.query(sql11));
+  await ensureSchema((sql13) => pool.query(sql13));
   const orm = makeOrmFromPool(pool);
   await seedNewsFeeds(orm);
   await runUsagePeakCleanup(orm);
@@ -2564,8 +2601,8 @@ function isHashCommentFile(filePath) {
 import fs13 from "fs";
 
 // src/commands/verify/blockComments/collectHashComments.ts
-function blankNonNewline(text9) {
-  return text9.replace(/[^\n]/g, " ");
+function blankNonNewline(text10) {
+  return text10.replace(/[^\n]/g, " ");
 }
 function isHeaderLine(line) {
   const trimmed = line.trim();
@@ -2642,23 +2679,23 @@ var MACHINE_DIRECTIVES = [
   "@vitest-environment",
   MAINTAINABILITY_OVERRIDE_MARKER
 ];
-function isCommentExempt(text9) {
-  const lower = text9.toLowerCase();
+function isCommentExempt(text10) {
+  const lower = text10.toLowerCase();
   return MACHINE_DIRECTIVES.some((d) => lower.includes(d));
 }
 
 // src/commands/verify/blockComments/collectSourceFindings.ts
-function toSingleLine(text9) {
-  return text9.replace(/\s+/g, " ").trim();
+function toSingleLine(text10) {
+  return text10.replace(/\s+/g, " ").trim();
 }
 function collectSourceFindings(file, lines, project) {
   const findings = [];
   const sourceFile = project.addSourceFileAtPath(file);
-  for (const { pos, text: text9 } of collectComments(sourceFile)) {
+  for (const { pos, text: text10 } of collectComments(sourceFile)) {
     const { line } = sourceFile.getLineAndColumnAtPos(pos);
     if (!lines.has(line)) continue;
-    if (isCommentExempt(text9)) continue;
-    findings.push({ file, line, text: toSingleLine(text9) });
+    if (isCommentExempt(text10)) continue;
+    findings.push({ file, line, text: toSingleLine(text10) });
   }
   return findings;
 }
@@ -2678,10 +2715,10 @@ function collectYamlComments(content) {
 // src/commands/verify/blockComments/collectFileComments.ts
 function toFindings(file, lines, raw, exempt) {
   const findings = [];
-  for (const { line, text: text9 } of raw) {
+  for (const { line, text: text10 } of raw) {
     if (!lines.has(line)) continue;
-    if (exempt && isCommentExempt(text9)) continue;
-    findings.push({ file, line, text: text9.replace(/\s+/g, " ").trim() });
+    if (exempt && isCommentExempt(text10)) continue;
+    findings.push({ file, line, text: text10.replace(/\s+/g, " ").trim() });
   }
   return findings;
 }
@@ -2779,8 +2816,8 @@ function blockComments() {
     process.exit(0);
   }
   console.log("Comments on changed lines:\n");
-  for (const { file, line, text: text9 } of findings) {
-    console.log(`${file}:${line} \u2192 ${text9}`);
+  for (const { file, line, text: text10 } of findings) {
+    console.log(`${file}:${line} \u2192 ${text10}`);
   }
   console.log(`
 Total: ${findings.length} comment(s)`);
@@ -4053,8 +4090,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 sql11 = `COPY ${table.name} (${table.columns.join(", ")}) TO STDOUT`;
-  const stream = client.query(copyTo(sql11));
+  const sql13 = `COPY ${table.name} (${table.columns.join(", ")}) TO STDOUT`;
+  const stream = client.query(copyTo(sql13));
   const chunks = [];
   for await (const chunk of stream) {
     chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
@@ -4596,11 +4633,11 @@ import { promisify } from "util";
 // src/shared/withSpinner.ts
 var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 var TICK_MS = 80;
-async function withSpinner(text9, task) {
+async function withSpinner(text10, task) {
   if (!process.stderr.isTTY) return task();
   let frame = 0;
   const render = () => {
-    process.stderr.write(`\r${SPINNER_FRAMES[frame]} ${text9}`);
+    process.stderr.write(`\r${SPINNER_FRAMES[frame]} ${text10}`);
   };
   render();
   const timer = setInterval(() => {
@@ -4937,6 +4974,18 @@ function attachSubtasks(item, rel, id) {
   if (subtasks.length > 0) item.subtasks = subtasks;
 }
 
+// src/commands/backlog/sumPhaseUsage.ts
+function sumPhaseUsage(usage) {
+  return usage.reduce(
+    (total, u) => ({
+      tokensUp: total.tokensUp + u.tokensUp,
+      tokensDown: total.tokensDown + u.tokensDown,
+      activeMs: total.activeMs + u.activeMs
+    }),
+    { tokensUp: 0, tokensDown: 0, activeMs: 0 }
+  );
+}
+
 // src/commands/backlog/attachUsage.ts
 function rowToUsage(u) {
   return {
@@ -4948,7 +4997,10 @@ function rowToUsage(u) {
 }
 function attachUsage(item, rel, id) {
   const usage = (rel.usage.get(id) ?? []).map(rowToUsage);
-  if (usage.length > 0) item.phaseUsage = usage;
+  if (usage.length > 0) {
+    item.phaseUsage = usage;
+    item.usageTotal = sumPhaseUsage(usage);
+  }
 }
 
 // src/commands/backlog/buildPlan.ts
@@ -5062,6 +5114,11 @@ var phaseUsageSchema = z3.strictObject({
   tokensDown: z3.number(),
   activeMs: z3.number()
 });
+var phaseUsageTotalSchema = z3.strictObject({
+  tokensUp: z3.number(),
+  tokensDown: z3.number(),
+  activeMs: z3.number()
+});
 var subtaskStatusSchema = z3.enum(["todo", "in-progress", "done"]);
 var subtaskSchema = z3.strictObject({
   title: z3.string(),
@@ -5104,6 +5161,7 @@ var backlogItemSchema = z3.strictObject({
   subtasks: z3.array(subtaskSchema).optional(),
   links: z3.array(backlogLinkSchema).optional(),
   phaseUsage: z3.array(phaseUsageSchema).optional(),
+  usageTotal: phaseUsageTotalSchema.optional(),
   gitRefs: z3.array(gitRefSchema).optional(),
   origin: z3.string().optional(),
   jiraKey: z3.string().optional()
@@ -6014,11 +6072,11 @@ import chalk45 from "chalk";
 
 // src/commands/backlog/appendComment.ts
 import { sql as sql4 } from "drizzle-orm";
-async function appendComment(orm, itemId2, text9, opts = {}) {
+async function appendComment(orm, itemId2, text10, opts = {}) {
   await orm.insert(comments).values({
     itemId: itemId2,
     idx: sql4`(SELECT COALESCE(MAX(${comments.idx}) + 1, 0) FROM ${comments} WHERE ${comments.itemId} = ${itemId2})`,
-    text: text9,
+    text: text10,
     phase: opts.phase ?? null,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     type: opts.type ?? "comment"
@@ -6121,7 +6179,7 @@ function formatComment(entry) {
 // src/shared/renderMarkdownTerminal.ts
 import { Marked } from "marked";
 import { markedTerminal } from "marked-terminal";
-function renderMarkdownTerminal(text9) {
+function renderMarkdownTerminal(text10) {
   const width = process.stdout.columns || 80;
   const marked = new Marked(markedTerminal({ width, reflowText: true }));
   marked.use({
@@ -6134,7 +6192,7 @@ function renderMarkdownTerminal(text9) {
       }
     }
   });
-  return marked.parse(text9).trimEnd();
+  return marked.parse(text10).trimEnd();
 }
 
 // src/commands/backlog/show/printActivity.ts
@@ -6154,9 +6212,9 @@ function groupActivityRefs(refs, commitLimit = ACTIVITY_COMMIT_LIMIT) {
 }
 
 // src/commands/backlog/show/printActivity.ts
-function printRef(label2, text9, ref) {
+function printRef(label2, text10, ref) {
   const url = ref.url ? ` ${chalk48.dim(ref.url)}` : "";
-  console.log(`  ${chalk48.cyan(label2)} ${text9}${url}`);
+  console.log(`  ${chalk48.cyan(label2)} ${text10}${url}`);
 }
 function printActivity(item) {
   const { branches, commits: commits2, prs: prs2, hiddenCommits } = groupActivityRefs(
@@ -6605,12 +6663,57 @@ function createFallbackHandler(routes3, htmlHandler2, extra) {
 import { eq as eq12 } from "drizzle-orm";
 
 // src/commands/backlog/loadItemSummaries.ts
-import { asc as asc5, eq as eq11, ne, sql as sql5 } from "drizzle-orm";
-async function loadItemSummaries(orm, origin) {
-  const incompleteCounts = orm.select({
+import { asc as asc5, eq as eq11 } from "drizzle-orm";
+
+// src/commands/backlog/incompleteSubtaskCounts.ts
+import { ne, sql as sql5 } from "drizzle-orm";
+function incompleteSubtaskCounts(orm) {
+  return 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");
+}
+
+// src/commands/backlog/phaseUsageTotals.ts
+import { sql as sql6 } from "drizzle-orm";
+function phaseUsageTotals(orm) {
+  return orm.select({
+    itemId: phaseUsage.itemId,
+    tokensUp: sql6`sum(${phaseUsage.tokensUp})::bigint`.as(
+      "total_tokens_up"
+    ),
+    tokensDown: sql6`sum(${phaseUsage.tokensDown})::bigint`.as(
+      "total_tokens_down"
+    ),
+    activeMs: sql6`sum(${phaseUsage.activeMs})::bigint`.as(
+      "total_active_ms"
+    )
+  }).from(phaseUsage).groupBy(phaseUsage.itemId).as("usage_totals");
+}
+
+// src/commands/backlog/rowToItemSummary.ts
+function rowToItemSummary(row) {
+  return {
+    id: row.id,
+    origin: row.origin,
+    type: row.type,
+    name: row.name,
+    status: row.status,
+    starred: row.starred,
+    jiraKey: row.jiraKey ?? void 0,
+    incompleteSubtasks: row.incompleteSubtasks ?? 0,
+    usageTotal: row.tokensUp == null ? void 0 : {
+      tokensUp: Number(row.tokensUp),
+      tokensDown: Number(row.tokensDown),
+      activeMs: Number(row.activeMs)
+    }
+  };
+}
+
+// src/commands/backlog/loadItemSummaries.ts
+async function loadItemSummaries(orm, origin) {
+  const incompleteCounts = incompleteSubtaskCounts(orm);
+  const usageTotals = phaseUsageTotals(orm);
   const rows = await orm.select({
     id: items.id,
     origin: items.origin,
@@ -6619,18 +6722,12 @@ async function loadItemSummaries(orm, origin) {
     status: items.status,
     starred: items.starred,
     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,
-    type: row.type,
-    name: row.name,
-    status: row.status,
-    starred: row.starred,
-    jiraKey: row.jiraKey ?? void 0,
-    incompleteSubtasks: row.incompleteSubtasks ?? 0
-  }));
+    incompleteSubtasks: incompleteCounts.count,
+    tokensUp: usageTotals.tokensUp,
+    tokensDown: usageTotals.tokensDown,
+    activeMs: usageTotals.activeMs
+  }).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);
 }
 
 // src/commands/backlog/loadBacklogSummaries.ts
@@ -7258,9 +7355,9 @@ function excerpt(xml, ...tags) {
   for (const tag of tags) {
     const raw = extractText(xml, tag);
     if (!raw) continue;
-    const text9 = stripHtml(raw);
-    if (text9.length <= MAX_EXCERPT) return text9;
-    return `${text9.slice(0, MAX_EXCERPT)}\u2026`;
+    const text10 = stripHtml(raw);
+    if (text10.length <= MAX_EXCERPT) return text10;
+    return `${text10.slice(0, MAX_EXCERPT)}\u2026`;
   }
   return "";
 }
@@ -8173,10 +8270,10 @@ function registerAssociateJiraCommand(cmd) {
 
 // src/commands/backlog/comment/index.ts
 import chalk63 from "chalk";
-async function comment(id, text9) {
+async function comment(id, text10) {
   const found = await findOneItem(id);
   if (!found) process.exit(1);
-  await appendComment(found.orm, found.item.id, text9);
+  await appendComment(found.orm, found.item.id, text10);
   console.log(
     chalk63.green(`Comment added to item ${formatItemId(found.item.id)}.`)
   );
@@ -8281,9 +8378,9 @@ function readLine(dump, start3) {
   return { text: dump.subarray(start3, eol).toString("utf8"), next: eol + 1 };
 }
 function parseHeader(dump) {
-  const { text: text9, next: next3 } = readLine(dump, 0);
+  const { text: text10, next: next3 } = readLine(dump, 0);
   try {
-    return { header: JSON.parse(text9), bodyStart: next3 };
+    return { header: JSON.parse(text10), bodyStart: next3 };
   } catch {
     return invalid("header is not valid JSON.");
   }
@@ -8292,9 +8389,9 @@ function parseSections(dump, bodyStart) {
   const sections = /* @__PURE__ */ new Map();
   let cursor = bodyStart;
   while (cursor < dump.length) {
-    const { text: text9, next: next3 } = readLine(dump, cursor);
-    const match = text9.match(/^@table (\S+) (\d+)$/);
-    if (!match) invalid(`malformed table marker "${text9}".`);
+    const { text: text10, next: next3 } = readLine(dump, cursor);
+    const match = text10.match(/^@table (\S+) (\d+)$/);
+    if (!match) invalid(`malformed table marker "${text10}".`);
     const [, name, bytes] = match;
     const end = next3 + Number(bytes);
     if (end > dump.length) invalid(`section "${name}" overruns the dump.`);
@@ -8370,8 +8467,8 @@ async function readStdinBuffer() {
 import { finished } from "stream/promises";
 import { from as copyFrom } from "pg-copy-streams";
 async function copyTableIn(client, table, data) {
-  const sql11 = `COPY ${table.name} (${table.columns.join(", ")}) FROM STDIN`;
-  const stream = client.query(copyFrom(sql11));
+  const sql13 = `COPY ${table.name} (${table.columns.join(", ")}) FROM STDIN`;
+  const stream = client.query(copyFrom(sql13));
   stream.end(data);
   await finished(stream);
 }
@@ -8416,8 +8513,8 @@ async function replaceData(client, parsed) {
     await copyTableIn(client, table, data);
   }
   for (const col of await introspectIdentityColumns(client)) {
-    const { text: text9, values } = resyncIdentitySql(col);
-    await client.query(text9, values);
+    const { text: text10, values } = resyncIdentitySql(col);
+    await client.query(text10, values);
   }
 }
 async function restore(client, parsed) {
@@ -8498,11 +8595,11 @@ async function insertPhaseAt(orm, itemId2, phaseIdx, name, tasks, manualChecks,
 }
 
 // src/commands/backlog/insertSubtask.ts
-import { sql as sql6 } from "drizzle-orm";
+import { sql as sql7 } from "drizzle-orm";
 async function insertSubtask(orm, itemId2, title, description) {
   await orm.insert(itemSubtasks).values({
     itemId: itemId2,
-    idx: sql6`(SELECT COALESCE(MAX(${itemSubtasks.idx}) + 1, 0) FROM ${itemSubtasks} WHERE ${itemSubtasks.itemId} = ${itemId2})`,
+    idx: sql7`(SELECT COALESCE(MAX(${itemSubtasks.idx}) + 1, 0) FROM ${itemSubtasks} WHERE ${itemSubtasks.itemId} = ${itemId2})`,
     title,
     description: description ?? null,
     status: "todo"
@@ -10264,8 +10361,8 @@ var RAW_BUILTIN_DENIES = [
     regex
   }))
 ];
-function matchBuiltinDeny(text9) {
-  return RAW_BUILTIN_DENIES.find((rule) => rule.regex.test(text9));
+function matchBuiltinDeny(text10) {
+  return RAW_BUILTIN_DENIES.find((rule) => rule.regex.test(text10));
 }
 function toDecision(rule) {
   if (!rule) return void 0;
@@ -11005,8 +11102,8 @@ function formatHuman(cli, commands) {
 `];
   for (const cmd of sorted) {
     const full = `${cli} ${cmd.path.join(" ")}`;
-    const text9 = cmd.description ? `${full} \u2014 ${cmd.description}` : full;
-    lines.push(`${prefix(classifyVerb(cmd.path))}${text9}`);
+    const text10 = cmd.description ? `${full} \u2014 ${cmd.description}` : full;
+    lines.push(`${prefix(classifyVerb(cmd.path))}${text10}`);
   }
   return lines.join("\n");
 }
@@ -11285,38 +11382,38 @@ import chalk108 from "chalk";
 // src/commands/codeComment/validateCommentText.ts
 var MAX_COMMENT_LENGTH = 50;
 function validateCommentText(raw, isHash = false) {
-  const text9 = isHash ? raw.replace(/^#\s?/, "") : raw.replace(/^\/\/\s?/, "");
-  if (/[\r\n]/.test(text9)) {
+  const text10 = isHash ? raw.replace(/^#\s?/, "") : raw.replace(/^\/\/\s?/, "");
+  if (/[\r\n]/.test(text10)) {
     return {
       ok: false,
       reason: "Comment must be a single line \u2014 multi-line comments are not allowed."
     };
   }
-  if (!isHash && (text9.includes("/*") || text9.includes("*/"))) {
+  if (!isHash && (text10.includes("/*") || text10.includes("*/"))) {
     return {
       ok: false,
       reason: "Block comments (/* */) are not allowed \u2014 only single-line // comments."
     };
   }
-  if (text9.length > MAX_COMMENT_LENGTH) {
+  if (text10.length > MAX_COMMENT_LENGTH) {
     return {
       ok: false,
-      reason: `Comment text is ${text9.length} chars; the cap is ${MAX_COMMENT_LENGTH}. Make it shorter or, better, make the code self-documenting.`
+      reason: `Comment text is ${text10.length} chars; the cap is ${MAX_COMMENT_LENGTH}. Make it shorter or, better, make the code self-documenting.`
     };
   }
-  return { ok: true, text: text9 };
+  return { ok: true, text: text10 };
 }
 
 // src/commands/codeComment/issuePin.ts
 import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync24 } from "fs";
 import { randomInt } from "crypto";
-function issuePin(file, lineNumber, text9) {
+function issuePin(file, lineNumber, text10) {
   const pin = generatePin();
   mkdirSync13(getRestrictedDir(), { recursive: true });
   sweepRestrictedDir();
   writeFileSync24(
     getPinStatePath(pin),
-    JSON.stringify({ pin, file, line: lineNumber, text: text9 })
+    JSON.stringify({ pin, file, line: lineNumber, text: text10 })
   );
   return showNotification({
     title: "assist code-comment pin",
@@ -11328,7 +11425,7 @@ function generatePin() {
 }
 
 // src/commands/codeComment/codeCommentSet.ts
-function codeCommentSet(file, line, text9) {
+function codeCommentSet(file, line, text10) {
   const lineNumber = Number.parseInt(line, 10);
   if (!Number.isInteger(lineNumber) || lineNumber < 1) {
     console.error(chalk108.red(`Invalid line number: ${line}`));
@@ -11337,7 +11434,7 @@ function codeCommentSet(file, line, text9) {
   }
   const hash = isHashCommentFile(file);
   const marker = hash ? "#" : "//";
-  const validation = validateCommentText(text9, hash);
+  const validation = validateCommentText(text10, hash);
   if (!validation.ok) {
     console.error(chalk108.red(`Refused: ${validation.reason}`));
     console.error(chalk108.red("No pin issued."));
@@ -13344,12 +13441,12 @@ function isSourceFile(filePath) {
   if (!filePath) return false;
   return SOURCE_EXTENSIONS.some((ext) => filePath.endsWith(ext));
 }
-function blankNonNewline2(text9) {
-  return text9.replace(/[^\n]/g, " ");
+function blankNonNewline2(text10) {
+  return text10.replace(/[^\n]/g, " ");
 }
-function extractComments(text9) {
+function extractComments(text10) {
   const comments3 = [];
-  let work = text9.replace(
+  let work = text10.replace(
     /"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`/g,
     blankNonNewline2
   );
@@ -13364,11 +13461,11 @@ function extractComments(text9) {
 }
 
 // src/commands/editHook/extractYamlComments.ts
-function blankNonNewline3(text9) {
-  return text9.replace(/[^\n]/g, " ");
+function blankNonNewline3(text10) {
+  return text10.replace(/[^\n]/g, " ");
 }
-function extractYamlComments(text9) {
-  const work = text9.replace(
+function extractYamlComments(text10) {
+  const work = text10.replace(
     /"(?:[^"\\]|\\.)*"|'(?:[^']|'')*'/g,
     blankNonNewline3
   );
@@ -13384,8 +13481,8 @@ function isHeaderLine2(line) {
   const trimmed = line.trim();
   return trimmed === "" || trimmed.startsWith("#");
 }
-function extractShellComments(text9) {
-  const lines = text9.split("\n");
+function extractShellComments(text10) {
+  const lines = text10.split("\n");
   let firstCodeLine = 0;
   while (firstCodeLine < lines.length && isHeaderLine2(lines[firstCodeLine])) {
     firstCodeLine++;
@@ -13755,9 +13852,9 @@ function registerGithub(program2) {
 }
 
 // src/commands/handover/countPendingHandovers.ts
-import { and as and16, eq as eq34, isNull, sql as sql7 } from "drizzle-orm";
+import { and as and16, eq as eq34, isNull, sql as sql8 } from "drizzle-orm";
 async function countPendingHandovers(orm, origin) {
-  const [row] = await orm.select({ count: sql7`count(*)::int` }).from(handovers).where(and16(eq34(handovers.origin, origin), isNull(handovers.recalledAt)));
+  const [row] = await orm.select({ count: sql8`count(*)::int` }).from(handovers).where(and16(eq34(handovers.origin, origin), isNull(handovers.recalledAt)));
   return row?.count ?? 0;
 }
 
@@ -13980,9 +14077,9 @@ import chalk140 from "chalk";
 
 // src/commands/jira/adfToText.ts
 function renderInline(node) {
-  const text9 = node.text ?? "";
-  if (node.marks?.some((m) => m.type === "code")) return `\`${text9}\``;
-  return text9;
+  const text10 = node.text ?? "";
+  if (node.marks?.some((m) => m.type === "code")) return `\`${text10}\``;
+  return text10;
 }
 function renderChildren(node, indent2) {
   return renderNodes(node.content ?? [], indent2);
@@ -14024,8 +14121,8 @@ function isListNode(node) {
 function renderListChild(child, indent2, pad, marker, isFirst) {
   if (isListNode(child)) return renderNodes([child], indent2 + 1);
   if (child.type !== "paragraph") return renderNode(child, indent2);
-  const text9 = renderChildren(child, indent2);
-  return isFirst ? `${pad}${marker} ${text9}` : `${pad}  ${text9}`;
+  const text10 = renderChildren(child, indent2);
+  return isFirst ? `${pad}${marker} ${text10}` : `${pad}  ${text10}`;
 }
 function renderListItem(node, indent2, marker) {
   const pad = "  ".repeat(indent2);
@@ -14184,9 +14281,9 @@ function registerDescriptionLaunch(program2, name, slashCommand, description, al
     "[description]",
     `Text to forward to the /${slashCommand} slash command`
   ).description(description).option("--once", "Exit when the initial task completes").option("--resume-session <id>", RESUME_SESSION_FLAG).action(
-    (text9, opts) => launchMode(slashCommand, {
+    (text10, opts) => launchMode(slashCommand, {
       once: opts.once,
-      description: text9,
+      description: text10,
       resumeSessionId: opts.resumeSession
     })
   );
@@ -14688,8 +14785,8 @@ function dedupeLinks(links2) {
 }
 
 // src/commands/netcap/linkifyMentions.ts
-function linkifyMentions(text9, mentions) {
-  let out = text9;
+function linkifyMentions(text10, mentions) {
+  let out = text10;
   for (const m of mentions) {
     if (m.name && out.includes(m.name)) {
       out = out.replace(m.name, `[${m.name}](${m.url})`);
@@ -14716,13 +14813,13 @@ function resolveAuthor(mentionMap, author) {
   return mentionMap.get(author) ?? { slug: author, url: profileUrl(author) };
 }
 function buildPost(raw, mentionMap, author) {
-  const text9 = joinText(raw.text);
-  if (!text9) return void 0;
+  const text10 = joinText(raw.text);
+  if (!text10) return void 0;
   const mentions = resolveMentions(raw, mentionMap, author);
   const relatedPosts = [...new Set(raw.related)];
   return {
-    text: text9,
-    markdown: linkifyMentions(text9, mentions),
+    text: text10,
+    markdown: linkifyMentions(text10, mentions),
     mentions,
     hashtags: [...new Set(raw.hashtags)],
     links: dedupeLinks(raw.links),
@@ -14863,8 +14960,8 @@ function activityUrnOf(update3) {
   return typeof urn === "string" ? urn : void 0;
 }
 function buildVoyagerPost(update3, profiles) {
-  const text9 = commentaryText(update3);
-  if (!text9) return void 0;
+  const text10 = commentaryText(update3);
+  if (!text10) return void 0;
   const author = resolveVoyagerAuthor(update3);
   const { mentions, hashtags, links: links2 } = collectVoyagerAttributes(
     update3,
@@ -14873,8 +14970,8 @@ function buildVoyagerPost(update3, profiles) {
   );
   const activityUrn = activityUrnOf(update3);
   return {
-    text: text9,
-    markdown: linkifyMentions(text9, mentions),
+    text: text10,
+    markdown: linkifyMentions(text10, mentions),
     mentions,
     hashtags,
     links: links2,
@@ -15378,8 +15475,8 @@ function isWallOfText(lines) {
   if (lines.some(isListLine)) {
     return false;
   }
-  const text9 = lines.join(" ").trim();
-  return text9.length > MAX_PARAGRAPH_CHARS || countSentences(text9) > MAX_PARAGRAPH_SENTENCES;
+  const text10 = lines.join(" ").trim();
+  return text10.length > MAX_PARAGRAPH_CHARS || countSentences(text10) > MAX_PARAGRAPH_SENTENCES;
 }
 function validatePrContent(title, body) {
   if (title.toLowerCase().includes("claude")) {
@@ -17133,9 +17230,9 @@ function resolveImports(target, dependencies, sourceFile, statements = []) {
 function extractTexts(target, allFunctions, statements) {
   const stmtTexts = statements.map((v) => v.getFullText().trim());
   const fnTexts = allFunctions.map((fn) => {
-    const text9 = fn.getFullText().trim();
-    if (fn === target && !text9.startsWith("export ")) return `export ${text9}`;
-    return text9;
+    const text10 = fn.getFullText().trim();
+    if (fn === target && !text10.startsWith("export ")) return `export ${text10}`;
+    return text10;
   });
   return [...stmtTexts, ...fnTexts];
 }
@@ -18985,9 +19082,9 @@ var MultiSpinner = class {
       elapsedPrefix: prefix2
     });
   }
-  failRemaining(text9) {
+  failRemaining(text10) {
     for (const entry of this.entries) {
-      if (entry.state === "running") this.resolve(entry, "failed", text9);
+      if (entry.state === "running") this.resolve(entry, "failed", text10);
     }
   }
   add(entry) {
@@ -19000,14 +19097,14 @@ var MultiSpinner = class {
       set text(value) {
         entry.text = value;
       },
-      succeed: (text9) => this.resolve(entry, "succeeded", text9),
-      fail: (text9) => this.resolve(entry, "failed", text9)
+      succeed: (text10) => this.resolve(entry, "succeeded", text10),
+      fail: (text10) => this.resolve(entry, "failed", text10)
     };
   }
-  resolve(entry, state, text9) {
+  resolve(entry, state, text10) {
     if (entry.state !== "running") return;
     entry.state = state;
-    if (text9 !== void 0) entry.text = text9;
+    if (text10 !== void 0) entry.text = text10;
     entry.elapsedStart = void 0;
     this.render();
     this.maybeFinish();
@@ -19082,12 +19179,12 @@ function skippedCodexResult(outputPath) {
 // src/commands/review/formatReviewerFailure.ts
 var FAST_FAIL_MS = 1e3;
 var STDOUT_TAIL_LINES = 20;
-function indent(text9) {
-  return text9.split(/\r?\n/).map((line) => `  ${line}`);
+function indent(text10) {
+  return text10.split(/\r?\n/).map((line) => `  ${line}`);
 }
-function tailLines(text9, maxLines) {
-  const lines = text9.split(/\r?\n/);
-  return lines.length <= maxLines ? text9 : lines.slice(-maxLines).join("\n");
+function tailLines(text10, maxLines) {
+  const lines = text10.split(/\r?\n/);
+  return lines.length <= maxLines ? text10 : lines.slice(-maxLines).join("\n");
 }
 function isFastFail(input) {
   return input.exitCode !== 0 && input.elapsedMs !== void 0 && input.elapsedMs < FAST_FAIL_MS;
@@ -20022,8 +20119,8 @@ function filterToSql(filter) {
 // src/commands/seq/fetchSeqData.ts
 function buildDataParams(filter, count8, from, to) {
   const sqlFilter = filterToSql(filter);
-  const sql11 = `select @Timestamp, @Level, @Exception, @Message from stream where ${sqlFilter} order by @Timestamp desc limit ${count8}`;
-  const params = new URLSearchParams({ q: sql11 });
+  const sql13 = `select @Timestamp, @Level, @Exception, @Message from stream where ${sqlFilter} order by @Timestamp desc limit ${count8}`;
+  const params = new URLSearchParams({ q: sql13 });
   if (from) params.set("rangeStartUtc", from);
   if (to) params.set("rangeEndUtc", to);
   return params;
@@ -20284,26 +20381,26 @@ import chalk187 from "chalk";
 // src/commands/sql/loadConnections.ts
 function loadConnections3() {
   const raw = loadGlobalConfigRaw();
-  const sql11 = raw.sql;
-  return sql11?.connections ?? [];
+  const sql13 = raw.sql;
+  return sql13?.connections ?? [];
 }
 function saveConnections3(connections) {
   const raw = loadGlobalConfigRaw();
-  const sql11 = raw.sql ?? {};
-  sql11.connections = connections;
-  raw.sql = sql11;
+  const sql13 = raw.sql ?? {};
+  sql13.connections = connections;
+  raw.sql = sql13;
   saveGlobalConfig(raw);
 }
 function getDefaultConnection2() {
   const raw = loadGlobalConfigRaw();
-  const sql11 = raw.sql;
-  return sql11?.defaultConnection;
+  const sql13 = raw.sql;
+  return sql13?.defaultConnection;
 }
 function setDefaultConnection2(name) {
   const raw = loadGlobalConfigRaw();
-  const sql11 = raw.sql ?? {};
-  sql11.defaultConnection = name;
-  raw.sql = sql11;
+  const sql13 = raw.sql ?? {};
+  sql13.defaultConnection = name;
+  raw.sql = sql13;
   saveGlobalConfig(raw);
 }
 
@@ -20374,9 +20471,9 @@ function resolveConnection3(name) {
 }
 
 // src/commands/sql/sqlConnect.ts
-import sql8 from "mssql";
+import sql9 from "mssql";
 async function sqlConnect(conn) {
-  return await sql8.connect({
+  return await sql9.connect({
     server: conn.server,
     port: conn.port,
     user: conn.user,
@@ -20453,11 +20550,11 @@ var MUTATION_PATTERN = new RegExp(
   `\\b(${MUTATION_KEYWORDS.join("|")})\\b`,
   "i"
 );
-function stripComments(sql11) {
-  return sql11.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/--[^\n]*/g, " ");
+function stripComments(sql13) {
+  return sql13.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/--[^\n]*/g, " ");
 }
-function isMutation(sql11) {
-  const stripped = stripComments(sql11);
+function isMutation(sql13) {
+  const stripped = stripComments(sql13);
   if (MUTATION_PATTERN.test(stripped)) return true;
   return /\bSELECT\b[\s\S]+\bINTO\s+\w/i.test(stripped);
 }
@@ -20656,8 +20753,8 @@ import {
 import { basename as basename10, join as join51 } from "path";
 
 // src/commands/transcript/cleanText.ts
-function cleanText(text9) {
-  const words = text9.split(/\s+/);
+function cleanText(text10) {
+  const words = text10.split(/\s+/);
   const cleaned = [];
   for (let i = 0; i < words.length; i++) {
     let isRepeat = false;
@@ -20677,8 +20774,8 @@ function cleanText(text9) {
 }
 
 // src/commands/transcript/convert/parseVtt/deduplicateCues/removeSubstringDuplicates.ts
-function normalizeText(text9) {
-  return text9.toLowerCase().trim();
+function normalizeText(text10) {
+  return text10.toLowerCase().trim();
 }
 function checkSubstringRelation(textI, textJ) {
   if (textI.includes(textJ) && textI.length > textJ.length)
@@ -20807,13 +20904,13 @@ function parseTimestampLine(line) {
   return { startMs: parseTimestamp(startStr), endMs: parseTimestamp(endStr) };
 }
 function buildCue(startMs, endMs, fullText) {
-  const { speaker, text: text9 } = extractSpeaker(fullText);
-  return text9 ? { startMs, endMs, speaker, text: text9 } : null;
+  const { speaker, text: text10 } = extractSpeaker(fullText);
+  return text10 ? { startMs, endMs, speaker, text: text10 } : null;
 }
 function parseCueLine(lines, i) {
   const { startMs, endMs } = parseTimestampLine(lines[i]);
-  const { text: text9, nextIndex: nextIndex2 } = collectTextLines(lines, i + 1);
-  return { cue: buildCue(startMs, endMs, text9), nextIndex: nextIndex2 };
+  const { text: text10, nextIndex: nextIndex2 } = collectTextLines(lines, i + 1);
+  return { cue: buildCue(startMs, endMs, text10), nextIndex: nextIndex2 };
 }
 function isCueSeparator(line) {
   return line.trim().includes("-->");
@@ -21396,8 +21493,8 @@ async function exchangeToken(params) {
     body: body.toString()
   });
   if (!response.ok) {
-    const text9 = await response.text();
-    throw new Error(`Token exchange failed (${response.status}): ${text9}`);
+    const text10 = await response.text();
+    throw new Error(`Token exchange failed (${response.status}): ${text10}`);
   }
   return response.json();
 }
@@ -22531,10 +22628,22 @@ function broadcastSessions(sessions, clients, windowsSessions = [], active) {
   });
 }
 
-// src/shared/db/recordUsagePeak.ts
+// src/shared/activeWindows.ts
 var WINDOWS = ["five_hour", "seven_day"];
-async function recordUsagePeak(db, rateLimits) {
+function activeWindows(rateLimits) {
+  if (!rateLimits) return [];
+  const out = [];
   for (const window of WINDOWS) {
+    const resetsAt = rateLimits[window]?.resets_at;
+    if (typeof resetsAt === "number") out.push({ window, resetsAt });
+  }
+  return out;
+}
+
+// src/shared/db/recordUsagePeak.ts
+var WINDOWS2 = ["five_hour", "seven_day"];
+async function recordUsagePeak(db, rateLimits) {
+  for (const window of WINDOWS2) {
     const w = rateLimits[window];
     if (!w || typeof w.resets_at !== "number" || typeof w.used_percentage !== "number")
       continue;
@@ -22567,6 +22676,9 @@ var ClientHub = class extends Set {
     broadcast(this, { type: "limits", rateLimits });
     this.persistPeak?.(rateLimits);
   }
+  currentWindows() {
+    return activeWindows(this.latestLimits);
+  }
   greet(client) {
     if (this.latestLimits) {
       sendTo(client, { type: "limits", rateLimits: this.latestLimits });
@@ -22781,13 +22893,13 @@ function logSpawnedSession(session) {
 }
 
 // src/shared/db/recordPhaseActiveMs.ts
-import { sql as sql9 } from "drizzle-orm";
+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: sql9`${phaseUsage.activeMs} + excluded.active_ms`
+      activeMs: sql10`${phaseUsage.activeMs} + excluded.active_ms`
     }
   });
 }
@@ -22929,38 +23041,114 @@ function makeStatusChangeHandler(dismiss, notify2, reuseForRun) {
   return (s, status2, exitCode) => applyStatusChange(s, status2, exitCode, dismiss, notify2, reuseForRun);
 }
 
-// src/shared/db/recordPhaseTokens.ts
-import { sql as sql10 } from "drizzle-orm";
-async function recordPhaseTokens(db, itemId2, phaseIdx, totalIn, totalOut) {
-  await db.insert(phaseUsage).values({ itemId: itemId2, phaseIdx, lastTotalIn: totalIn, lastTotalOut: totalOut }).onConflictDoUpdate({
-    target: [phaseUsage.itemId, phaseUsage.phaseIdx],
-    set: {
-      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`
-    }
+// src/shared/db/recordPhaseTranscriptUsage.ts
+import { sql as sql11 } 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);
+  const unique = [...byId.values()];
+  if (unique.length === 0) return { tokensUp: 0, tokensDown: 0 };
+  return db.transaction(async (tx) => {
+    const inserted = await tx.insert(phaseUsageMessages).values(unique.map((r) => ({ itemId: itemId2, phaseIdx, messageId: r.messageId }))).onConflictDoNothing().returning({ messageId: phaseUsageMessages.messageId });
+    let tokensUp = 0;
+    let tokensDown = 0;
+    for (const { messageId } of inserted) {
+      const r = byId.get(messageId);
+      if (!r) continue;
+      tokensUp += r.outputTokens;
+      tokensDown += r.inputTokens;
+    }
+    if (tokensUp <= 0 && tokensDown <= 0) return { tokensUp: 0, tokensDown: 0 };
+    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}`
+      }
+    });
+    return { tokensUp, tokensDown };
   });
 }
 
+// src/shared/db/recordWindowTokens.ts
+import { and as and19, eq as eq37, sql as sql12 } 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}`
+  }).where(
+    and19(
+      eq37(usagePeaks.window, window),
+      eq37(usagePeaks.resetsAt, resetsAt),
+      eq37(usagePeaks.segment, 0)
+    )
+  );
+}
+
+// src/commands/sessions/shared/transcriptUsage.ts
+import * as fs31 from "fs";
+function transcriptUsage(lines) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (entry.type !== "assistant") continue;
+    const id = entry.message?.id;
+    const usage = entry.message?.usage;
+    if (!id || !usage) continue;
+    byId.set(id, {
+      messageId: id,
+      inputTokens: usage.input_tokens ?? 0,
+      outputTokens: usage.output_tokens ?? 0
+    });
+  }
+  return [...byId.values()];
+}
+async function readTranscriptUsage(transcriptPath) {
+  const content = await fs31.promises.readFile(transcriptPath, "utf8");
+  return transcriptUsage(content.split("\n"));
+}
+
 // src/commands/sessions/daemon/persistPhaseTokens.ts
-async function persistPhaseTokens(itemId2, phaseIdx, totalIn, totalOut) {
+async function persistPhaseTokens(itemId2, phaseIdx, transcriptPath, windows) {
   try {
     if (!process.env.ASSIST_DATABASE_URL && !loadConfig().database.url) return;
-    await recordPhaseTokens(await getDb(), itemId2, phaseIdx, totalIn, totalOut);
+    const responses = await readTranscriptUsage(transcriptPath);
+    if (responses.length === 0) return;
+    const db = await getDb();
+    const { tokensUp, tokensDown } = await recordPhaseTranscriptUsage(
+      db,
+      itemId2,
+      phaseIdx,
+      responses
+    );
+    for (const { window, resetsAt } of windows) {
+      await recordWindowTokens(db, window, resetsAt, tokensUp, tokensDown);
+    }
   } catch (error) {
     daemonLog(`phase-tokens persist failed: ${String(error)}`);
   }
 }
 
 // src/commands/sessions/daemon/recordSessionUsage.ts
-function recordSessionUsage(sessions, claudeSessionId, totalIn, totalOut, usedPct) {
+function recordSessionUsage(sessions, claudeSessionId, transcriptPath, usedPct, windows) {
   for (const session of sessions) {
     if (session.claudeSessionId !== claudeSessionId) continue;
     session.usedPct = usedPct;
     const phase = sessionBacklogPhase(session);
-    if (phase)
-      void persistPhaseTokens(phase.itemId, phase.phaseIdx, totalIn, totalOut);
+    if (phase && transcriptPath)
+      void persistPhaseTokens(
+        phase.itemId,
+        phase.phaseIdx,
+        transcriptPath,
+        windows
+      );
     return true;
   }
   return false;
@@ -22982,10 +23170,10 @@ function applyReviewPause(session, activity2) {
 }
 
 // src/shared/db/getPhaseActiveMs.ts
-import { and as and19, eq as eq37 } from "drizzle-orm";
+import { and as and20, eq as eq38 } from "drizzle-orm";
 async function getPhaseActiveMs(db, itemId2, phaseIdx) {
   const [row] = await db.select({ activeMs: phaseUsage.activeMs }).from(phaseUsage).where(
-    and19(eq37(phaseUsage.itemId, itemId2), eq37(phaseUsage.phaseIdx, phaseIdx))
+    and20(eq38(phaseUsage.itemId, itemId2), eq38(phaseUsage.phaseIdx, phaseIdx))
   );
   return row?.activeMs ?? 0;
 }
@@ -24249,13 +24437,13 @@ var SessionManager = class {
   }
   /* why: the status line relays token totals keyed by Claude's session id; join
    * it to the running backlog phase so the spend accumulates against that row. */
-  recordUsage(claudeSessionId, totalIn, totalOut, usedPct) {
+  recordUsage(claudeSessionId, transcriptPath, usedPct) {
     if (recordSessionUsage(
       this.sessions.values(),
       claudeSessionId,
-      totalIn,
-      totalOut,
-      usedPct
+      transcriptPath,
+      usedPct,
+      this.clients.currentWindows()
     ))
       this.notify();
   }
@@ -24279,12 +24467,12 @@ import * as net3 from "net";
 import { createInterface as createInterface9 } from "readline";
 
 // src/commands/sessions/shared/discoverSessions.ts
-import * as fs32 from "fs";
+import * as fs33 from "fs";
 import * as os from "os";
 import * as path52 from "path";
 
 // src/commands/sessions/shared/parseSessionFile.ts
-import * as fs31 from "fs";
+import * as fs32 from "fs";
 import * as path51 from "path";
 
 // src/commands/sessions/shared/deriveHistoryFields.ts
@@ -24315,8 +24503,8 @@ function deriveSessionType(commandName, name) {
 }
 
 // src/commands/sessions/shared/backlogRunMarkers.ts
-function backlogRunMarkers(text9) {
-  const match = text9.match(/backlog item a(\d+):[ \t]*([^\n]*)/);
+function backlogRunMarkers(text10) {
+  const match = text10.match(/backlog item a(\d+):[ \t]*([^\n]*)/);
   if (!match) return { commandName: "", commandArgs: "" };
   const title = match[2].trim();
   return {
@@ -24370,11 +24558,11 @@ function messageText(entry) {
   const content = msg?.content;
   return typeof content === "string" ? content : Array.isArray(content) ? content.find((c) => c.type === "text")?.text ?? "" : "";
 }
-function stripMarkers(text9) {
-  return text9.replace(/<command-[^>]*>[^<]*<\/command-[^>]*>/g, "").trim().slice(0, 80);
+function stripMarkers(text10) {
+  return text10.replace(/<command-[^>]*>[^<]*<\/command-[^>]*>/g, "").trim().slice(0, 80);
 }
-function matchMarker(text9, tag) {
-  const match = text9.match(new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`));
+function matchMarker(text10, tag) {
+  const match = text10.match(new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`));
   return match ? match[1].trim() : "";
 }
 
@@ -24382,10 +24570,10 @@ function matchMarker(text9, tag) {
 async function parseSessionFile(filePath, origin = "wsl") {
   let handle;
   try {
-    handle = await fs31.promises.open(filePath, "r");
+    handle = await fs32.promises.open(filePath, "r");
     const meta = extractSessionMeta(await readHeadLines(handle));
     if (!meta.sessionId) return null;
-    const timestamp5 = meta.timestamp || (await fs31.promises.stat(filePath)).mtime.toISOString();
+    const timestamp5 = meta.timestamp || (await fs32.promises.stat(filePath)).mtime.toISOString();
     return {
       sessionId: meta.sessionId,
       name: meta.name || `Session ${meta.sessionId.slice(0, 8)}`,
@@ -24431,7 +24619,7 @@ async function discoverSessionJsonlPaths() {
     sessionRoots().map(async ({ dir, origin }) => {
       let projectDirs;
       try {
-        projectDirs = await fs32.promises.readdir(dir);
+        projectDirs = await fs33.promises.readdir(dir);
       } catch {
         return;
       }
@@ -24440,7 +24628,7 @@ async function discoverSessionJsonlPaths() {
           const dirPath = path52.join(dir, dirName);
           let entries;
           try {
-            entries = await fs32.promises.readdir(dirPath);
+            entries = await fs33.promises.readdir(dirPath);
           } catch {
             return;
           }
@@ -24473,7 +24661,7 @@ async function discoverSessions() {
 }
 
 // src/commands/sessions/shared/parseTranscript.ts
-import * as fs33 from "fs";
+import * as fs34 from "fs";
 
 // src/commands/sessions/shared/toolTarget.ts
 function toolTarget(input) {
@@ -24492,17 +24680,17 @@ function entryMessages(entry) {
   return [];
 }
 function userMessages(content) {
-  if (typeof content === "string") return text8("user", cleanUserText(content));
+  if (typeof content === "string") return text9("user", cleanUserText(content));
   if (!Array.isArray(content)) return [];
-  return content.filter((c) => c.type === "text").flatMap((c) => text8("user", cleanUserText(c.text ?? "")));
+  return content.filter((c) => c.type === "text").flatMap((c) => text9("user", cleanUserText(c.text ?? "")));
 }
 function assistantMessages(content) {
-  if (typeof content === "string") return text8("assistant", content.trim());
+  if (typeof content === "string") return text9("assistant", content.trim());
   if (!Array.isArray(content)) return [];
   return content.flatMap((c) => assistantItem(c));
 }
 function assistantItem(c) {
-  if (c.type === "text") return text8("assistant", (c.text ?? "").trim());
+  if (c.type === "text") return text9("assistant", (c.text ?? "").trim());
   if (c.type === "tool_use")
     return [
       {
@@ -24513,7 +24701,7 @@ function assistantItem(c) {
     ];
   return [];
 }
-function text8(role, value) {
+function text9(role, value) {
   return value ? [{ role, text: value }] : [];
 }
 function cleanUserText(value) {
@@ -24540,7 +24728,7 @@ async function parseTranscript(sessionId) {
   const filePath = await findSessionJsonlPath(sessionId);
   if (!filePath) return [];
   try {
-    const raw = await fs33.promises.readFile(filePath, "utf8");
+    const raw = await fs34.promises.readFile(filePath, "utf8");
     return parseTranscriptLines(raw.split("\n"));
   } catch {
     return [];
@@ -24638,8 +24826,7 @@ var messageHandlers = {
   limits: (_client, m, d) => m.clients.updateLimits(d.rateLimits),
   usage: (_client, m, d) => m.recordUsage(
     d.claudeSessionId,
-    d.totalIn,
-    d.totalOut,
+    d.transcriptPath,
     d.usedPct
   ),
   input: routed(
@@ -24850,17 +25037,17 @@ function registerDaemon(program2) {
 }
 
 // src/commands/sessions/summarise/index.ts
-import * as fs36 from "fs";
+import * as fs37 from "fs";
 import chalk193 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
-import * as fs34 from "fs";
+import * as fs35 from "fs";
 function writeSummary(jsonlPath2, summary) {
-  fs34.writeFileSync(summaryPathFor(jsonlPath2), `${summary.trim()}
+  fs35.writeFileSync(summaryPathFor(jsonlPath2), `${summary.trim()}
 `, "utf8");
 }
 function hasSummary(jsonlPath2) {
-  return fs34.existsSync(summaryPathFor(jsonlPath2));
+  return fs35.existsSync(summaryPathFor(jsonlPath2));
 }
 function summaryPathFor(jsonlPath2) {
   return jsonlPath2.replace(/\.jsonl$/, ".summary");
@@ -24870,7 +25057,7 @@ function summaryPathFor(jsonlPath2) {
 import { execFileSync as execFileSync10 } from "child_process";
 
 // src/commands/sessions/summarise/iterateUserMessages.ts
-import * as fs35 from "fs";
+import * as fs36 from "fs";
 
 // src/commands/sessions/summarise/parseUserLine.ts
 function parseUserLine(line) {
@@ -24883,16 +25070,16 @@ function parseUserLine(line) {
   if (entry.type !== "user") return void 0;
   const msg = entry.message;
   const c = msg?.content;
-  let text9;
+  let text10;
   if (typeof c === "string") {
-    text9 = c;
+    text10 = c;
   } else if (Array.isArray(c)) {
     const collected = c.filter((b) => b.type === "text").map((b) => b.text ?? "").join("\n");
-    text9 = collected || void 0;
+    text10 = collected || void 0;
   }
-  if (!text9) return void 0;
+  if (!text10) return void 0;
   return {
-    text: text9,
+    text: text10,
     entrypoint: typeof entry.entrypoint === "string" ? entry.entrypoint : void 0
   };
 }
@@ -24901,13 +25088,13 @@ function parseUserLine(line) {
 function* iterateUserMessages(filePath, maxBytes = 65536) {
   let content;
   try {
-    const fd = fs35.openSync(filePath, "r");
+    const fd = fs36.openSync(filePath, "r");
     try {
       const buf = Buffer.alloc(maxBytes);
-      const bytesRead = fs35.readSync(fd, buf, 0, buf.length, 0);
+      const bytesRead = fs36.readSync(fd, buf, 0, buf.length, 0);
       content = buf.toString("utf8", 0, bytesRead);
     } finally {
-      fs35.closeSync(fd);
+      fs36.closeSync(fd);
     }
   } catch {
     return;
@@ -24921,13 +25108,13 @@ function* iterateUserMessages(filePath, maxBytes = 65536) {
 
 // src/commands/sessions/summarise/extractFirstUserMessage.ts
 function extractFirstUserMessage(filePath) {
-  for (const text9 of iterateUserMessages(filePath)) {
-    return truncate3(text9);
+  for (const text10 of iterateUserMessages(filePath)) {
+    return truncate3(text10);
   }
   return void 0;
 }
-function truncate3(text9, maxChars = 500) {
-  const trimmed = text9.trim();
+function truncate3(text10, maxChars = 500) {
+  const trimmed = text10.trim();
   if (trimmed.length <= maxChars) return trimmed;
   return `${trimmed.slice(0, maxChars)}\u2026`;
 }
@@ -24935,28 +25122,28 @@ function truncate3(text9, maxChars = 500) {
 // src/commands/sessions/summarise/scanSessionBacklogRefs.ts
 function scanSessionBacklogRefs(filePath) {
   const ids = /* @__PURE__ */ new Set();
-  for (const text9 of iterateUserMessages(filePath, Number.MAX_SAFE_INTEGER)) {
-    for (const id of extractBacklogIds(text9)) {
+  for (const text10 of iterateUserMessages(filePath, Number.MAX_SAFE_INTEGER)) {
+    for (const id of extractBacklogIds(text10)) {
       ids.add(id);
     }
   }
   return [...ids].sort((a, b) => a - b);
 }
-function extractBacklogIds(text9) {
+function extractBacklogIds(text10) {
   const ids = [];
-  for (const m of text9.matchAll(/backlog\s+run\s+a(\d+)/gi)) {
+  for (const m of text10.matchAll(/backlog\s+run\s+a(\d+)/gi)) {
     ids.push(Number.parseInt(m[1], 10));
   }
-  for (const m of text9.matchAll(/backlog\s+(?:item\s+)?a(\d+)/gi)) {
+  for (const m of text10.matchAll(/backlog\s+(?:item\s+)?a(\d+)/gi)) {
     ids.push(Number.parseInt(m[1], 10));
   }
-  for (const m of text9.matchAll(/backlog\s+phase-done\s+a(\d+)/gi)) {
+  for (const m of text10.matchAll(/backlog\s+phase-done\s+a(\d+)/gi)) {
     ids.push(Number.parseInt(m[1], 10));
   }
-  for (const m of text9.matchAll(/backlog\s+comment\s+a(\d+)/gi)) {
+  for (const m of text10.matchAll(/backlog\s+comment\s+a(\d+)/gi)) {
     ids.push(Number.parseInt(m[1], 10));
   }
-  for (const m of text9.matchAll(/(?:^|[\s(])a(\d{1,4})(?=[\s).,;:!?]|$)/gm)) {
+  for (const m of text10.matchAll(/(?:^|[\s(])a(\d{1,4})(?=[\s).,;:!?]|$)/gm)) {
     ids.push(Number.parseInt(m[1], 10));
   }
   return ids;
@@ -25027,7 +25214,7 @@ function selectCandidates(files, options2) {
   const candidates = options2.force ? files : files.filter((f) => !hasSummary(f));
   candidates.sort((a, b) => {
     try {
-      return fs36.statSync(b).mtimeMs - fs36.statSync(a).mtimeMs;
+      return fs37.statSync(b).mtimeMs - fs37.statSync(a).mtimeMs;
     } catch {
       return 0;
     }
@@ -25207,14 +25394,13 @@ async function relayRateLimits(rateLimits) {
 }
 
 // src/commands/relayUsage.ts
-async function relayUsage(claudeSessionId, totalIn, totalOut, usedPct) {
+async function relayUsage(claudeSessionId, transcriptPath, usedPct) {
   if (!claudeSessionId) return;
   try {
     await sendToDaemon({
       type: "usage",
       claudeSessionId,
-      totalIn,
-      totalOut,
+      transcriptPath,
       usedPct
     });
   } catch {
@@ -25247,28 +25433,27 @@ async function statusLine() {
   await relayRateLimits(data.rate_limits);
   await relayUsage(
     data.session_id,
-    totalIn,
-    totalOut,
+    data.transcript_path,
     data.context_window.used_percentage
   );
 }
 
 // src/commands/sync.ts
-import * as fs39 from "fs";
+import * as fs40 from "fs";
 import * as os2 from "os";
 import * as path56 from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 
 // src/commands/sync/syncClaudeMd.ts
-import * as fs37 from "fs";
+import * as fs38 from "fs";
 import * as path54 from "path";
 import chalk196 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
   const source = path54.join(claudeDir, "CLAUDE.md");
   const target = path54.join(targetBase, "CLAUDE.md");
-  const sourceContent = fs37.readFileSync(source, "utf8");
-  if (fs37.existsSync(target)) {
-    const targetContent = fs37.readFileSync(target, "utf8");
+  const sourceContent = fs38.readFileSync(source, "utf8");
+  if (fs38.existsSync(target)) {
+    const targetContent = fs38.readFileSync(target, "utf8");
     if (sourceContent !== targetContent) {
       console.log(
         chalk196.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
@@ -25285,21 +25470,21 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs37.copyFileSync(source, target);
+  fs38.copyFileSync(source, target);
   console.log("Copied CLAUDE.md to ~/.claude/CLAUDE.md");
 }
 
 // src/commands/sync/syncSettings.ts
-import * as fs38 from "fs";
+import * as fs39 from "fs";
 import * as path55 from "path";
 import chalk197 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
   const source = path55.join(claudeDir, "settings.json");
   const target = path55.join(targetBase, "settings.json");
-  const sourceContent = fs38.readFileSync(source, "utf8");
+  const sourceContent = fs39.readFileSync(source, "utf8");
   const sourceSettings = JSON.parse(sourceContent);
-  const targetExists = fs38.existsSync(target);
-  const targetContent = targetExists ? fs38.readFileSync(target, "utf8") : "";
+  const targetExists = fs39.existsSync(target);
+  const targetContent = targetExists ? fs39.readFileSync(target, "utf8") : "";
   const preservedUserSettings = targetExists ? JSON.parse(targetContent) : {};
   const mergedContent = JSON.stringify(
     { ...preservedUserSettings, ...sourceSettings },
@@ -25328,7 +25513,7 @@ async function syncSettings(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs38.writeFileSync(target, mergedContent);
+  fs39.writeFileSync(target, mergedContent);
   console.log("Copied settings.json to ~/.claude/settings.json");
 }
 
@@ -25347,10 +25532,10 @@ async function sync(options2) {
 function syncCommands(claudeDir, targetBase) {
   const sourceDir = path56.join(claudeDir, "commands");
   const targetDir = path56.join(targetBase, "commands");
-  fs39.mkdirSync(targetDir, { recursive: true });
-  const files = fs39.readdirSync(sourceDir);
+  fs40.mkdirSync(targetDir, { recursive: true });
+  const files = fs40.readdirSync(sourceDir);
   for (const file of files) {
-    fs39.copyFileSync(path56.join(sourceDir, file), path56.join(targetDir, file));
+    fs40.copyFileSync(path56.join(sourceDir, file), path56.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);