@staff0rd/assist 0.386.0 → 0.387.1

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.386.0",
+  version: "0.387.1",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -422,13 +422,7 @@ function getTranscriptConfig() {
 }
 
 // src/shared/db/schema.ts
-import {
-  foreignKey,
-  integer as integer9,
-  pgTable as pgTable9,
-  primaryKey as primaryKey6,
-  text as text9
-} from "drizzle-orm/pg-core";
+import { integer as integer14, pgTable as pgTable14, text as text14 } from "drizzle-orm/pg-core";
 
 // src/shared/db/backups.ts
 import { bigint, integer, pgTable, text, timestamp } from "drizzle-orm/pg-core";
@@ -440,193 +434,236 @@ var backups = pgTable("backups", {
   durationMs: integer("duration_ms")
 });
 
-// src/shared/db/handovers.ts
-import { index, integer as integer2, pgTable as pgTable2, text as text2, timestamp as timestamp2 } from "drizzle-orm/pg-core";
-var handovers = pgTable2(
-  "handovers",
+// src/shared/db/comments.ts
+import { integer as integer3, pgTable as pgTable3, text as text3 } from "drizzle-orm/pg-core";
+
+// src/shared/db/items.ts
+import { boolean, index, integer as integer2, pgTable as pgTable2, text as text2 } from "drizzle-orm/pg-core";
+var items = pgTable2(
+  "items",
   {
     id: integer2().generatedByDefaultAsIdentity().primaryKey(),
     origin: text2().notNull(),
-    summary: text2().notNull(),
-    content: text2().notNull(),
+    type: text2().notNull().default("story"),
+    name: text2().notNull(),
+    description: text2(),
+    acceptanceCriteria: text2("acceptance_criteria").notNull().default("[]"),
+    status: text2().notNull().default("todo"),
+    currentPhase: integer2("current_phase"),
+    starred: boolean().notNull().default(false),
+    jiraKey: text2("jira_key")
+  },
+  (t) => [index("items_origin_idx").on(t.origin)]
+);
+
+// src/shared/db/comments.ts
+var comments = pgTable3("comments", {
+  id: integer3().generatedByDefaultAsIdentity().primaryKey(),
+  itemId: integer3("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+  idx: integer3().notNull(),
+  text: text3().notNull(),
+  phase: integer3(),
+  timestamp: text3().notNull(),
+  type: text3().notNull().default("comment")
+});
+
+// src/shared/db/handovers.ts
+import { index as index2, integer as integer4, pgTable as pgTable4, text as text4, timestamp as timestamp2 } from "drizzle-orm/pg-core";
+var handovers = pgTable4(
+  "handovers",
+  {
+    id: integer4().generatedByDefaultAsIdentity().primaryKey(),
+    origin: text4().notNull(),
+    summary: text4().notNull(),
+    content: text4().notNull(),
     createdAt: timestamp2("created_at", { withTimezone: true }).notNull().defaultNow(),
     recalledAt: timestamp2("recalled_at", { withTimezone: true })
   },
-  (t) => [index("handovers_origin_idx").on(t.origin)]
+  (t) => [index2("handovers_origin_idx").on(t.origin)]
 );
 
 // src/shared/db/itemGitRefs.ts
 import {
-  integer as integer4,
-  pgTable as pgTable4,
+  integer as integer5,
+  pgTable as pgTable5,
   primaryKey,
-  text as text4,
+  text as text5,
   timestamp as timestamp3
 } from "drizzle-orm/pg-core";
-
-// src/shared/db/items.ts
-import { boolean, index as index2, integer as integer3, pgTable as pgTable3, text as text3 } from "drizzle-orm/pg-core";
-var items = pgTable3(
-  "items",
-  {
-    id: integer3().generatedByDefaultAsIdentity().primaryKey(),
-    origin: text3().notNull(),
-    type: text3().notNull().default("story"),
-    name: text3().notNull(),
-    description: text3(),
-    acceptanceCriteria: text3("acceptance_criteria").notNull().default("[]"),
-    status: text3().notNull().default("todo"),
-    currentPhase: integer3("current_phase"),
-    starred: boolean().notNull().default(false),
-    jiraKey: text3("jira_key")
-  },
-  (t) => [index2("items_origin_idx").on(t.origin)]
-);
-
-// src/shared/db/itemGitRefs.ts
-var itemGitRefs = pgTable4(
+var itemGitRefs = pgTable5(
   "item_git_refs",
   {
-    itemId: integer4("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
-    kind: text4().notNull(),
-    ref: text4().notNull(),
-    title: text4(),
-    url: text4(),
-    state: text4(),
+    itemId: integer5("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+    kind: text5().notNull(),
+    ref: text5().notNull(),
+    title: text5(),
+    url: text5(),
+    state: text5(),
     createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow()
   },
   (t) => [primaryKey({ columns: [t.itemId, t.kind, t.ref] })]
 );
 
 // src/shared/db/itemSubtasks.ts
-import { integer as integer5, pgTable as pgTable5, primaryKey as primaryKey2, text as text5 } from "drizzle-orm/pg-core";
-var itemSubtasks = pgTable5(
+import { integer as integer6, pgTable as pgTable6, primaryKey as primaryKey2, text as text6 } from "drizzle-orm/pg-core";
+var itemSubtasks = pgTable6(
   "item_subtasks",
   {
-    itemId: integer5("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
-    idx: integer5().notNull(),
-    title: text5().notNull(),
-    description: text5(),
-    status: text5().notNull().default("todo")
+    itemId: integer6("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+    idx: integer6().notNull(),
+    title: text6().notNull(),
+    description: text6(),
+    status: text6().notNull().default("todo")
   },
   (t) => [primaryKey2({ columns: [t.itemId, t.idx] })]
 );
 
-// src/shared/db/phaseUsage.ts
-import {
-  bigint as bigint2,
-  doublePrecision,
-  integer as integer6,
-  pgTable as pgTable6,
-  primaryKey as primaryKey3,
-  text as text6
-} from "drizzle-orm/pg-core";
-var phaseUsage = pgTable6(
-  "phase_usage",
+// src/shared/db/links.ts
+import { integer as integer7, pgTable as pgTable7, primaryKey as primaryKey3, text as text7 } from "drizzle-orm/pg-core";
+var links = pgTable7(
+  "links",
   {
-    itemId: integer6("item_id").notNull(),
-    phaseIdx: integer6("phase_idx").notNull(),
-    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" }),
-    claudeSessionId: text6("claude_session_id")
+    itemId: integer7("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+    type: text7().notNull(),
+    targetId: integer7("target_id").notNull()
   },
-  (t) => [primaryKey3({ columns: [t.itemId, t.phaseIdx] })]
+  (t) => [primaryKey3({ columns: [t.itemId, t.type, t.targetId] })]
 );
 
-// src/shared/db/phaseUsageMessages.ts
-import { integer as integer7, pgTable as pgTable7, primaryKey as primaryKey4, text as text7 } from "drizzle-orm/pg-core";
-var phaseUsageMessages = pgTable7(
-  "phase_usage_messages",
+// src/shared/db/phaseCycleContext.ts
+import {
+  bigint as bigint2,
+  doublePrecision,
+  integer as integer8,
+  pgTable as pgTable8,
+  primaryKey as primaryKey4,
+  text as text8
+} from "drizzle-orm/pg-core";
+var phaseCycleContext = pgTable8(
+  "phase_cycle_context",
   {
-    itemId: integer7("item_id").notNull(),
-    phaseIdx: integer7("phase_idx").notNull(),
-    messageId: text7("message_id").notNull()
+    itemId: integer8("item_id").notNull(),
+    phaseIdx: integer8("phase_idx").notNull(),
+    window: text8().$type().notNull(),
+    resetsAt: bigint2("resets_at", { mode: "number" }).notNull(),
+    peakContextPct: doublePrecision("peak_context_pct").notNull().default(0)
   },
-  (t) => [primaryKey4({ columns: [t.itemId, t.phaseIdx, t.messageId] })]
+  (t) => [
+    primaryKey4({
+      columns: [t.itemId, t.phaseIdx, t.window, t.resetsAt]
+    })
+  ]
 );
 
-// src/shared/db/usagePeaks.ts
+// src/shared/db/phaseUsage.ts
 import {
   bigint as bigint3,
-  boolean as boolean2,
   doublePrecision as doublePrecision2,
-  integer as integer8,
-  pgTable as pgTable8,
+  integer as integer9,
+  pgTable as pgTable9,
   primaryKey as primaryKey5,
-  text as text8,
-  timestamp as timestamp4
+  text as text9
 } from "drizzle-orm/pg-core";
-var usagePeaks = pgTable8(
-  "usage_peaks",
+var phaseUsage = pgTable9(
+  "phase_usage",
   {
-    window: text8().$type().notNull(),
-    resetsAt: bigint3("resets_at", { mode: "number" }).notNull(),
-    segment: integer8().notNull().default(0),
-    usedPercentage: doublePrecision2("used_percentage").notNull(),
-    resetDetected: boolean2("reset_detected").notNull().default(false),
+    itemId: integer9("item_id").notNull(),
+    phaseIdx: integer9("phase_idx").notNull(),
     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()
+    activeMs: bigint3("active_ms", { mode: "number" }).notNull().default(0),
+    peakContextPct: doublePrecision2("peak_context_pct").notNull().default(0),
+    lastTotalIn: bigint3("last_total_in", { mode: "number" }),
+    lastTotalOut: bigint3("last_total_out", { mode: "number" }),
+    claudeSessionId: text9("claude_session_id")
   },
-  (t) => [primaryKey5({ columns: [t.window, t.resetsAt, t.segment] })]
+  (t) => [primaryKey5({ columns: [t.itemId, t.phaseIdx] })]
 );
 
-// src/shared/db/schema.ts
-var comments = pgTable9("comments", {
-  id: integer9().generatedByDefaultAsIdentity().primaryKey(),
-  itemId: integer9("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
-  idx: integer9().notNull(),
-  text: text9().notNull(),
-  phase: integer9(),
-  timestamp: text9().notNull(),
-  type: text9().notNull().default("comment")
-});
-var links = pgTable9(
-  "links",
+// src/shared/db/phaseUsageMessages.ts
+import { integer as integer10, pgTable as pgTable10, primaryKey as primaryKey6, text as text10 } from "drizzle-orm/pg-core";
+var phaseUsageMessages = pgTable10(
+  "phase_usage_messages",
   {
-    itemId: integer9("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
-    type: text9().notNull(),
-    targetId: integer9("target_id").notNull()
+    itemId: integer10("item_id").notNull(),
+    phaseIdx: integer10("phase_idx").notNull(),
+    messageId: text10("message_id").notNull()
   },
-  (t) => [primaryKey6({ columns: [t.itemId, t.type, t.targetId] })]
+  (t) => [primaryKey6({ columns: [t.itemId, t.phaseIdx, t.messageId] })]
 );
-var planPhases = pgTable9(
+
+// src/shared/db/planPhases.ts
+import { integer as integer11, pgTable as pgTable11, primaryKey as primaryKey7, text as text11 } from "drizzle-orm/pg-core";
+var planPhases = pgTable11(
   "plan_phases",
   {
-    itemId: integer9("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
-    idx: integer9().notNull(),
-    name: text9().notNull(),
-    manualChecks: text9("manual_checks")
+    itemId: integer11("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+    idx: integer11().notNull(),
+    name: text11().notNull(),
+    manualChecks: text11("manual_checks")
   },
-  (t) => [primaryKey6({ columns: [t.itemId, t.idx] })]
+  (t) => [primaryKey7({ columns: [t.itemId, t.idx] })]
 );
-var planTasks = pgTable9(
+
+// src/shared/db/planTasks.ts
+import {
+  foreignKey,
+  integer as integer12,
+  pgTable as pgTable12,
+  primaryKey as primaryKey8,
+  text as text12
+} from "drizzle-orm/pg-core";
+var planTasks = pgTable12(
   "plan_tasks",
   {
-    itemId: integer9("item_id").notNull(),
-    phaseIdx: integer9("phase_idx").notNull(),
-    idx: integer9().notNull(),
-    task: text9().notNull()
+    itemId: integer12("item_id").notNull(),
+    phaseIdx: integer12("phase_idx").notNull(),
+    idx: integer12().notNull(),
+    task: text12().notNull()
   },
   (t) => [
-    primaryKey6({ columns: [t.itemId, t.phaseIdx, t.idx] }),
+    primaryKey8({ columns: [t.itemId, t.phaseIdx, t.idx] }),
     foreignKey({
       columns: [t.itemId, t.phaseIdx],
       foreignColumns: [planPhases.itemId, planPhases.idx]
     }).onDelete("cascade")
   ]
 );
-var metadata = pgTable9("metadata", {
-  key: text9().primaryKey(),
-  value: text9().notNull()
+
+// src/shared/db/usagePeaks.ts
+import {
+  bigint as bigint4,
+  boolean as boolean2,
+  doublePrecision as doublePrecision3,
+  integer as integer13,
+  pgTable as pgTable13,
+  primaryKey as primaryKey9,
+  text as text13,
+  timestamp as timestamp4
+} from "drizzle-orm/pg-core";
+var usagePeaks = pgTable13(
+  "usage_peaks",
+  {
+    window: text13().$type().notNull(),
+    resetsAt: bigint4("resets_at", { mode: "number" }).notNull(),
+    segment: integer13().notNull().default(0),
+    usedPercentage: doublePrecision3("used_percentage").notNull(),
+    resetDetected: boolean2("reset_detected").notNull().default(false),
+    tokensUp: bigint4("tokens_up", { mode: "number" }).notNull().default(0),
+    tokensDown: bigint4("tokens_down", { mode: "number" }).notNull().default(0),
+    createdAt: timestamp4("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (t) => [primaryKey9({ columns: [t.window, t.resetsAt, t.segment] })]
+);
+
+// src/shared/db/schema.ts
+var metadata = pgTable14("metadata", {
+  key: text14().primaryKey(),
+  value: text14().notNull()
 });
-var feeds = pgTable9("feeds", {
-  id: integer9().generatedByDefaultAsIdentity().primaryKey(),
-  url: text9().notNull().unique()
+var feeds = pgTable14("feeds", {
+  id: integer14().generatedByDefaultAsIdentity().primaryKey(),
+  url: text14().notNull().unique()
 });
 var schema = {
   items,
@@ -642,7 +679,8 @@ var schema = {
   usagePeaks,
   backups,
   phaseUsage,
-  phaseUsageMessages
+  phaseUsageMessages,
+  phaseCycleContext
 };
 
 // src/commands/backlog/addFeed.ts
@@ -968,8 +1006,55 @@ var migration0001Baseline = {
   sql: sql2
 };
 
+// src/shared/db/migrations/migration0002UsagePeaksContext.ts
+var sql3 = `
+	ALTER TABLE usage_peaks ADD COLUMN IF NOT EXISTS context_pct_sum DOUBLE PRECISION NOT NULL DEFAULT 0;
+	ALTER TABLE usage_peaks ADD COLUMN IF NOT EXISTS context_readings BIGINT NOT NULL DEFAULT 0;
+`;
+var migration0002UsagePeaksContext = {
+  id: 2,
+  name: "usage-peaks-context",
+  sql: sql3
+};
+
+// src/shared/db/migrations/migration0003PhaseCycleContext.ts
+var sql4 = `
+	CREATE TABLE IF NOT EXISTS phase_cycle_context (
+		item_id INTEGER NOT NULL REFERENCES items(id) ON DELETE CASCADE,
+		phase_idx INTEGER NOT NULL,
+		"window" TEXT NOT NULL,
+		resets_at BIGINT NOT NULL,
+		peak_context_pct DOUBLE PRECISION NOT NULL DEFAULT 0,
+		PRIMARY KEY (item_id, phase_idx, "window", resets_at)
+	);
+`;
+var migration0003PhaseCycleContext = {
+  id: 3,
+  name: "phase-cycle-context",
+  sql: sql4
+};
+
+// src/shared/db/migrations/migration0004DropUsagePeaksContext.ts
+var sql5 = `
+	-- destructive-ok: the context_pct_sum/context_readings accumulator (added in
+	-- migration 2) was superseded by phase_cycle_context (migration 3); no build
+	-- reads these columns \u2014 they are unmapped in Drizzle and never selected.
+	ALTER TABLE usage_peaks DROP COLUMN IF EXISTS context_pct_sum;
+	ALTER TABLE usage_peaks DROP COLUMN IF EXISTS context_readings;
+`;
+var migration0004DropUsagePeaksContext = {
+  id: 4,
+  name: "drop-usage-peaks-context",
+  sql: sql5
+};
+
 // src/shared/db/migrations/index.ts
-var migrations = [migration0001Baseline];
+var migrations = [
+  migration0001Baseline,
+  migration0002UsagePeaksContext,
+  migration0003PhaseCycleContext,
+  migration0004DropUsagePeaksContext
+];
 var latestMigrationId = migrations.reduce(
   (max, m) => Math.max(max, m.id),
   0
@@ -1051,8 +1136,8 @@ async function assertMigrationsInSync(exec3) {
 // src/shared/db/migrations/MigrationExecutor.ts
 function pgExecutor(queryable) {
   return {
-    exec: (sql15) => queryable.query(sql15),
-    query: async (sql15, params) => (await queryable.query(sql15, params)).rows
+    exec: (sql20) => queryable.query(sql20),
+    query: async (sql20, params) => (await queryable.query(sql20, params)).rows
   };
 }
 
@@ -2776,8 +2861,8 @@ function isHashCommentFile(filePath) {
 import fs13 from "fs";
 
 // src/commands/verify/blockComments/collectHashComments.ts
-function blankNonNewline(text11) {
-  return text11.replace(/[^\n]/g, " ");
+function blankNonNewline(text16) {
+  return text16.replace(/[^\n]/g, " ");
 }
 function isHeaderLine(line) {
   const trimmed = line.trim();
@@ -2854,23 +2939,23 @@ var MACHINE_DIRECTIVES = [
   "@vitest-environment",
   MAINTAINABILITY_OVERRIDE_MARKER
 ];
-function isCommentExempt(text11) {
-  const lower = text11.toLowerCase();
+function isCommentExempt(text16) {
+  const lower = text16.toLowerCase();
   return MACHINE_DIRECTIVES.some((d) => lower.includes(d));
 }
 
 // src/commands/verify/blockComments/collectSourceFindings.ts
-function toSingleLine(text11) {
-  return text11.replace(/\s+/g, " ").trim();
+function toSingleLine(text16) {
+  return text16.replace(/\s+/g, " ").trim();
 }
 function collectSourceFindings(file, lines, project) {
   const findings = [];
   const sourceFile = project.addSourceFileAtPath(file);
-  for (const { pos, text: text11 } of collectComments(sourceFile)) {
+  for (const { pos, text: text16 } of collectComments(sourceFile)) {
     const { line } = sourceFile.getLineAndColumnAtPos(pos);
     if (!lines.has(line)) continue;
-    if (isCommentExempt(text11)) continue;
-    findings.push({ file, line, text: toSingleLine(text11) });
+    if (isCommentExempt(text16)) continue;
+    findings.push({ file, line, text: toSingleLine(text16) });
   }
   return findings;
 }
@@ -2890,10 +2975,10 @@ function collectYamlComments(content) {
 // src/commands/verify/blockComments/collectFileComments.ts
 function toFindings(file, lines, raw, exempt) {
   const findings = [];
-  for (const { line, text: text11 } of raw) {
+  for (const { line, text: text16 } of raw) {
     if (!lines.has(line)) continue;
-    if (exempt && isCommentExempt(text11)) continue;
-    findings.push({ file, line, text: text11.replace(/\s+/g, " ").trim() });
+    if (exempt && isCommentExempt(text16)) continue;
+    findings.push({ file, line, text: text16.replace(/\s+/g, " ").trim() });
   }
   return findings;
 }
@@ -2991,8 +3076,8 @@ function blockComments() {
     process.exit(0);
   }
   console.log("Comments on changed lines:\n");
-  for (const { file, line, text: text11 } of findings) {
-    console.log(`${file}:${line} \u2192 ${text11}`);
+  for (const { file, line, text: text16 } of findings) {
+    console.log(`${file}:${line} \u2192 ${text16}`);
   }
   console.log(`
 Total: ${findings.length} comment(s)`);
@@ -4450,8 +4535,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 sql15 = `COPY ${table.name} (${table.columns.join(", ")}) TO STDOUT`;
-  const stream = client.query(copyTo(sql15));
+  const sql20 = `COPY ${table.name} (${table.columns.join(", ")}) TO STDOUT`;
+  const stream = client.query(copyTo(sql20));
   const chunks = [];
   for await (const chunk of stream) {
     chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
@@ -4993,11 +5078,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(text11, task) {
+async function withSpinner(text16, task) {
   if (!process.stderr.isTTY) return task();
   let frame = 0;
   const render = () => {
-    process.stderr.write(`\r${SPINNER_FRAMES[frame]} ${text11}`);
+    process.stderr.write(`\r${SPINNER_FRAMES[frame]} ${text16}`);
   };
   render();
   const timer = setInterval(() => {
@@ -5682,13 +5767,13 @@ async function loadItem(orm, id) {
 }
 
 // src/commands/backlog/saveAllItems.ts
-import { eq as eq7, sql as sql3 } from "drizzle-orm";
+import { eq as eq7, sql as sql6 } from "drizzle-orm";
 
 // src/commands/backlog/deleteItemRelations.ts
 import { eq as eq6 } from "drizzle-orm";
 
 // src/commands/backlog/searchItemIds.ts
-import { and as and3, asc as asc4, eq as eq8, ilike, or, sql as sql4 } from "drizzle-orm";
+import { and as and3, asc as asc4, eq as eq8, ilike, or, sql as sql7 } from "drizzle-orm";
 async function searchItemIds(orm, query, origin) {
   const pattern2 = `%${query}%`;
   const numberPattern = `%${query.replace(/^#/, "")}%`;
@@ -5702,7 +5787,7 @@ async function searchItemIds(orm, query, origin) {
         ilike(items.jiraKey, pattern2),
         ilike(comments.text, pattern2),
         ilike(planPhases.name, pattern2),
-        ilike(sql4`${items.id}::text`, numberPattern)
+        ilike(sql7`${items.id}::text`, numberPattern)
       )
     )
   ).orderBy(asc4(items.id));
@@ -5825,12 +5910,12 @@ async function findPhaseBySessionId(db, itemId2, claudeSessionId) {
 }
 
 // src/commands/backlog/appendComment.ts
-import { sql as sql5 } from "drizzle-orm";
-async function appendComment(orm, itemId2, text11, opts = {}) {
+import { sql as sql8 } from "drizzle-orm";
+async function appendComment(orm, itemId2, text16, opts = {}) {
   await orm.insert(comments).values({
     itemId: itemId2,
-    idx: sql5`(SELECT COALESCE(MAX(${comments.idx}) + 1, 0) FROM ${comments} WHERE ${comments.itemId} = ${itemId2})`,
-    text: text11,
+    idx: sql8`(SELECT COALESCE(MAX(${comments.idx}) + 1, 0) FROM ${comments} WHERE ${comments.itemId} = ${itemId2})`,
+    text: text16,
     phase: opts.phase ?? null,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     type: opts.type ?? "comment"
@@ -6424,8 +6509,8 @@ function deriveSessionType(commandName, name) {
 }
 
 // src/commands/sessions/shared/backlogRunMarkers.ts
-function backlogRunMarkers(text11) {
-  const match = text11.match(/backlog item a(\d+):[ \t]*([^\n]*)/);
+function backlogRunMarkers(text16) {
+  const match = text16.match(/backlog item a(\d+):[ \t]*([^\n]*)/);
   if (!match) return { commandName: "", commandArgs: "" };
   const title = match[2].trim();
   return {
@@ -6479,11 +6564,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(text11) {
-  return text11.replace(/<command-[^>]*>[^<]*<\/command-[^>]*>/g, "").trim().slice(0, 80);
+function stripMarkers(text16) {
+  return text16.replace(/<command-[^>]*>[^<]*<\/command-[^>]*>/g, "").trim().slice(0, 80);
 }
-function matchMarker(text11, tag) {
-  const match = text11.match(new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`));
+function matchMarker(text16, tag) {
+  const match = text16.match(new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`));
   return match ? match[1].trim() : "";
 }
 
@@ -6938,7 +7023,7 @@ function formatComment(entry) {
 // src/shared/renderMarkdownTerminal.ts
 import { Marked } from "marked";
 import { markedTerminal } from "marked-terminal";
-function renderMarkdownTerminal(text11) {
+function renderMarkdownTerminal(text16) {
   const width = process.stdout.columns || 80;
   const marked = new Marked(markedTerminal({ width, reflowText: true }));
   marked.use({
@@ -6951,7 +7036,7 @@ function renderMarkdownTerminal(text11) {
       }
     }
   });
-  return marked.parse(text11).trimEnd();
+  return marked.parse(text16).trimEnd();
 }
 
 // src/commands/backlog/show/printActivity.ts
@@ -6971,9 +7056,9 @@ function groupActivityRefs(refs, commitLimit = ACTIVITY_COMMIT_LIMIT) {
 }
 
 // src/commands/backlog/show/printActivity.ts
-function printRef(label2, text11, ref) {
+function printRef(label2, text16, ref) {
   const url = ref.url ? ` ${chalk50.dim(ref.url)}` : "";
-  console.log(`  ${chalk50.cyan(label2)} ${text11}${url}`);
+  console.log(`  ${chalk50.cyan(label2)} ${text16}${url}`);
 }
 function printActivity(item) {
   const { branches, commits: commits2, prs: prs2, hiddenCommits } = groupActivityRefs(
@@ -7425,29 +7510,29 @@ import { eq as eq13 } from "drizzle-orm";
 import { asc as asc5, eq as eq12 } from "drizzle-orm";
 
 // src/commands/backlog/incompleteSubtaskCounts.ts
-import { ne, sql as sql6 } from "drizzle-orm";
+import { ne, sql as sql9 } from "drizzle-orm";
 function incompleteSubtaskCounts(orm) {
   return orm.select({
     itemId: itemSubtasks.itemId,
-    count: sql6`count(*)::int`.as("incomplete_subtasks")
+    count: sql9`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 sql7 } from "drizzle-orm";
+import { sql as sql10 } from "drizzle-orm";
 function phaseUsageTotals(orm) {
   return orm.select({
     itemId: phaseUsage.itemId,
-    tokensUp: sql7`sum(${phaseUsage.tokensUp})::bigint`.as(
+    tokensUp: sql10`sum(${phaseUsage.tokensUp})::bigint`.as(
       "total_tokens_up"
     ),
-    tokensDown: sql7`sum(${phaseUsage.tokensDown})::bigint`.as(
+    tokensDown: sql10`sum(${phaseUsage.tokensDown})::bigint`.as(
       "total_tokens_down"
     ),
-    activeMs: sql7`sum(${phaseUsage.activeMs})::bigint`.as(
+    activeMs: sql10`sum(${phaseUsage.activeMs})::bigint`.as(
       "total_active_ms"
     ),
-    peakContextPct: sql7`max(${phaseUsage.peakContextPct})`.as(
+    peakContextPct: sql10`max(${phaseUsage.peakContextPct})`.as(
       "max_peak_context_pct"
     )
   }).from(phaseUsage).groupBy(phaseUsage.itemId).as("usage_totals");
@@ -8119,9 +8204,9 @@ function excerpt(xml, ...tags) {
   for (const tag of tags) {
     const raw = extractText(xml, tag);
     if (!raw) continue;
-    const text11 = stripHtml(raw);
-    if (text11.length <= MAX_EXCERPT) return text11;
-    return `${text11.slice(0, MAX_EXCERPT)}\u2026`;
+    const text16 = stripHtml(raw);
+    if (text16.length <= MAX_EXCERPT) return text16;
+    return `${text16.slice(0, MAX_EXCERPT)}\u2026`;
   }
   return "";
 }
@@ -8199,9 +8284,25 @@ async function listNewsItems(_req, res) {
 }
 
 // src/shared/db/listUsagePeaks.ts
-import { count, desc as desc2 } from "drizzle-orm";
+import { and as and7, count, desc as desc2, eq as eq17, getTableColumns, sql as sql11 } from "drizzle-orm";
 async function listUsagePeaks(db, paging) {
-  const query = db.select().from(usagePeaks).orderBy(
+  const avgContext = db.select({
+    window: phaseCycleContext.window,
+    resetsAt: phaseCycleContext.resetsAt,
+    avgContextPct: sql11`cast(avg(${phaseCycleContext.peakContextPct}) as double precision)`.as(
+      "avg_context_pct"
+    )
+  }).from(phaseCycleContext).groupBy(phaseCycleContext.window, phaseCycleContext.resetsAt).as("avg_context");
+  const query = db.select({
+    ...getTableColumns(usagePeaks),
+    avgContextPct: avgContext.avgContextPct
+  }).from(usagePeaks).leftJoin(
+    avgContext,
+    and7(
+      eq17(usagePeaks.window, avgContext.window),
+      eq17(usagePeaks.resetsAt, avgContext.resetsAt)
+    )
+  ).orderBy(
     desc2(usagePeaks.resetsAt),
     usagePeaks.window,
     desc2(usagePeaks.createdAt),
@@ -8957,7 +9058,7 @@ function registerActivityCommands(cmd) {
 
 // src/commands/backlog/associate-jira/index.ts
 import chalk64 from "chalk";
-import { eq as eq17 } from "drizzle-orm";
+import { eq as eq18 } from "drizzle-orm";
 
 // src/commands/jira/fetchIssue.ts
 import { execSync as execSync29 } from "child_process";
@@ -8999,7 +9100,7 @@ async function associateJira(id, key, options2) {
   const { orm } = found;
   const itemId2 = found.item.id;
   if (options2.clear) {
-    await orm.update(items).set({ jiraKey: null }).where(eq17(items.id, itemId2));
+    await orm.update(items).set({ jiraKey: null }).where(eq18(items.id, itemId2));
     console.log(
       chalk64.green(`Cleared Jira association on item ${formatItemId(itemId2)}.`)
     );
@@ -9020,7 +9121,7 @@ async function associateJira(id, key, options2) {
   const parsed = fetchIssue(key, "summary");
   const fields = parsed?.fields;
   const summary = fields?.summary;
-  await orm.update(items).set({ jiraKey: key }).where(eq17(items.id, itemId2));
+  await orm.update(items).set({ jiraKey: key }).where(eq18(items.id, itemId2));
   console.log(
     chalk64.green(`Associated ${key} with item ${formatItemId(itemId2)}.`),
     summary ? chalk64.dim(`(${summary})`) : ""
@@ -9034,10 +9135,10 @@ function registerAssociateJiraCommand(cmd) {
 
 // src/commands/backlog/comment/index.ts
 import chalk65 from "chalk";
-async function comment(id, text11) {
+async function comment(id, text16) {
   const found = await findOneItem(id);
   if (!found) process.exit(1);
-  await appendComment(found.orm, found.item.id, text11);
+  await appendComment(found.orm, found.item.id, text16);
   console.log(
     chalk65.green(`Comment added to item ${formatItemId(found.item.id)}.`)
   );
@@ -9142,9 +9243,9 @@ function readLine(dump, start3) {
   return { text: dump.subarray(start3, eol).toString("utf8"), next: eol + 1 };
 }
 function parseHeader(dump) {
-  const { text: text11, next: next3 } = readLine(dump, 0);
+  const { text: text16, next: next3 } = readLine(dump, 0);
   try {
-    return { header: JSON.parse(text11), bodyStart: next3 };
+    return { header: JSON.parse(text16), bodyStart: next3 };
   } catch {
     return invalid("header is not valid JSON.");
   }
@@ -9153,9 +9254,9 @@ function parseSections(dump, bodyStart) {
   const sections = /* @__PURE__ */ new Map();
   let cursor = bodyStart;
   while (cursor < dump.length) {
-    const { text: text11, next: next3 } = readLine(dump, cursor);
-    const match = text11.match(/^@table (\S+) (\d+)$/);
-    if (!match) invalid(`malformed table marker "${text11}".`);
+    const { text: text16, next: next3 } = readLine(dump, cursor);
+    const match = text16.match(/^@table (\S+) (\d+)$/);
+    if (!match) invalid(`malformed table marker "${text16}".`);
     const [, name, bytes] = match;
     const end = next3 + Number(bytes);
     if (end > dump.length) invalid(`section "${name}" overruns the dump.`);
@@ -9231,8 +9332,8 @@ async function readStdinBuffer() {
 import { finished } from "stream/promises";
 import { from as copyFrom } from "pg-copy-streams";
 async function copyTableIn(client, table, data) {
-  const sql15 = `COPY ${table.name} (${table.columns.join(", ")}) FROM STDIN`;
-  const stream = client.query(copyFrom(sql15));
+  const sql20 = `COPY ${table.name} (${table.columns.join(", ")}) FROM STDIN`;
+  const stream = client.query(copyFrom(sql20));
   stream.end(data);
   await finished(stream);
 }
@@ -9277,8 +9378,8 @@ async function replaceData(client, parsed) {
     await copyTableIn(client, table, data);
   }
   for (const col of await introspectIdentityColumns(client)) {
-    const { text: text11, values } = resyncIdentitySql(col);
-    await client.query(text11, values);
+    const { text: text16, values } = resyncIdentitySql(col);
+    await client.query(text16, values);
   }
 }
 async function restore(client, parsed) {
@@ -9329,22 +9430,22 @@ function registerImportCommand(cmd) {
 import chalk71 from "chalk";
 
 // src/commands/backlog/insertPhaseAt.ts
-import { count as count2, eq as eq19 } from "drizzle-orm";
+import { count as count2, eq as eq20 } from "drizzle-orm";
 
 // src/commands/backlog/shiftPhasesUp.ts
-import { and as and7, desc as desc3, eq as eq18, gte } from "drizzle-orm";
+import { and as and8, desc as desc3, eq as eq19, gte } from "drizzle-orm";
 async function shiftPhasesUp(db, itemId2, fromIdx) {
-  const toShift = await db.select({ idx: planPhases.idx }).from(planPhases).where(and7(eq18(planPhases.itemId, itemId2), gte(planPhases.idx, fromIdx))).orderBy(desc3(planPhases.idx));
+  const toShift = await db.select({ idx: planPhases.idx }).from(planPhases).where(and8(eq19(planPhases.itemId, itemId2), gte(planPhases.idx, fromIdx))).orderBy(desc3(planPhases.idx));
   for (const p of toShift) {
-    await db.update(planTasks).set({ phaseIdx: p.idx + 1 }).where(and7(eq18(planTasks.itemId, itemId2), eq18(planTasks.phaseIdx, p.idx)));
-    await db.update(planPhases).set({ idx: p.idx + 1 }).where(and7(eq18(planPhases.itemId, itemId2), eq18(planPhases.idx, p.idx)));
+    await db.update(planTasks).set({ phaseIdx: p.idx + 1 }).where(and8(eq19(planTasks.itemId, itemId2), eq19(planTasks.phaseIdx, p.idx)));
+    await db.update(planPhases).set({ idx: p.idx + 1 }).where(and8(eq19(planPhases.itemId, itemId2), eq19(planPhases.idx, p.idx)));
   }
 }
 
 // src/commands/backlog/insertPhaseAt.ts
 async function insertPhaseAt(orm, itemId2, phaseIdx, name, tasks, manualChecks, currentPhase) {
   await orm.transaction(async (tx) => {
-    const [row] = await tx.select({ cnt: count2() }).from(planPhases).where(eq19(planPhases.itemId, itemId2));
+    const [row] = await tx.select({ cnt: count2() }).from(planPhases).where(eq20(planPhases.itemId, itemId2));
     const phaseCount = row?.cnt ?? 0;
     await shiftPhasesUp(tx, itemId2, phaseIdx);
     await tx.insert(planPhases).values({ itemId: itemId2, idx: phaseIdx, name, manualChecks });
@@ -9353,17 +9454,17 @@ async function insertPhaseAt(orm, itemId2, phaseIdx, name, tasks, manualChecks,
     }
     if (currentPhase !== void 0 && currentPhase - 1 >= phaseIdx) {
       const atReviewSlot = currentPhase - 1 >= phaseCount;
-      await tx.update(items).set({ currentPhase: atReviewSlot ? phaseIdx + 1 : currentPhase + 1 }).where(eq19(items.id, itemId2));
+      await tx.update(items).set({ currentPhase: atReviewSlot ? phaseIdx + 1 : currentPhase + 1 }).where(eq20(items.id, itemId2));
     }
   });
 }
 
 // src/commands/backlog/insertSubtask.ts
-import { sql as sql8 } from "drizzle-orm";
+import { sql as sql12 } from "drizzle-orm";
 async function insertSubtask(orm, itemId2, title, description) {
   await orm.insert(itemSubtasks).values({
     itemId: itemId2,
-    idx: sql8`(SELECT COALESCE(MAX(${itemSubtasks.idx}) + 1, 0) FROM ${itemSubtasks} WHERE ${itemSubtasks.itemId} = ${itemId2})`,
+    idx: sql12`(SELECT COALESCE(MAX(${itemSubtasks.idx}) + 1, 0) FROM ${itemSubtasks} WHERE ${itemSubtasks.itemId} = ${itemId2})`,
     title,
     description: description ?? null,
     status: "todo"
@@ -9487,9 +9588,9 @@ import chalk73 from "chalk";
 
 // src/commands/backlog/resolveInsertPosition.ts
 import chalk72 from "chalk";
-import { count as count3, eq as eq20 } from "drizzle-orm";
+import { count as count3, eq as eq21 } from "drizzle-orm";
 async function resolveInsertPosition(orm, itemId2, position) {
-  const [row] = await orm.select({ cnt: count3() }).from(planPhases).where(eq20(planPhases.itemId, itemId2));
+  const [row] = await orm.select({ cnt: count3() }).from(planPhases).where(eq21(planPhases.itemId, itemId2));
   const phaseCount = row?.cnt ?? 0;
   if (position === void 0) return phaseCount;
   const pos = Number.parseInt(position, 10);
@@ -9617,9 +9718,9 @@ function hasCycle(adjacency, fromId, toId) {
 }
 
 // src/commands/backlog/loadDependencyGraph.ts
-import { eq as eq21 } from "drizzle-orm";
+import { eq as eq22 } from "drizzle-orm";
 async function loadDependencyGraph(orm) {
-  const rows = await orm.select({ itemId: links.itemId, targetId: links.targetId }).from(links).where(eq21(links.type, "depends-on"));
+  const rows = await orm.select({ itemId: links.itemId, targetId: links.targetId }).from(links).where(eq22(links.type, "depends-on"));
   const graph = /* @__PURE__ */ new Map();
   for (const { itemId: itemId2, targetId } of rows) {
     const bucket = graph.get(itemId2);
@@ -9686,7 +9787,7 @@ async function link(fromId, toId, opts) {
 
 // src/commands/backlog/unlink.ts
 import chalk77 from "chalk";
-import { and as and8, eq as eq22 } from "drizzle-orm";
+import { and as and9, eq as eq23 } from "drizzle-orm";
 async function unlink(fromId, toId) {
   const fromNum = parseItemId(fromId);
   const toNum = parseItemId(toId);
@@ -9710,7 +9811,7 @@ async function unlink(fromId, toId) {
     );
     return;
   }
-  await orm.delete(links).where(and8(eq22(links.itemId, fromNum), eq22(links.targetId, toNum)));
+  await orm.delete(links).where(and9(eq23(links.itemId, fromNum), eq23(links.targetId, toNum)));
   console.log(
     chalk77.green(
       `Removed link from ${formatItemId(fromNum)} to ${formatItemId(toNum)}.`
@@ -9730,7 +9831,7 @@ function registerLinkCommands(cmd) {
 
 // src/commands/backlog/move-repo/index.ts
 import chalk79 from "chalk";
-import { eq as eq24 } from "drizzle-orm";
+import { eq as eq25 } from "drizzle-orm";
 
 // src/commands/backlog/move-repo/confirmMove.ts
 import chalk78 from "chalk";
@@ -9745,9 +9846,9 @@ async function confirmMove(cnt, oldOrigin, newOrigin) {
 }
 
 // src/commands/backlog/move-repo/countByOrigin.ts
-import { count as count4, eq as eq23 } from "drizzle-orm";
+import { count as count4, eq as eq24 } from "drizzle-orm";
 async function countByOrigin(orm, origin) {
-  const [{ cnt }] = await orm.select({ cnt: count4() }).from(items).where(eq23(items.origin, origin));
+  const [{ cnt }] = await orm.select({ cnt: count4() }).from(items).where(eq24(items.origin, origin));
   return cnt;
 }
 
@@ -9790,7 +9891,7 @@ async function moveRepo(oldOriginRaw, newOriginRaw, options2 = {}) {
     console.log(chalk79.yellow("Move cancelled; no changes made."));
     return;
   }
-  await orm.update(items).set({ origin: newOrigin }).where(eq24(items.origin, oldOrigin));
+  await orm.update(items).set({ origin: newOrigin }).where(eq25(items.origin, oldOrigin));
   console.log(
     chalk79.green(
       `Moved ${pluralItems(cnt)} from "${oldOrigin}" to "${newOrigin}".`
@@ -10155,10 +10256,10 @@ async function start(id) {
 
 // src/commands/backlog/stop/index.ts
 import chalk91 from "chalk";
-import { and as and9, eq as eq25 } from "drizzle-orm";
+import { and as and10, eq as eq26 } from "drizzle-orm";
 async function stop() {
   const { orm } = await getReady();
-  const stopped = await orm.update(items).set({ status: "todo", currentPhase: 1 }).where(and9(eq25(items.status, "in-progress"), eq25(items.origin, getOrigin()))).returning({ id: items.id, name: items.name });
+  const stopped = await orm.update(items).set({ status: "todo", currentPhase: 1 }).where(and10(eq26(items.status, "in-progress"), eq26(items.origin, getOrigin()))).returning({ id: items.id, name: items.name });
   if (stopped.length === 0) {
     console.log(chalk91.yellow("No in-progress items to stop."));
     return;
@@ -10275,13 +10376,13 @@ async function findSubtask(id, index3) {
 }
 
 // src/commands/backlog/updateSubtask.ts
-import { and as and10, eq as eq26 } from "drizzle-orm";
+import { and as and11, eq as eq27 } from "drizzle-orm";
 async function updateSubtask(orm, itemId2, idx, fields) {
   const set = {};
   if (fields.title !== void 0) set.title = fields.title;
   if (fields.description !== void 0) set.description = fields.description;
   if (fields.status !== void 0) set.status = fields.status;
-  const [row] = await orm.update(itemSubtasks).set(set).where(and10(eq26(itemSubtasks.itemId, itemId2), eq26(itemSubtasks.idx, idx))).returning({ title: itemSubtasks.title });
+  const [row] = await orm.update(itemSubtasks).set(set).where(and11(eq27(itemSubtasks.itemId, itemId2), eq27(itemSubtasks.idx, idx))).returning({ title: itemSubtasks.title });
   return row?.title;
 }
 
@@ -10336,16 +10437,16 @@ async function editSubtask(id, index3, options2) {
 import chalk97 from "chalk";
 
 // src/commands/backlog/deleteSubtask.ts
-import { and as and11, asc as asc6, eq as eq27 } from "drizzle-orm";
+import { and as and12, asc as asc6, eq as eq28 } from "drizzle-orm";
 async function deleteSubtask(orm, itemId2, idx) {
-  const [row] = await orm.delete(itemSubtasks).where(and11(eq27(itemSubtasks.itemId, itemId2), eq27(itemSubtasks.idx, idx))).returning({ title: itemSubtasks.title });
+  const [row] = await orm.delete(itemSubtasks).where(and12(eq28(itemSubtasks.itemId, itemId2), eq28(itemSubtasks.idx, idx))).returning({ title: itemSubtasks.title });
   if (!row) return void 0;
-  const remaining = await orm.select({ idx: itemSubtasks.idx }).from(itemSubtasks).where(eq27(itemSubtasks.itemId, itemId2)).orderBy(asc6(itemSubtasks.idx));
+  const remaining = await orm.select({ idx: itemSubtasks.idx }).from(itemSubtasks).where(eq28(itemSubtasks.itemId, itemId2)).orderBy(asc6(itemSubtasks.idx));
   for (let i = 0; i < remaining.length; i++) {
     const oldIdx = remaining[i].idx;
     if (oldIdx === i) continue;
     await orm.update(itemSubtasks).set({ idx: i }).where(
-      and11(eq27(itemSubtasks.itemId, itemId2), eq27(itemSubtasks.idx, oldIdx))
+      and12(eq28(itemSubtasks.itemId, itemId2), eq28(itemSubtasks.idx, oldIdx))
     );
   }
   return row.title;
@@ -10414,20 +10515,20 @@ function registerSubtaskCommands(cmd) {
 
 // src/commands/backlog/movePhase.ts
 import chalk99 from "chalk";
-import { count as count6, eq as eq30 } from "drizzle-orm";
+import { count as count6, eq as eq31 } from "drizzle-orm";
 
 // src/commands/backlog/reorderPhaseRows.ts
-import { and as and13, asc as asc8, eq as eq29 } from "drizzle-orm";
+import { and as and14, asc as asc8, eq as eq30 } from "drizzle-orm";
 
 // src/commands/backlog/reindexPhases.ts
-import { and as and12, asc as asc7, count as count5, eq as eq28 } from "drizzle-orm";
+import { and as and13, asc as asc7, count as count5, eq as eq29 } from "drizzle-orm";
 async function reindexPhases(db, itemId2) {
-  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq28(planPhases.itemId, itemId2)).orderBy(asc7(planPhases.idx));
+  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq29(planPhases.itemId, itemId2)).orderBy(asc7(planPhases.idx));
   for (let i = 0; i < remaining.length; i++) {
     const oldIdx = remaining[i].idx;
     if (oldIdx === i) continue;
-    await db.update(planTasks).set({ phaseIdx: i }).where(and12(eq28(planTasks.itemId, itemId2), eq28(planTasks.phaseIdx, oldIdx)));
-    await db.update(planPhases).set({ idx: i }).where(and12(eq28(planPhases.itemId, itemId2), eq28(planPhases.idx, oldIdx)));
+    await db.update(planTasks).set({ phaseIdx: i }).where(and13(eq29(planTasks.itemId, itemId2), eq29(planTasks.phaseIdx, oldIdx)));
+    await db.update(planPhases).set({ idx: i }).where(and13(eq29(planPhases.itemId, itemId2), eq29(planPhases.idx, oldIdx)));
   }
 }
 async function adjustCurrentPhase(db, item, removedIdx) {
@@ -10435,24 +10536,24 @@ async function adjustCurrentPhase(db, item, removedIdx) {
   if (currentPhase === void 0) return;
   const currentIdx = currentPhase - 1;
   if (removedIdx < currentIdx) {
-    await db.update(items).set({ currentPhase: currentPhase - 1 }).where(eq28(items.id, item.id));
+    await db.update(items).set({ currentPhase: currentPhase - 1 }).where(eq29(items.id, item.id));
     return;
   }
   if (removedIdx !== currentIdx) return;
-  const [row] = await db.select({ cnt: count5() }).from(planPhases).where(eq28(planPhases.itemId, item.id));
+  const [row] = await db.select({ cnt: count5() }).from(planPhases).where(eq29(planPhases.itemId, item.id));
   const cnt = row?.cnt ?? 0;
-  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq28(items.id, item.id));
+  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq29(items.id, item.id));
 }
 
 // src/commands/backlog/reorderPhaseRows.ts
 async function reorderPhaseRows(orm, itemId2, fromIdx, toIdx) {
   await orm.transaction(async (tx) => {
-    const [phaseRow] = await tx.select({ name: planPhases.name, manualChecks: planPhases.manualChecks }).from(planPhases).where(and13(eq29(planPhases.itemId, itemId2), eq29(planPhases.idx, fromIdx)));
-    const tasks = await tx.select({ idx: planTasks.idx, task: planTasks.task }).from(planTasks).where(and13(eq29(planTasks.itemId, itemId2), eq29(planTasks.phaseIdx, fromIdx))).orderBy(asc8(planTasks.idx));
+    const [phaseRow] = await tx.select({ name: planPhases.name, manualChecks: planPhases.manualChecks }).from(planPhases).where(and14(eq30(planPhases.itemId, itemId2), eq30(planPhases.idx, fromIdx)));
+    const tasks = await tx.select({ idx: planTasks.idx, task: planTasks.task }).from(planTasks).where(and14(eq30(planTasks.itemId, itemId2), eq30(planTasks.phaseIdx, fromIdx))).orderBy(asc8(planTasks.idx));
     await tx.delete(planTasks).where(
-      and13(eq29(planTasks.itemId, itemId2), eq29(planTasks.phaseIdx, fromIdx))
+      and14(eq30(planTasks.itemId, itemId2), eq30(planTasks.phaseIdx, fromIdx))
     );
-    await tx.delete(planPhases).where(and13(eq29(planPhases.itemId, itemId2), eq29(planPhases.idx, fromIdx)));
+    await tx.delete(planPhases).where(and14(eq30(planPhases.itemId, itemId2), eq30(planPhases.idx, fromIdx)));
     await reindexPhases(tx, itemId2);
     await shiftPhasesUp(tx, itemId2, toIdx);
     await tx.insert(planPhases).values({
@@ -10493,7 +10594,7 @@ async function movePhase(id, from, to) {
   if (!found) return;
   const { orm, item } = found;
   const itemId2 = item.id;
-  const [row] = await orm.select({ cnt: count6() }).from(planPhases).where(eq30(planPhases.itemId, itemId2));
+  const [row] = await orm.select({ cnt: count6() }).from(planPhases).where(eq31(planPhases.itemId, itemId2));
   const phaseCount = row?.cnt ?? 0;
   const fromIdx = toIndex(from, phaseCount);
   if (fromIdx === void 0) return;
@@ -10509,22 +10610,22 @@ async function movePhase(id, from, to) {
 import chalk101 from "chalk";
 
 // src/commands/backlog/applyPhaseUpdate.ts
-import { and as and14, eq as eq31 } from "drizzle-orm";
+import { and as and15, eq as eq32 } from "drizzle-orm";
 async function applyPhaseUpdate(orm, itemId2, phaseIdx, fields) {
   await orm.transaction(async (tx) => {
     if (fields.name) {
       await tx.update(planPhases).set({ name: fields.name }).where(
-        and14(eq31(planPhases.itemId, itemId2), eq31(planPhases.idx, phaseIdx))
+        and15(eq32(planPhases.itemId, itemId2), eq32(planPhases.idx, phaseIdx))
       );
     }
     if (fields.manualCheck) {
       await tx.update(planPhases).set({ manualChecks: JSON.stringify(fields.manualCheck) }).where(
-        and14(eq31(planPhases.itemId, itemId2), eq31(planPhases.idx, phaseIdx))
+        and15(eq32(planPhases.itemId, itemId2), eq32(planPhases.idx, phaseIdx))
       );
     }
     if (fields.task) {
       await tx.delete(planTasks).where(
-        and14(eq31(planTasks.itemId, itemId2), eq31(planTasks.phaseIdx, phaseIdx))
+        and15(eq32(planTasks.itemId, itemId2), eq32(planTasks.phaseIdx, phaseIdx))
       );
       if (fields.task.length) {
         await tx.insert(planTasks).values(
@@ -10542,14 +10643,14 @@ async function applyPhaseUpdate(orm, itemId2, phaseIdx, fields) {
 
 // src/commands/backlog/findPhase.ts
 import chalk100 from "chalk";
-import { and as and15, count as count7, eq as eq32 } from "drizzle-orm";
+import { and as and16, count as count7, eq as eq33 } from "drizzle-orm";
 async function findPhase(id, phase) {
   const found = await findOneItem(id);
   if (!found) return void 0;
   const { orm, item } = found;
   const itemId2 = item.id;
   const phaseIdx = Number.parseInt(phase, 10) - 1;
-  const [row] = await orm.select({ cnt: count7() }).from(planPhases).where(and15(eq32(planPhases.itemId, itemId2), eq32(planPhases.idx, phaseIdx)));
+  const [row] = await orm.select({ cnt: count7() }).from(planPhases).where(and16(eq33(planPhases.itemId, itemId2), eq33(planPhases.idx, phaseIdx)));
   if (!row || row.cnt === 0) {
     console.log(
       chalk100.red(
@@ -10722,16 +10823,16 @@ function registerUpdatePhaseCommand(cmd) {
 
 // src/commands/backlog/removePhase.ts
 import chalk102 from "chalk";
-import { and as and16, eq as eq33 } from "drizzle-orm";
+import { and as and17, eq as eq34 } from "drizzle-orm";
 async function removePhase(id, phase) {
   const found = await findPhase(id, phase);
   if (!found) return;
   const { item, orm, itemId: itemId2, phaseIdx } = found;
   await orm.transaction(async (tx) => {
     await tx.delete(planTasks).where(
-      and16(eq33(planTasks.itemId, itemId2), eq33(planTasks.phaseIdx, phaseIdx))
+      and17(eq34(planTasks.itemId, itemId2), eq34(planTasks.phaseIdx, phaseIdx))
     );
-    await tx.delete(planPhases).where(and16(eq33(planPhases.itemId, itemId2), eq33(planPhases.idx, phaseIdx)));
+    await tx.delete(planPhases).where(and17(eq34(planPhases.itemId, itemId2), eq34(planPhases.idx, phaseIdx)));
     await reindexPhases(tx, itemId2);
     await adjustCurrentPhase(tx, item, phaseIdx);
   });
@@ -10744,7 +10845,7 @@ async function removePhase(id, phase) {
 
 // src/commands/backlog/update/index.ts
 import chalk104 from "chalk";
-import { eq as eq34 } from "drizzle-orm";
+import { eq as eq35 } from "drizzle-orm";
 
 // src/commands/backlog/update/applyAcMutations.ts
 function hasAcMutations(options2) {
@@ -10824,7 +10925,7 @@ async function update(id, options2) {
   if (!built) return;
   const { orm } = found;
   const itemId2 = found.item.id;
-  await orm.update(items).set(built.set).where(eq34(items.id, itemId2));
+  await orm.update(items).set(built.set).where(eq35(items.id, itemId2));
   console.log(
     chalk104.green(`Updated ${built.fields} on item ${formatItemId(itemId2)}.`)
   );
@@ -11125,8 +11226,8 @@ var RAW_BUILTIN_DENIES = [
     regex
   }))
 ];
-function matchBuiltinDeny(text11) {
-  return RAW_BUILTIN_DENIES.find((rule) => rule.regex.test(text11));
+function matchBuiltinDeny(text16) {
+  return RAW_BUILTIN_DENIES.find((rule) => rule.regex.test(text16));
 }
 function toDecision(rule) {
   if (!rule) return void 0;
@@ -11866,8 +11967,8 @@ function formatHuman(cli, commands) {
 `];
   for (const cmd of sorted) {
     const full = `${cli} ${cmd.path.join(" ")}`;
-    const text11 = cmd.description ? `${full} \u2014 ${cmd.description}` : full;
-    lines.push(`${prefix(classifyVerb(cmd.path))}${text11}`);
+    const text16 = cmd.description ? `${full} \u2014 ${cmd.description}` : full;
+    lines.push(`${prefix(classifyVerb(cmd.path))}${text16}`);
   }
   return lines.join("\n");
 }
@@ -12146,38 +12247,38 @@ import chalk110 from "chalk";
 // src/commands/codeComment/validateCommentText.ts
 var MAX_COMMENT_LENGTH = 50;
 function validateCommentText(raw, isHash = false) {
-  const text11 = isHash ? raw.replace(/^#\s?/, "") : raw.replace(/^\/\/\s?/, "");
-  if (/[\r\n]/.test(text11)) {
+  const text16 = isHash ? raw.replace(/^#\s?/, "") : raw.replace(/^\/\/\s?/, "");
+  if (/[\r\n]/.test(text16)) {
     return {
       ok: false,
       reason: "Comment must be a single line \u2014 multi-line comments are not allowed."
     };
   }
-  if (!isHash && (text11.includes("/*") || text11.includes("*/"))) {
+  if (!isHash && (text16.includes("/*") || text16.includes("*/"))) {
     return {
       ok: false,
       reason: "Block comments (/* */) are not allowed \u2014 only single-line // comments."
     };
   }
-  if (text11.length > MAX_COMMENT_LENGTH) {
+  if (text16.length > MAX_COMMENT_LENGTH) {
     return {
       ok: false,
-      reason: `Comment text is ${text11.length} chars; the cap is ${MAX_COMMENT_LENGTH}. Make it shorter or, better, make the code self-documenting.`
+      reason: `Comment text is ${text16.length} chars; the cap is ${MAX_COMMENT_LENGTH}. Make it shorter or, better, make the code self-documenting.`
     };
   }
-  return { ok: true, text: text11 };
+  return { ok: true, text: text16 };
 }
 
 // src/commands/codeComment/issuePin.ts
 import { mkdirSync as mkdirSync14, writeFileSync as writeFileSync25 } from "fs";
 import { randomInt } from "crypto";
-function issuePin(file, lineNumber, text11) {
+function issuePin(file, lineNumber, text16) {
   const pin = generatePin();
   mkdirSync14(getRestrictedDir(), { recursive: true });
   sweepRestrictedDir();
   writeFileSync25(
     getPinStatePath(pin),
-    JSON.stringify({ pin, file, line: lineNumber, text: text11 })
+    JSON.stringify({ pin, file, line: lineNumber, text: text16 })
   );
   return showNotification({
     title: "assist code-comment pin",
@@ -12189,7 +12290,7 @@ function generatePin() {
 }
 
 // src/commands/codeComment/codeCommentSet.ts
-function codeCommentSet(file, line, text11) {
+function codeCommentSet(file, line, text16) {
   const lineNumber = Number.parseInt(line, 10);
   if (!Number.isInteger(lineNumber) || lineNumber < 1) {
     console.error(chalk110.red(`Invalid line number: ${line}`));
@@ -12198,7 +12299,7 @@ function codeCommentSet(file, line, text11) {
   }
   const hash = isHashCommentFile(file);
   const marker = hash ? "#" : "//";
-  const validation = validateCommentText(text11, hash);
+  const validation = validateCommentText(text16, hash);
   if (!validation.ok) {
     console.error(chalk110.red(`Refused: ${validation.reason}`));
     console.error(chalk110.red("No pin issued."));
@@ -14272,12 +14373,12 @@ function isSourceFile(filePath) {
   if (!filePath) return false;
   return SOURCE_EXTENSIONS.some((ext) => filePath.endsWith(ext));
 }
-function blankNonNewline2(text11) {
-  return text11.replace(/[^\n]/g, " ");
+function blankNonNewline2(text16) {
+  return text16.replace(/[^\n]/g, " ");
 }
-function extractComments(text11) {
+function extractComments(text16) {
   const comments3 = [];
-  let work = text11.replace(
+  let work = text16.replace(
     /"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`/g,
     blankNonNewline2
   );
@@ -14292,11 +14393,11 @@ function extractComments(text11) {
 }
 
 // src/commands/editHook/extractYamlComments.ts
-function blankNonNewline3(text11) {
-  return text11.replace(/[^\n]/g, " ");
+function blankNonNewline3(text16) {
+  return text16.replace(/[^\n]/g, " ");
 }
-function extractYamlComments(text11) {
-  const work = text11.replace(
+function extractYamlComments(text16) {
+  const work = text16.replace(
     /"(?:[^"\\]|\\.)*"|'(?:[^']|'')*'/g,
     blankNonNewline3
   );
@@ -14312,8 +14413,8 @@ function isHeaderLine2(line) {
   const trimmed = line.trim();
   return trimmed === "" || trimmed.startsWith("#");
 }
-function extractShellComments(text11) {
-  const lines = text11.split("\n");
+function extractShellComments(text16) {
+  const lines = text16.split("\n");
   let firstCodeLine = 0;
   while (firstCodeLine < lines.length && isHeaderLine2(lines[firstCodeLine])) {
     firstCodeLine++;
@@ -14683,9 +14784,9 @@ function registerGithub(program2) {
 }
 
 // src/commands/handover/countPendingHandovers.ts
-import { and as and17, eq as eq35, isNull, sql as sql9 } from "drizzle-orm";
+import { and as and18, eq as eq36, isNull, sql as sql13 } from "drizzle-orm";
 async function countPendingHandovers(orm, origin) {
-  const [row] = await orm.select({ count: sql9`count(*)::int` }).from(handovers).where(and17(eq35(handovers.origin, origin), isNull(handovers.recalledAt)));
+  const [row] = await orm.select({ count: sql13`count(*)::int` }).from(handovers).where(and18(eq36(handovers.origin, origin), isNull(handovers.recalledAt)));
   return row?.count ?? 0;
 }
 
@@ -14825,13 +14926,13 @@ async function load2(options2 = {}) {
 }
 
 // src/commands/handover/listPendingHandovers.ts
-import { and as and18, desc as desc4, eq as eq36, isNull as isNull2 } from "drizzle-orm";
+import { and as and19, desc as desc4, eq as eq37, 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(and18(eq36(handovers.origin, origin), isNull2(handovers.recalledAt))).orderBy(desc4(handovers.createdAt), desc4(handovers.id));
+  }).from(handovers).where(and19(eq37(handovers.origin, origin), isNull2(handovers.recalledAt))).orderBy(desc4(handovers.createdAt), desc4(handovers.id));
 }
 
 // src/commands/handover/printPendingHandovers.ts
@@ -14844,17 +14945,17 @@ async function printPendingHandovers() {
 }
 
 // src/commands/handover/recallHandover.ts
-import { and as and19, desc as desc5, eq as eq37, isNull as isNull3 } from "drizzle-orm";
+import { and as and20, desc as desc5, eq as eq38, isNull as isNull3 } from "drizzle-orm";
 async function recallHandover(orm, origin, id) {
   const [row] = await orm.select().from(handovers).where(
-    and19(
-      eq37(handovers.origin, origin),
+    and20(
+      eq38(handovers.origin, origin),
       isNull3(handovers.recalledAt),
-      ...id === void 0 ? [] : [eq37(handovers.id, id)]
+      ...id === void 0 ? [] : [eq38(handovers.id, id)]
     )
   ).orderBy(desc5(handovers.createdAt), desc5(handovers.id)).limit(1);
   if (!row) return void 0;
-  await orm.update(handovers).set({ recalledAt: /* @__PURE__ */ new Date() }).where(eq37(handovers.id, row.id));
+  await orm.update(handovers).set({ recalledAt: /* @__PURE__ */ new Date() }).where(eq38(handovers.id, row.id));
   return row.content;
 }
 
@@ -14908,9 +15009,9 @@ import chalk143 from "chalk";
 
 // src/commands/jira/adfToText.ts
 function renderInline(node) {
-  const text11 = node.text ?? "";
-  if (node.marks?.some((m) => m.type === "code")) return `\`${text11}\``;
-  return text11;
+  const text16 = node.text ?? "";
+  if (node.marks?.some((m) => m.type === "code")) return `\`${text16}\``;
+  return text16;
 }
 function renderChildren(node, indent2) {
   return renderNodes(node.content ?? [], indent2);
@@ -14952,8 +15053,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 text11 = renderChildren(child, indent2);
-  return isFirst ? `${pad}${marker} ${text11}` : `${pad}  ${text11}`;
+  const text16 = renderChildren(child, indent2);
+  return isFirst ? `${pad}${marker} ${text16}` : `${pad}  ${text16}`;
 }
 function renderListItem(node, indent2, marker) {
   const pad = "  ".repeat(indent2);
@@ -15112,9 +15213,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(
-    (text11, opts) => launchMode(slashCommand, {
+    (text16, opts) => launchMode(slashCommand, {
       once: opts.once,
-      description: text11,
+      description: text16,
       resumeSessionId: opts.resumeSession
     })
   );
@@ -15616,8 +15717,8 @@ function dedupeLinks(links2) {
 }
 
 // src/commands/netcap/linkifyMentions.ts
-function linkifyMentions(text11, mentions) {
-  let out = text11;
+function linkifyMentions(text16, mentions) {
+  let out = text16;
   for (const m of mentions) {
     if (m.name && out.includes(m.name)) {
       out = out.replace(m.name, `[${m.name}](${m.url})`);
@@ -15644,13 +15745,13 @@ function resolveAuthor(mentionMap, author) {
   return mentionMap.get(author) ?? { slug: author, url: profileUrl(author) };
 }
 function buildPost(raw, mentionMap, author) {
-  const text11 = joinText(raw.text);
-  if (!text11) return void 0;
+  const text16 = joinText(raw.text);
+  if (!text16) return void 0;
   const mentions = resolveMentions(raw, mentionMap, author);
   const relatedPosts = [...new Set(raw.related)];
   return {
-    text: text11,
-    markdown: linkifyMentions(text11, mentions),
+    text: text16,
+    markdown: linkifyMentions(text16, mentions),
     mentions,
     hashtags: [...new Set(raw.hashtags)],
     links: dedupeLinks(raw.links),
@@ -15791,8 +15892,8 @@ function activityUrnOf(update3) {
   return typeof urn === "string" ? urn : void 0;
 }
 function buildVoyagerPost(update3, profiles) {
-  const text11 = commentaryText(update3);
-  if (!text11) return void 0;
+  const text16 = commentaryText(update3);
+  if (!text16) return void 0;
   const author = resolveVoyagerAuthor(update3);
   const { mentions, hashtags, links: links2 } = collectVoyagerAttributes(
     update3,
@@ -15801,8 +15902,8 @@ function buildVoyagerPost(update3, profiles) {
   );
   const activityUrn = activityUrnOf(update3);
   return {
-    text: text11,
-    markdown: linkifyMentions(text11, mentions),
+    text: text16,
+    markdown: linkifyMentions(text16, mentions),
     mentions,
     hashtags,
     links: links2,
@@ -16306,8 +16407,8 @@ function isWallOfText(lines) {
   if (lines.some(isListLine)) {
     return false;
   }
-  const text11 = lines.join(" ").trim();
-  return text11.length > MAX_PARAGRAPH_CHARS || countSentences(text11) > MAX_PARAGRAPH_SENTENCES;
+  const text16 = lines.join(" ").trim();
+  return text16.length > MAX_PARAGRAPH_CHARS || countSentences(text16) > MAX_PARAGRAPH_SENTENCES;
 }
 function validatePrContent(title, body) {
   if (title.toLowerCase().includes("claude")) {
@@ -18061,9 +18162,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 text11 = fn.getFullText().trim();
-    if (fn === target && !text11.startsWith("export ")) return `export ${text11}`;
-    return text11;
+    const text16 = fn.getFullText().trim();
+    if (fn === target && !text16.startsWith("export ")) return `export ${text16}`;
+    return text16;
   });
   return [...stmtTexts, ...fnTexts];
 }
@@ -19913,9 +20014,9 @@ var MultiSpinner = class {
       elapsedPrefix: prefix2
     });
   }
-  failRemaining(text11) {
+  failRemaining(text16) {
     for (const entry of this.entries) {
-      if (entry.state === "running") this.resolve(entry, "failed", text11);
+      if (entry.state === "running") this.resolve(entry, "failed", text16);
     }
   }
   add(entry) {
@@ -19928,14 +20029,14 @@ var MultiSpinner = class {
       set text(value) {
         entry.text = value;
       },
-      succeed: (text11) => this.resolve(entry, "succeeded", text11),
-      fail: (text11) => this.resolve(entry, "failed", text11)
+      succeed: (text16) => this.resolve(entry, "succeeded", text16),
+      fail: (text16) => this.resolve(entry, "failed", text16)
     };
   }
-  resolve(entry, state, text11) {
+  resolve(entry, state, text16) {
     if (entry.state !== "running") return;
     entry.state = state;
-    if (text11 !== void 0) entry.text = text11;
+    if (text16 !== void 0) entry.text = text16;
     entry.elapsedStart = void 0;
     this.render();
     this.maybeFinish();
@@ -20010,12 +20111,12 @@ function skippedCodexResult(outputPath) {
 // src/commands/review/formatReviewerFailure.ts
 var FAST_FAIL_MS = 1e3;
 var STDOUT_TAIL_LINES = 20;
-function indent(text11) {
-  return text11.split(/\r?\n/).map((line) => `  ${line}`);
+function indent(text16) {
+  return text16.split(/\r?\n/).map((line) => `  ${line}`);
 }
-function tailLines(text11, maxLines) {
-  const lines = text11.split(/\r?\n/);
-  return lines.length <= maxLines ? text11 : lines.slice(-maxLines).join("\n");
+function tailLines(text16, maxLines) {
+  const lines = text16.split(/\r?\n/);
+  return lines.length <= maxLines ? text16 : lines.slice(-maxLines).join("\n");
 }
 function isFastFail(input) {
   return input.exitCode !== 0 && input.elapsedMs !== void 0 && input.elapsedMs < FAST_FAIL_MS;
@@ -20950,8 +21051,8 @@ function filterToSql(filter) {
 // src/commands/seq/fetchSeqData.ts
 function buildDataParams(filter, count8, from, to) {
   const sqlFilter = filterToSql(filter);
-  const sql15 = `select @Timestamp, @Level, @Exception, @Message from stream where ${sqlFilter} order by @Timestamp desc limit ${count8}`;
-  const params = new URLSearchParams({ q: sql15 });
+  const sql20 = `select @Timestamp, @Level, @Exception, @Message from stream where ${sqlFilter} order by @Timestamp desc limit ${count8}`;
+  const params = new URLSearchParams({ q: sql20 });
   if (from) params.set("rangeStartUtc", from);
   if (to) params.set("rangeEndUtc", to);
   return params;
@@ -21212,26 +21313,26 @@ import chalk190 from "chalk";
 // src/commands/sql/loadConnections.ts
 function loadConnections3() {
   const raw = loadGlobalConfigRaw();
-  const sql15 = raw.sql;
-  return sql15?.connections ?? [];
+  const sql20 = raw.sql;
+  return sql20?.connections ?? [];
 }
 function saveConnections3(connections) {
   const raw = loadGlobalConfigRaw();
-  const sql15 = raw.sql ?? {};
-  sql15.connections = connections;
-  raw.sql = sql15;
+  const sql20 = raw.sql ?? {};
+  sql20.connections = connections;
+  raw.sql = sql20;
   saveGlobalConfig(raw);
 }
 function getDefaultConnection2() {
   const raw = loadGlobalConfigRaw();
-  const sql15 = raw.sql;
-  return sql15?.defaultConnection;
+  const sql20 = raw.sql;
+  return sql20?.defaultConnection;
 }
 function setDefaultConnection2(name) {
   const raw = loadGlobalConfigRaw();
-  const sql15 = raw.sql ?? {};
-  sql15.defaultConnection = name;
-  raw.sql = sql15;
+  const sql20 = raw.sql ?? {};
+  sql20.defaultConnection = name;
+  raw.sql = sql20;
   saveGlobalConfig(raw);
 }
 
@@ -21302,9 +21403,9 @@ function resolveConnection3(name) {
 }
 
 // src/commands/sql/sqlConnect.ts
-import sql10 from "mssql";
+import sql14 from "mssql";
 async function sqlConnect(conn) {
-  return await sql10.connect({
+  return await sql14.connect({
     server: conn.server,
     port: conn.port,
     user: conn.user,
@@ -21381,11 +21482,11 @@ var MUTATION_PATTERN = new RegExp(
   `\\b(${MUTATION_KEYWORDS.join("|")})\\b`,
   "i"
 );
-function stripComments(sql15) {
-  return sql15.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/--[^\n]*/g, " ");
+function stripComments(sql20) {
+  return sql20.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/--[^\n]*/g, " ");
 }
-function isMutation(sql15) {
-  const stripped = stripComments(sql15);
+function isMutation(sql20) {
+  const stripped = stripComments(sql20);
   if (MUTATION_PATTERN.test(stripped)) return true;
   return /\bSELECT\b[\s\S]+\bINTO\s+\w/i.test(stripped);
 }
@@ -21584,8 +21685,8 @@ import {
 import { basename as basename13, join as join53 } from "path";
 
 // src/commands/transcript/cleanText.ts
-function cleanText(text11) {
-  const words = text11.split(/\s+/);
+function cleanText(text16) {
+  const words = text16.split(/\s+/);
   const cleaned = [];
   for (let i = 0; i < words.length; i++) {
     let isRepeat = false;
@@ -21605,8 +21706,8 @@ function cleanText(text11) {
 }
 
 // src/commands/transcript/convert/parseVtt/deduplicateCues/removeSubstringDuplicates.ts
-function normalizeText(text11) {
-  return text11.toLowerCase().trim();
+function normalizeText(text16) {
+  return text16.toLowerCase().trim();
 }
 function checkSubstringRelation(textI, textJ) {
   if (textI.includes(textJ) && textI.length > textJ.length)
@@ -21735,13 +21836,13 @@ function parseTimestampLine(line) {
   return { startMs: parseTimestamp(startStr), endMs: parseTimestamp(endStr) };
 }
 function buildCue(startMs, endMs, fullText) {
-  const { speaker, text: text11 } = extractSpeaker(fullText);
-  return text11 ? { startMs, endMs, speaker, text: text11 } : null;
+  const { speaker, text: text16 } = extractSpeaker(fullText);
+  return text16 ? { startMs, endMs, speaker, text: text16 } : null;
 }
 function parseCueLine(lines, i) {
   const { startMs, endMs } = parseTimestampLine(lines[i]);
-  const { text: text11, nextIndex: nextIndex2 } = collectTextLines(lines, i + 1);
-  return { cue: buildCue(startMs, endMs, text11), nextIndex: nextIndex2 };
+  const { text: text16, nextIndex: nextIndex2 } = collectTextLines(lines, i + 1);
+  return { cue: buildCue(startMs, endMs, text16), nextIndex: nextIndex2 };
 }
 function isCueSeparator(line) {
   return line.trim().includes("-->");
@@ -22329,8 +22430,8 @@ async function exchangeToken(params) {
     body: body.toString()
   });
   if (!response.ok) {
-    const text11 = await response.text();
-    throw new Error(`Token exchange failed (${response.status}): ${text11}`);
+    const text16 = await response.text();
+    throw new Error(`Token exchange failed (${response.status}): ${text16}`);
   }
   return response.json();
 }
@@ -23711,13 +23812,13 @@ function drainSessions(sessions, onDrained) {
 }
 
 // src/shared/db/recordPhaseActiveMs.ts
-import { sql as sql11 } from "drizzle-orm";
+import { sql as sql15 } 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: sql11`${phaseUsage.activeMs} + excluded.active_ms`
+      activeMs: sql15`${phaseUsage.activeMs} + excluded.active_ms`
     }
   });
 }
@@ -23908,19 +24009,36 @@ function makeStatusChangeHandler(dismiss, notify2, reuseForRun) {
   return (s, status3, exitCode) => applyStatusChange(s, status3, exitCode, dismiss, notify2, reuseForRun);
 }
 
+// src/shared/db/recordPhaseCycleContext.ts
+import { sql as sql16 } from "drizzle-orm";
+async function recordPhaseCycleContext(db, itemId2, phaseIdx, window, resetsAt, pct) {
+  if (pct <= 0) return;
+  await db.insert(phaseCycleContext).values({ itemId: itemId2, phaseIdx, window, resetsAt, peakContextPct: pct }).onConflictDoUpdate({
+    target: [
+      phaseCycleContext.itemId,
+      phaseCycleContext.phaseIdx,
+      phaseCycleContext.window,
+      phaseCycleContext.resetsAt
+    ],
+    set: {
+      peakContextPct: sql16`GREATEST(${phaseCycleContext.peakContextPct}, ${pct})`
+    }
+  });
+}
+
 // src/shared/db/recordPhasePeakContext.ts
-import { sql as sql12 } from "drizzle-orm";
+import { sql as sql17 } 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: sql12`GREATEST(${phaseUsage.peakContextPct}, ${pct})`
+      peakContextPct: sql17`GREATEST(${phaseUsage.peakContextPct}, ${pct})`
     }
   });
 }
 
 // src/shared/db/recordPhaseTranscriptUsage.ts
-import { sql as sql13 } from "drizzle-orm";
+import { sql as sql18 } 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);
@@ -23940,8 +24058,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: sql13`${phaseUsage.tokensUp} + ${tokensUp}`,
-        tokensDown: sql13`${phaseUsage.tokensDown} + ${tokensDown}`
+        tokensUp: sql18`${phaseUsage.tokensUp} + ${tokensUp}`,
+        tokensDown: sql18`${phaseUsage.tokensDown} + ${tokensDown}`
       }
     });
     return { tokensUp, tokensDown };
@@ -23949,17 +24067,17 @@ async function recordPhaseTranscriptUsage(db, itemId2, phaseIdx, responses) {
 }
 
 // src/shared/db/recordWindowTokens.ts
-import { and as and20, eq as eq38, sql as sql14 } from "drizzle-orm";
+import { and as and21, eq as eq39, sql as sql19 } from "drizzle-orm";
 async function recordWindowTokens(db, window, resetsAt, tokensUp, tokensDown) {
   if (tokensUp <= 0 && tokensDown <= 0) return;
   await db.update(usagePeaks).set({
-    tokensUp: sql14`${usagePeaks.tokensUp} + ${tokensUp}`,
-    tokensDown: sql14`${usagePeaks.tokensDown} + ${tokensDown}`
+    tokensUp: sql19`${usagePeaks.tokensUp} + ${tokensUp}`,
+    tokensDown: sql19`${usagePeaks.tokensDown} + ${tokensDown}`
   }).where(
-    and20(
-      eq38(usagePeaks.window, window),
-      eq38(usagePeaks.resetsAt, resetsAt),
-      eq38(usagePeaks.segment, 0)
+    and21(
+      eq39(usagePeaks.window, window),
+      eq39(usagePeaks.resetsAt, resetsAt),
+      eq39(usagePeaks.segment, 0)
     )
   );
 }
@@ -23998,8 +24116,19 @@ async function persistPhaseTokens(itemId2, phaseIdx, transcriptPath, usedPct, wi
   try {
     if (!process.env.ASSIST_DATABASE_URL && !loadConfig().database.url) return;
     const db = await getDb();
-    if (usedPct !== void 0)
+    if (usedPct !== void 0) {
       await recordPhasePeakContext(db, itemId2, phaseIdx, usedPct);
+      for (const { window, resetsAt } of windows) {
+        await recordPhaseCycleContext(
+          db,
+          itemId2,
+          phaseIdx,
+          window,
+          resetsAt,
+          usedPct
+        );
+      }
+    }
     const responses = await readTranscriptUsage(transcriptPath);
     if (responses.length === 0) return;
     const { tokensUp, tokensDown } = await recordPhaseTranscriptUsage(
@@ -24052,10 +24181,10 @@ function applyReviewPause(session, activity2) {
 }
 
 // src/shared/db/getPhaseActiveMs.ts
-import { and as and21, eq as eq39 } from "drizzle-orm";
+import { and as and22, eq as eq40 } from "drizzle-orm";
 async function getPhaseActiveMs(db, itemId2, phaseIdx) {
   const [row] = await db.select({ activeMs: phaseUsage.activeMs }).from(phaseUsage).where(
-    and21(eq39(phaseUsage.itemId, itemId2), eq39(phaseUsage.phaseIdx, phaseIdx))
+    and22(eq40(phaseUsage.itemId, itemId2), eq40(phaseUsage.phaseIdx, phaseIdx))
   );
   return row?.activeMs ?? 0;
 }
@@ -25373,17 +25502,17 @@ function entryMessages(entry) {
   return [];
 }
 function userMessages(content) {
-  if (typeof content === "string") return text10("user", cleanUserText(content));
+  if (typeof content === "string") return text15("user", cleanUserText(content));
   if (!Array.isArray(content)) return [];
-  return content.filter((c) => c.type === "text").flatMap((c) => text10("user", cleanUserText(c.text ?? "")));
+  return content.filter((c) => c.type === "text").flatMap((c) => text15("user", cleanUserText(c.text ?? "")));
 }
 function assistantMessages(content) {
-  if (typeof content === "string") return text10("assistant", content.trim());
+  if (typeof content === "string") return text15("assistant", content.trim());
   if (!Array.isArray(content)) return [];
   return content.flatMap((c) => assistantItem(c));
 }
 function assistantItem(c) {
-  if (c.type === "text") return text10("assistant", (c.text ?? "").trim());
+  if (c.type === "text") return text15("assistant", (c.text ?? "").trim());
   if (c.type === "tool_use")
     return [
       {
@@ -25394,7 +25523,7 @@ function assistantItem(c) {
     ];
   return [];
 }
-function text10(role, value) {
+function text15(role, value) {
   return value ? [{ role, text: value }] : [];
 }
 function cleanUserText(value) {
@@ -25760,16 +25889,16 @@ function parseUserLine(line) {
   if (entry.type !== "user") return void 0;
   const msg = entry.message;
   const c = msg?.content;
-  let text11;
+  let text16;
   if (typeof c === "string") {
-    text11 = c;
+    text16 = c;
   } else if (Array.isArray(c)) {
     const collected = c.filter((b) => b.type === "text").map((b) => b.text ?? "").join("\n");
-    text11 = collected || void 0;
+    text16 = collected || void 0;
   }
-  if (!text11) return void 0;
+  if (!text16) return void 0;
   return {
-    text: text11,
+    text: text16,
     entrypoint: typeof entry.entrypoint === "string" ? entry.entrypoint : void 0
   };
 }
@@ -25798,13 +25927,13 @@ function* iterateUserMessages(filePath, maxBytes = 65536) {
 
 // src/commands/sessions/summarise/extractFirstUserMessage.ts
 function extractFirstUserMessage(filePath) {
-  for (const text11 of iterateUserMessages(filePath)) {
-    return truncate3(text11);
+  for (const text16 of iterateUserMessages(filePath)) {
+    return truncate3(text16);
   }
   return void 0;
 }
-function truncate3(text11, maxChars = 500) {
-  const trimmed = text11.trim();
+function truncate3(text16, maxChars = 500) {
+  const trimmed = text16.trim();
   if (trimmed.length <= maxChars) return trimmed;
   return `${trimmed.slice(0, maxChars)}\u2026`;
 }
@@ -25812,28 +25941,28 @@ function truncate3(text11, maxChars = 500) {
 // src/commands/sessions/summarise/scanSessionBacklogRefs.ts
 function scanSessionBacklogRefs(filePath) {
   const ids = /* @__PURE__ */ new Set();
-  for (const text11 of iterateUserMessages(filePath, Number.MAX_SAFE_INTEGER)) {
-    for (const id of extractBacklogIds(text11)) {
+  for (const text16 of iterateUserMessages(filePath, Number.MAX_SAFE_INTEGER)) {
+    for (const id of extractBacklogIds(text16)) {
       ids.add(id);
     }
   }
   return [...ids].sort((a, b) => a - b);
 }
-function extractBacklogIds(text11) {
+function extractBacklogIds(text16) {
   const ids = [];
-  for (const m of text11.matchAll(/backlog\s+run\s+a(\d+)/gi)) {
+  for (const m of text16.matchAll(/backlog\s+run\s+a(\d+)/gi)) {
     ids.push(Number.parseInt(m[1], 10));
   }
-  for (const m of text11.matchAll(/backlog\s+(?:item\s+)?a(\d+)/gi)) {
+  for (const m of text16.matchAll(/backlog\s+(?:item\s+)?a(\d+)/gi)) {
     ids.push(Number.parseInt(m[1], 10));
   }
-  for (const m of text11.matchAll(/backlog\s+phase-done\s+a(\d+)/gi)) {
+  for (const m of text16.matchAll(/backlog\s+phase-done\s+a(\d+)/gi)) {
     ids.push(Number.parseInt(m[1], 10));
   }
-  for (const m of text11.matchAll(/backlog\s+comment\s+a(\d+)/gi)) {
+  for (const m of text16.matchAll(/backlog\s+comment\s+a(\d+)/gi)) {
     ids.push(Number.parseInt(m[1], 10));
   }
-  for (const m of text11.matchAll(/(?:^|[\s(])a(\d{1,4})(?=[\s).,;:!?]|$)/gm)) {
+  for (const m of text16.matchAll(/(?:^|[\s(])a(\d{1,4})(?=[\s).,;:!?]|$)/gm)) {
     ids.push(Number.parseInt(m[1], 10));
   }
   return ids;