@staff0rd/assist 0.227.0 → 0.228.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.227.0",
+  version: "0.228.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -44,6 +44,7 @@ var package_default = {
     chalk: "^5.6.2",
     commander: "^14.0.2",
     diff: "^8.0.2",
+    "drizzle-orm": "^0.45.2",
     enquirer: "^2.4.1",
     entities: "^7.0.1",
     "is-wsl": "^3.1.0",
@@ -413,21 +414,93 @@ function getTranscriptConfig() {
   return config.transcript;
 }
 
-// src/commands/backlog/deleteItemRelations.ts
-async function deleteItemRelations(db, itemId) {
-  await db.run("DELETE FROM plan_tasks WHERE item_id = ?", [itemId]);
-  await db.run("DELETE FROM plan_phases WHERE item_id = ?", [itemId]);
-  await db.run("DELETE FROM comments WHERE item_id = ?", [itemId]);
-  await db.run("DELETE FROM links WHERE item_id = ?", [itemId]);
-}
+// src/commands/backlog/deleteItem.ts
+import { eq } from "drizzle-orm";
+
+// src/commands/backlog/backlogSchema.ts
+import {
+  foreignKey,
+  index,
+  integer,
+  pgTable,
+  primaryKey,
+  text
+} from "drizzle-orm/pg-core";
+var items = pgTable(
+  "items",
+  {
+    id: integer().generatedByDefaultAsIdentity().primaryKey(),
+    origin: text().notNull(),
+    type: text().notNull().default("story"),
+    name: text().notNull(),
+    description: text(),
+    acceptanceCriteria: text("acceptance_criteria").notNull().default("[]"),
+    status: text().notNull().default("todo"),
+    currentPhase: integer("current_phase")
+  },
+  (t) => [index("items_origin_idx").on(t.origin)]
+);
+var comments = pgTable("comments", {
+  id: integer().generatedByDefaultAsIdentity().primaryKey(),
+  itemId: integer("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+  idx: integer().notNull(),
+  text: text().notNull(),
+  phase: integer(),
+  timestamp: text().notNull(),
+  type: text().notNull().default("comment")
+});
+var links = pgTable(
+  "links",
+  {
+    itemId: integer("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+    type: text().notNull(),
+    targetId: integer("target_id").notNull()
+  },
+  (t) => [primaryKey({ columns: [t.itemId, t.type, t.targetId] })]
+);
+var planPhases = pgTable(
+  "plan_phases",
+  {
+    itemId: integer("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+    idx: integer().notNull(),
+    name: text().notNull(),
+    manualChecks: text("manual_checks")
+  },
+  (t) => [primaryKey({ columns: [t.itemId, t.idx] })]
+);
+var planTasks = pgTable(
+  "plan_tasks",
+  {
+    itemId: integer("item_id").notNull(),
+    phaseIdx: integer("phase_idx").notNull(),
+    idx: integer().notNull(),
+    task: text().notNull()
+  },
+  (t) => [
+    primaryKey({ columns: [t.itemId, t.phaseIdx, t.idx] }),
+    foreignKey({
+      columns: [t.itemId, t.phaseIdx],
+      foreignColumns: [planPhases.itemId, planPhases.idx]
+    }).onDelete("cascade")
+  ]
+);
+var metadata = pgTable("metadata", {
+  key: text().primaryKey(),
+  value: text().notNull()
+});
+var backlogSchema = {
+  items,
+  comments,
+  links,
+  planPhases,
+  planTasks,
+  metadata
+};
 
 // src/commands/backlog/deleteItem.ts
-async function deleteItem(db, id) {
-  return db.transaction(async (tx) => {
-    await deleteItemRelations(tx, id);
-    const result = await tx.run("DELETE FROM items WHERE id = ?", [id]);
-    return result.changes > 0;
-  });
+async function deleteItem(orm, id) {
+  const [row] = await orm.delete(items).where(eq(items.id, id)).returning({ name: items.name });
+  return row?.name;
 }
 
 // src/commands/backlog/migrateLocalBacklog.ts
@@ -469,74 +542,70 @@ function gitPullBacklog(dir) {
   }
 }
 
+// src/commands/backlog/itemColumns.ts
+function itemColumns(item, origin) {
+  return {
+    origin,
+    type: item.type,
+    name: item.name,
+    description: item.description ?? null,
+    acceptanceCriteria: JSON.stringify(item.acceptanceCriteria),
+    status: item.status,
+    currentPhase: item.currentPhase ?? null
+  };
+}
+
 // src/commands/backlog/insertItem.ts
 async function insertItem(db, item, origin) {
-  const row = await db.get(
-    `INSERT INTO items (origin, type, name, description, acceptance_criteria, status, current_phase)
-		 VALUES (?, ?, ?, ?, ?, ?, ?)
-		 RETURNING id`,
-    [
-      origin,
-      item.type,
-      item.name,
-      item.description ?? null,
-      JSON.stringify(item.acceptanceCriteria),
-      item.status,
-      item.currentPhase ?? null
-    ]
-  );
+  const [row] = await db.insert(items).values(itemColumns(item, origin)).returning({ id: items.id });
   if (!row) throw new Error("Failed to insert backlog item");
   return row.id;
 }
 
 // src/commands/backlog/insertItemRelations.ts
 async function insertComments(db, item) {
-  if (!item.comments) return;
-  for (let i = 0; i < item.comments.length; i++) {
-    const c = item.comments[i];
-    if (c.id !== void 0) {
-      await db.run(
-        "INSERT INTO comments (id, item_id, idx, text, phase, timestamp, type) VALUES (?, ?, ?, ?, ?, ?, ?)",
-        [c.id, item.id, i, c.text, c.phase ?? null, c.timestamp, c.type]
-      );
-    } else {
-      await db.run(
-        "INSERT INTO comments (item_id, idx, text, phase, timestamp, type) VALUES (?, ?, ?, ?, ?, ?)",
-        [item.id, i, c.text, c.phase ?? null, c.timestamp, c.type]
-      );
-    }
-  }
+  if (!item.comments?.length) return;
+  await db.insert(comments).values(
+    item.comments.map((c, i) => ({
+      id: c.id,
+      itemId: item.id,
+      idx: i,
+      text: c.text,
+      phase: c.phase ?? null,
+      timestamp: c.timestamp,
+      type: c.type
+    }))
+  );
 }
 async function insertLinks(db, item) {
-  if (!item.links) return;
-  for (const l of item.links) {
-    await db.run(
-      "INSERT INTO links (item_id, type, target_id) VALUES (?, ?, ?)",
-      [item.id, l.type, l.targetId]
-    );
-  }
+  if (!item.links?.length) return;
+  await db.insert(links).values(
+    item.links.map((l) => ({
+      itemId: item.id,
+      type: l.type,
+      targetId: l.targetId
+    }))
+  );
 }
 async function insertPlan(db, item) {
-  if (!item.plan) return;
-  for (let pi = 0; pi < item.plan.length; pi++) {
-    const phase = item.plan[pi];
-    await db.run(
-      "INSERT INTO plan_phases (item_id, idx, name, manual_checks) VALUES (?, ?, ?, ?)",
-      [
-        item.id,
-        pi,
-        phase.name,
-        phase.manualChecks ? JSON.stringify(phase.manualChecks) : null
-      ]
-    );
-    for (let ti = 0; ti < phase.tasks.length; ti++) {
-      const task = phase.tasks[ti];
-      await db.run(
-        "INSERT INTO plan_tasks (item_id, phase_idx, idx, task) VALUES (?, ?, ?, ?)",
-        [item.id, pi, ti, task.task]
-      );
-    }
-  }
+  if (!item.plan?.length) return;
+  await db.insert(planPhases).values(
+    item.plan.map((phase, pi) => ({
+      itemId: item.id,
+      idx: pi,
+      name: phase.name,
+      manualChecks: phase.manualChecks ? JSON.stringify(phase.manualChecks) : null
+    }))
+  );
+  const tasks = item.plan.flatMap(
+    (phase, pi) => phase.tasks.map((task, ti) => ({
+      itemId: item.id,
+      phaseIdx: pi,
+      idx: ti,
+      task: task.task
+    }))
+  );
+  if (tasks.length) await db.insert(planTasks).values(tasks);
 }
 async function insertItemRelations(db, item) {
   await insertComments(db, item);
@@ -559,98 +628,138 @@ function remap(item, newId, oldToNew) {
   };
   return remapped;
 }
-async function importItemsRemapped(db, items, origin) {
-  return db.transaction(async (tx) => {
+async function importItemsRemapped(orm, items2, origin) {
+  return orm.transaction(async (tx) => {
     const oldToNew = /* @__PURE__ */ new Map();
-    for (const item of items) {
+    for (const item of items2) {
       oldToNew.set(item.id, await insertItem(tx, item, origin));
     }
-    for (const item of items) {
+    for (const item of items2) {
       const newId = oldToNew.get(item.id);
       if (newId === void 0) continue;
       await insertItemRelations(tx, remap(item, newId, oldToNew));
     }
-    return items.length;
+    return items2.length;
   });
 }
 
-// src/commands/backlog/loadComments.ts
-async function loadComments(db, itemId) {
-  const rows = await db.all(
-    "SELECT id, text, phase, timestamp, type FROM comments WHERE item_id = ? ORDER BY idx",
-    [itemId]
-  );
-  return rows.map((r) => {
-    const c = {
-      id: r.id,
-      text: r.text,
-      timestamp: r.timestamp,
-      type: r.type
-    };
-    if (r.phase != null) c.phase = r.phase;
-    return c;
-  });
+// src/commands/backlog/loadAllItems.ts
+import { asc as asc2, eq as eq2 } from "drizzle-orm";
+
+// src/commands/backlog/loadRelations.ts
+import { asc, inArray } from "drizzle-orm";
+function groupByItem(rows) {
+  const map = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const bucket = map.get(row.itemId);
+    if (bucket) bucket.push(row);
+    else map.set(row.itemId, [row]);
+  }
+  return map;
+}
+var selectComments = (orm, ids) => orm.select().from(comments).where(inArray(comments.itemId, ids)).orderBy(asc(comments.itemId), asc(comments.idx));
+var selectLinks = (orm, ids) => orm.select().from(links).where(inArray(links.itemId, ids)).orderBy(asc(links.itemId));
+var selectPhases = (orm, ids) => orm.select().from(planPhases).where(inArray(planPhases.itemId, ids)).orderBy(asc(planPhases.itemId), asc(planPhases.idx));
+var selectTasks = (orm, ids) => orm.select().from(planTasks).where(inArray(planTasks.itemId, ids)).orderBy(
+  asc(planTasks.itemId),
+  asc(planTasks.phaseIdx),
+  asc(planTasks.idx)
+);
+async function loadRelations(orm, ids) {
+  const [commentRows, linkRows, phaseRows, taskRows] = await Promise.all([
+    selectComments(orm, ids),
+    selectLinks(orm, ids),
+    selectPhases(orm, ids),
+    selectTasks(orm, ids)
+  ]);
+  return {
+    comments: groupByItem(commentRows),
+    links: groupByItem(linkRows),
+    phases: groupByItem(phaseRows),
+    tasks: groupByItem(taskRows)
+  };
 }
 
-// src/commands/backlog/loadPlan.ts
-async function toPhase(db, itemId, p) {
-  const tasks = await db.all(
-    "SELECT task FROM plan_tasks WHERE item_id = ? AND phase_idx = ? ORDER BY idx",
-    [itemId, p.idx]
-  );
+// src/commands/backlog/rowToItem.ts
+function rowToComment(c) {
+  const comment3 = {
+    id: c.id,
+    text: c.text,
+    timestamp: c.timestamp,
+    type: c.type
+  };
+  if (c.phase != null) comment3.phase = c.phase;
+  return comment3;
+}
+function rowToLink(l) {
+  return { type: l.type, targetId: l.targetId };
+}
+function groupTasksByPhase(taskRows) {
+  const byPhase = /* @__PURE__ */ new Map();
+  for (const t of taskRows) {
+    const bucket = byPhase.get(t.phaseIdx);
+    if (bucket) bucket.push(t);
+    else byPhase.set(t.phaseIdx, [t]);
+  }
+  return byPhase;
+}
+function rowToPhase(p, byPhase) {
   const phase = {
     name: p.name,
-    tasks: tasks.map((t) => ({ task: t.task }))
+    tasks: (byPhase.get(p.idx) ?? []).map((t) => ({ task: t.task }))
   };
-  if (p.manual_checks) {
-    phase.manualChecks = JSON.parse(p.manual_checks);
-  }
+  if (p.manualChecks) phase.manualChecks = JSON.parse(p.manualChecks);
   return phase;
 }
-async function loadPlan(db, itemId) {
-  const phases = await db.all(
-    "SELECT idx, name, manual_checks FROM plan_phases WHERE item_id = ? ORDER BY idx",
-    [itemId]
-  );
-  if (phases.length === 0) return void 0;
-  return Promise.all(phases.map((p) => toPhase(db, itemId, p)));
+function buildPlan(phaseRows, taskRows) {
+  const byPhase = groupTasksByPhase(taskRows);
+  return phaseRows.map((p) => rowToPhase(p, byPhase));
 }
-
-// src/commands/backlog/loadAllItems.ts
-async function loadLinks(db, itemId) {
-  return db.all(
-    'SELECT type, target_id as "targetId" FROM links WHERE item_id = ?',
-    [itemId]
-  );
+function assignOptionalColumns(item, row) {
+  if (row.description != null) item.description = row.description;
+  if (row.currentPhase != null) item.currentPhase = row.currentPhase;
 }
-async function rowToItem(db, row) {
-  const comments2 = await loadComments(db, row.id);
-  const links = await loadLinks(db, row.id);
-  const plan2 = await loadPlan(db, row.id);
+function baseItem(row) {
   const item = {
     id: row.id,
     type: row.type,
     name: row.name,
-    acceptanceCriteria: JSON.parse(row.acceptance_criteria),
+    acceptanceCriteria: JSON.parse(row.acceptanceCriteria),
     status: row.status,
     origin: row.origin
   };
-  if (row.description != null) item.description = row.description;
-  if (row.current_phase != null) item.currentPhase = row.current_phase;
-  if (comments2.length > 0) item.comments = comments2;
-  if (links && links.length > 0) item.links = links;
-  if (plan2) item.plan = plan2;
+  assignOptionalColumns(item, row);
+  return item;
+}
+function attachComments(item, rel, id) {
+  const comments3 = (rel.comments.get(id) ?? []).map(rowToComment);
+  if (comments3.length > 0) item.comments = comments3;
+}
+function attachLinks(item, rel, id) {
+  const links2 = (rel.links.get(id) ?? []).map(rowToLink);
+  if (links2.length > 0) item.links = links2;
+}
+function attachPlan(item, rel, id) {
+  const phases = rel.phases.get(id) ?? [];
+  if (phases.length > 0) item.plan = buildPlan(phases, rel.tasks.get(id) ?? []);
+}
+function rowToItem(row, rel) {
+  const item = baseItem(row);
+  attachComments(item, rel, row.id);
+  attachLinks(item, rel, row.id);
+  attachPlan(item, rel, row.id);
   return item;
 }
-async function loadAllItems(db, origin) {
-  const rows = await db.all(
-    `SELECT id, type, name, description, acceptance_criteria, status, current_phase, origin
-		 FROM items
-		 WHERE (?::text IS NULL OR origin = ?)
-		 ORDER BY id`,
-    [origin ?? null, origin ?? null]
+
+// src/commands/backlog/loadAllItems.ts
+async function loadAllItems(orm, origin) {
+  const rows = await orm.select().from(items).where(origin === void 0 ? void 0 : eq2(items.origin, origin)).orderBy(asc2(items.id));
+  if (rows.length === 0) return [];
+  const rel = await loadRelations(
+    orm,
+    rows.map((r) => r.id)
   );
-  return Promise.all(rows.map((row) => rowToItem(db, row)));
+  return rows.map((row) => rowToItem(row, rel));
 }
 
 // src/commands/backlog/parseBacklogJsonl.ts
@@ -707,22 +816,22 @@ function parseBacklogJsonl(path52) {
 function jsonlPath(dir) {
   return join4(dir, ".assist", "backlog.jsonl");
 }
-async function verifyImport(db, origin, items, imported) {
-  const reloaded = await loadAllItems(db, origin);
+async function verifyImport(orm, origin, items2, imported) {
+  const reloaded = await loadAllItems(orm, origin);
   if (reloaded.length !== imported) {
     throw new Error(
       `backlog migrate: expected ${imported} item(s) for ${origin} after import but found ${reloaded.length}.`
     );
   }
-  if (items.length > 0 && !reloaded.some((i) => i.name === items[0].name)) {
+  if (items2.length > 0 && !reloaded.some((i) => i.name === items2[0].name)) {
     throw new Error(
-      `backlog migrate: spot-check failed; "${items[0].name}" not found after import.`
+      `backlog migrate: spot-check failed; "${items2[0].name}" not found after import.`
     );
   }
 }
-async function migrateLocalBacklog(db, dir, origin) {
+async function migrateLocalBacklog(orm, dir, origin) {
   if (!existsSync5(jsonlPath(dir))) return;
-  const existing = (await loadAllItems(db, origin)).length;
+  const existing = (await loadAllItems(orm, origin)).length;
   if (existing > 0) {
     const moved2 = backupLocalBacklogFiles(dir);
     console.error(
@@ -733,9 +842,9 @@ async function migrateLocalBacklog(db, dir, origin) {
     return;
   }
   gitPullBacklog(dir);
-  const items = parseBacklogJsonl(jsonlPath(dir));
-  const imported = await importItemsRemapped(db, items, origin);
-  await verifyImport(db, origin, items, imported);
+  const items2 = parseBacklogJsonl(jsonlPath(dir));
+  const imported = await importItemsRemapped(orm, items2, origin);
+  await verifyImport(orm, origin, items2, imported);
   const moved = backupLocalBacklogFiles(dir);
   console.error(
     chalk4.green(
@@ -746,10 +855,10 @@ async function migrateLocalBacklog(db, dir, origin) {
 
 // src/commands/backlog/ensureMigrated.ts
 var attempted = /* @__PURE__ */ new Set();
-async function ensureMigrated(db, dir, origin) {
+async function ensureMigrated(orm, dir, origin) {
   if (attempted.has(origin)) return;
   attempted.add(origin);
-  await migrateLocalBacklog(db, dir, origin);
+  await migrateLocalBacklog(orm, dir, origin);
 }
 
 // src/commands/backlog/findBacklogUp.ts
@@ -771,64 +880,16 @@ function findBacklogUp(startDir) {
   return null;
 }
 
-// src/commands/backlog/getBacklogDb.ts
+// src/commands/backlog/getBacklogOrm.ts
 import chalk5 from "chalk";
 import { Pool } from "pg";
 
-// src/commands/backlog/BacklogDb.ts
-function toPg(sql2) {
-  let i = 0;
-  return sql2.replace(/\?/g, () => `$${++i}`);
-}
-var PgBacklogDb = class _PgBacklogDb {
-  constructor(queryable, pool) {
-    this.queryable = queryable;
-    this.pool = pool;
-  }
-  async all(sql2, params = []) {
-    const result = await this.queryable.query(toPg(sql2), params);
-    return result.rows;
-  }
-  async get(sql2, params = []) {
-    const result = await this.queryable.query(toPg(sql2), params);
-    return result.rows[0];
-  }
-  async run(sql2, params = []) {
-    const result = await this.queryable.query(toPg(sql2), params);
-    return { changes: result.rowCount ?? result.affectedRows ?? 0 };
-  }
-  async exec(sql2) {
-    if (this.queryable.exec) {
-      await this.queryable.exec(sql2);
-    } else {
-      await this.queryable.query(sql2);
-    }
-  }
-  async transaction(fn) {
-    const client = this.pool ? await this.pool.connect() : void 0;
-    const tx = client ? new _PgBacklogDb({
-      query: (sql2, params) => client.query(sql2, params)
-    }) : this;
-    try {
-      return await tx.atomic(fn);
-    } finally {
-      client?.release();
-    }
-  }
-  async atomic(fn) {
-    await this.queryable.query("BEGIN");
-    try {
-      const result = await fn(this);
-      await this.queryable.query("COMMIT");
-      return result;
-    } catch (error) {
-      await this.queryable.query("ROLLBACK");
-      throw error;
-    }
-  }
-};
-function makeBacklogDb(queryable, pool) {
-  return new PgBacklogDb(queryable, pool);
+// src/commands/backlog/BacklogOrm.ts
+import {
+  drizzle as drizzleNodePg
+} from "drizzle-orm/node-postgres";
+function makeOrmFromPool(pool) {
+  return drizzleNodePg(pool, { schema: backlogSchema });
 }
 
 // src/commands/backlog/ensureSchema.ts
@@ -886,11 +947,11 @@ var SCHEMA = `
 		value TEXT NOT NULL
 	);
 `;
-async function ensureSchema(db) {
-  await db.exec(SCHEMA);
+async function ensureSchema(exec3) {
+  await exec3(SCHEMA);
 }
 
-// src/commands/backlog/getBacklogDb.ts
+// src/commands/backlog/getBacklogOrm.ts
 var DATABASE_URL_ENV = "ASSIST_BACKLOG_DATABASE_URL";
 var MISSING_URL_MESSAGE = `No backlog database configured.
 
@@ -911,27 +972,23 @@ function getDatabaseUrl() {
   }
   return url;
 }
-var _db;
 var _connecting;
 var _pool;
-function getBacklogDb() {
-  if (_db) return Promise.resolve(_db);
+var _orm;
+function getBacklogOrm() {
+  if (_orm) return Promise.resolve(_orm);
   if (_connecting) return _connecting;
   _connecting = (async () => {
     const pool = new Pool({ connectionString: getDatabaseUrl() });
     _pool = pool;
-    const db = makeBacklogDb(
-      { query: (sql2, params) => pool.query(sql2, params) },
-      pool
-    );
-    await ensureSchema(db);
-    _db = db;
-    return db;
+    await ensureSchema((sql4) => pool.query(sql4));
+    _orm = makeOrmFromPool(pool);
+    return _orm;
   })();
   return _connecting;
 }
 async function withBacklogClient(fn) {
-  await getBacklogDb();
+  await getBacklogOrm();
   const pool = _pool;
   if (!pool) {
     throw new Error("COPY streaming requires a pooled Postgres connection.");
@@ -947,7 +1004,7 @@ async function closeBacklogDb() {
   const pool = _pool;
   if (!pool) return;
   _pool = void 0;
-  _db = void 0;
+  _orm = void 0;
   _connecting = void 0;
   await pool.end();
 }
@@ -1001,55 +1058,44 @@ function getCurrentOrigin(cwd) {
   return `local:${root ?? cwd}`;
 }
 
+// src/commands/backlog/saveAllItems.ts
+import { eq as eq4, sql } from "drizzle-orm";
+
+// src/commands/backlog/deleteItemRelations.ts
+import { eq as eq3 } from "drizzle-orm";
+async function deleteItemRelations(db, itemId) {
+  await db.delete(planTasks).where(eq3(planTasks.itemId, itemId));
+  await db.delete(planPhases).where(eq3(planPhases.itemId, itemId));
+  await db.delete(comments).where(eq3(comments.itemId, itemId));
+  await db.delete(links).where(eq3(links.itemId, itemId));
+}
+
 // src/commands/backlog/saveAllItems.ts
 async function upsertItem(db, item, origin) {
-  await db.run(
-    `INSERT INTO items (id, origin, type, name, description, acceptance_criteria, status, current_phase)
-		 VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-		 ON CONFLICT(id) DO UPDATE SET
-			origin = excluded.origin,
-			type = excluded.type,
-			name = excluded.name,
-			description = excluded.description,
-			acceptance_criteria = excluded.acceptance_criteria,
-			status = excluded.status,
-			current_phase = excluded.current_phase`,
-    [
-      item.id,
-      origin,
-      item.type,
-      item.name,
-      item.description ?? null,
-      JSON.stringify(item.acceptanceCriteria),
-      item.status,
-      item.currentPhase ?? null
-    ]
-  );
+  const values = itemColumns(item, origin);
+  await db.insert(items).values({ id: item.id, ...values }).onConflictDoUpdate({ target: items.id, set: values });
   await deleteItemRelations(db, item.id);
   await insertItemRelations(db, item);
 }
 async function resyncSequences(db) {
-  await db.exec(
-    "SELECT setval(pg_get_serial_sequence('items', 'id'), COALESCE((SELECT MAX(id) FROM items), 0) + 1, false)"
+  await db.execute(
+    sql`SELECT setval(pg_get_serial_sequence('items', 'id'), COALESCE((SELECT MAX(id) FROM items), 0) + 1, false)`
   );
-  await db.exec(
-    "SELECT setval(pg_get_serial_sequence('comments', 'id'), COALESCE((SELECT MAX(id) FROM comments), 0) + 1, false)"
+  await db.execute(
+    sql`SELECT setval(pg_get_serial_sequence('comments', 'id'), COALESCE((SELECT MAX(id) FROM comments), 0) + 1, false)`
   );
 }
-async function saveAllItems(db, items, origin) {
-  await db.transaction(async (tx) => {
-    const existingIds = await tx.all(
-      "SELECT id FROM items WHERE origin = ?",
-      [origin]
-    );
-    const newIds = new Set(items.map((i) => i.id));
+async function saveAllItems(orm, file, origin) {
+  await orm.transaction(async (tx) => {
+    const existingIds = await tx.select({ id: items.id }).from(items).where(eq4(items.origin, origin));
+    const newIds = new Set(file.map((i) => i.id));
     for (const { id } of existingIds) {
       if (!newIds.has(id)) {
         await deleteItemRelations(tx, id);
-        await tx.run("DELETE FROM items WHERE id = ?", [id]);
+        await tx.delete(items).where(eq4(items.id, id));
       }
     }
-    for (const item of items) {
+    for (const item of file) {
       await upsertItem(tx, item, origin);
     }
     await resyncSequences(tx);
@@ -1057,51 +1103,35 @@ async function saveAllItems(db, items, origin) {
 }
 
 // src/commands/backlog/searchItemIds.ts
-async function searchItemIds(db, query, origin) {
+import { and, asc as asc3, eq as eq5, ilike, or } from "drizzle-orm";
+async function searchItemIds(orm, query, origin) {
   const pattern2 = `%${query}%`;
-  const rows = await db.all(
-    `SELECT DISTINCT i.id
-		 FROM items i
-		 LEFT JOIN comments c ON c.item_id = i.id
-		 LEFT JOIN plan_phases p ON p.item_id = i.id
-		 WHERE (?::text IS NULL OR i.origin = ?)
-		   AND (
-		     i.name ILIKE ?
-		     OR i.description ILIKE ?
-		     OR i.acceptance_criteria ILIKE ?
-		     OR c.text ILIKE ?
-		     OR p.name ILIKE ?
-		   )
-		 ORDER BY i.id`,
-    [
-      origin ?? null,
-      origin ?? null,
-      pattern2,
-      pattern2,
-      pattern2,
-      pattern2,
-      pattern2
-    ]
-  );
+  const rows = await orm.selectDistinct({ id: items.id }).from(items).leftJoin(comments, eq5(comments.itemId, items.id)).leftJoin(planPhases, eq5(planPhases.itemId, items.id)).where(
+    and(
+      origin ? eq5(items.origin, origin) : void 0,
+      or(
+        ilike(items.name, pattern2),
+        ilike(items.description, pattern2),
+        ilike(items.acceptanceCriteria, pattern2),
+        ilike(comments.text, pattern2),
+        ilike(planPhases.name, pattern2)
+      )
+    )
+  ).orderBy(asc3(items.id));
   return rows.map((r) => r.id);
 }
 
 // src/commands/backlog/updateCurrentPhase.ts
-async function updateCurrentPhase(db, id, phase) {
-  const result = await db.run(
-    "UPDATE items SET current_phase = ? WHERE id = ?",
-    [phase, id]
-  );
-  return result.changes > 0;
+import { eq as eq6 } from "drizzle-orm";
+async function updateCurrentPhase(orm, id, phase) {
+  await orm.update(items).set({ currentPhase: phase }).where(eq6(items.id, id));
 }
 
 // src/commands/backlog/updateStatus.ts
-async function updateStatus(db, id, status2) {
-  const result = await db.run("UPDATE items SET status = ? WHERE id = ?", [
-    status2,
-    id
-  ]);
-  return result.changes > 0;
+import { eq as eq7 } from "drizzle-orm";
+async function updateStatus(orm, id, status2) {
+  const [row] = await orm.update(items).set({ status: status2 }).where(eq7(items.id, id)).returning({ name: items.name });
+  return row?.name;
 }
 
 // src/commands/backlog/shared.ts
@@ -1115,58 +1145,54 @@ function getBacklogDir() {
 function getOrigin() {
   return getCurrentOrigin(getBacklogDir());
 }
-async function getDb() {
-  const db = await getBacklogDb();
+async function getReady() {
+  const orm = await getBacklogOrm();
   const dir = getBacklogDir();
-  await ensureMigrated(db, dir, getCurrentOrigin(dir));
-  return db;
+  await ensureMigrated(orm, dir, getCurrentOrigin(dir));
+  return { orm };
 }
 async function loadBacklog(allRepos = false) {
-  const db = await getDb();
-  return loadAllItems(db, allRepos ? void 0 : getOrigin());
+  const { orm } = await getReady();
+  return loadAllItems(orm, allRepos ? void 0 : getOrigin());
 }
 async function searchBacklog(query) {
-  const db = await getDb();
+  const { orm } = await getReady();
   const origin = getOrigin();
-  const ids = await searchItemIds(db, query, origin);
-  const allItems = await loadAllItems(db, origin);
+  const ids = await searchItemIds(orm, query, origin);
+  const allItems = await loadAllItems(orm, origin);
   return allItems.filter((item) => ids.includes(item.id));
 }
-async function saveBacklog(items) {
-  const db = await getDb();
-  await saveAllItems(db, items, getOrigin());
+async function saveBacklog(items2) {
+  const { orm } = await getReady();
+  await saveAllItems(orm, items2, getOrigin());
 }
-function findItem(items, id) {
-  return items.find((item) => item.id === id);
+function findItem(items2, id) {
+  return items2.find((item) => item.id === id);
 }
 async function loadAndFindItem(id) {
-  const items = await loadBacklog();
-  const item = findItem(items, Number.parseInt(id, 10));
+  const items2 = await loadBacklog();
+  const item = findItem(items2, Number.parseInt(id, 10));
   if (!item) {
     console.log(chalk6.red(`Item #${id} not found.`));
     return void 0;
   }
-  return { items, item };
+  return { items: items2, item };
 }
 async function setStatus(id, status2) {
-  const result = await loadAndFindItem(id);
-  if (!result) return void 0;
-  const db = await getBacklogDb();
-  await updateStatus(db, result.item.id, status2);
-  return result.item.name;
+  const { orm } = await getReady();
+  const name = await updateStatus(orm, Number.parseInt(id, 10), status2);
+  if (name === void 0) console.log(chalk6.red(`Item #${id} not found.`));
+  return name;
 }
 async function setCurrentPhase(id, phase) {
-  const result = await loadAndFindItem(id);
-  if (!result) return;
-  const db = await getBacklogDb();
-  await updateCurrentPhase(db, result.item.id, phase);
+  const { orm } = await getReady();
+  await updateCurrentPhase(orm, Number.parseInt(id, 10), phase);
 }
 async function removeItem(id) {
-  const result = await loadAndFindItem(id);
-  if (!result) return void 0;
-  const db = await getBacklogDb();
-  await deleteItem(db, result.item.id);
-  return result.item.name;
+  const { orm } = await getReady();
+  const name = await deleteItem(orm, Number.parseInt(id, 10));
+  if (name === void 0) console.log(chalk6.red(`Item #${id} not found.`));
+  return name;
 }
 
 // src/commands/backlog/acquireLock.ts
@@ -1232,17 +1258,17 @@ function phaseLabel(item) {
   if (!item.plan) return "";
   return chalk7.dim(` (phase ${item.currentPhase ?? 1}/${item.plan.length})`);
 }
-function isBlocked(item, items) {
+function isBlocked(item, items2) {
   const deps2 = (item.links ?? []).filter((l) => l.type === "depends-on");
   return deps2.some((dep) => {
-    const target = items.find((i) => i.id === dep.targetId);
+    const target = items2.find((i) => i.id === dep.targetId);
     return target !== void 0 && target.status !== "done";
   });
 }
-function dependencyLabel(item, items) {
+function dependencyLabel(item, items2) {
   const deps2 = (item.links ?? []).filter((l) => l.type === "depends-on");
   if (deps2.length === 0) return "";
-  if (isBlocked(item, items)) return chalk7.red(" [blocked]");
+  if (isBlocked(item, items2)) return chalk7.red(" [blocked]");
   return chalk7.dim(` [${deps2.length} dep${deps2.length > 1 ? "s" : ""}]`);
 }
 function printVerboseDetails(item) {
@@ -1259,21 +1285,21 @@ function printVerboseDetails(item) {
 }
 
 // src/commands/backlog/findResumable.ts
-function findResumable(items) {
-  return items.find(
-    (i) => i.status === "in-progress" && i.plan && !isLockedByOther(i.id) && !isBlocked(i, items)
+function findResumable(items2) {
+  return items2.find(
+    (i) => i.status === "in-progress" && i.plan && !isLockedByOther(i.id) && !isBlocked(i, items2)
   );
 }
 
 // src/commands/backlog/findUnblockedTodos.ts
 import chalk8 from "chalk";
-function findUnblockedTodos(items) {
-  const todo = items.filter((i) => i.status === "todo");
+function findUnblockedTodos(items2) {
+  const todo = items2.filter((i) => i.status === "todo");
   if (todo.length === 0) {
     console.log(chalk8.green("All backlog items complete."));
     return void 0;
   }
-  const unblocked = todo.filter((i) => !isBlocked(i, items));
+  const unblocked = todo.filter((i) => !isBlocked(i, items2));
   if (unblocked.length === 0) {
     console.log(
       chalk8.yellow("All remaining todo items are blocked by dependencies.")
@@ -1344,9 +1370,9 @@ function spawnClaude(prompt, options2 = {}) {
 }
 
 // src/commands/backlog/buildCommentLines.ts
-function buildCommentLines(comments2) {
-  if (!comments2?.length) return [];
-  return ["", "Comments:", ...comments2.map(formatPromptComment)];
+function buildCommentLines(comments3) {
+  if (!comments3?.length) return [];
+  return ["", "Comments:", ...comments3.map(formatPromptComment)];
 }
 function formatPromptComment(entry) {
   const id = entry.id !== void 0 ? `#${entry.id} ` : "";
@@ -1503,8 +1529,8 @@ function cleanupSignal() {
   }
 }
 async function isTerminalStatus(itemId) {
-  const items = await loadBacklog();
-  const item = items.find((i) => i.id === itemId);
+  const items2 = await loadBacklog();
+  const item = items2.find((i) => i.id === itemId);
   return item?.status === "done" || item?.status === "wontdo";
 }
 async function resolvePhaseResult(phaseIndex, itemId) {
@@ -1660,23 +1686,23 @@ async function ensureDone(id) {
 }
 
 // src/commands/backlog/next.ts
-function toChoice(item, items) {
+function toChoice(item, items2) {
   const name = `${typeLabel(item.type)} #${item.id}: ${item.name}`;
-  return isBlocked(item, items) ? { name, disabled: chalk13.red("[blocked]") } : { name };
+  return isBlocked(item, items2) ? { name, disabled: chalk13.red("[blocked]") } : { name };
 }
-async function selectItem(todo, items) {
+async function selectItem(todo, items2) {
   const { selected } = await exitOnCancel(
     enquirer2.prompt({
       type: "select",
       name: "selected",
       message: "Choose a backlog item to start:",
-      choices: todo.map((i) => toChoice(i, items))
+      choices: todo.map((i) => toChoice(i, items2))
     })
   );
   return selected.match(/#(\d+)/)?.[1] ?? "";
 }
-async function pickItem(items, firstPick = false) {
-  const resumable = findResumable(items);
+async function pickItem(items2, firstPick = false) {
+  const resumable = findResumable(items2);
   if (resumable) {
     console.log(
       chalk13.bold(
@@ -1685,15 +1711,15 @@ async function pickItem(items, firstPick = false) {
     );
     return String(resumable.id);
   }
-  const unblocked = findUnblockedTodos(items);
+  const unblocked = findUnblockedTodos(items2);
   if (!unblocked) return void 0;
   if (firstPick && unblocked.length === 1) {
     const item = unblocked[0];
     console.log(chalk13.bold(`Auto-selecting item #${item.id}: ${item.name}`));
     return String(item.id);
   }
-  const todo = items.filter((i) => i.status === "todo");
-  return selectItem(todo, items);
+  const todo = items2.filter((i) => i.status === "todo");
+  return selectItem(todo, items2);
 }
 async function next(options2) {
   if (blockedByHandover()) return;
@@ -1710,46 +1736,50 @@ async function next(options2) {
 // src/commands/backlog/phaseDone.ts
 import chalk14 from "chalk";
 
-// src/commands/backlog/addComment.ts
-function addComment(item, text, phase) {
-  const entry = {
-    text,
+// src/commands/backlog/appendComment.ts
+import { sql as sql2 } from "drizzle-orm";
+async function appendComment(orm, itemId, text2, opts = {}) {
+  await orm.insert(comments).values({
+    itemId,
+    idx: sql2`(SELECT COALESCE(MAX(${comments.idx}) + 1, 0) FROM ${comments} WHERE ${comments.itemId} = ${itemId})`,
+    text: text2,
+    phase: opts.phase ?? null,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    type: "comment",
-    ...phase !== void 0 && { phase }
-  };
-  if (!item.comments) item.comments = [];
-  item.comments.push(entry);
+    type: opts.type ?? "comment"
+  });
 }
-function addPhaseSummary(item, text, phase) {
-  const entry = {
-    text,
-    phase,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    type: "summary"
-  };
-  if (!item.comments) item.comments = [];
-  item.comments.push(entry);
+
+// src/commands/backlog/getItemStatus.ts
+import { eq as eq8 } from "drizzle-orm";
+async function getItemStatus(orm, id) {
+  const [row] = await orm.select({ status: items.status }).from(items).where(eq8(items.id, id));
+  return row?.status;
 }
 
 // src/commands/backlog/phaseDone.ts
 async function phaseDone(id, phase, summary) {
   const phaseNumber = Number.parseInt(phase, 10);
   const phaseIndex = phaseNumber - 1;
+  const itemId = Number.parseInt(id, 10);
   writeSignal("phase-done", {
-    itemId: Number.parseInt(id, 10),
+    itemId,
     phaseIndex,
     completedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
-  const result = await loadAndFindItem(id);
-  if (result?.item.status === "done") {
-    console.log(chalk14.dim(`Item #${id} already done, skipping phase advance.`));
+  const { orm } = await getReady();
+  const status2 = await getItemStatus(orm, itemId);
+  if (status2 === void 0) {
+    console.log(chalk14.red(`Item #${id} not found.`));
     return;
   }
-  if (result) {
-    addPhaseSummary(result.item, summary, phaseNumber);
-    await saveBacklog(result.items);
+  if (status2 === "done") {
+    console.log(chalk14.dim(`Item #${id} already done, skipping phase advance.`));
+    return;
   }
+  await appendComment(orm, itemId, summary, {
+    phase: phaseNumber,
+    type: "summary"
+  });
   await setCurrentPhase(id, phaseNumber + 1);
   console.log(
     chalk14.green(`Phase ${phaseNumber} of item #${id} marked as complete.`)
@@ -1793,12 +1823,12 @@ function formatComment(entry) {
 
 // src/commands/backlog/show/printLinks.ts
 import chalk17 from "chalk";
-function printLinks(item, items) {
-  const links = item.links ?? [];
-  if (links.length === 0) return;
+function printLinks(item, items2) {
+  const links2 = item.links ?? [];
+  if (links2.length === 0) return;
   console.log(chalk17.bold("Links"));
-  for (const link3 of links) {
-    const target = items.find((i) => i.id === link3.targetId);
+  for (const link3 of links2) {
+    const target = items2.find((i) => i.id === link3.targetId);
     const typeLabel2 = link3.type === "depends-on" ? chalk17.red("depends-on") : chalk17.blue("relates-to");
     if (target) {
       console.log(
@@ -1837,14 +1867,14 @@ function printPlan(item) {
   }
   console.log();
 }
-function phaseHeader(index, name, isCurrent) {
-  const phaseNumber = index + 1;
+function phaseHeader(index2, name, isCurrent) {
+  const phaseNumber = index2 + 1;
   const marker = isCurrent ? chalk19.green("\u25B6 ") : "  ";
   const label2 = isCurrent ? chalk19.green.bold(`Phase ${phaseNumber}: ${name}`) : `${chalk19.bold(`Phase ${phaseNumber}:`)} ${name}`;
   return `${marker}${label2}`;
 }
-function printPhase(phase, index, isCurrent) {
-  console.log(phaseHeader(index, phase.name, isCurrent));
+function printPhase(phase, index2, isCurrent) {
+  console.log(phaseHeader(index2, phase.name, isCurrent));
   printPhaseTasks(phase);
 }
 function printHeader(item) {
@@ -1865,7 +1895,7 @@ function printAcceptanceCriteria(criteria) {
 async function show(id) {
   const result = await loadAndFindItem(id);
   if (!result) process.exit(1);
-  const { item, items } = result;
+  const { item, items: items2 } = result;
   printHeader(item);
   if (item.description) {
     console.log(chalk19.bold("Description"));
@@ -1873,7 +1903,7 @@ async function show(id) {
     console.log();
   }
   printAcceptanceCriteria(item.acceptanceCriteria);
-  printLinks(item, items);
+  printLinks(item, items2);
   printPlan(item);
   printComments(item);
 }
@@ -2009,7 +2039,7 @@ async function parseRewindBody(req) {
 // src/commands/backlog/web/createItem.ts
 async function createItem(req, res) {
   const body = await parseItemBody(req);
-  const db = await getBacklogDb();
+  const orm = await getBacklogOrm();
   const newItem = {
     type: body.type ?? "story",
     name: body.name,
@@ -2017,15 +2047,37 @@ async function createItem(req, res) {
     acceptanceCriteria: body.acceptanceCriteria ?? [],
     status: "todo"
   };
-  const id = await insertItem(db, newItem, getOrigin());
+  const id = await insertItem(orm, newItem, getOrigin());
   respondJson(res, 201, { id, ...newItem });
 }
 
+// src/commands/backlog/addComment.ts
+function addComment(item, text2, phase) {
+  const entry = {
+    text: text2,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    type: "comment",
+    ...phase !== void 0 && { phase }
+  };
+  if (!item.comments) item.comments = [];
+  item.comments.push(entry);
+}
+function addPhaseSummary(item, text2, phase) {
+  const entry = {
+    text: text2,
+    phase,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    type: "summary"
+  };
+  if (!item.comments) item.comments = [];
+  item.comments.push(entry);
+}
+
 // src/commands/backlog/web/rewindItemPhase.ts
 async function rewindItemPhase(req, res, id) {
   const { phase, reason } = await parseRewindBody(req);
-  const items = await loadBacklog();
-  const item = items.find((i) => i.id === id);
+  const items2 = await loadBacklog();
+  const item = items2.find((i) => i.id === id);
   if (!item) {
     respondJson(res, 404, { error: "Not found" });
     return;
@@ -2043,7 +2095,7 @@ async function rewindItemPhase(req, res, id) {
   );
   item.currentPhase = phase;
   item.status = "in-progress";
-  await saveBacklog(items);
+  await saveBacklog(items2);
   respondJson(res, 200, item);
 }
 function validateRewind(item, phase) {
@@ -2067,13 +2119,13 @@ async function listItems(req, res) {
   respondJson(res, 200, q ? await searchBacklog(q) : await loadBacklog());
 }
 async function findItemOr404(res, id) {
-  const items = await loadBacklog();
-  const item = items.find((i) => i.id === id);
+  const items2 = await loadBacklog();
+  const item = items2.find((i) => i.id === id);
   if (!item) {
     respondJson(res, 404, { error: "Not found" });
     return void 0;
   }
-  return { items, item };
+  return { items: items2, item };
 }
 async function getItemById(res, id) {
   const result = await findItemOr404(res, id);
@@ -2539,8 +2591,8 @@ function safeParse(line) {
 function extractName(entry) {
   const msg = entry.message;
   const content = msg?.content;
-  const text = typeof content === "string" ? content : Array.isArray(content) ? content.find((c) => c.type === "text")?.text ?? "" : "";
-  return text.replace(/<command-[^>]*>[^<]*<\/command-[^>]*>/g, "").trim().slice(0, 80);
+  const text2 = typeof content === "string" ? content : Array.isArray(content) ? content.find((c) => c.type === "text")?.text ?? "" : "";
+  return text2.replace(/<command-[^>]*>[^<]*<\/command-[^>]*>/g, "").trim().slice(0, 80);
 }
 
 // src/commands/sessions/web/parseSessionFile.ts
@@ -2839,9 +2891,9 @@ import chalk22 from "chalk";
 // src/commands/backlog/tryRunById.ts
 import chalk21 from "chalk";
 async function tryRunById(id, options2) {
-  const items = await loadBacklog();
+  const items2 = await loadBacklog();
   const numericId = Number.parseInt(id, 10);
-  const item = Number.isNaN(numericId) ? void 0 : items.find((i) => i.id === numericId);
+  const item = Number.isNaN(numericId) ? void 0 : items2.find((i) => i.id === numericId);
   if (!item) {
     console.log(chalk21.red(`Item #${id} not found.`));
     return false;
@@ -2854,7 +2906,7 @@ async function tryRunById(id, options2) {
     console.log(chalk21.red(`Item #${id} is marked won't do.`));
     return false;
   }
-  if (isBlocked(item, items)) {
+  if (isBlocked(item, items2)) {
     console.log(
       chalk21.red(`Item #${id} is blocked by unresolved dependencies.`)
     );
@@ -2889,8 +2941,8 @@ async function launchMode(slashCommand) {
 import chalk23 from "chalk";
 import enquirer3 from "enquirer";
 async function pickItemForRefine() {
-  const items = await loadBacklog();
-  const active = items.filter(
+  const items2 = await loadBacklog();
+  const active = items2.filter(
     (i) => i.status === "todo" || i.status === "in-progress"
   );
   if (active.length === 0) {
@@ -3606,8 +3658,8 @@ var options = [
 ];
 
 // src/commands/verify/init/getAvailableOptions/index.ts
-function resolveDescription(desc, setup2) {
-  return typeof desc === "function" ? desc(setup2) : desc;
+function resolveDescription(desc2, setup2) {
+  return typeof desc2 === "function" ? desc2(setup2) : desc2;
 }
 function toVerifyOption(def, setup2) {
   return {
@@ -4332,10 +4384,10 @@ ${failed2.length} script(s) failed:`);
     console.error(`  - ${f.script} (exit code ${f.code})`);
   }
 }
-function createTimerCallback(taskStatuses, index) {
+function createTimerCallback(taskStatuses, index2) {
   return (exitCode) => {
-    taskStatuses[index].endTime = Date.now();
-    taskStatuses[index].code = exitCode;
+    taskStatuses[index2].endTime = Date.now();
+    taskStatuses[index2].code = exitCode;
     printTaskStatuses(taskStatuses);
   };
 }
@@ -4414,9 +4466,9 @@ function runAllEntries(entries, timer) {
   const taskStatuses = initTaskStatuses(entries.map((e) => e.name));
   return Promise.all(
     entries.map(
-      (entry, index) => runEntry(
+      (entry, index2) => runEntry(
         entry,
-        timer ? createTimerCallback(taskStatuses, index) : void 0
+        timer ? createTimerCallback(taskStatuses, index2) : void 0
       )
     )
   );
@@ -4900,13 +4952,13 @@ async function activity(options2) {
   const activeDays = data.filter((d) => d.count > 0).length;
   console.log(`${total} commits across ${activeDays} active days.`);
   const weekly = /* @__PURE__ */ new Map();
-  for (const { date, count } of data) {
+  for (const { date, count: count4 } of data) {
     const d = new Date(date);
     d.setDate(d.getDate() - d.getDay());
     const weekStart = d.toISOString().slice(0, 10);
-    weekly.set(weekStart, (weekly.get(weekStart) ?? 0) + count);
+    weekly.set(weekStart, (weekly.get(weekStart) ?? 0) + count4);
   }
-  const weeklyData = [...weekly.entries()].map(([date, count]) => ({ date, count })).sort((a, b) => a.date.localeCompare(b.date));
+  const weeklyData = [...weekly.entries()].map(([date, count4]) => ({ date, count: count4 })).sort((a, b) => a.date.localeCompare(b.date));
   const until = data[data.length - 1].date;
   activityChart(weeklyData, { since, until });
 }
@@ -4921,17 +4973,17 @@ function registerActivity(program2) {
 
 // src/commands/backlog/comment/index.ts
 import chalk46 from "chalk";
-async function comment(id, text) {
+async function comment(id, text2) {
   const result = await loadAndFindItem(id);
   if (!result) process.exit(1);
-  addComment(result.item, text);
+  addComment(result.item, text2);
   await saveBacklog(result.items);
   console.log(chalk46.green(`Comment added to item #${id}.`));
 }
 
 // src/commands/backlog/comments/index.ts
 import chalk47 from "chalk";
-async function comments(id) {
+async function comments2(id) {
   const result = await loadAndFindItem(id);
   if (!result) process.exit(1);
   const { item } = result;
@@ -4952,17 +5004,12 @@ async function comments(id) {
 import chalk48 from "chalk";
 
 // src/commands/backlog/deleteComment.ts
-async function deleteComment(db, itemId, commentId) {
-  const row = await db.get(
-    "SELECT type FROM comments WHERE id = ? AND item_id = ?",
-    [commentId, itemId]
-  );
+import { and as and2, eq as eq9 } from "drizzle-orm";
+async function deleteComment(orm, itemId, commentId) {
+  const [row] = await orm.select({ type: comments.type }).from(comments).where(and2(eq9(comments.id, commentId), eq9(comments.itemId, itemId)));
   if (!row) return "not-found";
   if (row.type === "summary") return "is-summary";
-  await db.run("DELETE FROM comments WHERE id = ? AND item_id = ?", [
-    commentId,
-    itemId
-  ]);
+  await orm.delete(comments).where(and2(eq9(comments.id, commentId), eq9(comments.itemId, itemId)));
   return "deleted";
 }
 
@@ -4970,9 +5017,9 @@ async function deleteComment(db, itemId, commentId) {
 async function deleteCommentCmd(id, commentId) {
   const result = await loadAndFindItem(id);
   if (!result) process.exit(1);
-  const db = await getBacklogDb();
+  const orm = await getBacklogOrm();
   const outcome = await deleteComment(
-    db,
+    orm,
     result.item.id,
     Number.parseInt(commentId, 10)
   );
@@ -5000,7 +5047,7 @@ async function deleteCommentCmd(id, commentId) {
 // src/commands/backlog/registerCommentCommands.ts
 function registerCommentCommands(cmd) {
   cmd.command("comment <id> <text>").description("Add a comment to a backlog item").action(comment);
-  cmd.command("comments <id>").description("List comments and summaries for a backlog item").action(comments);
+  cmd.command("comments <id>").description("List comments and summaries for a backlog item").action(comments2);
   cmd.command("delete-comment <id> <comment-id>").description("Delete a comment from a backlog item").action(deleteCommentCmd);
 }
 
@@ -5056,8 +5103,8 @@ async function buildDump(copyOut) {
 // src/commands/backlog/dump/copyTableOut.ts
 import { to as copyTo } from "pg-copy-streams";
 async function copyTableOut(client, table) {
-  const sql2 = `COPY ${table.name} (${table.columns.join(", ")}) TO STDOUT`;
-  const stream = client.query(copyTo(sql2));
+  const sql4 = `COPY ${table.name} (${table.columns.join(", ")}) TO STDOUT`;
+  const stream = client.query(copyTo(sql4));
   const chunks = [];
   for await (const chunk of stream) {
     chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
@@ -5094,10 +5141,10 @@ import chalk51 from "chalk";
 // src/commands/backlog/dump/countCopyRows.ts
 function countCopyRows(data) {
   let rows = 0;
-  let index = data.indexOf(10);
-  while (index !== -1) {
+  let index2 = data.indexOf(10);
+  while (index2 !== -1) {
     rows++;
-    index = data.indexOf(10, index + 1);
+    index2 = data.indexOf(10, index2 + 1);
   }
   return rows;
 }
@@ -5113,9 +5160,9 @@ function readLine(dump, start3) {
   return { text: dump.subarray(start3, eol).toString("utf8"), next: eol + 1 };
 }
 function parseHeader(dump) {
-  const { text, next: next3 } = readLine(dump, 0);
+  const { text: text2, next: next3 } = readLine(dump, 0);
   try {
-    return { header: JSON.parse(text), bodyStart: next3 };
+    return { header: JSON.parse(text2), bodyStart: next3 };
   } catch {
     return invalid("header is not valid JSON.");
   }
@@ -5124,9 +5171,9 @@ function parseSections(dump, bodyStart) {
   const sections = /* @__PURE__ */ new Map();
   let cursor = bodyStart;
   while (cursor < dump.length) {
-    const { text, next: next3 } = readLine(dump, cursor);
-    const match = text.match(/^@table (\S+) (\d+)$/);
-    if (!match) invalid(`malformed table marker "${text}".`);
+    const { text: text2, next: next3 } = readLine(dump, cursor);
+    const match = text2.match(/^@table (\S+) (\d+)$/);
+    if (!match) invalid(`malformed table marker "${text2}".`);
     const [, name, bytes] = match;
     const end = next3 + Number(bytes);
     if (end > dump.length) invalid(`section "${name}" overruns the dump.`);
@@ -5207,8 +5254,8 @@ async function readStdinBuffer() {
 import { finished } from "stream/promises";
 import { from as copyFrom } from "pg-copy-streams";
 async function copyTableIn(client, table, data) {
-  const sql2 = `COPY ${table.name} (${table.columns.join(", ")}) FROM STDIN`;
-  const stream = client.query(copyFrom(sql2));
+  const sql4 = `COPY ${table.name} (${table.columns.join(", ")}) FROM STDIN`;
+  const stream = client.query(copyFrom(sql4));
   stream.end(data);
   await finished(stream);
 }
@@ -5354,9 +5401,9 @@ async function add(options2) {
   const name = options2.name ?? await promptName();
   const description = options2.desc?.replaceAll("\\n", "\n") ?? await promptDescription();
   const acceptanceCriteria2 = options2.ac ?? await promptAcceptanceCriteria();
-  const db = await getBacklogDb();
+  const orm = await getBacklogOrm();
   const id = await insertItem(
-    db,
+    orm,
     {
       type,
       name,
@@ -5373,48 +5420,37 @@ async function add(options2) {
 import chalk54 from "chalk";
 
 // src/commands/backlog/insertPhaseAt.ts
-async function insertPhaseAt(db, itemId, phaseIdx, name, tasks, manualChecks, currentPhase) {
-  await db.transaction(async (tx) => {
-    const toShift = await tx.all(
-      "SELECT idx FROM plan_phases WHERE item_id = ? AND idx >= ? ORDER BY idx DESC",
-      [itemId, phaseIdx]
-    );
-    for (const p of toShift) {
-      await tx.run(
-        "UPDATE plan_tasks SET phase_idx = ? WHERE item_id = ? AND phase_idx = ?",
-        [p.idx + 1, itemId, p.idx]
-      );
-      await tx.run(
-        "UPDATE plan_phases SET idx = ? WHERE item_id = ? AND idx = ?",
-        [p.idx + 1, itemId, p.idx]
-      );
-    }
-    await tx.run(
-      "INSERT INTO plan_phases (item_id, idx, name, manual_checks) VALUES (?, ?, ?, ?)",
-      [itemId, phaseIdx, name, manualChecks]
-    );
-    for (let i = 0; i < tasks.length; i++) {
-      await tx.run(
-        "INSERT INTO plan_tasks (item_id, phase_idx, idx, task) VALUES (?, ?, ?, ?)",
-        [itemId, phaseIdx, i, tasks[i]]
-      );
+import { eq as eq11 } from "drizzle-orm";
+
+// src/commands/backlog/shiftPhasesUp.ts
+import { and as and3, desc, eq as eq10, gte } from "drizzle-orm";
+async function shiftPhasesUp(db, itemId, fromIdx) {
+  const toShift = await db.select({ idx: planPhases.idx }).from(planPhases).where(and3(eq10(planPhases.itemId, itemId), gte(planPhases.idx, fromIdx))).orderBy(desc(planPhases.idx));
+  for (const p of toShift) {
+    await db.update(planTasks).set({ phaseIdx: p.idx + 1 }).where(and3(eq10(planTasks.itemId, itemId), eq10(planTasks.phaseIdx, p.idx)));
+    await db.update(planPhases).set({ idx: p.idx + 1 }).where(and3(eq10(planPhases.itemId, itemId), eq10(planPhases.idx, p.idx)));
+  }
+}
+
+// src/commands/backlog/insertPhaseAt.ts
+async function insertPhaseAt(orm, itemId, phaseIdx, name, tasks, manualChecks, currentPhase) {
+  await orm.transaction(async (tx) => {
+    await shiftPhasesUp(tx, itemId, phaseIdx);
+    await tx.insert(planPhases).values({ itemId, idx: phaseIdx, name, manualChecks });
+    if (tasks.length) {
+      await tx.insert(planTasks).values(tasks.map((task, i) => ({ itemId, phaseIdx, idx: i, task })));
     }
     if (currentPhase !== void 0 && currentPhase - 1 >= phaseIdx) {
-      await tx.run("UPDATE items SET current_phase = ? WHERE id = ?", [
-        currentPhase + 1,
-        itemId
-      ]);
+      await tx.update(items).set({ currentPhase: currentPhase + 1 }).where(eq11(items.id, itemId));
     }
   });
 }
 
 // src/commands/backlog/resolveInsertPosition.ts
 import chalk53 from "chalk";
-async function resolveInsertPosition(db, itemId, position) {
-  const row = await db.get(
-    "SELECT COUNT(*)::int as cnt FROM plan_phases WHERE item_id = ?",
-    [itemId]
-  );
+import { count, eq as eq12 } from "drizzle-orm";
+async function resolveInsertPosition(orm, itemId, position) {
+  const [row] = await orm.select({ cnt: count() }).from(planPhases).where(eq12(planPhases.itemId, itemId));
   const phaseCount = row?.cnt ?? 0;
   if (position === void 0) return phaseCount;
   const pos = Number.parseInt(position, 10);
@@ -5445,12 +5481,12 @@ async function addPhase(id, name, options2) {
     process.exitCode = 1;
     return;
   }
-  const db = await getBacklogDb();
+  const orm = await getBacklogOrm();
   const itemId = result.item.id;
-  const phaseIdx = await resolveInsertPosition(db, itemId, options2.position);
+  const phaseIdx = await resolveInsertPosition(orm, itemId, options2.position);
   if (phaseIdx === void 0) return;
   await insertPhaseAt(
-    db,
+    orm,
     itemId,
     phaseIdx,
     name,
@@ -5469,7 +5505,7 @@ async function addPhase(id, name, options2) {
 // src/commands/backlog/init/index.ts
 import chalk55 from "chalk";
 async function init6() {
-  await getBacklogDb();
+  await getBacklogOrm();
   console.log(
     chalk55.green(
       `Backlog database ready. This repository maps to origin: ${getOrigin()}`
@@ -5493,22 +5529,22 @@ function originDisplayName(origin) {
 }
 
 // src/commands/backlog/list/index.ts
-function filterItems(items, options2) {
-  if (options2.status) return items.filter((i) => i.status === options2.status);
+function filterItems(items2, options2) {
+  if (options2.status) return items2.filter((i) => i.status === options2.status);
   if (!options2.all)
-    return items.filter((i) => i.status !== "done" && i.status !== "wontdo");
-  return items;
+    return items2.filter((i) => i.status !== "done" && i.status !== "wontdo");
+  return items2;
 }
 async function list2(options2) {
   const allItems = await loadBacklog(options2.allRepos);
-  const items = filterItems(allItems, options2);
-  if (items.length === 0) {
+  const items2 = filterItems(allItems, options2);
+  if (items2.length === 0) {
     console.log(chalk56.dim("Backlog is empty."));
     return;
   }
   const repoNameOf = (item) => item.origin ? originDisplayName(item.origin) : "";
-  const prefixWidth = options2.allRepos ? Math.max(0, ...items.map((i) => repoNameOf(i).length)) : 0;
-  for (const item of items) {
+  const prefixWidth = options2.allRepos ? Math.max(0, ...items2.map((i) => repoNameOf(i).length)) : 0;
+  for (const item of items2) {
     const repoPrefix2 = options2.allRepos ? `${chalk56.dim(repoNameOf(item).padEnd(prefixWidth))} ` : "";
     console.log(
       `${repoPrefix2}${statusIcon(item.status)} ${typeLabel(item.type)} ${chalk56.dim(`#${item.id}`)} ${item.name}${phaseLabel(item)}${dependencyLabel(item, allItems)}`
@@ -5540,7 +5576,7 @@ function registerItemCommands(cmd) {
 import chalk58 from "chalk";
 
 // src/commands/backlog/hasCycle.ts
-function hasCycle(items, fromId, toId) {
+function hasCycle(adjacency, fromId, toId) {
   const visited = /* @__PURE__ */ new Set();
   const stack = [toId];
   while (stack.length > 0) {
@@ -5548,100 +5584,107 @@ function hasCycle(items, fromId, toId) {
     if (current === fromId) return true;
     if (visited.has(current)) continue;
     visited.add(current);
-    const item = items.find((i) => i.id === current);
-    if (!item?.links) continue;
-    for (const link3 of item.links) {
-      if (link3.type === "depends-on") {
-        stack.push(link3.targetId);
-      }
+    for (const target of adjacency.get(current) ?? []) {
+      stack.push(target);
     }
   }
   return false;
 }
 
+// src/commands/backlog/loadDependencyGraph.ts
+import { eq as eq13 } from "drizzle-orm";
+async function loadDependencyGraph(orm) {
+  const rows = await orm.select({ itemId: links.itemId, targetId: links.targetId }).from(links).where(eq13(links.type, "depends-on"));
+  const graph = /* @__PURE__ */ new Map();
+  for (const { itemId, targetId } of rows) {
+    const bucket = graph.get(itemId);
+    if (bucket) bucket.push(targetId);
+    else graph.set(itemId, [targetId]);
+  }
+  return graph;
+}
+
+// src/commands/backlog/loadItem.ts
+import { eq as eq14 } from "drizzle-orm";
+async function loadItem(orm, id) {
+  const [row] = await orm.select().from(items).where(eq14(items.id, id));
+  if (!row) return void 0;
+  const rel = await loadRelations(orm, [id]);
+  return rowToItem(row, rel);
+}
+
 // src/commands/backlog/validateLinkTarget.ts
 import chalk57 from "chalk";
-function validateLinkTarget(items, fromItem, fromId, toId, toNum, linkType) {
-  const toItem = items.find((i) => i.id === toNum);
-  if (!toItem) {
-    console.log(chalk57.red(`Item #${toId} not found.`));
-    return void 0;
-  }
-  if (!fromItem.links) fromItem.links = [];
-  const duplicate = fromItem.links.some(
+function validateLinkTarget(fromItem, fromNum, toNum, linkType) {
+  const duplicate = (fromItem.links ?? []).some(
     (l) => l.targetId === toNum && l.type === linkType
   );
   if (duplicate) {
     console.log(
-      chalk57.yellow(`Link already exists: #${fromId} ${linkType} #${toId}`)
+      chalk57.yellow(`Link already exists: #${fromNum} ${linkType} #${toNum}`)
     );
-    return void 0;
+    return false;
   }
-  return toItem;
+  return true;
 }
 
 // src/commands/backlog/link.ts
+function fail(message) {
+  console.log(chalk58.red(message));
+  return void 0;
+}
+function parseLinkType(type) {
+  const linkType = type ?? "relates-to";
+  if (linkType === "relates-to" || linkType === "depends-on") return linkType;
+  return fail(`Invalid link type: ${linkType}`);
+}
+async function createsCycle(orm, linkType, fromNum, toNum) {
+  if (linkType !== "depends-on") return false;
+  const graph = await loadDependencyGraph(orm);
+  if (!hasCycle(graph, fromNum, toNum)) return false;
+  fail(`Cannot add dependency: #${fromNum} \u2192 #${toNum} would create a cycle.`);
+  return true;
+}
 async function link(fromId, toId, opts) {
-  const linkType = opts.type ?? "relates-to";
-  if (linkType !== "relates-to" && linkType !== "depends-on") {
-    console.log(chalk58.red(`Invalid link type: ${linkType}`));
-    return;
-  }
+  const linkType = parseLinkType(opts.type);
+  if (!linkType) return;
   const fromNum = Number.parseInt(fromId, 10);
   const toNum = Number.parseInt(toId, 10);
-  if (fromNum === toNum) {
-    console.log(chalk58.red("Cannot link an item to itself."));
-    return;
-  }
-  const result = await loadAndFindItem(fromId);
-  if (!result) return;
-  const { items, item: fromItem } = result;
-  const toItem = validateLinkTarget(
-    items,
-    fromItem,
-    fromId,
-    toId,
-    toNum,
-    linkType
-  );
-  if (!toItem) return;
-  if (linkType === "depends-on" && hasCycle(items, fromNum, toNum)) {
-    console.log(
-      chalk58.red(
-        `Cannot add dependency: #${fromId} \u2192 #${toId} would create a circular dependency.`
-      )
-    );
-    return;
-  }
-  if (!fromItem.links) fromItem.links = [];
-  fromItem.links.push({ type: linkType, targetId: toNum });
-  await saveBacklog(items);
+  if (fromNum === toNum) return void fail("Cannot link an item to itself.");
+  const { orm } = await getReady();
+  const fromItem = await loadItem(orm, fromNum);
+  if (!fromItem) return void fail(`Item #${fromNum} not found.`);
+  const toItem = await loadItem(orm, toNum);
+  if (!toItem) return void fail(`Item #${toNum} not found.`);
+  if (!validateLinkTarget(fromItem, fromNum, toNum, linkType)) return;
+  if (await createsCycle(orm, linkType, fromNum, toNum)) return;
+  await orm.insert(links).values({ itemId: fromNum, type: linkType, targetId: toNum });
   console.log(
-    chalk58.green(`Linked #${fromId} ${linkType} #${toId} (${toItem.name})`)
+    chalk58.green(`Linked #${fromNum} ${linkType} #${toNum} (${toItem.name})`)
   );
 }
 
 // src/commands/backlog/unlink.ts
 import chalk59 from "chalk";
+import { and as and4, eq as eq15 } from "drizzle-orm";
 async function unlink(fromId, toId) {
+  const fromNum = Number.parseInt(fromId, 10);
   const toNum = Number.parseInt(toId, 10);
-  const result = await loadAndFindItem(fromId);
-  if (!result) return;
-  const { items, item: fromItem } = result;
+  const { orm } = await getReady();
+  const fromItem = await loadItem(orm, fromNum);
+  if (!fromItem) {
+    console.log(chalk59.red(`Item #${fromId} not found.`));
+    return;
+  }
   if (!fromItem.links || fromItem.links.length === 0) {
     console.log(chalk59.yellow(`No links found on item #${fromId}.`));
     return;
   }
-  const before = fromItem.links.length;
-  fromItem.links = fromItem.links.filter((l) => l.targetId !== toNum);
-  if (fromItem.links.length === before) {
+  if (!fromItem.links.some((l) => l.targetId === toNum)) {
     console.log(chalk59.yellow(`No link from #${fromId} to #${toId} found.`));
     return;
   }
-  if (fromItem.links.length === 0) {
-    fromItem.links = void 0;
-  }
-  await saveBacklog(items);
+  await orm.delete(links).where(and4(eq15(links.itemId, fromNum), eq15(links.targetId, toNum)));
   console.log(chalk59.green(`Removed link from #${fromId} to #${toId}.`));
 }
 
@@ -5679,9 +5722,12 @@ function validateRewind2(item, phaseNumber) {
 async function rewindPhase(id, phase, opts) {
   const phaseNumber = Number.parseInt(phase, 10);
   const phaseIndex = phaseNumber - 1;
-  const result = await loadAndFindItem(id);
-  if (!result) return;
-  const { item } = result;
+  const { orm } = await getReady();
+  const item = await loadItem(orm, Number.parseInt(id, 10));
+  if (!item) {
+    console.log(chalk60.red(`Item #${id} not found.`));
+    return;
+  }
   const error = validateRewind2(item, phaseNumber);
   if (error) {
     console.log(chalk60.red(error));
@@ -5689,12 +5735,12 @@ async function rewindPhase(id, phase, opts) {
     return;
   }
   const phaseName = item.plan?.[phaseIndex].name;
-  addComment(
-    item,
+  await appendComment(
+    orm,
+    item.id,
     `Rewound to phase ${phaseNumber} (${phaseName}): ${opts.reason}`,
-    phaseNumber
+    { phase: phaseNumber }
   );
-  await saveBacklog(result.items);
   await setCurrentPhase(id, phaseNumber);
   await setStatus(id, "in-progress");
   writeSignal("rewind", {
@@ -5721,18 +5767,18 @@ function registerRunCommand(cmd) {
 // src/commands/backlog/search/index.ts
 import chalk61 from "chalk";
 async function search(query) {
-  const items = await searchBacklog(query);
-  if (items.length === 0) {
+  const items2 = await searchBacklog(query);
+  if (items2.length === 0) {
     console.log(chalk61.dim(`No items matching "${query}".`));
     return;
   }
   console.log(
     chalk61.dim(
-      `${items.length} item${items.length === 1 ? "" : "s"} matching "${query}":
+      `${items2.length} item${items2.length === 1 ? "" : "s"} matching "${query}":
 `
     )
   );
-  for (const item of items) {
+  for (const item of items2) {
     console.log(
       `${statusIcon(item.status)} ${typeLabel(item.type)} ${chalk61.dim(`#${item.id}`)} ${item.name}`
     );
@@ -5796,8 +5842,8 @@ async function start(id) {
 // src/commands/backlog/stop/index.ts
 import chalk65 from "chalk";
 async function stop() {
-  const items = await loadBacklog();
-  const inProgress = items.filter((item) => item.status === "in-progress");
+  const items2 = await loadBacklog();
+  const inProgress = items2.filter((item) => item.status === "in-progress");
   if (inProgress.length === 0) {
     console.log(chalk65.yellow("No in-progress items to stop."));
     return;
@@ -5806,7 +5852,7 @@ async function stop() {
     item.status = "todo";
     item.currentPhase = 1;
   }
-  await saveBacklog(items);
+  await saveBacklog(items2);
   for (const item of inProgress) {
     console.log(chalk65.yellow(`Stopped item #${item.id}: ${item.name}`));
   }
@@ -5837,19 +5883,18 @@ function registerStatusCommands(cmd) {
 
 // src/commands/backlog/removePhase.ts
 import chalk68 from "chalk";
+import { and as and7, eq as eq18 } from "drizzle-orm";
 
 // src/commands/backlog/findPhase.ts
 import chalk67 from "chalk";
+import { and as and5, count as count2, eq as eq16 } from "drizzle-orm";
 async function findPhase(id, phase) {
   const result = await loadAndFindItem(id);
   if (!result) return void 0;
-  const db = await getBacklogDb();
+  const orm = await getBacklogOrm();
   const itemId = result.item.id;
   const phaseIdx = Number.parseInt(phase, 10) - 1;
-  const row = await db.get(
-    "SELECT COUNT(*)::int as cnt FROM plan_phases WHERE item_id = ? AND idx = ?",
-    [itemId, phaseIdx]
-  );
+  const [row] = await orm.select({ cnt: count2() }).from(planPhases).where(and5(eq16(planPhases.itemId, itemId), eq16(planPhases.idx, phaseIdx)));
   if (!row || row.cnt === 0) {
     console.log(
       chalk67.red(`Phase ${phaseIdx + 1} not found on item #${itemId}.`)
@@ -5857,26 +5902,18 @@ async function findPhase(id, phase) {
     process.exitCode = 1;
     return void 0;
   }
-  return { result, db, itemId, phaseIdx };
+  return { result, orm, itemId, phaseIdx };
 }
 
 // src/commands/backlog/reindexPhases.ts
+import { and as and6, asc as asc4, count as count3, eq as eq17 } from "drizzle-orm";
 async function reindexPhases(db, itemId) {
-  const remaining = await db.all(
-    "SELECT idx FROM plan_phases WHERE item_id = ? ORDER BY idx",
-    [itemId]
-  );
+  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq17(planPhases.itemId, itemId)).orderBy(asc4(planPhases.idx));
   for (let i = 0; i < remaining.length; i++) {
     const oldIdx = remaining[i].idx;
     if (oldIdx === i) continue;
-    await db.run(
-      "UPDATE plan_tasks SET phase_idx = ? WHERE item_id = ? AND phase_idx = ?",
-      [i, itemId, oldIdx]
-    );
-    await db.run(
-      "UPDATE plan_phases SET idx = ? WHERE item_id = ? AND idx = ?",
-      [i, itemId, oldIdx]
-    );
+    await db.update(planTasks).set({ phaseIdx: i }).where(and6(eq17(planTasks.itemId, itemId), eq17(planTasks.phaseIdx, oldIdx)));
+    await db.update(planPhases).set({ idx: i }).where(and6(eq17(planPhases.itemId, itemId), eq17(planPhases.idx, oldIdx)));
   }
 }
 async function adjustCurrentPhase(db, item, removedIdx) {
@@ -5884,38 +5921,25 @@ async function adjustCurrentPhase(db, item, removedIdx) {
   if (currentPhase === void 0) return;
   const currentIdx = currentPhase - 1;
   if (removedIdx < currentIdx) {
-    await db.run("UPDATE items SET current_phase = ? WHERE id = ?", [
-      currentPhase - 1,
-      item.id
-    ]);
+    await db.update(items).set({ currentPhase: currentPhase - 1 }).where(eq17(items.id, item.id));
     return;
   }
   if (removedIdx !== currentIdx) return;
-  const row = await db.get(
-    "SELECT COUNT(*)::int as cnt FROM plan_phases WHERE item_id = ?",
-    [item.id]
-  );
+  const [row] = await db.select({ cnt: count3() }).from(planPhases).where(eq17(planPhases.itemId, item.id));
   const cnt = row?.cnt ?? 0;
-  await db.run("UPDATE items SET current_phase = ? WHERE id = ?", [
-    cnt === 0 ? null : Math.min(currentPhase, cnt),
-    item.id
-  ]);
+  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq17(items.id, item.id));
 }
 
 // src/commands/backlog/removePhase.ts
 async function removePhase(id, phase) {
   const found = await findPhase(id, phase);
   if (!found) return;
-  const { result, db, itemId, phaseIdx } = found;
-  await db.transaction(async (tx) => {
-    await tx.run("DELETE FROM plan_tasks WHERE item_id = ? AND phase_idx = ?", [
-      itemId,
-      phaseIdx
-    ]);
-    await tx.run("DELETE FROM plan_phases WHERE item_id = ? AND idx = ?", [
-      itemId,
-      phaseIdx
-    ]);
+  const { result, orm, itemId, phaseIdx } = found;
+  await orm.transaction(async (tx) => {
+    await tx.delete(planTasks).where(
+      and7(eq18(planTasks.itemId, itemId), eq18(planTasks.phaseIdx, phaseIdx))
+    );
+    await tx.delete(planPhases).where(and7(eq18(planPhases.itemId, itemId), eq18(planPhases.idx, phaseIdx)));
     await reindexPhases(tx, itemId);
     await adjustCurrentPhase(tx, result.item, phaseIdx);
   });
@@ -5926,20 +5950,21 @@ async function removePhase(id, phase) {
 
 // src/commands/backlog/update/index.ts
 import chalk70 from "chalk";
+import { eq as eq19 } from "drizzle-orm";
 
 // src/commands/backlog/update/parseListIndex.ts
 function parseListIndex(raw, length, label2) {
   if (!/^\d+$/.test(raw)) {
     return { ok: false, error: `${label2} must be a positive integer.` };
   }
-  const index = Number.parseInt(raw, 10);
-  if (index < 1 || index > length) {
+  const index2 = Number.parseInt(raw, 10);
+  if (index2 < 1 || index2 > length) {
     return {
       ok: false,
-      error: `${label2} ${index} is out of range (1-${length}).`
+      error: `${label2} ${index2} is out of range (1-${length}).`
     };
   }
-  return { ok: true, index };
+  return { ok: true, index: index2 };
 }
 
 // src/commands/backlog/update/applyListMutations.ts
@@ -5949,7 +5974,7 @@ function hasListMutations(options2) {
   );
 }
 function applyListMutations(current, options2, flags) {
-  let items = [...current];
+  let items2 = [...current];
   if (options2.edit) {
     const [rawIndex, ...textParts] = options2.edit;
     if (rawIndex === void 0 || textParts.length === 0) {
@@ -5960,25 +5985,25 @@ function applyListMutations(current, options2, flags) {
     }
     const parsed = parseListIndex(
       rawIndex,
-      items.length,
+      items2.length,
       `${flags.edit} index`
     );
     if (!parsed.ok) return parsed;
-    items[parsed.index - 1] = textParts.join(" ");
+    items2[parsed.index - 1] = textParts.join(" ");
   }
   if (options2.remove) {
     const parsed = parseListIndex(
       options2.remove,
-      items.length,
+      items2.length,
       `${flags.remove} index`
     );
     if (!parsed.ok) return parsed;
-    items = items.filter((_, i) => i !== parsed.index - 1);
+    items2 = items2.filter((_, i) => i !== parsed.index - 1);
   }
   if (options2.add) {
-    items.push(...options2.add);
+    items2.push(...options2.add);
   }
-  return { ok: true, items };
+  return { ok: true, items: items2 };
 }
 
 // src/commands/backlog/update/applyAcMutations.ts
@@ -5999,11 +6024,11 @@ function applyAcMutations(current, options2) {
   return { ok: true, criteria: result.items };
 }
 
-// src/commands/backlog/update/buildUpdateSql.ts
+// src/commands/backlog/update/buildUpdateValues.ts
 import chalk69 from "chalk";
-function buildUpdateSql(options2) {
-  const { name, desc, type, ac } = options2;
-  if (!name && !desc && !type && !ac) {
+function buildUpdateValues(options2) {
+  const { name, desc: desc2, type, ac } = options2;
+  if (!name && !desc2 && !type && !ac) {
     console.log(chalk69.red("Nothing to update. Provide at least one flag."));
     process.exitCode = 1;
     return void 0;
@@ -6013,30 +6038,25 @@ function buildUpdateSql(options2) {
     process.exitCode = 1;
     return void 0;
   }
-  const sets = [];
-  const params = [];
+  const set = {};
   const fieldNames = [];
   if (name) {
-    sets.push("name = ?");
-    params.push(name);
+    set.name = name;
     fieldNames.push("name");
   }
-  if (desc) {
-    sets.push("description = ?");
-    params.push(desc);
+  if (desc2) {
+    set.description = desc2;
     fieldNames.push("description");
   }
   if (type) {
-    sets.push("type = ?");
-    params.push(type);
+    set.type = type;
     fieldNames.push("type");
   }
   if (ac) {
-    sets.push("acceptance_criteria = ?");
-    params.push(JSON.stringify(ac));
+    set.acceptanceCriteria = JSON.stringify(ac);
     fieldNames.push("acceptance criteria");
   }
-  return { sets, params, fields: fieldNames.join(", ") };
+  return { set, fields: fieldNames.join(", ") };
 }
 
 // src/commands/backlog/update/index.ts
@@ -6060,14 +6080,11 @@ async function update(id, options2) {
     }
     ac = mutation.criteria;
   }
-  const built = buildUpdateSql({ ...options2, ac });
+  const built = buildUpdateValues({ ...options2, ac });
   if (!built) return;
-  const db = await getBacklogDb();
+  const orm = await getBacklogOrm();
   const itemId = result.item.id;
-  await db.run(`UPDATE items SET ${built.sets.join(", ")} WHERE id = ?`, [
-    ...built.params,
-    itemId
-  ]);
+  await orm.update(items).set(built.set).where(eq19(items.id, itemId));
   console.log(chalk70.green(`Updated ${built.fields} on item #${itemId}.`));
 }
 
@@ -6075,29 +6092,31 @@ async function update(id, options2) {
 import chalk71 from "chalk";
 
 // src/commands/backlog/applyPhaseUpdate.ts
-async function applyPhaseUpdate(db, itemId, phaseIdx, fields) {
-  await db.transaction(async (tx) => {
+import { and as and8, eq as eq20 } from "drizzle-orm";
+async function applyPhaseUpdate(orm, itemId, phaseIdx, fields) {
+  await orm.transaction(async (tx) => {
     if (fields.name) {
-      await tx.run(
-        "UPDATE plan_phases SET name = ? WHERE item_id = ? AND idx = ?",
-        [fields.name, itemId, phaseIdx]
+      await tx.update(planPhases).set({ name: fields.name }).where(
+        and8(eq20(planPhases.itemId, itemId), eq20(planPhases.idx, phaseIdx))
       );
     }
     if (fields.manualCheck) {
-      await tx.run(
-        "UPDATE plan_phases SET manual_checks = ? WHERE item_id = ? AND idx = ?",
-        [JSON.stringify(fields.manualCheck), itemId, phaseIdx]
+      await tx.update(planPhases).set({ manualChecks: JSON.stringify(fields.manualCheck) }).where(
+        and8(eq20(planPhases.itemId, itemId), eq20(planPhases.idx, phaseIdx))
       );
     }
     if (fields.task) {
-      await tx.run(
-        "DELETE FROM plan_tasks WHERE item_id = ? AND phase_idx = ?",
-        [itemId, phaseIdx]
+      await tx.delete(planTasks).where(
+        and8(eq20(planTasks.itemId, itemId), eq20(planTasks.phaseIdx, phaseIdx))
       );
-      for (let i = 0; i < fields.task.length; i++) {
-        await tx.run(
-          "INSERT INTO plan_tasks (item_id, phase_idx, idx, task) VALUES (?, ?, ?, ?)",
-          [itemId, phaseIdx, i, fields.task[i]]
+      if (fields.task.length) {
+        await tx.insert(planTasks).values(
+          fields.task.map((task, i) => ({
+            itemId,
+            phaseIdx,
+            idx: i,
+            task
+          }))
         );
       }
     }
@@ -6171,7 +6190,7 @@ function resolvePhaseFields(options2, current) {
 async function updatePhase(id, phase, options2) {
   const found = await findPhase(id, phase);
   if (!found) return;
-  const { result, db, itemId, phaseIdx } = found;
+  const { result, orm, itemId, phaseIdx } = found;
   const resolved = resolvePhaseFields(options2, result.item.plan?.[phaseIdx]);
   if (!resolved.ok) {
     console.log(chalk71.red(resolved.error));
@@ -6179,7 +6198,7 @@ async function updatePhase(id, phase, options2) {
     return;
   }
   const { name, task, manualCheck } = resolved.fields;
-  await applyPhaseUpdate(db, itemId, phaseIdx, { name, task, manualCheck });
+  await applyPhaseUpdate(orm, itemId, phaseIdx, { name, task, manualCheck });
   const fields = [
     name && "name",
     task && "tasks",
@@ -6380,7 +6399,7 @@ import { mkdirSync as mkdirSync4 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join18 } from "path";
 import Database from "better-sqlite3";
-var _db2;
+var _db;
 function getDbDir() {
   return join18(homedir4(), ".assist");
 }
@@ -6398,13 +6417,13 @@ function initSchema(db) {
 	`);
 }
 function openPromptsDb(dir) {
-  if (_db2) return _db2;
+  if (_db) return _db;
   const dbDir = dir ?? getDbDir();
   mkdirSync4(dbDir, { recursive: true });
   const db = new Database(join18(dbDir, "assist.db"));
   db.pragma("journal_mode = WAL");
   initSchema(db);
-  _db2 = db;
+  _db = db;
   return db;
 }
 function logDeniedToolCall(entry) {
@@ -6881,17 +6900,17 @@ function isClaudeCode() {
 }
 
 // src/commands/permitCliReads/mapAsync.ts
-async function mapAsync(items, concurrency, fn) {
-  const results = new Array(items.length);
+async function mapAsync(items2, concurrency, fn) {
+  const results = new Array(items2.length);
   let next3 = 0;
   async function worker() {
-    while (next3 < items.length) {
+    while (next3 < items2.length) {
       const idx = next3++;
-      results[idx] = await fn(items[idx]);
+      results[idx] = await fn(items2[idx]);
     }
   }
   const workers = Array.from(
-    { length: Math.min(concurrency, items.length) },
+    { length: Math.min(concurrency, items2.length) },
     () => worker()
   );
   await Promise.all(workers);
@@ -7089,8 +7108,8 @@ function formatHuman(cli, commands) {
 `];
   for (const cmd of sorted) {
     const full = `${cli} ${cmd.path.join(" ")}`;
-    const text = cmd.description ? `${full} \u2014 ${cmd.description}` : full;
-    lines.push(`${prefix(classifyVerb(cmd.path))}${text}`);
+    const text2 = cmd.description ? `${full} \u2014 ${cmd.description}` : full;
+    lines.push(`${prefix(classifyVerb(cmd.path))}${text2}`);
   }
   return lines.join("\n");
 }
@@ -7225,12 +7244,12 @@ function denyList() {
 import chalk75 from "chalk";
 function denyRemove(pattern2, options2) {
   const { deny, saveDeny } = loadDenyConfig(options2.global);
-  const index = deny.findIndex((r) => r.pattern === pattern2);
-  if (index === -1) {
+  const index2 = deny.findIndex((r) => r.pattern === pattern2);
+  if (index2 === -1) {
     console.log(chalk75.yellow(`No deny rule found for: ${pattern2}`));
     return;
   }
-  deny.splice(index, 1);
+  deny.splice(index2, 1);
   saveDeny(deny.length > 0 ? deny : void 0);
   console.log(chalk75.green(`Removed deny rule: ${pattern2}`));
 }
@@ -7467,7 +7486,7 @@ function calculateHalstead(node) {
 // src/commands/complexity/shared/countSloc.ts
 function countSloc(content) {
   let inMultiLineComment = false;
-  let count = 0;
+  let count4 = 0;
   for (const line of content.split("\n")) {
     const trimmed = line.trim();
     if (inMultiLineComment) {
@@ -7475,7 +7494,7 @@ function countSloc(content) {
         inMultiLineComment = false;
         const afterComment = trimmed.substring(trimmed.indexOf("*/") + 2);
         if (afterComment.trim().length > 0) {
-          count++;
+          count4++;
         }
       }
       continue;
@@ -7487,7 +7506,7 @@ function countSloc(content) {
       if (trimmed.includes("*/")) {
         const afterComment = trimmed.substring(trimmed.indexOf("*/") + 2);
         if (afterComment.trim().length > 0) {
-          count++;
+          count4++;
         }
       } else {
         inMultiLineComment = true;
@@ -7495,10 +7514,10 @@ function countSloc(content) {
       continue;
     }
     if (trimmed.length > 0) {
-      count++;
+      count4++;
     }
   }
-  return count;
+  return count4;
 }
 
 // src/commands/complexity/shared/index.ts
@@ -9193,16 +9212,16 @@ function parseUserLine(line) {
   if (entry.type !== "user") return void 0;
   const msg = entry.message;
   const c = msg?.content;
-  let text;
+  let text2;
   if (typeof c === "string") {
-    text = c;
+    text2 = c;
   } else if (Array.isArray(c)) {
     const collected = c.filter((b) => b.type === "text").map((b) => b.text ?? "").join("\n");
-    text = collected || void 0;
+    text2 = collected || void 0;
   }
-  if (!text) return void 0;
+  if (!text2) return void 0;
   return {
-    text,
+    text: text2,
     entrypoint: typeof entry.entrypoint === "string" ? entry.entrypoint : void 0
   };
 }
@@ -9253,12 +9272,12 @@ ${payload}`;
     return "";
   }
 }
-function stripPreludes(text) {
-  return text.replace(/<command-name>[\s\S]*?<\/command-name>/g, "").replace(/<command-message>[\s\S]*?<\/command-message>/g, "").replace(/<command-args>[\s\S]*?<\/command-args>/g, "").replace(/<local-command-stdout>[\s\S]*?<\/local-command-stdout>/g, "").replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "").trim();
+function stripPreludes(text2) {
+  return text2.replace(/<command-name>[\s\S]*?<\/command-name>/g, "").replace(/<command-message>[\s\S]*?<\/command-message>/g, "").replace(/<command-args>[\s\S]*?<\/command-args>/g, "").replace(/<local-command-stdout>[\s\S]*?<\/local-command-stdout>/g, "").replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "").trim();
 }
-function capPayload(text, maxBytes) {
-  const buf = Buffer.from(text, "utf8");
-  if (buf.length <= maxBytes) return text;
+function capPayload(text2, maxBytes) {
+  const buf = Buffer.from(text2, "utf8");
+  if (buf.length <= maxBytes) return text2;
   return buf.subarray(buf.length - maxBytes).toString("utf8");
 }
 function normaliseOutput(raw) {
@@ -9327,9 +9346,9 @@ import chalk103 from "chalk";
 
 // src/commands/jira/adfToText.ts
 function renderInline(node) {
-  const text = node.text ?? "";
-  if (node.marks?.some((m) => m.type === "code")) return `\`${text}\``;
-  return text;
+  const text2 = node.text ?? "";
+  if (node.marks?.some((m) => m.type === "code")) return `\`${text2}\``;
+  return text2;
 }
 function renderChildren(node, indent2) {
   return renderNodes(node.content ?? [], indent2);
@@ -9371,8 +9390,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 text = renderChildren(child, indent2);
-  return isFirst ? `${pad}${marker} ${text}` : `${pad}  ${text}`;
+  const text2 = renderChildren(child, indent2);
+  return isFirst ? `${pad}${marker} ${text2}` : `${pad}  ${text2}`;
 }
 function renderListItem(node, indent2, marker) {
   const pad = "  ".repeat(indent2);
@@ -9735,9 +9754,9 @@ function excerpt(xml, ...tags) {
   for (const tag of tags) {
     const raw = extractText(xml, tag);
     if (!raw) continue;
-    const text = stripHtml(raw);
-    if (text.length <= MAX_EXCERPT) return text;
-    return `${text.slice(0, MAX_EXCERPT)}\u2026`;
+    const text2 = stripHtml(raw);
+    if (text2.length <= MAX_EXCERPT) return text2;
+    return `${text2.slice(0, MAX_EXCERPT)}\u2026`;
   }
   return "";
 }
@@ -9782,22 +9801,22 @@ async function fetchFeeds(urls, onProgress) {
       const origin = new URL(url).origin;
       const res = await fetch(url);
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
-      const items2 = parseFeed(await res.text(), origin);
+      const items3 = parseFeed(await res.text(), origin);
       done2++;
       onProgress?.(done2, urls.length);
-      return items2;
+      return items3;
     })
   );
-  const items = [];
+  const items2 = [];
   for (const result of results) {
     if (result.status === "fulfilled") {
-      items.push(...result.value);
+      items2.push(...result.value);
     }
   }
-  items.sort(
+  items2.sort(
     (a, b) => new Date(b.pubDate).getTime() - new Date(a.pubDate).getTime()
   );
-  return items;
+  return items2;
 }
 
 // src/commands/news/web/getHtml.ts
@@ -9833,13 +9852,13 @@ function prefetch() {
     process.stdout.write(
       `\r${chalk109.dim(`Fetching feeds ${bar} ${done2}/${t}`)}`
     );
-  }).then((items) => {
+  }).then((items2) => {
     process.stdout.write(
-      `\r${chalk109.green(`Fetched ${items.length} items from ${total} feed(s)`)}
+      `\r${chalk109.green(`Fetched ${items2.length} items from ${total} feed(s)`)}
 `
     );
-    cachedItems = items;
-    return items;
+    cachedItems = items2;
+    return items2;
   });
 }
 async function listItems2(_req, res) {
@@ -9901,11 +9920,11 @@ function printPromptsTable(rows) {
   console.log(chalk110.dim(header));
   console.log(chalk110.dim("-".repeat(header.length)));
   for (const row of rows) {
-    const count = String(row.count).padStart(countWidth);
+    const count4 = String(row.count).padStart(countWidth);
     const tool = row.tool.padEnd(toolWidth);
     const command = truncate(row.command, 60).padEnd(commandWidth);
     console.log(
-      `${chalk110.yellow(count)}  ${tool}  ${command}  ${chalk110.dim(row.repos)}`
+      `${chalk110.yellow(count4)}  ${tool}  ${command}  ${chalk110.dim(row.repos)}`
     );
   }
 }
@@ -10196,8 +10215,8 @@ function requireCache(prNumber) {
   }
   return cache;
 }
-function findLineComment(comments2, commentId) {
-  return comments2.find((c) => c.type === "line" && c.id === commentId);
+function findLineComment(comments3, commentId) {
+  return comments3.find((c) => c.type === "line" && c.id === commentId);
 }
 function requireLineComment(cache, commentId) {
   const comment3 = findLineComment(cache.comments, commentId);
@@ -10330,8 +10349,8 @@ function mapLineComment(c, threadInfo) {
   };
 }
 function fetchLineComments(org, repo, prNumber, threadInfo) {
-  const comments2 = fetchJson(`repos/${org}/${repo}/pulls/${prNumber}/comments`);
-  return comments2.map(
+  const comments3 = fetchJson(`repos/${org}/${repo}/pulls/${prNumber}/comments`);
+  return comments3.map(
     (c) => mapLineComment(c, threadInfo)
   );
 }
@@ -10355,33 +10374,33 @@ function formatForHuman(comment3) {
     ""
   ].join("\n");
 }
-function summarise2(comments2) {
-  const lineCount = comments2.filter((c) => c.type === "line").length;
-  const reviewCount = comments2.filter((c) => c.type === "review").length;
+function summarise2(comments3) {
+  const lineCount = comments3.filter((c) => c.type === "line").length;
+  const reviewCount = comments3.filter((c) => c.type === "review").length;
   const parts = [];
   if (lineCount > 0) parts.push(`${lineCount} line`);
   if (reviewCount > 0) parts.push(`${reviewCount} review`);
-  return `Found ${parts.join(" and ")} comment${comments2.length === 1 ? "" : "s"}.`;
+  return `Found ${parts.join(" and ")} comment${comments3.length === 1 ? "" : "s"}.`;
 }
 function printComments2(result) {
-  const { comments: comments2, cachePath } = result;
-  if (comments2.length === 0) {
+  const { comments: comments3, cachePath } = result;
+  if (comments3.length === 0) {
     console.log("No comments found.");
     return;
   }
   if (!isClaudeCode()) {
-    for (const comment3 of comments2) {
+    for (const comment3 of comments3) {
       console.log(formatForHuman(comment3));
     }
   }
-  console.log(summarise2(comments2));
+  console.log(summarise2(comments3));
   if (cachePath) {
     console.log(`Saved to ${cachePath}`);
   }
 }
 
 // src/commands/prs/listComments/index.ts
-function writeCommentsCache(prNumber, comments2) {
+function writeCommentsCache(prNumber, comments3) {
   const assistDir = join34(process.cwd(), ".assist");
   if (!existsSync34(assistDir)) {
     mkdirSync9(assistDir, { recursive: true });
@@ -10389,7 +10408,7 @@ function writeCommentsCache(prNumber, comments2) {
   const cacheData = {
     prNumber,
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    comments: comments2
+    comments: comments3
   };
   const cachePath = join34(assistDir, `pr-${prNumber}-comments.yaml`);
   writeFileSync23(cachePath, stringify(cacheData));
@@ -10406,9 +10425,9 @@ function handleKnownErrors(error) {
   }
   return null;
 }
-function updateCache(prNumber, comments2) {
-  if (comments2.some((c) => c.type === "line")) {
-    writeCommentsCache(prNumber, comments2);
+function updateCache(prNumber, comments3) {
+  if (comments3.some((c) => c.type === "line")) {
+    writeCommentsCache(prNumber, comments3);
   } else {
     deleteCommentsCache(prNumber);
   }
@@ -10515,8 +10534,8 @@ async function promptNavigation(currentPage, totalPages) {
   });
   return parseAction(action);
 }
-function computeTotalPages(count) {
-  return Math.ceil(count / PAGE_SIZE);
+function computeTotalPages(count4) {
+  return Math.ceil(count4 / PAGE_SIZE);
 }
 async function navigateAndDisplay(pullRequests, totalPages, currentPage) {
   const delta = await promptNavigation(currentPage, totalPages);
@@ -10704,9 +10723,9 @@ function opExec(args) {
   }).trim();
 }
 function searchItems(search2) {
-  let items;
+  let items2;
   try {
-    items = JSON.parse(opExec("item list --format=json"));
+    items2 = JSON.parse(opExec("item list --format=json"));
   } catch {
     console.error(
       chalk114.red(
@@ -10716,7 +10735,7 @@ function searchItems(search2) {
     process.exit(1);
   }
   const lower = search2.toLowerCase();
-  return items.filter((i) => i.title.toLowerCase().includes(lower));
+  return items2.filter((i) => i.title.toLowerCase().includes(lower));
 }
 function getItemFields(itemId) {
   try {
@@ -10740,14 +10759,14 @@ async function selectOpSecret(searchTerm) {
     name: "search",
     message: "Search 1Password for API key item:"
   }).run();
-  const items = searchItems(search2);
-  if (items.length === 0) {
+  const items2 = searchItems(search2);
+  if (items2.length === 0) {
     console.error(chalk115.red(`No items found matching "${search2}".`));
     process.exit(1);
   }
   const itemId = await selectOne(
     "Select item:",
-    items.map((i) => ({ name: `${i.title} (${i.vault.name})`, value: i.id }))
+    items2.map((i) => ({ name: `${i.title} (${i.vault.name})`, value: i.id }))
   );
   const fields = getItemFields(itemId);
   if (fields.length === 0) {
@@ -11611,9 +11630,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 text = fn.getFullText().trim();
-    if (fn === target && !text.startsWith("export ")) return `export ${text}`;
-    return text;
+    const text2 = fn.getFullText().trim();
+    if (fn === target && !text2.startsWith("export ")) return `export ${text2}`;
+    return text2;
   });
   return [...stmtTexts, ...fnTexts];
 }
@@ -11769,7 +11788,7 @@ function sourceReferencesName(sourceFile, functionName, extractedNames) {
 }
 
 // src/commands/refactor/extract/buildPlan.ts
-function buildPlan(functionName, sourceFile, sourcePath, destPath, project) {
+function buildPlan2(functionName, sourceFile, sourcePath, destPath, project) {
   const analysis = analyseTarget(sourceFile, functionName);
   const sourceRelPath = getRelativeImportPath(destPath, sourcePath);
   const rewrittenImports = rewriteImportPaths(
@@ -11923,7 +11942,7 @@ async function extract(file, functionName, destination, options2 = {}) {
   const cwd = process.cwd();
   const relDest = path36.relative(cwd, destPath);
   const { project, sourceFile } = loadProjectFile(file);
-  const plan2 = buildPlan(
+  const plan2 = buildPlan2(
     functionName,
     sourceFile,
     sourcePath,
@@ -12417,8 +12436,8 @@ import fs25 from "fs";
 import path45 from "path";
 function collectEntry(results, dir, entry) {
   const full = path45.join(dir, entry.name);
-  const items = entry.isDirectory() ? listFilesRecursive(full) : [full];
-  results.push(...items);
+  const items2 = entry.isDirectory() ? listFilesRecursive(full) : [full];
+  results.push(...items2);
 }
 function listFilesRecursive(dir) {
   if (!fs25.existsSync(dir)) return [];
@@ -12502,7 +12521,7 @@ function planFileMoves(clusters) {
 }
 
 // src/commands/refactor/restructure/index.ts
-function buildPlan2(candidateFiles, tsConfigPath) {
+function buildPlan3(candidateFiles, tsConfigPath) {
   const candidates = new Set(candidateFiles.map((f) => path47.resolve(f)));
   const graph = buildImportGraph(candidates, tsConfigPath);
   const allProjectFiles = /* @__PURE__ */ new Set([
@@ -12527,7 +12546,7 @@ async function restructure(pattern2, options2 = {}) {
     return;
   }
   const tsConfigPath = path47.resolve("tsconfig.json");
-  const plan2 = buildPlan2(files, tsConfigPath);
+  const plan2 = buildPlan3(files, tsConfigPath);
   if (plan2.moves.length === 0) {
     console.log(chalk134.green("No restructuring needed"));
     return;
@@ -12585,10 +12604,10 @@ function threadKey(c, byId) {
   }
   return `root-${c.id}`;
 }
-function groupIntoThreads(comments2) {
-  const byId = new Map(comments2.map((c) => [c.id, c]));
+function groupIntoThreads(comments3) {
+  const byId = new Map(comments3.map((c) => [c.id, c]));
   const threads = /* @__PURE__ */ new Map();
-  for (const c of comments2) {
+  for (const c of comments3) {
     const key = threadKey(c, byId);
     const existing = threads.get(key);
     const parent = c.inReplyToId !== null ? byId.get(c.inReplyToId) : void 0;
@@ -12616,9 +12635,9 @@ function formatThread(thread) {
   return lines.join("\n\n");
 }
 var INTRO = `The PR already has the review comments below (including resolved and outdated threads). Avoid re-raising findings that a prior comment substantively covers.`;
-function formatPriorComments(comments2) {
-  if (comments2.length === 0) return "";
-  const blocks = groupIntoThreads(comments2).map(formatThread);
+function formatPriorComments(comments3) {
+  if (comments3.length === 0) return "";
+  const blocks = groupIntoThreads(comments3).map(formatThread);
   return `## Prior review comments
 
 ${INTRO}
@@ -13020,9 +13039,9 @@ function warnUnlocated(unlocated) {
 }
 
 // src/commands/review/postReviewToPr.ts
-async function confirmPost(prNumber, count, options2) {
+async function confirmPost(prNumber, count4, options2) {
   if (!options2.prompt) return true;
-  return promptConfirm(`Post ${count} comment(s) to PR #${prNumber}?`, false);
+  return promptConfirm(`Post ${count4} comment(s) to PR #${prNumber}?`, false);
 }
 async function postReviewToPr(synthesisPath, options2) {
   const prNumber = findCurrentPrNumber();
@@ -13222,9 +13241,9 @@ var MultiSpinner = class {
       elapsedPrefix: prefix2
     });
   }
-  failRemaining(text) {
+  failRemaining(text2) {
     for (const entry of this.entries) {
-      if (entry.state === "running") this.resolve(entry, "failed", text);
+      if (entry.state === "running") this.resolve(entry, "failed", text2);
     }
   }
   add(entry) {
@@ -13237,14 +13256,14 @@ var MultiSpinner = class {
       set text(value) {
         entry.text = value;
       },
-      succeed: (text) => this.resolve(entry, "succeeded", text),
-      fail: (text) => this.resolve(entry, "failed", text)
+      succeed: (text2) => this.resolve(entry, "succeeded", text2),
+      fail: (text2) => this.resolve(entry, "failed", text2)
     };
   }
-  resolve(entry, state, text) {
+  resolve(entry, state, text2) {
     if (entry.state !== "running") return;
     entry.state = state;
-    if (text !== void 0) entry.text = text;
+    if (text2 !== void 0) entry.text = text2;
     entry.elapsedStart = void 0;
     this.render();
     this.maybeFinish();
@@ -13319,12 +13338,12 @@ function skippedCodexResult(outputPath) {
 // src/commands/review/formatReviewerFailure.ts
 var FAST_FAIL_MS = 1e3;
 var STDOUT_TAIL_LINES = 20;
-function indent(text) {
-  return text.split(/\r?\n/).map((line) => `  ${line}`);
+function indent(text2) {
+  return text2.split(/\r?\n/).map((line) => `  ${line}`);
 }
-function tailLines(text, maxLines) {
-  const lines = text.split(/\r?\n/);
-  return lines.length <= maxLines ? text : lines.slice(-maxLines).join("\n");
+function tailLines(text2, maxLines) {
+  const lines = text2.split(/\r?\n/);
+  return lines.length <= maxLines ? text2 : lines.slice(-maxLines).join("\n");
 }
 function isFastFail(input) {
   return input.exitCode !== 0 && input.elapsedMs !== void 0 && input.elapsedMs < FAST_FAIL_MS;
@@ -14046,9 +14065,9 @@ async function runReviewPipeline(paths, options2) {
 }
 
 // src/commands/review/reviewPr.ts
-function logPriorComments(count) {
-  if (count === 0) return;
-  console.log(`Including ${count} prior review comment(s) in request.md.`);
+function logPriorComments(count4) {
+  if (count4 === 0) return;
+  console.log(`Including ${count4} prior review comment(s) in request.md.`);
 }
 function gatherChangedContext() {
   const context = gatherContext();
@@ -14290,10 +14309,10 @@ function filterToSql(filter) {
 }
 
 // src/commands/seq/fetchSeqData.ts
-async function fetchSeqData(conn, filter, count, from, to) {
+async function fetchSeqData(conn, filter, count4, from, to) {
   const sqlFilter = filterToSql(filter);
-  const sql2 = `select @Timestamp, @Level, @Exception, @Message from stream where ${sqlFilter} order by @Timestamp desc limit ${count}`;
-  const params = new URLSearchParams({ q: sql2 });
+  const sql4 = `select @Timestamp, @Level, @Exception, @Message from stream where ${sqlFilter} order by @Timestamp desc limit ${count4}`;
+  const params = new URLSearchParams({ q: sql4 });
   if (from) params.set("fromDateUtc", from);
   if (to) params.set("toDateUtc", to);
   const response = await fetchSeq(conn, "/api/data", params);
@@ -14462,12 +14481,12 @@ function resolveConnection2(name) {
 async function seqQuery(filter, options2) {
   rejectTimestampFilter(filter);
   const conn = resolveConnection2(options2.connection);
-  const count = Number.parseInt(options2.count ?? "1000", 10);
+  const count4 = Number.parseInt(options2.count ?? "1000", 10);
   const from = options2.from ? parseRelativeTime(options2.from) : void 0;
   const to = options2.to ? parseRelativeTime(options2.to) : void 0;
-  const events = from || to ? await fetchSeqData(conn, filter, count, from, to) : await fetchSeqEvents(
+  const events = from || to ? await fetchSeqData(conn, filter, count4, from, to) : await fetchSeqEvents(
     conn,
-    new URLSearchParams({ filter, count: String(count) })
+    new URLSearchParams({ filter, count: String(count4) })
   );
   if (events.length === 0) {
     console.log(chalk141.yellow("No events found."));
@@ -14483,10 +14502,10 @@ async function seqQuery(filter, options2) {
   }
   console.log(chalk141.dim(`
 ${events.length} events`));
-  if (events.length >= count) {
+  if (events.length >= count4) {
     console.log(
       chalk141.yellow(
-        `Results limited to ${count}. Use --count to retrieve more.`
+        `Results limited to ${count4}. Use --count to retrieve more.`
       )
     );
   }
@@ -14545,26 +14564,26 @@ import chalk144 from "chalk";
 // src/commands/sql/loadConnections.ts
 function loadConnections3() {
   const raw = loadGlobalConfigRaw();
-  const sql2 = raw.sql;
-  return sql2?.connections ?? [];
+  const sql4 = raw.sql;
+  return sql4?.connections ?? [];
 }
 function saveConnections3(connections) {
   const raw = loadGlobalConfigRaw();
-  const sql2 = raw.sql ?? {};
-  sql2.connections = connections;
-  raw.sql = sql2;
+  const sql4 = raw.sql ?? {};
+  sql4.connections = connections;
+  raw.sql = sql4;
   saveGlobalConfig(raw);
 }
 function getDefaultConnection2() {
   const raw = loadGlobalConfigRaw();
-  const sql2 = raw.sql;
-  return sql2?.defaultConnection;
+  const sql4 = raw.sql;
+  return sql4?.defaultConnection;
 }
 function setDefaultConnection2(name) {
   const raw = loadGlobalConfigRaw();
-  const sql2 = raw.sql ?? {};
-  sql2.defaultConnection = name;
-  raw.sql = sql2;
+  const sql4 = raw.sql ?? {};
+  sql4.defaultConnection = name;
+  raw.sql = sql4;
   saveGlobalConfig(raw);
 }
 
@@ -14635,9 +14654,9 @@ function resolveConnection3(name) {
 }
 
 // src/commands/sql/sqlConnect.ts
-import sql from "mssql";
+import sql3 from "mssql";
 async function sqlConnect(conn) {
-  return await sql.connect({
+  return await sql3.connect({
     server: conn.server,
     port: conn.port,
     user: conn.user,
@@ -14700,11 +14719,11 @@ var MUTATION_PATTERN = new RegExp(
   `\\b(${MUTATION_KEYWORDS.join("|")})\\b`,
   "i"
 );
-function stripComments(sql2) {
-  return sql2.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/--[^\n]*/g, " ");
+function stripComments(sql4) {
+  return sql4.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/--[^\n]*/g, " ");
 }
-function isMutation(sql2) {
-  const stripped = stripComments(sql2);
+function isMutation(sql4) {
+  const stripped = stripComments(sql4);
   if (MUTATION_PATTERN.test(stripped)) return true;
   return /\bSELECT\b[\s\S]+\bINTO\s+\w/i.test(stripped);
 }
@@ -15000,8 +15019,8 @@ import { existsSync as existsSync39, mkdirSync as mkdirSync11, readFileSync as r
 import { basename as basename9, dirname as dirname21, join as join39 } from "path";
 
 // src/commands/transcript/cleanText.ts
-function cleanText(text) {
-  const words = text.split(/\s+/);
+function cleanText(text2) {
+  const words = text2.split(/\s+/);
   const cleaned = [];
   for (let i = 0; i < words.length; i++) {
     let isRepeat = false;
@@ -15021,8 +15040,8 @@ function cleanText(text) {
 }
 
 // src/commands/transcript/format/processVttFile/parseVtt/deduplicateCues/removeSubstringDuplicates.ts
-function normalizeText(text) {
-  return text.toLowerCase().trim();
+function normalizeText(text2) {
+  return text2.toLowerCase().trim();
 }
 function checkSubstringRelation(textI, textJ) {
   if (textI.includes(textJ) && textI.length > textJ.length)
@@ -15151,13 +15170,13 @@ function parseTimestampLine(line) {
   return { startMs: parseTimestamp(startStr), endMs: parseTimestamp(endStr) };
 }
 function buildCue(startMs, endMs, fullText) {
-  const { speaker, text } = extractSpeaker(fullText);
-  return text ? { startMs, endMs, speaker, text } : null;
+  const { speaker, text: text2 } = extractSpeaker(fullText);
+  return text2 ? { startMs, endMs, speaker, text: text2 } : null;
 }
 function parseCueLine(lines, i) {
   const { startMs, endMs } = parseTimestampLine(lines[i]);
-  const { text, nextIndex } = collectTextLines(lines, i + 1);
-  return { cue: buildCue(startMs, endMs, text), nextIndex };
+  const { text: text2, nextIndex } = collectTextLines(lines, i + 1);
+  return { cue: buildCue(startMs, endMs, text2), nextIndex };
 }
 function isCueSeparator(line) {
   return line.trim().includes("-->");
@@ -15521,13 +15540,13 @@ function logs(options2) {
     console.log("No voice log file found");
     return;
   }
-  const count = Number.parseInt(options2.lines ?? "150", 10);
+  const count4 = Number.parseInt(options2.lines ?? "150", 10);
   const content = readFileSync33(voicePaths.log, "utf-8").trim();
   if (!content) {
     console.log("Voice log is empty");
     return;
   }
-  const lines = content.split("\n").slice(-count);
+  const lines = content.split("\n").slice(-count4);
   for (const line of lines) {
     try {
       const event = JSON.parse(line);
@@ -15674,10 +15693,10 @@ function isProcessAlive3(pid) {
     return false;
   }
 }
-function readRecentLogs(count) {
+function readRecentLogs(count4) {
   if (!existsSync45(voicePaths.log)) return [];
   const lines = readFileSync35(voicePaths.log, "utf-8").trim().split("\n");
-  return lines.slice(-count);
+  return lines.slice(-count4);
 }
 function status() {
   if (!existsSync45(voicePaths.pid)) {
@@ -15869,8 +15888,8 @@ async function exchangeToken(params) {
     body: body.toString()
   });
   if (!response.ok) {
-    const text = await response.text();
-    throw new Error(`Token exchange failed (${response.status}): ${text}`);
+    const text2 = await response.text();
+    throw new Error(`Token exchange failed (${response.status}): ${text2}`);
   }
   return response.json();
 }
@@ -16184,11 +16203,11 @@ import { join as join49 } from "path";
 
 // src/commands/run/extractOption.ts
 function extractOption(args, flag) {
-  const index = args.indexOf(flag);
-  if (index === -1) return { value: void 0, remaining: args };
+  const index2 = args.indexOf(flag);
+  if (index2 === -1) return { value: void 0, remaining: args };
   return {
-    value: args[index + 1],
-    remaining: [...args.slice(0, index), ...args.slice(index + 2)]
+    value: args[index2 + 1],
+    remaining: [...args.slice(0, index2), ...args.slice(index2 + 2)]
   };
 }
 
@@ -16568,13 +16587,13 @@ function* iterateUserMessages(filePath, maxBytes = 65536) {
 
 // src/commands/sessions/summarise/extractFirstUserMessage.ts
 function extractFirstUserMessage(filePath) {
-  for (const text of iterateUserMessages(filePath)) {
-    return truncate3(text);
+  for (const text2 of iterateUserMessages(filePath)) {
+    return truncate3(text2);
   }
   return void 0;
 }
-function truncate3(text, maxChars = 500) {
-  const trimmed = text.trim();
+function truncate3(text2, maxChars = 500) {
+  const trimmed = text2.trim();
   if (trimmed.length <= maxChars) return trimmed;
   return `${trimmed.slice(0, maxChars)}\u2026`;
 }
@@ -16582,28 +16601,28 @@ function truncate3(text, maxChars = 500) {
 // src/commands/sessions/summarise/scanSessionBacklogRefs.ts
 function scanSessionBacklogRefs(filePath) {
   const ids = /* @__PURE__ */ new Set();
-  for (const text of iterateUserMessages(filePath, Number.MAX_SAFE_INTEGER)) {
-    for (const id of extractBacklogIds(text)) {
+  for (const text2 of iterateUserMessages(filePath, Number.MAX_SAFE_INTEGER)) {
+    for (const id of extractBacklogIds(text2)) {
       ids.add(id);
     }
   }
   return [...ids].sort((a, b) => a - b);
 }
-function extractBacklogIds(text) {
+function extractBacklogIds(text2) {
   const ids = [];
-  for (const m of text.matchAll(/backlog\s+run\s+(\d+)/gi)) {
+  for (const m of text2.matchAll(/backlog\s+run\s+(\d+)/gi)) {
     ids.push(Number.parseInt(m[1], 10));
   }
-  for (const m of text.matchAll(/backlog\s+(?:item\s+)?#(\d+)/gi)) {
+  for (const m of text2.matchAll(/backlog\s+(?:item\s+)?#(\d+)/gi)) {
     ids.push(Number.parseInt(m[1], 10));
   }
-  for (const m of text.matchAll(/backlog\s+phase-done\s+(\d+)/gi)) {
+  for (const m of text2.matchAll(/backlog\s+phase-done\s+(\d+)/gi)) {
     ids.push(Number.parseInt(m[1], 10));
   }
-  for (const m of text.matchAll(/backlog\s+comment\s+(\d+)/gi)) {
+  for (const m of text2.matchAll(/backlog\s+comment\s+(\d+)/gi)) {
     ids.push(Number.parseInt(m[1], 10));
   }
-  for (const m of text.matchAll(/(?:^|[\s(])#(\d{1,4})(?=[\s).,;:!?]|$)/gm)) {
+  for (const m of text2.matchAll(/(?:^|[\s(])#(\d{1,4})(?=[\s).,;:!?]|$)/gm)) {
     ids.push(Number.parseInt(m[1], 10));
   }
   return ids;