@staff0rd/assist 0.953.0 → 0.954.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.953.0",
+  version: "0.954.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -3755,29 +3755,19 @@ function getRepoLocation(req, res) {
   respondJson(res, 200, resolveRepoLocation(origin, void 0, baseDir));
 }
 
+// src/commands/backlog/updateStarred.ts
+import { eq as eq12 } from "drizzle-orm";
+async function updateStarred(orm, id, starred) {
+  const [row3] = await orm.update(items).set({ starred }).where(eq12(items.id, id)).returning({ name: items.name });
+  return row3?.name;
+}
+
 // src/commands/backlog/web/applyCwdFromReq.ts
 function applyCwdFromReq(req) {
   const url = new URL(req.url ?? "/", "http://localhost");
   setBacklogDir(url.searchParams.get("cwd") ?? void 0);
 }
 
-// src/commands/backlog/deleteComment.ts
-import { and as and4, eq as eq12 } from "drizzle-orm";
-async function deleteComment(orm, itemId2, commentId) {
-  const [row3] = await orm.select({ type: comments.type }).from(comments).where(and4(eq12(comments.id, commentId), eq12(comments.itemId, itemId2)));
-  if (!row3) return "not-found";
-  if (row3.type === "summary") return "is-summary";
-  await orm.delete(comments).where(and4(eq12(comments.id, commentId), eq12(comments.itemId, itemId2)));
-  return "deleted";
-}
-
-// src/commands/backlog/updateStarred.ts
-import { eq as eq13 } from "drizzle-orm";
-async function updateStarred(orm, id, starred) {
-  const [row3] = await orm.update(items).set({ starred }).where(eq13(items.id, id)).returning({ name: items.name });
-  return row3?.name;
-}
-
 // src/commands/sessions/shared/lookupSessionsById.ts
 import * as path8 from "path";
 
@@ -4518,212 +4508,6 @@ async function patchItemStar(req, res, id) {
   respondJson(res, 200, updated2);
 }
 
-// src/commands/backlog/web/deleteItemComment.ts
-async function deleteItemComment(res, itemId2, commentId) {
-  const result = await findItemOr404(res, itemId2);
-  if (!result) return;
-  const outcome = await deleteComment(result.orm, itemId2, commentId);
-  if (outcome === "not-found") {
-    respondJson(res, 404, {
-      error: `Comment #${commentId} not found on item ${formatItemId(itemId2)}.`
-    });
-    return;
-  }
-  if (outcome === "is-summary") {
-    respondJson(res, 400, {
-      error: `Comment #${commentId} is a phase summary and cannot be deleted.`
-    });
-    return;
-  }
-  respondJson(res, 200, await loadItem(result.orm, itemId2));
-}
-
-// src/commands/backlog/appendComment.ts
-import { sql as sql15 } from "drizzle-orm";
-async function appendComment(orm, itemId2, text18, opts = {}) {
-  await orm.insert(comments).values({
-    itemId: itemId2,
-    idx: sql15`(SELECT COALESCE(MAX(${comments.idx}) + 1, 0) FROM ${comments} WHERE ${comments.itemId} = ${itemId2})`,
-    text: text18,
-    phase: opts.phase ?? null,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    type: opts.type ?? "comment"
-  });
-}
-
-// src/commands/backlog/writeSignal.ts
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
-import { homedir as homedir9 } from "os";
-import { dirname as dirname7, join as join17 } from "path";
-import chalk8 from "chalk";
-
-// src/commands/backlog/recordSignalOwner.ts
-import {
-  existsSync as existsSync13,
-  mkdirSync as mkdirSync3,
-  readFileSync as readFileSync6,
-  rmSync as rmSync3,
-  writeFileSync as writeFileSync3
-} from "fs";
-import { homedir as homedir8 } from "os";
-import { dirname as dirname6, join as join16 } from "path";
-function getOwnerPath(itemId2) {
-  return join16(homedir8(), ".assist", "signals", `owner-${itemId2}.json`);
-}
-function recordSignalOwner(itemId2) {
-  const sessionId = process.env.ASSIST_SESSION_ID;
-  if (!sessionId) return;
-  const path108 = getOwnerPath(itemId2);
-  mkdirSync3(dirname6(path108), { recursive: true });
-  writeFileSync3(path108, JSON.stringify({ sessionId }));
-}
-function readSignalOwner(itemId2) {
-  const path108 = getOwnerPath(itemId2);
-  if (!existsSync13(path108)) return void 0;
-  try {
-    const parsed = JSON.parse(readFileSync6(path108, "utf8"));
-    return parsed.sessionId;
-  } catch {
-    return void 0;
-  }
-}
-function clearSignalOwner(itemId2) {
-  const path108 = getOwnerPath(itemId2);
-  try {
-    rmSync3(path108);
-  } catch {
-  }
-}
-
-// src/commands/backlog/writeSignal.ts
-function getSignalPath(sessionId = process.env.ASSIST_SESSION_ID) {
-  if (!sessionId) return void 0;
-  return join17(homedir9(), ".assist", "signals", `signal-${sessionId}.json`);
-}
-function resolveSignalTarget(event, data) {
-  const caller = process.env.ASSIST_SESSION_ID;
-  const itemId2 = typeof data?.itemId === "number" ? data.itemId : void 0;
-  if (itemId2 === void 0) return caller;
-  const owner = readSignalOwner(itemId2);
-  if (owner) {
-    if (caller && owner !== caller) {
-      console.log(
-        chalk8.dim(
-          `Routing ${event} signal for item ${itemId2} to its run (${owner}), not this session (${caller}).`
-        )
-      );
-    }
-    return owner;
-  }
-  if (caller) {
-    console.log(
-      chalk8.yellow(
-        `Not signalling ${event} for item ${itemId2}: no live run owns it, and this session (${caller}) does not either.`
-      )
-    );
-  }
-  return void 0;
-}
-function writeSignal(event, data) {
-  const target = resolveSignalTarget(event, data);
-  if (!target) return;
-  const path108 = getSignalPath(target);
-  if (!path108) return;
-  const signal = { event, sessionId: target, ...data };
-  mkdirSync4(dirname7(path108), { recursive: true });
-  writeFileSync4(path108, JSON.stringify(signal));
-}
-
-// src/commands/backlog/rewindItemToPhase.ts
-async function rewindItemToPhase(orm, item, phaseNumber, reason4) {
-  const plan2 = resolveRewindPlan(item);
-  if (phaseNumber < 1 || phaseNumber > plan2.length) {
-    return {
-      ok: false,
-      error: `Phase ${phaseNumber} does not exist. Valid range: 1\u2013${plan2.length}.`
-    };
-  }
-  const currentPhase = item.currentPhase ?? 1;
-  if (phaseNumber >= currentPhase) {
-    return {
-      ok: false,
-      error: `Phase ${phaseNumber} is not earlier than the current phase (${currentPhase}).`
-    };
-  }
-  const phaseName = plan2[phaseNumber - 1].name;
-  await appendComment(
-    orm,
-    item.id,
-    `Rewound to phase ${phaseNumber} (${phaseName}): ${reason4}`,
-    { phase: phaseNumber }
-  );
-  await updateCurrentPhase(orm, item.id, phaseNumber);
-  await updateStatus(orm, item.id, "in-progress");
-  writeSignal("rewind", { itemId: item.id, targetPhase: phaseNumber - 1 });
-  return { ok: true, phaseName };
-}
-
-// src/commands/backlog/web/rewindItemPhase.ts
-async function rewindItemPhase(req, res, id) {
-  const { phase, reason: reason4 } = await parseRewindBody(req);
-  const result = await findItemOr404(res, id);
-  if (!result) return;
-  const { orm, item } = result;
-  const outcome = await rewindItemToPhase(orm, item, phase, reason4);
-  if (!outcome.ok) {
-    respondJson(res, 400, { error: outcome.error });
-    return;
-  }
-  respondJson(res, 200, await loadItem(orm, id));
-}
-
-// src/commands/backlog/web/handleItemRoute.ts
-var itemId = (match, group = 1) => parseItemId(match[group]);
-var subId = (match, group) => Number.parseInt(match[group], 10);
-var routes = [
-  {
-    pattern: /^\/api\/items\/(a?\d+)\/rewind$/,
-    method: "POST",
-    run: (req, res, m) => rewindItemPhase(req, res, itemId(m))
-  },
-  {
-    pattern: /^\/api\/items\/(a?\d+)\/star$/,
-    method: "POST",
-    run: (req, res, m) => patchItemStar(req, res, itemId(m))
-  },
-  {
-    pattern: /^\/api\/items\/(a?\d+)\/comments\/(\d+)$/,
-    method: "DELETE",
-    run: (_req, res, m) => deleteItemComment(res, itemId(m), subId(m, 2))
-  },
-  {
-    pattern: /^\/api\/items\/(a?\d+)$/,
-    method: "GET",
-    run: (_req, res, m) => getItemById(res, itemId(m))
-  },
-  {
-    pattern: /^\/api\/items\/(a?\d+)$/,
-    method: "PATCH",
-    run: (req, res, m) => patchItemStatus(req, res, itemId(m))
-  },
-  {
-    pattern: /^\/api\/items\/(a?\d+)$/,
-    method: "DELETE",
-    run: (_req, res, m) => deleteItem2(res, itemId(m))
-  }
-];
-async function handleItemRoute(req, res, pathname) {
-  for (const route of routes) {
-    const match = pathname.match(route.pattern);
-    if (match && req.method === route.method) {
-      applyCwdFromReq(req);
-      await route.run(req, res, match);
-      return true;
-    }
-  }
-  return false;
-}
-
 // src/commands/sessions/web/readJsonBody.ts
 async function readJsonBody(req) {
   const chunks = [];
@@ -4920,20 +4704,20 @@ function includesCommittedChanges(cwd) {
 }
 
 // src/shared/db/findItemBySessionId.ts
-import { asc as asc6, eq as eq14 } from "drizzle-orm";
+import { asc as asc6, eq as eq13 } from "drizzle-orm";
 async function findItemBySessionId(db, claudeSessionId) {
-  const rows = await db.select({ itemId: phaseUsage.itemId }).from(phaseUsage).where(eq14(phaseUsage.claudeSessionId, claudeSessionId)).orderBy(asc6(phaseUsage.itemId), asc6(phaseUsage.phaseIdx)).limit(1);
+  const rows = await db.select({ itemId: phaseUsage.itemId }).from(phaseUsage).where(eq13(phaseUsage.claudeSessionId, claudeSessionId)).orderBy(asc6(phaseUsage.itemId), asc6(phaseUsage.phaseIdx)).limit(1);
   return rows[0]?.itemId;
 }
 
 // src/shared/db/listCommitRefs.ts
-import { and as and5, asc as asc7, eq as eq15 } from "drizzle-orm";
+import { and as and4, asc as asc7, eq as eq14 } from "drizzle-orm";
 async function listCommitRefs(db, itemId2) {
   const rows = await db.select({
     ref: itemGitRefs.ref,
     title: itemGitRefs.title,
     url: itemGitRefs.url
-  }).from(itemGitRefs).where(and5(eq15(itemGitRefs.itemId, itemId2), eq15(itemGitRefs.kind, "commit"))).orderBy(asc7(itemGitRefs.createdAt), asc7(itemGitRefs.ref));
+  }).from(itemGitRefs).where(and4(eq14(itemGitRefs.itemId, itemId2), eq14(itemGitRefs.kind, "commit"))).orderBy(asc7(itemGitRefs.createdAt), asc7(itemGitRefs.ref));
   return rows.map((row3) => ({
     sha: row3.ref,
     ...row3.title ? { title: row3.title } : {},
@@ -5182,12 +4966,12 @@ async function diffScopes(req, res) {
 }
 
 // src/commands/sessions/daemon/recordPromptJournal.ts
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync5 } from "fs";
-import { dirname as dirname8 } from "path";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname6 } from "path";
 function recordPromptJournal(entry) {
   const line = JSON.stringify({ at: (/* @__PURE__ */ new Date()).toISOString(), ...entry });
   try {
-    mkdirSync5(dirname8(daemonPaths.promptJournal), { recursive: true });
+    mkdirSync3(dirname6(daemonPaths.promptJournal), { recursive: true });
     appendFileSync2(daemonPaths.promptJournal, `${line}
 `);
   } catch {
@@ -5360,11 +5144,11 @@ async function fileContent(req, res) {
 import { basename as basename6 } from "path";
 
 // src/commands/sessions/web/fromGithub/listClones.ts
-import { existsSync as existsSync14, readdirSync as readdirSync2 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync13, readdirSync as readdirSync2 } from "fs";
+import { join as join16 } from "path";
 function listClones(baseDir) {
-  if (!existsSync14(baseDir)) return [];
-  return readdirSync2(baseDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join18(baseDir, entry.name)).filter((dir) => existsSync14(join18(dir, ".git"))).sort();
+  if (!existsSync13(baseDir)) return [];
+  return readdirSync2(baseDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join16(baseDir, entry.name)).filter((dir) => existsSync13(join16(dir, ".git"))).sort();
 }
 
 // src/commands/sessions/web/fromGithub/getClones.ts
@@ -5551,8 +5335,8 @@ function azureDevopsRepoUrl({ org, project, repo }) {
 }
 
 // src/commands/sessions/web/fromGithub/findAzureDevopsClone.ts
-import { existsSync as existsSync15, readdirSync as readdirSync3 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync3 } from "fs";
+import { join as join17 } from "path";
 
 // src/shared/azureDevops/parseAzureDevopsRemote.ts
 var HTTPS_DEV = /^https?:\/\/(?:[^@/]+@)?dev\.azure\.com\/([^/]+)\/([^/]+)\/_git\/([^/]+)$/i;
@@ -5573,15 +5357,15 @@ function sameAzureDevopsRepo(a, b) {
 
 // src/commands/sessions/web/fromGithub/findAzureDevopsClone.ts
 function clonesRepo(dir, repo) {
-  if (!existsSync15(join19(dir, ".git"))) return false;
+  if (!existsSync14(join17(dir, ".git"))) return false;
   const url = remoteUrl(dir).url;
   const remote = url ? parseAzureDevopsRemote(url) : null;
   return remote !== null && sameAzureDevopsRepo(remote, repo);
 }
 function findAzureDevopsClone(repo, baseDir) {
-  if (!existsSync15(baseDir)) return void 0;
-  const named = join19(baseDir, repo.repo);
-  const others = readdirSync3(baseDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join19(baseDir, entry.name)).filter((dir) => dir !== named).sort();
+  if (!existsSync14(baseDir)) return void 0;
+  const named = join17(baseDir, repo.repo);
+  const others = readdirSync3(baseDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join17(baseDir, entry.name)).filter((dir) => dir !== named).sort();
   return [named, ...others].find((dir) => clonesRepo(dir, repo));
 }
 
@@ -6674,11 +6458,11 @@ var reviewConfigHelp = [
 ];
 
 // src/commands/sync/printAutoConfirmHint.ts
-import chalk9 from "chalk";
+import chalk8 from "chalk";
 var autoConfirmHintCommand = "assist config set sync.autoConfirm true --global";
 function printAutoConfirmHint() {
   console.log(
-    chalk9.dim(
+    chalk8.dim(
       `Tip: run \`${autoConfirmHintCommand}\` to overwrite automatically next time`
     )
   );
@@ -7221,7 +7005,7 @@ function getHtml() {
 }
 
 // src/shared/resolveRunConfigs.ts
-import { dirname as dirname9, relative as relative2, resolve as resolve7 } from "path";
+import { dirname as dirname7, relative as relative2, resolve as resolve7 } from "path";
 
 // src/shared/assertNoDuplicateRunNames.ts
 function findDuplicateNames(configs) {
@@ -7243,14 +7027,14 @@ function assertNoDuplicateRunNames(configs) {
 }
 
 // src/shared/findLinkedConfigPath.ts
-import { existsSync as existsSync16 } from "fs";
-import { join as join20, resolve as resolve5 } from "path";
+import { existsSync as existsSync15 } from "fs";
+import { join as join18, resolve as resolve5 } from "path";
 function findLinkedConfigPath(linkPath, fromDir) {
   const resolved = resolve5(fromDir, linkPath);
-  const claudePath = join20(resolved, ".claude", "assist.yml");
-  if (existsSync16(claudePath)) return claudePath;
-  const rootPath = join20(resolved, "assist.yml");
-  if (existsSync16(rootPath)) return rootPath;
+  const claudePath = join18(resolved, ".claude", "assist.yml");
+  if (existsSync15(claudePath)) return claudePath;
+  const rootPath = join18(resolved, "assist.yml");
+  if (existsSync15(rootPath)) return rootPath;
   throw new Error(`No assist.yml found in linked project: ${resolved}`);
 }
 
@@ -7292,7 +7076,7 @@ function loadAndResolveLink(linkPath, configDir, ctx) {
   const entries = loadLinkedEntries(configPath, ctx.visited);
   const defaultCwd = relativeToRoot(ctx, resolve7(configDir, linkPath));
   return setDefaultCwd(
-    resolveRecursive(entries, dirname9(configPath), ctx),
+    resolveRecursive(entries, dirname7(configPath), ctx),
     defaultCwd
   );
 }
@@ -7343,20 +7127,20 @@ function handleServerRuns(req, res) {
 
 // src/commands/sessions/web/getReviewSynthesis.ts
 import { execFile as execFile4 } from "child_process";
-import { readFileSync as readFileSync7 } from "fs";
-import { homedir as homedir10 } from "os";
-import { basename as basename9, join as join22 } from "path";
+import { readFileSync as readFileSync6 } from "fs";
+import { homedir as homedir8 } from "os";
+import { basename as basename9, join as join20 } from "path";
 import { promisify as promisify4 } from "util";
 
 // src/commands/sessions/web/findSynthesisForBranch.ts
-import { existsSync as existsSync17, readdirSync as readdirSync4, statSync as statSync4 } from "fs";
-import { basename as basename8, dirname as dirname10, join as join21 } from "path";
+import { existsSync as existsSync16, readdirSync as readdirSync4, statSync as statSync4 } from "fs";
+import { basename as basename8, dirname as dirname8, join as join19 } from "path";
 function findSynthesisForBranch(repoReviewsDir, branch2) {
-  const branchKeyPath = join21(repoReviewsDir, `${branch2}-`);
-  const parent = dirname10(branchKeyPath);
+  const branchKeyPath = join19(repoReviewsDir, `${branch2}-`);
+  const parent = dirname8(branchKeyPath);
   const branchPrefix = basename8(branchKeyPath);
-  if (!existsSync17(parent)) return null;
-  const synthesisFiles = readdirSync4(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join21(parent, name, "synthesis.md")).filter((path108) => existsSync17(path108)).map((path108) => ({ path: path108, mtime: statSync4(path108).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  if (!existsSync16(parent)) return null;
+  const synthesisFiles = readdirSync4(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join19(parent, name, "synthesis.md")).filter((path108) => existsSync16(path108)).map((path108) => ({ path: path108, mtime: statSync4(path108).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   return synthesisFiles[0]?.path ?? null;
 }
 
@@ -7374,8 +7158,8 @@ async function resolveSynthesisPath(cwd) {
     runGit2(cwd, ["rev-parse", "--show-toplevel"]),
     runGit2(cwd, ["rev-parse", "--abbrev-ref", "HEAD"])
   ]);
-  const repoReviewsDir = join22(
-    homedir10(),
+  const repoReviewsDir = join20(
+    homedir8(),
     ".assist",
     "reviews",
     basename9(repoRoot2)
@@ -7391,7 +7175,7 @@ async function getReviewSynthesis(req, res) {
       respondJson(res, 404, { error: "No synthesis found" });
       return;
     }
-    respondJson(res, 200, { synthesis: readFileSync7(path108, "utf8") });
+    respondJson(res, 200, { synthesis: readFileSync6(path108, "utf8") });
   } catch {
     respondJson(res, 404, { error: "No synthesis found" });
   }
@@ -7683,6 +7467,416 @@ async function gitStatus(req, res) {
   }
 }
 
+// src/commands/backlog/deleteComment.ts
+import { and as and5, eq as eq15 } from "drizzle-orm";
+async function deleteComment(orm, itemId2, commentId) {
+  const [row3] = await orm.select({ type: comments.type }).from(comments).where(and5(eq15(comments.id, commentId), eq15(comments.itemId, itemId2)));
+  if (!row3) return "not-found";
+  if (row3.type === "summary") return "is-summary";
+  await orm.delete(comments).where(and5(eq15(comments.id, commentId), eq15(comments.itemId, itemId2)));
+  return "deleted";
+}
+
+// src/commands/backlog/web/deleteItemComment.ts
+async function deleteItemComment(res, itemId2, commentId) {
+  const result = await findItemOr404(res, itemId2);
+  if (!result) return;
+  const outcome = await deleteComment(result.orm, itemId2, commentId);
+  if (outcome === "not-found") {
+    respondJson(res, 404, {
+      error: `Comment #${commentId} not found on item ${formatItemId(itemId2)}.`
+    });
+    return;
+  }
+  if (outcome === "is-summary") {
+    respondJson(res, 400, {
+      error: `Comment #${commentId} is a phase summary and cannot be deleted.`
+    });
+    return;
+  }
+  respondJson(res, 200, await loadItem(result.orm, itemId2));
+}
+
+// src/commands/backlog/appendComment.ts
+import { sql as sql15 } from "drizzle-orm";
+async function appendComment(orm, itemId2, text18, opts = {}) {
+  await orm.insert(comments).values({
+    itemId: itemId2,
+    idx: sql15`(SELECT COALESCE(MAX(${comments.idx}) + 1, 0) FROM ${comments} WHERE ${comments.itemId} = ${itemId2})`,
+    text: text18,
+    phase: opts.phase ?? null,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    type: opts.type ?? "comment"
+  });
+}
+
+// src/commands/backlog/writeSignal.ts
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir10 } from "os";
+import { dirname as dirname10, join as join22 } from "path";
+import chalk9 from "chalk";
+
+// src/commands/backlog/recordSignalOwner.ts
+import {
+  existsSync as existsSync17,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync7,
+  rmSync as rmSync3,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { homedir as homedir9 } from "os";
+import { dirname as dirname9, join as join21 } from "path";
+function getOwnerPath(itemId2) {
+  return join21(homedir9(), ".assist", "signals", `owner-${itemId2}.json`);
+}
+function recordSignalOwner(itemId2) {
+  const sessionId = process.env.ASSIST_SESSION_ID;
+  if (!sessionId) return;
+  const path108 = getOwnerPath(itemId2);
+  mkdirSync4(dirname9(path108), { recursive: true });
+  writeFileSync3(path108, JSON.stringify({ sessionId }));
+}
+function readSignalOwner(itemId2) {
+  const path108 = getOwnerPath(itemId2);
+  if (!existsSync17(path108)) return void 0;
+  try {
+    const parsed = JSON.parse(readFileSync7(path108, "utf8"));
+    return parsed.sessionId;
+  } catch {
+    return void 0;
+  }
+}
+function clearSignalOwner(itemId2) {
+  const path108 = getOwnerPath(itemId2);
+  try {
+    rmSync3(path108);
+  } catch {
+  }
+}
+
+// src/commands/backlog/writeSignal.ts
+function getSignalPath(sessionId = process.env.ASSIST_SESSION_ID) {
+  if (!sessionId) return void 0;
+  return join22(homedir10(), ".assist", "signals", `signal-${sessionId}.json`);
+}
+function resolveSignalTarget(event, data) {
+  const caller = process.env.ASSIST_SESSION_ID;
+  const itemId2 = typeof data?.itemId === "number" ? data.itemId : void 0;
+  if (itemId2 === void 0) return caller;
+  const owner = readSignalOwner(itemId2);
+  if (owner) {
+    if (caller && owner !== caller) {
+      console.log(
+        chalk9.dim(
+          `Routing ${event} signal for item ${itemId2} to its run (${owner}), not this session (${caller}).`
+        )
+      );
+    }
+    return owner;
+  }
+  if (caller) {
+    console.log(
+      chalk9.yellow(
+        `Not signalling ${event} for item ${itemId2}: no live run owns it, and this session (${caller}) does not either.`
+      )
+    );
+  }
+  return void 0;
+}
+function writeSignal(event, data) {
+  const target = resolveSignalTarget(event, data);
+  if (!target) return;
+  const path108 = getSignalPath(target);
+  if (!path108) return;
+  const signal = { event, sessionId: target, ...data };
+  mkdirSync5(dirname10(path108), { recursive: true });
+  writeFileSync4(path108, JSON.stringify(signal));
+}
+
+// src/commands/backlog/rewindItemToPhase.ts
+async function rewindItemToPhase(orm, item, phaseNumber, reason4) {
+  const plan2 = resolveRewindPlan(item);
+  if (phaseNumber < 1 || phaseNumber > plan2.length) {
+    return {
+      ok: false,
+      error: `Phase ${phaseNumber} does not exist. Valid range: 1\u2013${plan2.length}.`
+    };
+  }
+  const currentPhase = item.currentPhase ?? 1;
+  if (phaseNumber >= currentPhase) {
+    return {
+      ok: false,
+      error: `Phase ${phaseNumber} is not earlier than the current phase (${currentPhase}).`
+    };
+  }
+  const phaseName = plan2[phaseNumber - 1].name;
+  await appendComment(
+    orm,
+    item.id,
+    `Rewound to phase ${phaseNumber} (${phaseName}): ${reason4}`,
+    { phase: phaseNumber }
+  );
+  await updateCurrentPhase(orm, item.id, phaseNumber);
+  await updateStatus(orm, item.id, "in-progress");
+  writeSignal("rewind", { itemId: item.id, targetPhase: phaseNumber - 1 });
+  return { ok: true, phaseName };
+}
+
+// src/commands/backlog/web/rewindItemPhase.ts
+async function rewindItemPhase(req, res, id) {
+  const { phase, reason: reason4 } = await parseRewindBody(req);
+  const result = await findItemOr404(res, id);
+  if (!result) return;
+  const { orm, item } = result;
+  const outcome = await rewindItemToPhase(orm, item, phase, reason4);
+  if (!outcome.ok) {
+    respondJson(res, 400, { error: outcome.error });
+    return;
+  }
+  respondJson(res, 200, await loadItem(orm, id));
+}
+
+// src/commands/backlog/web/handleItemRoute.ts
+var itemId = (match, group = 1) => parseItemId(match[group]);
+var subId = (match, group) => Number.parseInt(match[group], 10);
+var routes = [
+  {
+    pattern: /^\/api\/items\/(a?\d+)\/rewind$/,
+    method: "POST",
+    run: (req, res, m) => rewindItemPhase(req, res, itemId(m))
+  },
+  {
+    pattern: /^\/api\/items\/(a?\d+)\/star$/,
+    method: "POST",
+    run: (req, res, m) => patchItemStar(req, res, itemId(m))
+  },
+  {
+    pattern: /^\/api\/items\/(a?\d+)\/comments\/(\d+)$/,
+    method: "DELETE",
+    run: (_req, res, m) => deleteItemComment(res, itemId(m), subId(m, 2))
+  },
+  {
+    pattern: /^\/api\/items\/(a?\d+)$/,
+    method: "GET",
+    run: (_req, res, m) => getItemById(res, itemId(m))
+  },
+  {
+    pattern: /^\/api\/items\/(a?\d+)$/,
+    method: "PATCH",
+    run: (req, res, m) => patchItemStatus(req, res, itemId(m))
+  },
+  {
+    pattern: /^\/api\/items\/(a?\d+)$/,
+    method: "DELETE",
+    run: (_req, res, m) => deleteItem2(res, itemId(m))
+  }
+];
+async function handleItemRoute(req, res, pathname) {
+  for (const route of routes) {
+    const match = pathname.match(route.pattern);
+    if (match && req.method === route.method) {
+      applyCwdFromReq(req);
+      await route.run(req, res, match);
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/shared/db/dismissInboxMessage.ts
+import { and as and6, eq as eq16, isNull } from "drizzle-orm";
+async function dismissInboxMessage(orm, source, messageId) {
+  const dismissed = await orm.update(inboxMessages).set({ dismissedAt: /* @__PURE__ */ new Date() }).where(
+    and6(
+      eq16(inboxMessages.source, source),
+      eq16(inboxMessages.messageId, messageId),
+      isNull(inboxMessages.dismissedAt)
+    )
+  ).returning({ messageId: inboxMessages.messageId });
+  return dismissed.length > 0;
+}
+
+// src/commands/sessions/web/inbox/inboxMessageKey.ts
+function inboxMessageKey(source, messageId) {
+  return `${source}:${messageId}`;
+}
+function parseInboxMessageKey(key) {
+  const separator = key.indexOf(":");
+  if (separator <= 0 || separator === key.length - 1) return void 0;
+  return {
+    source: key.slice(0, separator),
+    messageId: key.slice(separator + 1)
+  };
+}
+
+// src/commands/sessions/web/inbox/handleInboxRoute.ts
+var DISMISS = /^\/api\/inbox\/([^/]+)\/dismiss$/;
+async function handleInboxRoute(req, res, pathname) {
+  const match = DISMISS.exec(pathname);
+  if (!match || req.method !== "POST") return false;
+  const key = parseInboxMessageKey(decodeURIComponent(match[1]));
+  if (!key) {
+    respondJson(res, 400, { error: "Invalid inbox message id" });
+    return true;
+  }
+  const dismissed = await dismissInboxMessage(
+    await getDb(),
+    key.source,
+    key.messageId
+  );
+  respondJson(
+    res,
+    dismissed ? 200 : 404,
+    dismissed ? { ok: true } : { error: "Not found" }
+  );
+  return true;
+}
+
+// src/commands/sessions/shared/loadLinkSpecs.ts
+function loadLinkSpecs() {
+  return loadConfig().sessions?.links ?? [];
+}
+function findLinkSpec(name) {
+  return loadLinkSpecs().find((spec) => spec.name === name);
+}
+
+// src/commands/sessions/shared/newTraceId.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var TRACE_HEADER = "x-assist-trace-id";
+function newTraceId() {
+  return randomUUID2().slice(0, 8);
+}
+
+// src/commands/sessions/web/forwardToPeer.ts
+import {
+  request as httpRequest
+} from "http";
+import { request as httpsRequest } from "https";
+
+// src/commands/sessions/web/boundUpstream.ts
+function boundUpstream(upstream, res, timeoutMs) {
+  upstream.setTimeout(
+    timeoutMs,
+    () => upstream.destroy(new Error(`no response after ${timeoutMs}ms`))
+  );
+  res.on("close", () => {
+    if (!res.writableFinished) upstream.destroy();
+  });
+}
+
+// src/commands/sessions/web/peerTimeoutMs.ts
+var peerTimeoutMs = 2e4;
+
+// src/commands/sessions/web/peerTimeoutFor.ts
+var ASSIST_UPDATE_DURATION_MS = 6e5;
+function peerTimeoutFor(pathname) {
+  return pathname === "/api/self-update" ? ASSIST_UPDATE_DURATION_MS : peerTimeoutMs;
+}
+
+// src/commands/sessions/web/isQuietPoll.ts
+var POLLED_PATHS = /* @__PURE__ */ new Set(["/api/git-status", "/api/updates"]);
+function isQuietPoll(pathname, status2) {
+  return POLLED_PATHS.has(pathname) && status2 >= 200 && status2 < 300;
+}
+
+// src/commands/sessions/web/relayPeerResponse.ts
+function relayPeerResponse(peer, res, pathname, log2, done2) {
+  const status2 = peer.statusCode ?? 502;
+  if (!isQuietPoll(pathname, status2)) log2(String(status2));
+  res.writeHead(status2, peer.headers);
+  peer.pipe(res);
+  peer.on("end", done2);
+  peer.on("error", done2);
+}
+
+// src/commands/sessions/web/forwardToPeer.ts
+var LINKED_FROM_HEADER = "x-assist-linked-from";
+function forwardToPeer(req, res, node, url) {
+  const started = Date.now();
+  const traceId = newTraceId();
+  const label = `link ${node} http: ${req.method} ${url.pathname} trace=${traceId}`;
+  const log2 = (outcome) => console.log(`${label} -> ${outcome} (${Date.now() - started}ms)`);
+  const send = url.protocol === "https:" ? httpsRequest : httpRequest;
+  return new Promise((resolve31) => {
+    const upstream = send(
+      url,
+      {
+        method: req.method,
+        headers: {
+          ...req.headers,
+          host: url.host,
+          [LINKED_FROM_HEADER]: resolveNodeName(),
+          [TRACE_HEADER]: traceId
+        }
+      },
+      (peer) => relayPeerResponse(peer, res, url.pathname, log2, resolve31)
+    );
+    boundUpstream(upstream, res, peerTimeoutFor(url.pathname));
+    upstream.on("error", (error) => {
+      log2(`failed: ${error.message}`);
+      if (res.headersSent) res.destroy();
+      else
+        respondJson(res, 502, {
+          error: `${node} unreachable: ${error.message}`
+        });
+      resolve31();
+    });
+    req.pipe(upstream);
+  });
+}
+
+// src/commands/sessions/web/proxyToNode.ts
+var LINKED_FROM_HEADER2 = "x-assist-linked-from";
+function arrivedOverLink(req) {
+  return Boolean(req.headers[LINKED_FROM_HEADER2]);
+}
+function proxyTarget(req) {
+  const url = new URL(req.url ?? "/", "http://localhost");
+  const node = url.searchParams.get("node");
+  if (!url.pathname.startsWith("/api/") || !node) return { kind: "local" };
+  if (arrivedOverLink(req) || node === resolveNodeName())
+    return { kind: "local" };
+  const link3 = findLinkSpec(node);
+  if (!link3) return { kind: "unknown", node };
+  url.searchParams.delete("node");
+  return {
+    kind: "link",
+    node,
+    url: new URL(`${url.pathname}${url.search}`, link3.url)
+  };
+}
+function logLinkedRequest(req, res) {
+  const started = Date.now();
+  const from = req.headers[LINKED_FROM_HEADER2];
+  const trace = req.headers[TRACE_HEADER] ?? "none";
+  const path108 = new URL(req.url ?? "/", "http://localhost").pathname;
+  res.once("finish", () => {
+    if (isQuietPoll(path108, res.statusCode)) return;
+    console.log(
+      `link-from ${from} http: ${req.method} ${path108} trace=${trace} -> ${res.statusCode} (${Date.now() - started}ms)`
+    );
+  });
+}
+async function proxyToNode(req, res) {
+  if (arrivedOverLink(req)) logLinkedRequest(req, res);
+  const target = proxyTarget(req);
+  if (target.kind === "local") return false;
+  if (target.kind === "unknown") {
+    console.log(
+      `link ${target.node} http: ${req.method} ${req.url} -> no such link`
+    );
+    respondJson(res, 404, { error: `No link to node ${target.node}` });
+    return true;
+  }
+  await forwardToPeer(req, res, target.node, target.url);
+  return true;
+}
+
+// src/commands/sessions/web/handleDynamicRoute.ts
+async function handleDynamicRoute(req, res, pathname) {
+  return await proxyToNode(req, res) || await handleInboxRoute(req, res, pathname) || handleItemRoute(req, res, pathname);
+}
+
 // src/commands/sessions/web/harnessCapabilities.ts
 function harnessCapabilities(_req, res) {
   const config = loadConfig().harness;
@@ -7781,6 +7975,33 @@ async function historySearch(req, res) {
   respondJson(res, 200, { sessions: reply2.sessions ?? [] });
 }
 
+// src/shared/db/listInboxMessages.ts
+import { desc as desc2, isNull as isNull2, sql as sql16 } from "drizzle-orm";
+function listInboxMessages(orm) {
+  return orm.select().from(inboxMessages).where(isNull2(inboxMessages.dismissedAt)).orderBy(
+    desc2(
+      sql16`coalesce(${inboxMessages.receivedAt}, ${inboxMessages.flaggedAt})`
+    )
+  );
+}
+
+// src/commands/sessions/web/inbox/listInbox.ts
+async function listInbox(_req, res) {
+  const rows = await listInboxMessages(await getDb());
+  respondJson(
+    res,
+    200,
+    rows.map((row3) => ({
+      id: inboxMessageKey(row3.source, row3.messageId),
+      source: row3.source,
+      sender: row3.sender,
+      summary: row3.summary,
+      link: row3.link,
+      receivedAt: (row3.receivedAt ?? row3.flaggedAt).toISOString()
+    }))
+  );
+}
+
 // src/shared/hotkeys/resolveHotkeys.ts
 function resolveHotkeys(overrides) {
   const bindings = { ...defaultHotkeys };
@@ -8895,22 +9116,22 @@ function listScopedRules(req, res) {
 }
 
 // src/shared/db/countUsagePeaks.ts
-import { count, eq as eq16 } from "drizzle-orm";
+import { count, eq as eq17 } from "drizzle-orm";
 async function countUsagePeaks(db, window) {
-  const [row3] = await db.select({ value: count() }).from(usagePeaks).where(window ? eq16(usagePeaks.window, window) : void 0);
+  const [row3] = await db.select({ value: count() }).from(usagePeaks).where(window ? eq17(usagePeaks.window, window) : void 0);
   return row3?.value ?? 0;
 }
 
 // src/shared/db/listUsagePeaks.ts
-import { and as and6, desc as desc2, eq as eq17, getTableColumns } from "drizzle-orm";
+import { and as and7, desc as desc3, eq as eq18, getTableColumns } from "drizzle-orm";
 
 // src/shared/db/avgContextPerCycle.ts
-import { count as count2, sql as sql16 } from "drizzle-orm";
+import { count as count2, sql as sql17 } from "drizzle-orm";
 function avgContextPerCycle(db) {
   return db.select({
     window: phaseCycleContext.window,
     resetsAt: phaseCycleContext.resetsAt,
-    avgContextPct: sql16`cast(avg(${phaseCycleContext.peakContextPct}) as double precision)`.as(
+    avgContextPct: sql17`cast(avg(${phaseCycleContext.peakContextPct}) as double precision)`.as(
       "avg_context_pct"
     ),
     phaseCount: count2().as("phase_count")
@@ -8926,15 +9147,15 @@ async function listUsagePeaks(db, options2) {
     phaseCount: avgContext.phaseCount
   }).from(usagePeaks).leftJoin(
     avgContext,
-    and6(
-      eq17(usagePeaks.window, avgContext.window),
-      eq17(usagePeaks.resetsAt, avgContext.resetsAt)
+    and7(
+      eq18(usagePeaks.window, avgContext.window),
+      eq18(usagePeaks.resetsAt, avgContext.resetsAt)
     )
-  ).where(options2?.window ? eq17(usagePeaks.window, options2.window) : void 0).orderBy(
-    desc2(usagePeaks.resetsAt),
+  ).where(options2?.window ? eq18(usagePeaks.window, options2.window) : void 0).orderBy(
+    desc3(usagePeaks.resetsAt),
     usagePeaks.window,
-    desc2(usagePeaks.createdAt),
-    desc2(usagePeaks.segment)
+    desc3(usagePeaks.createdAt),
+    desc3(usagePeaks.segment)
   );
   if (options2?.limit !== void 0) {
     return query.limit(options2.limit).offset(options2.offset ?? 0);
@@ -8999,26 +9220,26 @@ function listUsageHistory(req, res) {
 }
 
 // src/shared/db/countItemUsageByOrigin.ts
-import { asc as asc8, desc as desc3, eq as eq18, sql as sql17 } from "drizzle-orm";
+import { asc as asc8, desc as desc4, eq as eq19, sql as sql18 } from "drizzle-orm";
 async function countItemUsageByOrigin(db) {
-  const count10 = sql17`count(distinct ${phaseUsage.itemId})::int`;
-  const rows = await db.select({ origin: items.origin, count: count10 }).from(items).innerJoin(phaseUsage, eq18(phaseUsage.itemId, items.id)).groupBy(items.origin).orderBy(desc3(count10), asc8(items.origin));
+  const count10 = sql18`count(distinct ${phaseUsage.itemId})::int`;
+  const rows = await db.select({ origin: items.origin, count: count10 }).from(items).innerJoin(phaseUsage, eq19(phaseUsage.itemId, items.id)).groupBy(items.origin).orderBy(desc4(count10), asc8(items.origin));
   return rows.map((row3) => ({ origin: row3.origin, count: Number(row3.count) }));
 }
 
 // src/shared/db/itemUsageWhere.ts
-import { and as and7, eq as eq19, notInArray } from "drizzle-orm";
+import { and as and8, eq as eq20, notInArray } from "drizzle-orm";
 function parseItemUsageStatus(value) {
   return value === "done" || value === "running" ? value : void 0;
 }
 function statusClause(status2) {
-  if (status2 === "done") return eq19(items.status, "done");
+  if (status2 === "done") return eq20(items.status, "done");
   if (status2 === "running") return notInArray(items.status, ["done", "wontdo"]);
   return void 0;
 }
 function itemUsageWhere(filter) {
-  return and7(
-    filter?.origin ? eq19(items.origin, filter.origin) : void 0,
+  return and8(
+    filter?.origin ? eq20(items.origin, filter.origin) : void 0,
     statusClause(filter?.status)
   );
 }
@@ -9043,23 +9264,23 @@ function parseItemUsageSort(field, direction) {
 }
 
 // src/shared/db/itemUsageStats.ts
-import { eq as eq20, sql as sql18 } from "drizzle-orm";
+import { eq as eq21, sql as sql19 } from "drizzle-orm";
 function median(value) {
-  return sql18`coalesce(percentile_cont(0.5) within group (order by (${value})::double precision), 0)`;
+  return sql19`coalesce(percentile_cont(0.5) within group (order by (${value})::double precision), 0)`;
 }
 async function itemUsageStats(db, options2) {
   const totals = phaseUsageTotals(db);
   const planned = planPhaseCounts(db);
   const [row3] = await db.select({
-    itemCount: sql18`count(*)::int`,
-    doneCount: sql18`count(*) filter (where ${items.status} = 'done')::int`,
-    repoCount: sql18`count(distinct ${items.origin})::int`,
+    itemCount: sql19`count(*)::int`,
+    doneCount: sql19`count(*) filter (where ${items.status} = 'done')::int`,
+    repoCount: sql19`count(distinct ${items.origin})::int`,
     medianPhases: median(
-      sql18`coalesce(${planned.count}, ${totals.recordedPhases})`
+      sql19`coalesce(${planned.count}, ${totals.recordedPhases})`
     ),
     medianActiveMs: median(totals.activeMs),
-    medianTokens: median(sql18`${totals.tokensUp} + ${totals.tokensDown}`)
-  }).from(items).innerJoin(totals, eq20(totals.itemId, items.id)).leftJoin(planned, eq20(planned.itemId, items.id)).where(itemUsageWhere(options2));
+    medianTokens: median(sql19`${totals.tokensUp} + ${totals.tokensDown}`)
+  }).from(items).innerJoin(totals, eq21(totals.itemId, items.id)).leftJoin(planned, eq21(planned.itemId, items.id)).where(itemUsageWhere(options2));
   return {
     itemCount: Number(row3?.itemCount ?? 0),
     doneCount: Number(row3?.doneCount ?? 0),
@@ -9071,30 +9292,30 @@ async function itemUsageStats(db, options2) {
 }
 
 // src/shared/db/listItemUsageSummaries.ts
-import { eq as eq21 } from "drizzle-orm";
+import { eq as eq22 } from "drizzle-orm";
 
 // src/shared/db/itemUsageOrderBy.ts
-import { desc as desc4, sql as sql19 } from "drizzle-orm";
+import { desc as desc5, sql as sql20 } from "drizzle-orm";
 function itemUsageOrderBy(joins, sort = defaultItemUsageSort) {
   const { totals, planned, lastPhase } = joins;
   const sortable = {
-    phases: sql19`coalesce(${planned.count}, ${totals.recordedPhases})`,
-    active: sql19`${totals.activeMs}`,
-    tokens: sql19`${totals.tokensUp} + ${totals.tokensDown}`,
-    peakContext: sql19`${totals.peakContextPct}`,
-    lastPhase: sql19`${lastPhase.at}`
+    phases: sql20`coalesce(${planned.count}, ${totals.recordedPhases})`,
+    active: sql20`${totals.activeMs}`,
+    tokens: sql20`${totals.tokensUp} + ${totals.tokensDown}`,
+    peakContext: sql20`${totals.peakContextPct}`,
+    lastPhase: sql20`${lastPhase.at}`
   };
-  const order = sort.direction === "asc" ? sql19`asc` : sql19`desc`;
-  return [sql19`${sortable[sort.field]} ${order} nulls last`, desc4(items.id)];
+  const order = sort.direction === "asc" ? sql20`asc` : sql20`desc`;
+  return [sql20`${sortable[sort.field]} ${order} nulls last`, desc5(items.id)];
 }
 
 // src/shared/db/lastPhaseActivity.ts
-import { sql as sql20 } from "drizzle-orm";
+import { sql as sql21 } from "drizzle-orm";
 function lastPhaseActivity(db) {
   return db.select({
     itemId: phaseSessions.itemId,
-    at: sql20`max(${phaseSessions.createdAt})`.as("last_phase_at"),
-    atIso: sql20`to_char(max(${phaseSessions.createdAt}) at time zone 'utc', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')`.as(
+    at: sql21`max(${phaseSessions.createdAt})`.as("last_phase_at"),
+    atIso: sql21`to_char(max(${phaseSessions.createdAt}) at time zone 'utc', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')`.as(
       "last_phase_at_iso"
     )
   }).from(phaseSessions).groupBy(phaseSessions.itemId).as("last_phase_activity");
@@ -9132,7 +9353,7 @@ async function listItemUsageSummaries(db, options2) {
     activeMs: totals.activeMs,
     peakContextPct: totals.peakContextPct,
     lastPhaseAt: lastPhase.atIso
-  }).from(items).innerJoin(totals, eq21(totals.itemId, items.id)).leftJoin(planned, eq21(planned.itemId, items.id)).leftJoin(lastPhase, eq21(lastPhase.itemId, items.id)).where(itemUsageWhere(options2)).orderBy(
+  }).from(items).innerJoin(totals, eq22(totals.itemId, items.id)).leftJoin(planned, eq22(planned.itemId, items.id)).leftJoin(lastPhase, eq22(lastPhase.itemId, items.id)).where(itemUsageWhere(options2)).orderBy(
     ...itemUsageOrderBy({ totals, planned, lastPhase }, options2?.sort)
   );
   const rows = options2?.limit === void 0 ? await query : await query.limit(options2.limit).offset(options2.offset ?? 0);
@@ -9236,146 +9457,6 @@ async function prList(req, res) {
   respondJson(res, 200, { prs: await getOpenPrs(cwd) });
 }
 
-// src/commands/sessions/shared/loadLinkSpecs.ts
-function loadLinkSpecs() {
-  return loadConfig().sessions?.links ?? [];
-}
-function findLinkSpec(name) {
-  return loadLinkSpecs().find((spec) => spec.name === name);
-}
-
-// src/commands/sessions/shared/newTraceId.ts
-import { randomUUID as randomUUID2 } from "crypto";
-var TRACE_HEADER = "x-assist-trace-id";
-function newTraceId() {
-  return randomUUID2().slice(0, 8);
-}
-
-// src/commands/sessions/web/forwardToPeer.ts
-import {
-  request as httpRequest
-} from "http";
-import { request as httpsRequest } from "https";
-
-// src/commands/sessions/web/boundUpstream.ts
-function boundUpstream(upstream, res, timeoutMs) {
-  upstream.setTimeout(
-    timeoutMs,
-    () => upstream.destroy(new Error(`no response after ${timeoutMs}ms`))
-  );
-  res.on("close", () => {
-    if (!res.writableFinished) upstream.destroy();
-  });
-}
-
-// src/commands/sessions/web/peerTimeoutMs.ts
-var peerTimeoutMs = 2e4;
-
-// src/commands/sessions/web/peerTimeoutFor.ts
-var ASSIST_UPDATE_DURATION_MS = 6e5;
-function peerTimeoutFor(pathname) {
-  return pathname === "/api/self-update" ? ASSIST_UPDATE_DURATION_MS : peerTimeoutMs;
-}
-
-// src/commands/sessions/web/isQuietPoll.ts
-var POLLED_PATHS = /* @__PURE__ */ new Set(["/api/git-status", "/api/updates"]);
-function isQuietPoll(pathname, status2) {
-  return POLLED_PATHS.has(pathname) && status2 >= 200 && status2 < 300;
-}
-
-// src/commands/sessions/web/relayPeerResponse.ts
-function relayPeerResponse(peer, res, pathname, log2, done2) {
-  const status2 = peer.statusCode ?? 502;
-  if (!isQuietPoll(pathname, status2)) log2(String(status2));
-  res.writeHead(status2, peer.headers);
-  peer.pipe(res);
-  peer.on("end", done2);
-  peer.on("error", done2);
-}
-
-// src/commands/sessions/web/forwardToPeer.ts
-var LINKED_FROM_HEADER = "x-assist-linked-from";
-function forwardToPeer(req, res, node, url) {
-  const started = Date.now();
-  const traceId = newTraceId();
-  const label = `link ${node} http: ${req.method} ${url.pathname} trace=${traceId}`;
-  const log2 = (outcome) => console.log(`${label} -> ${outcome} (${Date.now() - started}ms)`);
-  const send = url.protocol === "https:" ? httpsRequest : httpRequest;
-  return new Promise((resolve31) => {
-    const upstream = send(
-      url,
-      {
-        method: req.method,
-        headers: {
-          ...req.headers,
-          host: url.host,
-          [LINKED_FROM_HEADER]: resolveNodeName(),
-          [TRACE_HEADER]: traceId
-        }
-      },
-      (peer) => relayPeerResponse(peer, res, url.pathname, log2, resolve31)
-    );
-    boundUpstream(upstream, res, peerTimeoutFor(url.pathname));
-    upstream.on("error", (error) => {
-      log2(`failed: ${error.message}`);
-      if (res.headersSent) res.destroy();
-      else
-        respondJson(res, 502, {
-          error: `${node} unreachable: ${error.message}`
-        });
-      resolve31();
-    });
-    req.pipe(upstream);
-  });
-}
-
-// src/commands/sessions/web/proxyToNode.ts
-var LINKED_FROM_HEADER2 = "x-assist-linked-from";
-function arrivedOverLink(req) {
-  return Boolean(req.headers[LINKED_FROM_HEADER2]);
-}
-function proxyTarget(req) {
-  const url = new URL(req.url ?? "/", "http://localhost");
-  const node = url.searchParams.get("node");
-  if (!url.pathname.startsWith("/api/") || !node) return { kind: "local" };
-  if (arrivedOverLink(req) || node === resolveNodeName())
-    return { kind: "local" };
-  const link3 = findLinkSpec(node);
-  if (!link3) return { kind: "unknown", node };
-  url.searchParams.delete("node");
-  return {
-    kind: "link",
-    node,
-    url: new URL(`${url.pathname}${url.search}`, link3.url)
-  };
-}
-function logLinkedRequest(req, res) {
-  const started = Date.now();
-  const from = req.headers[LINKED_FROM_HEADER2];
-  const trace = req.headers[TRACE_HEADER] ?? "none";
-  const path108 = new URL(req.url ?? "/", "http://localhost").pathname;
-  res.once("finish", () => {
-    if (isQuietPoll(path108, res.statusCode)) return;
-    console.log(
-      `link-from ${from} http: ${req.method} ${path108} trace=${trace} -> ${res.statusCode} (${Date.now() - started}ms)`
-    );
-  });
-}
-async function proxyToNode(req, res) {
-  if (arrivedOverLink(req)) logLinkedRequest(req, res);
-  const target = proxyTarget(req);
-  if (target.kind === "local") return false;
-  if (target.kind === "unknown") {
-    console.log(
-      `link ${target.node} http: ${req.method} ${req.url} -> no such link`
-    );
-    respondJson(res, 404, { error: `No link to node ${target.node}` });
-    return true;
-  }
-  await forwardToPeer(req, res, target.node, target.url);
-  return true;
-}
-
 // src/commands/sessions/web/previewImage.ts
 import { createReadStream as createReadStream2 } from "fs";
 import { stat as stat2 } from "fs/promises";
@@ -11059,10 +11140,10 @@ function currentRepoLabel(shared, origin) {
 }
 
 // src/shared/db/saveRepoConfig.ts
-import { eq as eq22 } from "drizzle-orm";
+import { eq as eq23 } from "drizzle-orm";
 async function saveRepoConfig(orm, repoKey, config) {
   if (Object.keys(config).length === 0) {
-    await orm.delete(repoConfigs).where(eq22(repoConfigs.repoKey, repoKey));
+    await orm.delete(repoConfigs).where(eq23(repoConfigs.repoKey, repoKey));
     return;
   }
   await orm.insert(repoConfigs).values({ repoKey, config }).onConflictDoUpdate({
@@ -11935,6 +12016,7 @@ var routes2 = {
   "GET /api/pr-list": prList,
   "GET /api/next": nextItems,
   "POST /api/next/pickup": nextPickup,
+  "GET /api/inbox": listInbox,
   "GET /api/news/items": listNewsItems,
   "GET /api/news/nav": newsNavConfig,
   "GET /api/releases/state": releasesState,
@@ -11954,7 +12036,7 @@ var routes2 = {
 var handleRequest = createFallbackHandler(
   routes2,
   htmlHandler,
-  async (req, res, pathname) => await proxyToNode(req, res) || handleItemRoute(req, res, pathname)
+  handleDynamicRoute
 );
 
 // src/commands/sessions/web/restartMenu/installRestartMenu.ts
@@ -15292,11 +15374,11 @@ function registerActivityCommands(cmd) {
 
 // src/commands/backlog/associateGithub.ts
 import chalk43 from "chalk";
-import { eq as eq24 } from "drizzle-orm";
+import { eq as eq25 } from "drizzle-orm";
 
 // src/commands/backlog/beginAssociation.ts
 import chalk42 from "chalk";
-import { eq as eq23 } from "drizzle-orm";
+import { eq as eq24 } from "drizzle-orm";
 async function beginAssociation(id, options2, clearPatch, label) {
   const found = await findOneItem(id);
   if (!found) {
@@ -15306,7 +15388,7 @@ async function beginAssociation(id, options2, clearPatch, label) {
   const { orm } = found;
   const itemId2 = found.item.id;
   if (options2.clear) {
-    await orm.update(items).set(clearPatch).where(eq23(items.id, itemId2));
+    await orm.update(items).set(clearPatch).where(eq24(items.id, itemId2));
     console.log(
       chalk42.green(
         `Cleared ${label} association on item ${formatItemId(itemId2)}.`
@@ -15374,7 +15456,7 @@ async function associateGithub(id, issue, options2) {
     return;
   }
   const title = fetchGithubIssueTitle(normalized);
-  await orm.update(items).set({ githubIssue: normalized, jiraKey: null }).where(eq24(items.id, itemId2));
+  await orm.update(items).set({ githubIssue: normalized, jiraKey: null }).where(eq25(items.id, itemId2));
   console.log(
     chalk43.green(`Associated ${normalized} with item ${formatItemId(itemId2)}.`),
     title ? chalk43.dim(`(${title})`) : ""
@@ -15388,7 +15470,7 @@ function registerAssociateGithubCommand(cmd) {
 
 // src/commands/backlog/associateJira.ts
 import chalk45 from "chalk";
-import { eq as eq25 } from "drizzle-orm";
+import { eq as eq26 } from "drizzle-orm";
 
 // src/commands/jira/fetchIssue.ts
 import { execSync as execSync17 } from "child_process";
@@ -15453,7 +15535,7 @@ async function associateJira(id, key, options2) {
   const parsed = fetchIssue(normalized, "summary");
   const fields = parsed?.fields;
   const summary = fields?.summary;
-  await orm.update(items).set({ jiraKey: normalized, githubIssue: null }).where(eq25(items.id, itemId2));
+  await orm.update(items).set({ jiraKey: normalized, githubIssue: null }).where(eq26(items.id, itemId2));
   console.log(
     chalk45.green(`Associated ${normalized} with item ${formatItemId(itemId2)}.`),
     summary ? chalk45.dim(`(${summary})`) : ""
@@ -15838,15 +15920,15 @@ function isClaudeCode() {
 }
 
 // src/commands/backlog/insertPhaseAt.ts
-import { eq as eq27 } from "drizzle-orm";
+import { eq as eq28 } from "drizzle-orm";
 
 // src/commands/backlog/shiftPhasesUp.ts
-import { and as and8, desc as desc5, eq as eq26, gte } from "drizzle-orm";
+import { and as and9, desc as desc6, eq as eq27, gte } from "drizzle-orm";
 async function shiftPhasesUp(db, itemId2, fromIdx) {
-  const toShift = await db.select({ idx: planPhases.idx }).from(planPhases).where(and8(eq26(planPhases.itemId, itemId2), gte(planPhases.idx, fromIdx))).orderBy(desc5(planPhases.idx));
+  const toShift = await db.select({ idx: planPhases.idx }).from(planPhases).where(and9(eq27(planPhases.itemId, itemId2), gte(planPhases.idx, fromIdx))).orderBy(desc6(planPhases.idx));
   for (const p of toShift) {
-    await db.update(planTasks).set({ phaseIdx: p.idx + 1 }).where(and8(eq26(planTasks.itemId, itemId2), eq26(planTasks.phaseIdx, p.idx)));
-    await db.update(planPhases).set({ idx: p.idx + 1 }).where(and8(eq26(planPhases.itemId, itemId2), eq26(planPhases.idx, p.idx)));
+    await db.update(planTasks).set({ phaseIdx: p.idx + 1 }).where(and9(eq27(planTasks.itemId, itemId2), eq27(planTasks.phaseIdx, p.idx)));
+    await db.update(planPhases).set({ idx: p.idx + 1 }).where(and9(eq27(planPhases.itemId, itemId2), eq27(planPhases.idx, p.idx)));
   }
 }
 
@@ -15859,7 +15941,7 @@ async function insertPhaseAt(orm, itemId2, phaseIdx, name, tasks, manualChecks,
       await tx.insert(planTasks).values(tasks.map((task, i) => ({ itemId: itemId2, phaseIdx, idx: i, task })));
     }
     if (currentPhase !== void 0 && currentPhase - 1 >= phaseIdx) {
-      await tx.update(items).set({ currentPhase: phaseIdx + 1 }).where(eq27(items.id, itemId2));
+      await tx.update(items).set({ currentPhase: phaseIdx + 1 }).where(eq28(items.id, itemId2));
     }
   });
 }
@@ -16016,9 +16098,9 @@ import chalk56 from "chalk";
 
 // src/commands/backlog/resolveInsertPosition.ts
 import chalk55 from "chalk";
-import { count as count3, eq as eq28 } from "drizzle-orm";
+import { count as count3, eq as eq29 } from "drizzle-orm";
 async function resolveInsertPosition(orm, itemId2, position) {
-  const [row3] = await orm.select({ cnt: count3() }).from(planPhases).where(eq28(planPhases.itemId, itemId2));
+  const [row3] = await orm.select({ cnt: count3() }).from(planPhases).where(eq29(planPhases.itemId, itemId2));
   const phaseCount = row3?.cnt ?? 0;
   if (position === void 0) return phaseCount;
   const pos = Number.parseInt(position, 10);
@@ -16438,9 +16520,9 @@ function hasCycle(adjacency, fromId, toId) {
 }
 
 // src/commands/backlog/loadDependencyGraph.ts
-import { eq as eq29 } from "drizzle-orm";
+import { eq as eq30 } from "drizzle-orm";
 async function loadDependencyGraph(orm) {
-  const rows = await orm.select({ itemId: links.itemId, targetId: links.targetId }).from(links).where(eq29(links.type, "depends-on"));
+  const rows = await orm.select({ itemId: links.itemId, targetId: links.targetId }).from(links).where(eq30(links.type, "depends-on"));
   const graph = /* @__PURE__ */ new Map();
   for (const { itemId: itemId2, targetId } of rows) {
     const bucket = graph.get(itemId2);
@@ -16507,7 +16589,7 @@ async function link(fromId, toId, opts) {
 
 // src/commands/backlog/unlink.ts
 import chalk64 from "chalk";
-import { and as and9, eq as eq30 } from "drizzle-orm";
+import { and as and10, eq as eq31 } from "drizzle-orm";
 async function unlink(fromId, toId) {
   const fromNum = parseItemId(fromId);
   const toNum = parseItemId(toId);
@@ -16531,7 +16613,7 @@ async function unlink(fromId, toId) {
     );
     return;
   }
-  await orm.delete(links).where(and9(eq30(links.itemId, fromNum), eq30(links.targetId, toNum)));
+  await orm.delete(links).where(and10(eq31(links.itemId, fromNum), eq31(links.targetId, toNum)));
   console.log(
     chalk64.green(
       `Removed link from ${formatItemId(fromNum)} to ${formatItemId(toNum)}.`
@@ -16551,7 +16633,7 @@ function registerLinkCommands(cmd) {
 
 // src/commands/backlog/moveRepo.ts
 import chalk66 from "chalk";
-import { eq as eq32 } from "drizzle-orm";
+import { eq as eq33 } from "drizzle-orm";
 
 // src/commands/backlog/move-repo/confirmMove.ts
 import chalk65 from "chalk";
@@ -16566,9 +16648,9 @@ async function confirmMove(cnt, oldOrigin, newOrigin) {
 }
 
 // src/commands/backlog/move-repo/countByOrigin.ts
-import { count as count4, eq as eq31 } from "drizzle-orm";
+import { count as count4, eq as eq32 } from "drizzle-orm";
 async function countByOrigin(orm, origin) {
-  const [{ cnt }] = await orm.select({ cnt: count4() }).from(items).where(eq31(items.origin, origin));
+  const [{ cnt }] = await orm.select({ cnt: count4() }).from(items).where(eq32(items.origin, origin));
   return cnt;
 }
 
@@ -16611,7 +16693,7 @@ async function moveRepo(oldOriginRaw, newOriginRaw, options2 = {}) {
     console.log(chalk66.yellow("Move cancelled; no changes made."));
     return;
   }
-  await orm.update(items).set({ origin: newOrigin }).where(eq32(items.origin, oldOrigin));
+  await orm.update(items).set({ origin: newOrigin }).where(eq33(items.origin, oldOrigin));
   console.log(
     chalk66.green(
       `Moved ${pluralItems(cnt)} from "${oldOrigin}" to "${newOrigin}".`
@@ -17193,12 +17275,12 @@ async function ensureDone(id) {
 import chalk70 from "chalk";
 
 // src/shared/db/findPhaseBySessionId.ts
-import { and as and10, eq as eq33 } from "drizzle-orm";
+import { and as and11, eq as eq34 } from "drizzle-orm";
 async function findPhaseBySessionId(db, itemId2, claudeSessionId) {
   const rows = await db.select({ phaseIdx: phaseUsage.phaseIdx }).from(phaseUsage).where(
-    and10(
-      eq33(phaseUsage.itemId, itemId2),
-      eq33(phaseUsage.claudeSessionId, claudeSessionId)
+    and11(
+      eq34(phaseUsage.itemId, itemId2),
+      eq34(phaseUsage.claudeSessionId, claudeSessionId)
     )
   ).limit(1);
   return rows[0]?.phaseIdx;
@@ -17665,7 +17747,7 @@ import { randomUUID as randomUUID6 } from "crypto";
 import os4 from "os";
 
 // src/shared/db/recordPhaseSession.ts
-import { sql as sql21 } from "drizzle-orm";
+import { sql as sql22 } from "drizzle-orm";
 async function recordPhaseSession(db, itemId2, phaseIdx, claudeSessionId, hostname2, osUser) {
   await db.insert(phaseSessions).values({ itemId: itemId2, phaseIdx, claudeSessionId, hostname: hostname2, osUser }).onConflictDoUpdate({
     target: [
@@ -17674,7 +17756,7 @@ async function recordPhaseSession(db, itemId2, phaseIdx, claudeSessionId, hostna
       phaseSessions.claudeSessionId
     ],
     set: { hostname: hostname2, osUser },
-    setWhere: sql21`${phaseSessions.hostname} = 'unknown'`
+    setWhere: sql22`${phaseSessions.hostname} = 'unknown'`
   });
 }
 
@@ -18545,10 +18627,10 @@ async function start(id) {
 
 // src/commands/backlog/stop.ts
 import chalk92 from "chalk";
-import { and as and11, eq as eq34 } from "drizzle-orm";
+import { and as and12, eq as eq35 } from "drizzle-orm";
 async function stop() {
   const { orm } = await getReady();
-  const stopped = await orm.update(items).set({ status: "todo", currentPhase: 1 }).where(and11(eq34(items.status, "in-progress"), eq34(items.origin, getOrigin()))).returning({ id: items.id, name: items.name });
+  const stopped = await orm.update(items).set({ status: "todo", currentPhase: 1 }).where(and12(eq35(items.status, "in-progress"), eq35(items.origin, getOrigin()))).returning({ id: items.id, name: items.name });
   if (stopped.length === 0) {
     console.log(chalk92.yellow("No in-progress items to stop."));
     return;
@@ -18606,20 +18688,20 @@ function registerStatusCommands(cmd) {
 
 // src/commands/backlog/movePhase.ts
 import chalk95 from "chalk";
-import { count as count6, eq as eq37 } from "drizzle-orm";
+import { count as count6, eq as eq38 } from "drizzle-orm";
 
 // src/commands/backlog/reorderPhaseRows.ts
-import { and as and13, asc as asc10, eq as eq36 } from "drizzle-orm";
+import { and as and14, asc as asc10, eq as eq37 } from "drizzle-orm";
 
 // src/commands/backlog/reindexPhases.ts
-import { and as and12, asc as asc9, count as count5, eq as eq35 } from "drizzle-orm";
+import { and as and13, asc as asc9, count as count5, eq as eq36 } from "drizzle-orm";
 async function reindexPhases(db, itemId2) {
-  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq35(planPhases.itemId, itemId2)).orderBy(asc9(planPhases.idx));
+  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq36(planPhases.itemId, itemId2)).orderBy(asc9(planPhases.idx));
   for (let i = 0; i < remaining.length; i++) {
     const oldIdx = remaining[i].idx;
     if (oldIdx === i) continue;
-    await db.update(planTasks).set({ phaseIdx: i }).where(and12(eq35(planTasks.itemId, itemId2), eq35(planTasks.phaseIdx, oldIdx)));
-    await db.update(planPhases).set({ idx: i }).where(and12(eq35(planPhases.itemId, itemId2), eq35(planPhases.idx, oldIdx)));
+    await db.update(planTasks).set({ phaseIdx: i }).where(and13(eq36(planTasks.itemId, itemId2), eq36(planTasks.phaseIdx, oldIdx)));
+    await db.update(planPhases).set({ idx: i }).where(and13(eq36(planPhases.itemId, itemId2), eq36(planPhases.idx, oldIdx)));
   }
 }
 async function adjustCurrentPhase(db, item, removedIdx) {
@@ -18627,24 +18709,24 @@ async function adjustCurrentPhase(db, item, removedIdx) {
   if (currentPhase === void 0) return;
   const currentIdx = currentPhase - 1;
   if (removedIdx < currentIdx) {
-    await db.update(items).set({ currentPhase: currentPhase - 1 }).where(eq35(items.id, item.id));
+    await db.update(items).set({ currentPhase: currentPhase - 1 }).where(eq36(items.id, item.id));
     return;
   }
   if (removedIdx !== currentIdx) return;
-  const [row3] = await db.select({ cnt: count5() }).from(planPhases).where(eq35(planPhases.itemId, item.id));
+  const [row3] = await db.select({ cnt: count5() }).from(planPhases).where(eq36(planPhases.itemId, item.id));
   const cnt = row3?.cnt ?? 0;
-  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq35(items.id, item.id));
+  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq36(items.id, item.id));
 }
 
 // src/commands/backlog/reorderPhaseRows.ts
 async function reorderPhaseRows(orm, itemId2, fromIdx, toIdx) {
   await orm.transaction(async (tx) => {
-    const [phaseRow] = await tx.select({ name: planPhases.name, manualChecks: planPhases.manualChecks }).from(planPhases).where(and13(eq36(planPhases.itemId, itemId2), eq36(planPhases.idx, fromIdx)));
-    const tasks = await tx.select({ idx: planTasks.idx, task: planTasks.task }).from(planTasks).where(and13(eq36(planTasks.itemId, itemId2), eq36(planTasks.phaseIdx, fromIdx))).orderBy(asc10(planTasks.idx));
+    const [phaseRow] = await tx.select({ name: planPhases.name, manualChecks: planPhases.manualChecks }).from(planPhases).where(and14(eq37(planPhases.itemId, itemId2), eq37(planPhases.idx, fromIdx)));
+    const tasks = await tx.select({ idx: planTasks.idx, task: planTasks.task }).from(planTasks).where(and14(eq37(planTasks.itemId, itemId2), eq37(planTasks.phaseIdx, fromIdx))).orderBy(asc10(planTasks.idx));
     await tx.delete(planTasks).where(
-      and13(eq36(planTasks.itemId, itemId2), eq36(planTasks.phaseIdx, fromIdx))
+      and14(eq37(planTasks.itemId, itemId2), eq37(planTasks.phaseIdx, fromIdx))
     );
-    await tx.delete(planPhases).where(and13(eq36(planPhases.itemId, itemId2), eq36(planPhases.idx, fromIdx)));
+    await tx.delete(planPhases).where(and14(eq37(planPhases.itemId, itemId2), eq37(planPhases.idx, fromIdx)));
     await reindexPhases(tx, itemId2);
     await shiftPhasesUp(tx, itemId2, toIdx);
     await tx.insert(planPhases).values({
@@ -18685,7 +18767,7 @@ async function movePhase(id, from, to) {
   if (!found) return;
   const { orm, item } = found;
   const itemId2 = item.id;
-  const [row3] = await orm.select({ cnt: count6() }).from(planPhases).where(eq37(planPhases.itemId, itemId2));
+  const [row3] = await orm.select({ cnt: count6() }).from(planPhases).where(eq38(planPhases.itemId, itemId2));
   const phaseCount = row3?.cnt ?? 0;
   const fromIdx = toIndex2(from, phaseCount);
   if (fromIdx === void 0) return;
@@ -18701,22 +18783,22 @@ async function movePhase(id, from, to) {
 import chalk97 from "chalk";
 
 // src/commands/backlog/applyPhaseUpdate.ts
-import { and as and14, eq as eq38 } from "drizzle-orm";
+import { and as and15, eq as eq39 } from "drizzle-orm";
 async function applyPhaseUpdate(orm, itemId2, phaseIdx, fields) {
   await orm.transaction(async (tx) => {
     if (fields.name) {
       await tx.update(planPhases).set({ name: fields.name }).where(
-        and14(eq38(planPhases.itemId, itemId2), eq38(planPhases.idx, phaseIdx))
+        and15(eq39(planPhases.itemId, itemId2), eq39(planPhases.idx, phaseIdx))
       );
     }
     if (fields.manualCheck) {
       await tx.update(planPhases).set({ manualChecks: JSON.stringify(fields.manualCheck) }).where(
-        and14(eq38(planPhases.itemId, itemId2), eq38(planPhases.idx, phaseIdx))
+        and15(eq39(planPhases.itemId, itemId2), eq39(planPhases.idx, phaseIdx))
       );
     }
     if (fields.task) {
       await tx.delete(planTasks).where(
-        and14(eq38(planTasks.itemId, itemId2), eq38(planTasks.phaseIdx, phaseIdx))
+        and15(eq39(planTasks.itemId, itemId2), eq39(planTasks.phaseIdx, phaseIdx))
       );
       if (fields.task.length) {
         await tx.insert(planTasks).values(
@@ -18734,14 +18816,14 @@ async function applyPhaseUpdate(orm, itemId2, phaseIdx, fields) {
 
 // src/commands/backlog/findPhase.ts
 import chalk96 from "chalk";
-import { and as and15, count as count7, eq as eq39 } from "drizzle-orm";
+import { and as and16, count as count7, eq as eq40 } from "drizzle-orm";
 async function findPhase(id, phase) {
   const found = await findOneItem(id);
   if (!found) return void 0;
   const { orm, item } = found;
   const itemId2 = item.id;
   const phaseIdx = Number.parseInt(phase, 10) - 1;
-  const [row3] = await orm.select({ cnt: count7() }).from(planPhases).where(and15(eq39(planPhases.itemId, itemId2), eq39(planPhases.idx, phaseIdx)));
+  const [row3] = await orm.select({ cnt: count7() }).from(planPhases).where(and16(eq40(planPhases.itemId, itemId2), eq40(planPhases.idx, phaseIdx)));
   if (!row3 || row3.cnt === 0) {
     console.log(
       chalk96.red(
@@ -18914,16 +18996,16 @@ function registerUpdatePhaseCommand(cmd) {
 
 // src/commands/backlog/removePhase.ts
 import chalk98 from "chalk";
-import { and as and16, eq as eq40 } from "drizzle-orm";
+import { and as and17, eq as eq41 } from "drizzle-orm";
 async function removePhase(id, phase) {
   const found = await findPhase(id, phase);
   if (!found) return;
   const { item, orm, itemId: itemId2, phaseIdx } = found;
   await orm.transaction(async (tx) => {
     await tx.delete(planTasks).where(
-      and16(eq40(planTasks.itemId, itemId2), eq40(planTasks.phaseIdx, phaseIdx))
+      and17(eq41(planTasks.itemId, itemId2), eq41(planTasks.phaseIdx, phaseIdx))
     );
-    await tx.delete(planPhases).where(and16(eq40(planPhases.itemId, itemId2), eq40(planPhases.idx, phaseIdx)));
+    await tx.delete(planPhases).where(and17(eq41(planPhases.itemId, itemId2), eq41(planPhases.idx, phaseIdx)));
     await reindexPhases(tx, itemId2);
     await adjustCurrentPhase(tx, item, phaseIdx);
   });
@@ -18936,7 +19018,7 @@ async function removePhase(id, phase) {
 
 // src/commands/backlog/update/update.ts
 import chalk102 from "chalk";
-import { eq as eq41 } from "drizzle-orm";
+import { eq as eq42 } from "drizzle-orm";
 
 // src/commands/backlog/update/buildUpdateValues.ts
 import chalk99 from "chalk";
@@ -19047,7 +19129,7 @@ async function update(id, options2) {
   if (!built) return;
   const { orm } = found;
   const itemId2 = found.item.id;
-  await orm.update(items).set(built.set).where(eq41(items.id, itemId2));
+  await orm.update(items).set(built.set).where(eq42(items.id, itemId2));
   console.log(
     chalk102.green(`Updated ${built.fields} on item ${formatItemId(itemId2)}.`)
   );
@@ -19093,7 +19175,7 @@ function readPlanUpdate(source) {
 }
 
 // src/commands/backlog/updatePlan/replacePlan.ts
-import { eq as eq42 } from "drizzle-orm";
+import { eq as eq43 } from "drizzle-orm";
 
 // src/commands/backlog/updatePlan/clampCurrentPhase.ts
 function clampCurrentPhase(currentPhase, phaseCount) {
@@ -19104,8 +19186,8 @@ function clampCurrentPhase(currentPhase, phaseCount) {
 // src/commands/backlog/updatePlan/replacePlan.ts
 async function replacePlan(orm, itemId2, phases, currentPhase) {
   await orm.transaction(async (tx) => {
-    await tx.delete(planTasks).where(eq42(planTasks.itemId, itemId2));
-    await tx.delete(planPhases).where(eq42(planPhases.itemId, itemId2));
+    await tx.delete(planTasks).where(eq43(planTasks.itemId, itemId2));
+    await tx.delete(planPhases).where(eq43(planPhases.itemId, itemId2));
     if (phases.length > 0) {
       await tx.insert(planPhases).values(
         phases.map((phase, idx) => ({
@@ -19123,7 +19205,7 @@ async function replacePlan(orm, itemId2, phases, currentPhase) {
     if (currentPhase === void 0) return;
     const clamped = clampCurrentPhase(currentPhase, phases.length);
     if (clamped === currentPhase) return;
-    await tx.update(items).set({ currentPhase: clamped }).where(eq42(items.id, itemId2));
+    await tx.update(items).set({ currentPhase: clamped }).where(eq43(items.id, itemId2));
   });
 }
 
@@ -27567,18 +27649,6 @@ function registerGithub(program) {
 
 // src/commands/inbox/list.ts
 import chalk171 from "chalk";
-
-// src/shared/db/listInboxMessages.ts
-import { desc as desc6, isNull, sql as sql22 } from "drizzle-orm";
-function listInboxMessages(orm) {
-  return orm.select().from(inboxMessages).where(isNull(inboxMessages.dismissedAt)).orderBy(
-    desc6(
-      sql22`coalesce(${inboxMessages.receivedAt}, ${inboxMessages.flaggedAt})`
-    )
-  );
-}
-
-// src/commands/inbox/list.ts
 async function list3() {
   const messages = await listInboxMessages(await getDb());
   if (messages.length === 0) {
@@ -27599,10 +27669,10 @@ async function list3() {
 import chalk172 from "chalk";
 
 // src/shared/db/readInboxLastScan.ts
-import { eq as eq43 } from "drizzle-orm";
+import { eq as eq44 } from "drizzle-orm";
 var INBOX_LAST_SCAN_KEY = "inbox.lastScanAt";
 async function readInboxLastScan(orm) {
-  const [row3] = await orm.select().from(metadata).where(eq43(metadata.key, INBOX_LAST_SCAN_KEY));
+  const [row3] = await orm.select().from(metadata).where(eq44(metadata.key, INBOX_LAST_SCAN_KEY));
   return row3 ? new Date(row3.value) : void 0;
 }
 
@@ -30337,9 +30407,9 @@ async function list4() {
 import chalk188 from "chalk";
 
 // src/commands/backlog/removeFeed.ts
-import { eq as eq44 } from "drizzle-orm";
+import { eq as eq45 } from "drizzle-orm";
 async function removeFeed(db, url) {
-  const deleted = await db.delete(feeds).where(eq44(feeds.url, url)).returning({ id: feeds.id });
+  const deleted = await db.delete(feeds).where(eq45(feeds.url, url)).returning({ id: feeds.id });
   return deleted.length > 0;
 }
 
@@ -38454,7 +38524,10 @@ function selectInDiffFindings(lineBound, prDiff) {
   return {
     inDiff,
     unanchored: outOfDiff.map(
-      (finding) => ({ ...finding, reason: "out-of-diff" })
+      (finding) => ({
+        ...finding,
+        reason: "out-of-diff"
+      })
     )
   };
 }
@@ -38491,7 +38564,10 @@ function selectPostableFindings(markdown, prInfo) {
     );
   }
   const carriedUnlocated = unlocated.map(
-    (finding) => ({ ...finding, reason: "unlocated" })
+    (finding) => ({
+      ...finding,
+      reason: "unlocated"
+    })
   );
   if (lineBound.length === 0) {
     console.log("No line-bound findings to comment on.");
@@ -44675,12 +44751,12 @@ function parseEnvPairs(pairs) {
   if (pairs.length === 0) return void 0;
   const env = {};
   for (const pair of pairs) {
-    const eq47 = pair.indexOf("=");
-    if (eq47 <= 0) {
+    const eq48 = pair.indexOf("=");
+    if (eq48 <= 0) {
       console.error(`--env must be KEY=VALUE, got "${pair}"`);
       process.exit(1);
     }
-    env[pair.slice(0, eq47)] = pair.slice(eq47 + 1);
+    env[pair.slice(0, eq48)] = pair.slice(eq48 + 1);
   }
   return env;
 }
@@ -44693,11 +44769,11 @@ function fail9(spec) {
   process.exit(1);
 }
 function parseParamSpec(spec) {
-  const eq47 = spec.indexOf("=");
-  const name = eq47 === -1 ? spec : spec.slice(0, eq47);
-  if (eq47 !== -1) {
-    if (eq47 === 0 || name.endsWith("!")) fail9(spec);
-    return { name, default: spec.slice(eq47 + 1) };
+  const eq48 = spec.indexOf("=");
+  const name = eq48 === -1 ? spec : spec.slice(0, eq48);
+  if (eq48 !== -1) {
+    if (eq48 === 0 || name.endsWith("!")) fail9(spec);
+    return { name, default: spec.slice(eq48 + 1) };
   }
   if (name.endsWith("!")) {
     if (name.length === 1) fail9(spec);
@@ -47961,10 +48037,10 @@ function applyReviewPause(session, activity2) {
 }
 
 // src/shared/db/getPhaseActiveMs.ts
-import { and as and17, eq as eq45 } from "drizzle-orm";
+import { and as and18, eq as eq46 } from "drizzle-orm";
 async function getPhaseActiveMs(db, itemId2, phaseIdx) {
   const [row3] = await db.select({ activeMs: phaseUsage.activeMs }).from(phaseUsage).where(
-    and17(eq45(phaseUsage.itemId, itemId2), eq45(phaseUsage.phaseIdx, phaseIdx))
+    and18(eq46(phaseUsage.itemId, itemId2), eq46(phaseUsage.phaseIdx, phaseIdx))
   );
   return row3?.activeMs ?? 0;
 }
@@ -48806,17 +48882,17 @@ async function recordPhaseTranscriptUsage(db, itemId2, phaseIdx, responses) {
 }
 
 // src/shared/db/recordWindowTokens.ts
-import { and as and18, eq as eq46, sql as sql28 } from "drizzle-orm";
+import { and as and19, eq as eq47, sql as sql28 } from "drizzle-orm";
 async function recordWindowTokens(db, window, resetsAt, tokensUp, tokensDown) {
   if (tokensUp <= 0 && tokensDown <= 0) return;
   await db.update(usagePeaks).set({
     tokensUp: sql28`${usagePeaks.tokensUp} + ${tokensUp}`,
     tokensDown: sql28`${usagePeaks.tokensDown} + ${tokensDown}`
   }).where(
-    and18(
-      eq46(usagePeaks.window, window),
-      eq46(usagePeaks.resetsAt, resetsAt),
-      eq46(usagePeaks.segment, 0)
+    and19(
+      eq47(usagePeaks.window, window),
+      eq47(usagePeaks.resetsAt, resetsAt),
+      eq47(usagePeaks.segment, 0)
     )
   );
 }