@staff0rd/assist 0.461.3 → 0.463.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.461.3",
+  version: "0.463.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -3365,7 +3365,7 @@ function collectHashComments(content, options2) {
 function collectComments(sourceFile) {
   const seen = /* @__PURE__ */ new Set();
   const comments3 = [];
-  const collect6 = (node) => {
+  const collect5 = (node) => {
     for (const range of [
       ...node.getLeadingCommentRanges(),
       ...node.getTrailingCommentRanges()
@@ -3376,8 +3376,8 @@ function collectComments(sourceFile) {
       comments3.push({ pos, text: range.getText() });
     }
   };
-  collect6(sourceFile);
-  sourceFile.forEachDescendant(collect6);
+  collect5(sourceFile);
+  sourceFile.forEachDescendant(collect5);
   return comments3;
 }
 
@@ -3596,16 +3596,19 @@ var WRAPPER_TYPES = /* @__PURE__ */ new Set([
   "readonly",
   "catch"
 ]);
+var OPTIONAL_TYPES = /* @__PURE__ */ new Set(["optional", "nullish"]);
 function unwrapSchemaNode(node) {
   let current = node;
   let defaultValue;
+  let optional = false;
   while (current.def && WRAPPER_TYPES.has(current.def.type ?? "") && current.def.innerType) {
     if (current.def.type === "default" && defaultValue === void 0) {
       defaultValue = current.def.defaultValue;
     }
+    if (OPTIONAL_TYPES.has(current.def.type ?? "")) optional = true;
     current = current.def.innerType;
   }
-  return { inner: current, defaultValue };
+  return { inner: current, defaultValue, optional };
 }
 
 // src/shared/scalarUnionMembers.ts
@@ -3649,7 +3652,67 @@ function scalarArrayItemType(node) {
   return isScalarLeafType(type) ? type : void 0;
 }
 
-// src/shared/describeConfigLeaves.ts
+// src/shared/listConfigNode.ts
+function scalarListNode(inner, base, item) {
+  const itemType = scalarArrayItemType(inner);
+  if (!itemType || item.kind !== "scalar") return void 0;
+  return { ...base, kind: "scalarList", itemType, item };
+}
+function objectListNode(base, item) {
+  if (item.kind !== "object" && item.kind !== "unionOfObjects")
+    return void 0;
+  return { ...base, kind: "objectList", item };
+}
+function listConfigNode(inner, base, build2) {
+  const element = inner.def?.element;
+  if (inner.def?.type !== "array" || !element) return void 0;
+  const item = build2(element, [...base.path, { kind: "item" }]);
+  return scalarListNode(inner, base, item) ?? objectListNode(base, item);
+}
+
+// src/shared/objectConfigNode.ts
+function objectConfigNode(inner, base, build2) {
+  const shape = inner.def?.shape;
+  if (inner.def?.type !== "object" || !shape) return void 0;
+  const fields = Object.entries(shape).map(
+    ([name, child]) => build2(child, [...base.path, { kind: "key", name }])
+  );
+  return { ...base, kind: "object", fields };
+}
+function unionOfObjectsConfigNode(inner, base, build2) {
+  const options2 = inner.def?.options;
+  if (inner.def?.type !== "union" || !options2?.length) return void 0;
+  const variants = [];
+  for (const option of options2) {
+    const variant = build2(option, base.path);
+    if (variant.kind !== "object") return void 0;
+    variants.push(variant);
+  }
+  return { ...base, kind: "unionOfObjects", variants };
+}
+
+// src/shared/recordConfigNode.ts
+function recordConfigNode(inner, base, build2) {
+  const valueType = inner.def?.valueType;
+  if (inner.def?.type !== "record" || !valueType) return void 0;
+  const value = build2(valueType, [...base.path, { kind: "entry" }]);
+  return { ...base, kind: "record", value };
+}
+
+// src/shared/scalarConfigNode.ts
+function scalarConfigNode(inner, base) {
+  const unionTypes = scalarUnionMembers(inner);
+  if (unionTypes) return { ...base, kind: "scalar", type: "union", unionTypes };
+  const type = leafTypeOf(inner);
+  if (!isScalarLeafType(type)) return void 0;
+  const values = type === "enum" ? enumValues(inner) : void 0;
+  return {
+    ...base,
+    kind: "scalar",
+    type,
+    ...values ? { enumValues: values } : {}
+  };
+}
 function enumValues(node) {
   const entries = node.def?.entries;
   if (!entries) return void 0;
@@ -3657,31 +3720,81 @@ function enumValues(node) {
     (value) => typeof value === "string"
   );
 }
-function toLeaf(key, node, defaultValue) {
-  const unionTypes = scalarUnionMembers(node);
-  const type = unionTypes ? "union" : leafTypeOf(node);
-  const leaf = { key, type };
-  if (type === "enum") leaf.enumValues = enumValues(node);
-  if (unionTypes) leaf.unionTypes = unionTypes;
-  const itemType = scalarArrayItemType(node);
-  if (itemType) leaf.itemType = itemType;
-  if (defaultValue !== void 0) leaf.defaultValue = defaultValue;
+
+// src/shared/describeConfigNode.ts
+function opaqueConfigNode(inner, base) {
+  return { ...base, kind: "other", type: leafTypeOf(inner) };
+}
+function build(node, path71) {
+  const { inner, defaultValue, optional } = unwrapSchemaNode(node);
+  const base = {
+    path: path71,
+    ...optional ? { optional: true } : {},
+    ...defaultValue === void 0 ? {} : { defaultValue }
+  };
+  return scalarConfigNode(inner, base) ?? objectConfigNode(inner, base, build) ?? listConfigNode(inner, base, build) ?? recordConfigNode(inner, base, build) ?? unionOfObjectsConfigNode(inner, base, build) ?? opaqueConfigNode(inner, base);
+}
+function describeConfigNode(schema2) {
+  return build(schema2, []);
+}
+
+// src/shared/formatConfigPath.ts
+var RECORD_ENTRY_TOKEN = "*";
+function segmentText(segment) {
+  if (segment.kind === "key") return segment.name;
+  if (segment.kind === "entry") return RECORD_ENTRY_TOKEN;
+  if (segment.kind === "index") return `[${segment.index}]`;
+  return "[]";
+}
+function formatConfigPath(path71) {
+  let text17 = "";
+  for (const segment of path71) {
+    const dotted = segment.kind === "key" || segment.kind === "entry";
+    const rendered = segmentText(segment);
+    text17 += dotted && text17 ? `.${rendered}` : rendered;
+  }
+  return text17;
+}
+
+// src/shared/describeConfigLeaves.ts
+function leafType(node) {
+  switch (node.kind) {
+    case "scalar":
+      return node.type;
+    case "scalarList":
+    case "objectList":
+      return "array";
+    case "record":
+      return "record";
+    case "other":
+      return node.type;
+    default:
+      return "other";
+  }
+}
+function toLeaf(node) {
+  const leaf = {
+    key: formatConfigPath(node.path),
+    type: leafType(node)
+  };
+  if (node.kind === "scalar") {
+    if (node.enumValues) leaf.enumValues = node.enumValues;
+    if (node.unionTypes) leaf.unionTypes = node.unionTypes;
+  }
+  if (node.kind === "scalarList") leaf.itemType = node.itemType;
+  if (node.defaultValue !== void 0) leaf.defaultValue = node.defaultValue;
   return leaf;
 }
-function collect(node, prefix2, out) {
-  const { inner, defaultValue } = unwrapSchemaNode(node);
-  const shape = inner.def?.shape;
-  if (inner.def?.type === "object" && shape) {
-    for (const [key, child] of Object.entries(shape)) {
-      collect(child, prefix2 ? `${prefix2}.${key}` : key, out);
-    }
+function flatten(node, out) {
+  if (node.kind === "object") {
+    for (const field of node.fields) flatten(field, out);
     return;
   }
-  out.push(toLeaf(prefix2, inner, defaultValue));
+  out.push(toLeaf(node));
 }
 function describeConfigLeaves(schema2) {
   const out = [];
-  collect(schema2, "", out);
+  flatten(describeConfigNode(schema2), out);
   return out.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
 }
 
@@ -3773,9 +3886,9 @@ function forbiddenStrings() {
     console.log("No forbidden-strings rules configured.");
     process.exit(0);
   }
-  const cache4 = /* @__PURE__ */ new Map();
+  const cache5 = /* @__PURE__ */ new Map();
   const readJson = (file) => {
-    if (cache4.has(file)) return cache4.get(file);
+    if (cache5.has(file)) return cache5.get(file);
     if (!existsSync12(file)) {
       console.log(`Forbidden-strings file not found: ${file}`);
       process.exit(1);
@@ -3787,7 +3900,7 @@ function forbiddenStrings() {
       console.log(`Could not parse ${file}: ${error.message}`);
       process.exit(1);
     }
-    cache4.set(file, parsed);
+    cache5.set(file, parsed);
     return parsed;
   };
   const violations = findForbiddenStrings(rules, readJson);
@@ -8456,19 +8569,19 @@ import { dirname as dirname19, join as join23 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function createBundleHandler(importMetaUrl, bundlePath, contentType = "application/javascript") {
   const file = join23(dirname19(fileURLToPath4(importMetaUrl)), bundlePath);
-  let cache4;
+  let cache5;
   return (req, res) => {
     const mtimeMs = statSync2(file).mtimeMs;
-    if (cache4?.mtimeMs !== mtimeMs) {
+    if (cache5?.mtimeMs !== mtimeMs) {
       const body = readFileSync19(file, "utf8");
       const etag = `"${createHash("sha256").update(body).digest("hex").slice(0, 16)}"`;
-      cache4 = { body, etag, mtimeMs };
+      cache5 = { body, etag, mtimeMs };
     }
     const headers = {
-      ETag: cache4.etag,
+      ETag: cache5.etag,
       "Cache-Control": "no-cache"
     };
-    if (req.headers["if-none-match"] === cache4.etag) {
+    if (req.headers["if-none-match"] === cache5.etag) {
       res.writeHead(304, headers);
       res.end();
       return;
@@ -8477,7 +8590,7 @@ function createBundleHandler(importMetaUrl, bundlePath, contentType = "applicati
       "Content-Type": contentType,
       ...headers
     });
-    res.end(cache4.body);
+    res.end(cache5.body);
   };
 }
 
@@ -8971,67 +9084,119 @@ function getSessionParam(req) {
   return url.searchParams.get("session") ?? void 0;
 }
 
-// src/shared/db/findCommitAnchor.ts
-import { and as and7, asc as asc6, eq as eq16, inArray as inArray3 } from "drizzle-orm";
-async function findCommitAnchor(db, itemId2) {
-  const rows = await db.select({ kind: itemGitRefs.kind, ref: itemGitRefs.ref }).from(itemGitRefs).where(
-    and7(
-      eq16(itemGitRefs.itemId, itemId2),
-      inArray3(itemGitRefs.kind, ["commit", "commit-parent"])
-    )
-  ).orderBy(asc6(itemGitRefs.createdAt));
-  const anchor = {};
-  for (const row of rows) {
-    if (row.kind === "commit") anchor.commit ??= row.ref;
-    else anchor.parent ??= row.ref;
-  }
-  return anchor;
-}
-
 // src/shared/db/findItemBySessionId.ts
-import { asc as asc7, eq as eq17 } from "drizzle-orm";
+import { asc as asc6, eq as eq16 } from "drizzle-orm";
 async function findItemBySessionId(db, claudeSessionId) {
-  const rows = await db.select({ itemId: phaseUsage.itemId }).from(phaseUsage).where(eq17(phaseUsage.claudeSessionId, claudeSessionId)).orderBy(asc7(phaseUsage.itemId), asc7(phaseUsage.phaseIdx)).limit(1);
+  const rows = await db.select({ itemId: phaseUsage.itemId }).from(phaseUsage).where(eq16(phaseUsage.claudeSessionId, claudeSessionId)).orderBy(asc6(phaseUsage.itemId), asc6(phaseUsage.phaseIdx)).limit(1);
   return rows[0]?.itemId;
 }
 
-// src/commands/sessions/web/sessionCommitAnchor.ts
-var EMPTY_TTL_MS = 3e4;
-var cache3 = /* @__PURE__ */ new Map();
-var inFlight = /* @__PURE__ */ new Map();
-async function sessionCommitAnchor(sessionId) {
-  const cached = cache3.get(sessionId);
-  if (cached && cached.expiresAt > Date.now()) return cached.anchor;
-  const pending = inFlight.get(sessionId);
-  if (pending) return pending;
-  const lookup = loadAnchor(sessionId).finally(
-    () => inFlight.delete(sessionId)
-  );
-  inFlight.set(sessionId, lookup);
-  return lookup;
-}
-async function loadAnchor(sessionId) {
-  const anchor = await queryAnchor(sessionId);
-  const found = Boolean(anchor.commit || anchor.parent);
-  cache3.set(sessionId, {
-    anchor,
-    expiresAt: found ? Number.POSITIVE_INFINITY : Date.now() + EMPTY_TTL_MS
-  });
-  return anchor;
+// src/shared/db/listCommitRefs.ts
+import { and as and7, asc as asc7, eq as eq17 } 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(and7(eq17(itemGitRefs.itemId, itemId2), eq17(itemGitRefs.kind, "commit"))).orderBy(asc7(itemGitRefs.createdAt), asc7(itemGitRefs.ref));
+  return rows.map((row) => ({
+    sha: row.ref,
+    ...row.title ? { title: row.title } : {},
+    ...row.url ? { url: row.url } : {}
+  }));
 }
-async function queryAnchor(sessionId) {
+
+// src/commands/sessions/web/itemCommits.ts
+async function itemCommits(sessionId) {
   try {
     if (!process.env.ASSIST_DATABASE_URL && !loadConfig().database.url)
-      return {};
+      return [];
     const db = await getDb();
     const itemId2 = await findItemBySessionId(db, sessionId);
-    if (itemId2 === void 0) return {};
-    return await findCommitAnchor(db, itemId2);
+    if (itemId2 === void 0) return [];
+    return await listCommitRefs(db, itemId2);
   } catch {
-    return {};
+    return [];
   }
 }
 
+// src/commands/sessions/web/resolveCommit.ts
+var GIT_EMPTY_TREE_HASH = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+async function resolveCommit(cwd, sha) {
+  if (!await commitExists(cwd, sha)) return void 0;
+  const parent = await parentOf(cwd, sha);
+  return {
+    base: parent ?? GIT_EMPTY_TREE_HASH,
+    paths: await commitPaths(cwd, sha)
+  };
+}
+async function commitExists(cwd, sha) {
+  try {
+    await execGit(cwd, ["cat-file", "-e", `${sha}^{commit}`]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function parentOf(cwd, sha) {
+  try {
+    const parent = await execGit(cwd, [
+      "rev-parse",
+      "--verify",
+      "--quiet",
+      `${sha}^`
+    ]);
+    return parent.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function commitPaths(cwd, sha) {
+  try {
+    const output = await execGit(cwd, [
+      "diff-tree",
+      "--no-commit-id",
+      "--name-only",
+      "-r",
+      "--root",
+      sha
+    ]);
+    return output.split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+// src/commands/sessions/web/committedPaths.ts
+var cache3 = /* @__PURE__ */ new Map();
+var inFlight = /* @__PURE__ */ new Map();
+var CACHE_TTL_MS = 1e4;
+async function committedPaths(cwd, sessionId) {
+  const key = `${cwd} ${sessionId}`;
+  const cached = cache3.get(key);
+  if (cached && cached.expiresAt > Date.now()) return cached.value;
+  const pending = inFlight.get(key);
+  if (pending) return pending;
+  const lookup = loadCommittedPaths(cwd, sessionId).then((value) => {
+    cache3.set(key, { value, expiresAt: Date.now() + CACHE_TTL_MS });
+    return value;
+  }).finally(() => inFlight.delete(key));
+  inFlight.set(key, lookup);
+  return lookup;
+}
+async function loadCommittedPaths(cwd, sessionId) {
+  const commits2 = await itemCommits(sessionId);
+  const bases = /* @__PURE__ */ new Map();
+  for (const commit2 of commits2) {
+    const resolved = await resolveCommit(cwd, commit2.sha);
+    if (!resolved) continue;
+    for (const path71 of resolved.paths) {
+      if (!bases.has(path71)) bases.set(path71, resolved.base);
+    }
+  }
+  return { commits: commits2, bases };
+}
+
 // src/commands/sessions/web/windowsCwdToWslPath.ts
 function windowsCwdToWslPath(cwd) {
   const match = /^([A-Za-z]):[\\/](.*)$/.exec(cwd);
@@ -9046,55 +9211,37 @@ function toGitCwd(cwd) {
   return detectPlatform() === "wsl" ? windowsCwdToWslPath(cwd) : cwd;
 }
 
-// src/commands/sessions/web/resolveDiffBase.ts
-function baseCandidates(defaultBranch) {
-  return [
-    defaultBranch && `origin/${defaultBranch}`,
-    defaultBranch,
-    "origin/main",
-    "origin/master",
-    "main",
-    "master"
-  ].filter((candidate) => Boolean(candidate));
+// src/commands/sessions/web/itemChangeSet.ts
+async function itemChangeSet(cwd, sessionId) {
+  if (!sessionId || !includesCommittedChanges(cwd)) return void 0;
+  const { commits: commits2, bases } = await committedPaths(cwd, sessionId);
+  if (bases.size === 0) return void 0;
+  const groups = groupByBase(bases);
+  const dirty = await dirtyPaths(cwd, bases);
+  if (dirty.length > 0) groups.push({ base: "HEAD", paths: dirty });
+  return { commits: commits2, groups };
 }
-async function refExists2(cwd, ref) {
+function includesCommittedChanges(cwd) {
   try {
-    await execGit(cwd, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]);
-    return true;
+    return Boolean(
+      loadConfigFrom(toGitCwd(cwd)).sessions?.includeCommittedChanges
+    );
   } catch {
     return false;
   }
 }
-async function anchoredBase(cwd, sessionId) {
-  const { commit: commit2, parent } = await sessionCommitAnchor(sessionId);
-  if (parent && await refExists2(cwd, parent)) return parent;
-  if (commit2 && await refExists2(cwd, `${commit2}^`)) return `${commit2}^`;
-  return void 0;
-}
-async function resolveDiffBase(cwd, sessionId) {
-  let defaultBranch;
-  try {
-    const config = loadConfigFrom(toGitCwd(cwd));
-    if (!config.sessions?.includeCommittedChanges) return "HEAD";
-    defaultBranch = config.branch?.defaultBranch;
-  } catch {
-    return "HEAD";
-  }
-  if (sessionId) {
-    const anchored = await anchoredBase(cwd, sessionId);
-    if (anchored) return anchored;
-  }
-  for (const candidate of baseCandidates(defaultBranch)) {
-    if (!await refExists2(cwd, candidate)) continue;
-    try {
-      const base = await execGit(cwd, ["merge-base", "HEAD", candidate]);
-      const sha = base.trim();
-      if (sha) return sha;
-    } catch {
-    }
-    return "HEAD";
+function groupByBase(bases) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const [path71, base] of bases) {
+    const paths = groups.get(base);
+    if (paths) paths.push(path71);
+    else groups.set(base, [path71]);
   }
-  return "HEAD";
+  return [...groups].map(([base, paths]) => ({ base, paths: paths.sort() }));
+}
+async function dirtyPaths(cwd, bases) {
+  const output = await execGit(cwd, ["diff", "--name-only", "HEAD"]);
+  return output.split("\n").filter((path71) => path71 && !bases.has(path71)).sort();
 }
 
 // src/commands/sessions/web/diff.ts
@@ -9117,14 +9264,26 @@ async function untrackedDiff(cwd) {
   );
   return diffs.join("");
 }
+async function groupedDiff(cwd, groups) {
+  const diffs = await Promise.all(
+    groups.map(
+      (group) => execGit(cwd, ["diff", group.base, "--", ...group.paths], {
+        maxBuffer: MAX_DIFF_BYTES
+      })
+    )
+  );
+  return diffs.join("");
+}
+async function trackedDiff(cwd, session) {
+  const changeSet = await itemChangeSet(cwd, session);
+  if (changeSet) return groupedDiff(cwd, changeSet.groups);
+  return execGit(cwd, ["diff", "HEAD"], { maxBuffer: MAX_DIFF_BYTES });
+}
 async function diff2(req, res) {
   const cwd = getCwdParam(req, res);
   if (!cwd) return;
   try {
-    const base = await resolveDiffBase(cwd, getSessionParam(req));
-    const tracked = await execGit(cwd, ["diff", base], {
-      maxBuffer: MAX_DIFF_BYTES
-    });
+    const tracked = await trackedDiff(cwd, getSessionParam(req));
     const untracked = await untrackedDiff(cwd);
     res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
     res.end(tracked + untracked);
@@ -9224,16 +9383,104 @@ function resolveConfigSource(key, layers) {
   return "default";
 }
 
+// src/shared/configNodeFieldName.ts
+function configNodeFieldName(node) {
+  const last = node.path.at(-1);
+  return last?.kind === "key" ? last.name : void 0;
+}
+
+// src/shared/findConfigNode.ts
+function objectField(node, segment) {
+  if (segment.kind !== "key") return void 0;
+  return node.fields.find(
+    (field) => configNodeFieldName(field) === segment.name
+  );
+}
+function variantField(node, segment) {
+  for (const variant of node.variants) {
+    const found = objectField(variant, segment);
+    if (found) return found;
+  }
+  return void 0;
+}
+function step(node, segment) {
+  const intoItem = segment.kind === "item" || segment.kind === "index";
+  const intoEntry = segment.kind === "entry" || segment.kind === "key";
+  switch (node.kind) {
+    case "object":
+      return objectField(node, segment);
+    case "unionOfObjects":
+      return variantField(node, segment);
+    case "objectList":
+    case "scalarList":
+      return intoItem ? node.item : void 0;
+    case "record":
+      return intoEntry ? node.value : void 0;
+    default:
+      return void 0;
+  }
+}
+function findConfigNode(root, path71) {
+  let current = root;
+  for (const segment of path71) {
+    if (!current) return void 0;
+    current = step(current, segment);
+  }
+  return current;
+}
+
+// src/shared/parseConfigPath.ts
+var INDEX = /^\d+$/;
+function bracketSegment(inner) {
+  if (inner === "") return { kind: "item" };
+  return INDEX.test(inner) ? { kind: "index", index: Number(inner) } : void 0;
+}
+function nameSegment(name) {
+  return name === RECORD_ENTRY_TOKEN ? { kind: "entry" } : { kind: "key", name };
+}
+function parseConfigPath(text17) {
+  const path71 = [];
+  let at2 = 0;
+  while (at2 < text17.length) {
+    if (text17[at2] === "[") {
+      const close = text17.indexOf("]", at2);
+      const segment = close === -1 ? void 0 : bracketSegment(text17.slice(at2 + 1, close));
+      if (!segment) return void 0;
+      path71.push(segment);
+      at2 = close + 1;
+      continue;
+    }
+    if (text17[at2] === ".") {
+      if (path71.length === 0) return void 0;
+      at2 += 1;
+    }
+    const start3 = at2;
+    while (at2 < text17.length && text17[at2] !== "." && text17[at2] !== "[") at2 += 1;
+    const name = text17.slice(start3, at2);
+    if (!name) return void 0;
+    path71.push(nameSegment(name));
+  }
+  return path71;
+}
+
+// src/commands/config/configEntryNode.ts
+function configEntryNode(root, key) {
+  const path71 = parseConfigPath(key);
+  return path71 ? findConfigNode(root, path71) : void 0;
+}
+
 // src/commands/config/readConfigEntries.ts
 var KEYS_STRIPPED_FROM_MERGED_CONFIG = /* @__PURE__ */ new Set(["repos"]);
 function readConfigEntries(cwd) {
   const config = loadConfigFrom(cwd);
   const layers = readRawConfigLayers(cwd);
+  const schema2 = describeConfigNode(assistConfigSchema);
   return describeConfigLeaves(assistConfigSchema).filter((leaf) => !KEYS_STRIPPED_FROM_MERGED_CONFIG.has(leaf.key)).map((leaf) => ({
     ...leaf,
     value: getNestedValue(config, leaf.key),
     source: resolveConfigSource(leaf.key, layers),
-    globalOnly: isGlobalOnlyConfigKey(leaf.key)
+    globalOnly: isGlobalOnlyConfigKey(leaf.key),
+    node: configEntryNode(schema2, leaf.key)
   }));
 }
 
@@ -9421,6 +9668,111 @@ function parseGitStatus(output) {
   return result;
 }
 
+// src/shared/db/findCommitAnchor.ts
+import { and as and8, asc as asc8, eq as eq18, inArray as inArray3 } from "drizzle-orm";
+async function findCommitAnchor(db, itemId2) {
+  const rows = await db.select({ kind: itemGitRefs.kind, ref: itemGitRefs.ref }).from(itemGitRefs).where(
+    and8(
+      eq18(itemGitRefs.itemId, itemId2),
+      inArray3(itemGitRefs.kind, ["commit", "commit-parent"])
+    )
+  ).orderBy(asc8(itemGitRefs.createdAt));
+  const anchor = {};
+  for (const row of rows) {
+    if (row.kind === "commit") anchor.commit ??= row.ref;
+    else anchor.parent ??= row.ref;
+  }
+  return anchor;
+}
+
+// src/commands/sessions/web/sessionCommitAnchor.ts
+var EMPTY_TTL_MS = 3e4;
+var cache4 = /* @__PURE__ */ new Map();
+var inFlight2 = /* @__PURE__ */ new Map();
+async function sessionCommitAnchor(sessionId) {
+  const cached = cache4.get(sessionId);
+  if (cached && cached.expiresAt > Date.now()) return cached.anchor;
+  const pending = inFlight2.get(sessionId);
+  if (pending) return pending;
+  const lookup = loadAnchor(sessionId).finally(
+    () => inFlight2.delete(sessionId)
+  );
+  inFlight2.set(sessionId, lookup);
+  return lookup;
+}
+async function loadAnchor(sessionId) {
+  const anchor = await queryAnchor(sessionId);
+  const found = Boolean(anchor.commit || anchor.parent);
+  cache4.set(sessionId, {
+    anchor,
+    expiresAt: found ? Number.POSITIVE_INFINITY : Date.now() + EMPTY_TTL_MS
+  });
+  return anchor;
+}
+async function queryAnchor(sessionId) {
+  try {
+    if (!process.env.ASSIST_DATABASE_URL && !loadConfig().database.url)
+      return {};
+    const db = await getDb();
+    const itemId2 = await findItemBySessionId(db, sessionId);
+    if (itemId2 === void 0) return {};
+    return await findCommitAnchor(db, itemId2);
+  } catch {
+    return {};
+  }
+}
+
+// src/commands/sessions/web/resolveDiffBase.ts
+function baseCandidates(defaultBranch) {
+  return [
+    defaultBranch && `origin/${defaultBranch}`,
+    defaultBranch,
+    "origin/main",
+    "origin/master",
+    "main",
+    "master"
+  ].filter((candidate) => Boolean(candidate));
+}
+async function refExists2(cwd, ref) {
+  try {
+    await execGit(cwd, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function anchoredBase(cwd, sessionId) {
+  const { commit: commit2, parent } = await sessionCommitAnchor(sessionId);
+  if (parent && await refExists2(cwd, parent)) return parent;
+  if (commit2 && await refExists2(cwd, `${commit2}^`)) return `${commit2}^`;
+  return void 0;
+}
+async function resolveDiffBase(cwd, sessionId) {
+  let defaultBranch;
+  try {
+    const config = loadConfigFrom(toGitCwd(cwd));
+    if (!config.sessions?.includeCommittedChanges) return "HEAD";
+    defaultBranch = config.branch?.defaultBranch;
+  } catch {
+    return "HEAD";
+  }
+  if (sessionId) {
+    const anchored = await anchoredBase(cwd, sessionId);
+    if (anchored) return anchored;
+  }
+  for (const candidate of baseCandidates(defaultBranch)) {
+    if (!await refExists2(cwd, candidate)) continue;
+    try {
+      const base = await execGit(cwd, ["merge-base", "HEAD", candidate]);
+      const sha = base.trim();
+      if (sha) return sha;
+    } catch {
+    }
+    return "HEAD";
+  }
+  return "HEAD";
+}
+
 // src/commands/sessions/web/gitStatus.ts
 async function untrackedPaths(cwd) {
   const list5 = await execGit(cwd, [
@@ -9586,7 +9938,7 @@ function rankFilePaths(paths, query, limit) {
 
 // src/commands/sessions/web/listFiles.ts
 var MAX_RESULTS = 20;
-var CACHE_TTL_MS = 5e3;
+var CACHE_TTL_MS2 = 5e3;
 var LS_FILES_MAX_BUFFER = 32 * 1024 * 1024;
 var fileListCache = /* @__PURE__ */ new Map();
 async function repoFiles(cwd) {
@@ -9598,7 +9950,7 @@ async function repoFiles(cwd) {
     { maxBuffer: LS_FILES_MAX_BUFFER }
   );
   const files = [...new Set(output.split(/\r?\n/).filter(Boolean))];
-  fileListCache.set(cwd, { files, expires: Date.now() + CACHE_TTL_MS });
+  fileListCache.set(cwd, { files, expires: Date.now() + CACHE_TTL_MS2 });
   return files;
 }
 async function listFiles(req, res) {
@@ -9737,14 +10089,14 @@ async function listNewsItems(_req, res) {
 }
 
 // src/shared/db/countUsagePeaks.ts
-import { count, eq as eq18 } from "drizzle-orm";
+import { count, eq as eq19 } from "drizzle-orm";
 async function countUsagePeaks(db, window) {
-  const [row] = await db.select({ value: count() }).from(usagePeaks).where(window ? eq18(usagePeaks.window, window) : void 0);
+  const [row] = await db.select({ value: count() }).from(usagePeaks).where(window ? eq19(usagePeaks.window, window) : void 0);
   return row?.value ?? 0;
 }
 
 // src/shared/db/listUsagePeaks.ts
-import { and as and8, desc as desc2, eq as eq19, getTableColumns } from "drizzle-orm";
+import { and as and9, desc as desc2, eq as eq20, getTableColumns } from "drizzle-orm";
 
 // src/shared/db/avgContextPerCycle.ts
 import { count as count2, sql as sql16 } from "drizzle-orm";
@@ -9768,11 +10120,11 @@ async function listUsagePeaks(db, options2) {
     phaseCount: avgContext.phaseCount
   }).from(usagePeaks).leftJoin(
     avgContext,
-    and8(
-      eq19(usagePeaks.window, avgContext.window),
-      eq19(usagePeaks.resetsAt, avgContext.resetsAt)
+    and9(
+      eq20(usagePeaks.window, avgContext.window),
+      eq20(usagePeaks.resetsAt, avgContext.resetsAt)
     )
-  ).where(options2?.window ? eq19(usagePeaks.window, options2.window) : void 0).orderBy(
+  ).where(options2?.window ? eq20(usagePeaks.window, options2.window) : void 0).orderBy(
     desc2(usagePeaks.resetsAt),
     usagePeaks.window,
     desc2(usagePeaks.createdAt),
@@ -9824,14 +10176,14 @@ async function openInCode(req, res) {
 import { execFile as execFile5 } from "child_process";
 import { promisify as promisify5 } from "util";
 var execFileAsync4 = promisify5(execFile5);
-var CACHE_TTL_MS2 = 3e4;
+var CACHE_TTL_MS3 = 3e4;
 function createCachedGhJson(args, parse3, fallback, options2 = {}) {
   const { cacheFallback = true } = options2;
-  const cache4 = /* @__PURE__ */ new Map();
+  const cache5 = /* @__PURE__ */ new Map();
   return async (cwd, extraArgs = []) => {
     const key = extraArgs.length ? `${cwd}\0${extraArgs.join("\0")}` : cwd;
     const now = Date.now();
-    const cached = cache4.get(key);
+    const cached = cache5.get(key);
     if (cached && cached.expires > now) return cached.value;
     let value = fallback;
     try {
@@ -9844,7 +10196,7 @@ function createCachedGhJson(args, parse3, fallback, options2 = {}) {
       value = fallback;
     }
     if (cacheFallback || value !== fallback)
-      cache4.set(key, { value, expires: now + CACHE_TTL_MS2 });
+      cache5.set(key, { value, expires: now + CACHE_TTL_MS3 });
     return value;
   };
 }
@@ -10155,6 +10507,41 @@ function coerceString(key, raw) {
   return { ok: false, error: `${key}: expected a string` };
 }
 
+// src/shared/configLeafSchema.ts
+function configLeafSchema(schema2, key) {
+  let current = schema2;
+  for (const name of key.split(".")) {
+    const { inner } = unwrapSchemaNode(current);
+    const child = inner.def?.type === "object" ? inner.def.shape?.[name] : void 0;
+    if (!child) return void 0;
+    current = child;
+  }
+  return current;
+}
+
+// src/commands/config/coerceStructuredConfigValue.ts
+function coerceStructuredConfigValue(key, raw) {
+  const schema2 = configLeafSchema(assistConfigSchema, key);
+  if (!schema2) return { ok: false, error: `Unknown config key "${key}"` };
+  const parsed = schema2.safeParse(raw);
+  if (parsed.success)
+    return { ok: true, value: parsed.data };
+  return {
+    ok: false,
+    error: parsed.error.issues.map((issue) => formatIssue2(key, issue)).join("\n")
+  };
+}
+function formatIssue2(key, issue) {
+  const path71 = formatConfigPath([
+    { kind: "key", name: key },
+    ...issue.path.map(toSegment)
+  ]);
+  return `${path71}: ${issue.message}`;
+}
+function toSegment(part) {
+  return typeof part === "number" ? { kind: "index", index: part } : { kind: "key", name: String(part) };
+}
+
 // src/commands/config/coerceConfigValue.ts
 var EDITABLE_TYPES = /* @__PURE__ */ new Set([
   "string",
@@ -10169,12 +10556,8 @@ function coerceConfigValue(key, raw) {
   );
   if (!leaf) return { ok: false, error: `Unknown config key "${key}"` };
   if (leaf.itemType) return coerceScalarList(key, raw, leaf.itemType);
-  if (!EDITABLE_TYPES.has(leaf.type)) {
-    return {
-      ok: false,
-      error: `"${key}" is a ${leaf.type} value and is read-only here`
-    };
-  }
+  if (!EDITABLE_TYPES.has(leaf.type))
+    return coerceStructuredConfigValue(key, raw);
   if (leaf.type === "union")
     return coerceUnion(key, raw, leaf.unionTypes ?? []);
   return coerceConfigScalar(key, raw, leaf.type);
@@ -10393,22 +10776,22 @@ import { readFileSync as readFileSync21 } from "fs";
 import { createRequire as createRequire2 } from "module";
 var require3 = createRequire2(import.meta.url);
 function createCssHandler(packageEntry) {
-  let cache4;
+  let cache5;
   return (req, res) => {
-    if (!cache4) {
+    if (!cache5) {
       const resolved = require3.resolve(packageEntry);
       const body = readFileSync21(resolved, "utf8");
       const etag = `"${createHash2("sha256").update(body).digest("hex").slice(0, 16)}"`;
-      cache4 = { body, etag };
+      cache5 = { body, etag };
     }
-    const headers = { ETag: cache4.etag, "Cache-Control": "no-cache" };
-    if (req.headers["if-none-match"] === cache4.etag) {
+    const headers = { ETag: cache5.etag, "Cache-Control": "no-cache" };
+    if (req.headers["if-none-match"] === cache5.etag) {
       res.writeHead(304, headers);
       res.end();
       return;
     }
     res.writeHead(200, { "Content-Type": "text/css", ...headers });
-    res.end(cache4.body);
+    res.end(cache5.body);
   };
 }
 
@@ -10907,11 +11290,11 @@ function registerActivityCommands(cmd) {
 
 // src/commands/backlog/associate-github/index.ts
 import chalk64 from "chalk";
-import { eq as eq21 } from "drizzle-orm";
+import { eq as eq22 } from "drizzle-orm";
 
 // src/commands/backlog/beginAssociation.ts
 import chalk63 from "chalk";
-import { eq as eq20 } from "drizzle-orm";
+import { eq as eq21 } from "drizzle-orm";
 async function beginAssociation(id, options2, clearPatch, label2) {
   const found = await findOneItem(id);
   if (!found) {
@@ -10921,7 +11304,7 @@ async function beginAssociation(id, options2, clearPatch, label2) {
   const { orm } = found;
   const itemId2 = found.item.id;
   if (options2.clear) {
-    await orm.update(items).set(clearPatch).where(eq20(items.id, itemId2));
+    await orm.update(items).set(clearPatch).where(eq21(items.id, itemId2));
     console.log(
       chalk63.green(
         `Cleared ${label2} association on item ${formatItemId(itemId2)}.`
@@ -10989,7 +11372,7 @@ async function associateGithub(id, issue, options2) {
     return;
   }
   const title = fetchGithubIssueTitle(normalized);
-  await orm.update(items).set({ githubIssue: normalized, jiraKey: null }).where(eq21(items.id, itemId2));
+  await orm.update(items).set({ githubIssue: normalized, jiraKey: null }).where(eq22(items.id, itemId2));
   console.log(
     chalk64.green(`Associated ${normalized} with item ${formatItemId(itemId2)}.`),
     title ? chalk64.dim(`(${title})`) : ""
@@ -11003,7 +11386,7 @@ function registerAssociateGithubCommand(cmd) {
 
 // src/commands/backlog/associate-jira/index.ts
 import chalk66 from "chalk";
-import { eq as eq22 } from "drizzle-orm";
+import { eq as eq23 } from "drizzle-orm";
 
 // src/commands/jira/fetchIssue.ts
 import { execSync as execSync33 } from "child_process";
@@ -11068,7 +11451,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(eq22(items.id, itemId2));
+  await orm.update(items).set({ jiraKey: normalized, githubIssue: null }).where(eq23(items.id, itemId2));
   console.log(
     chalk66.green(`Associated ${normalized} with item ${formatItemId(itemId2)}.`),
     summary ? chalk66.dim(`(${summary})`) : ""
@@ -11446,15 +11829,15 @@ function isClaudeCode() {
 }
 
 // src/commands/backlog/insertPhaseAt.ts
-import { eq as eq24 } from "drizzle-orm";
+import { eq as eq25 } from "drizzle-orm";
 
 // src/commands/backlog/shiftPhasesUp.ts
-import { and as and9, desc as desc3, eq as eq23, gte } from "drizzle-orm";
+import { and as and10, desc as desc3, eq as eq24, gte } from "drizzle-orm";
 async function shiftPhasesUp(db, itemId2, fromIdx) {
-  const toShift = await db.select({ idx: planPhases.idx }).from(planPhases).where(and9(eq23(planPhases.itemId, itemId2), gte(planPhases.idx, fromIdx))).orderBy(desc3(planPhases.idx));
+  const toShift = await db.select({ idx: planPhases.idx }).from(planPhases).where(and10(eq24(planPhases.itemId, itemId2), gte(planPhases.idx, fromIdx))).orderBy(desc3(planPhases.idx));
   for (const p of toShift) {
-    await db.update(planTasks).set({ phaseIdx: p.idx + 1 }).where(and9(eq23(planTasks.itemId, itemId2), eq23(planTasks.phaseIdx, p.idx)));
-    await db.update(planPhases).set({ idx: p.idx + 1 }).where(and9(eq23(planPhases.itemId, itemId2), eq23(planPhases.idx, p.idx)));
+    await db.update(planTasks).set({ phaseIdx: p.idx + 1 }).where(and10(eq24(planTasks.itemId, itemId2), eq24(planTasks.phaseIdx, p.idx)));
+    await db.update(planPhases).set({ idx: p.idx + 1 }).where(and10(eq24(planPhases.itemId, itemId2), eq24(planPhases.idx, p.idx)));
   }
 }
 
@@ -11467,7 +11850,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(eq24(items.id, itemId2));
+      await tx.update(items).set({ currentPhase: phaseIdx + 1 }).where(eq25(items.id, itemId2));
     }
   });
 }
@@ -11639,9 +12022,9 @@ import chalk76 from "chalk";
 
 // src/commands/backlog/resolveInsertPosition.ts
 import chalk75 from "chalk";
-import { count as count3, eq as eq25 } from "drizzle-orm";
+import { count as count3, eq as eq26 } from "drizzle-orm";
 async function resolveInsertPosition(orm, itemId2, position) {
-  const [row] = await orm.select({ cnt: count3() }).from(planPhases).where(eq25(planPhases.itemId, itemId2));
+  const [row] = await orm.select({ cnt: count3() }).from(planPhases).where(eq26(planPhases.itemId, itemId2));
   const phaseCount = row?.cnt ?? 0;
   if (position === void 0) return phaseCount;
   const pos = Number.parseInt(position, 10);
@@ -11997,9 +12380,9 @@ function hasCycle(adjacency, fromId, toId) {
 }
 
 // src/commands/backlog/loadDependencyGraph.ts
-import { eq as eq26 } from "drizzle-orm";
+import { eq as eq27 } from "drizzle-orm";
 async function loadDependencyGraph(orm) {
-  const rows = await orm.select({ itemId: links.itemId, targetId: links.targetId }).from(links).where(eq26(links.type, "depends-on"));
+  const rows = await orm.select({ itemId: links.itemId, targetId: links.targetId }).from(links).where(eq27(links.type, "depends-on"));
   const graph = /* @__PURE__ */ new Map();
   for (const { itemId: itemId2, targetId } of rows) {
     const bucket = graph.get(itemId2);
@@ -12066,7 +12449,7 @@ async function link(fromId, toId, opts) {
 
 // src/commands/backlog/unlink.ts
 import chalk82 from "chalk";
-import { and as and10, eq as eq27 } from "drizzle-orm";
+import { and as and11, eq as eq28 } from "drizzle-orm";
 async function unlink(fromId, toId) {
   const fromNum = parseItemId(fromId);
   const toNum = parseItemId(toId);
@@ -12090,7 +12473,7 @@ async function unlink(fromId, toId) {
     );
     return;
   }
-  await orm.delete(links).where(and10(eq27(links.itemId, fromNum), eq27(links.targetId, toNum)));
+  await orm.delete(links).where(and11(eq28(links.itemId, fromNum), eq28(links.targetId, toNum)));
   console.log(
     chalk82.green(
       `Removed link from ${formatItemId(fromNum)} to ${formatItemId(toNum)}.`
@@ -12110,7 +12493,7 @@ function registerLinkCommands(cmd) {
 
 // src/commands/backlog/move-repo/index.ts
 import chalk84 from "chalk";
-import { eq as eq29 } from "drizzle-orm";
+import { eq as eq30 } from "drizzle-orm";
 
 // src/commands/backlog/move-repo/confirmMove.ts
 import chalk83 from "chalk";
@@ -12125,9 +12508,9 @@ async function confirmMove(cnt, oldOrigin, newOrigin) {
 }
 
 // src/commands/backlog/move-repo/countByOrigin.ts
-import { count as count4, eq as eq28 } from "drizzle-orm";
+import { count as count4, eq as eq29 } from "drizzle-orm";
 async function countByOrigin(orm, origin) {
-  const [{ cnt }] = await orm.select({ cnt: count4() }).from(items).where(eq28(items.origin, origin));
+  const [{ cnt }] = await orm.select({ cnt: count4() }).from(items).where(eq29(items.origin, origin));
   return cnt;
 }
 
@@ -12170,7 +12553,7 @@ async function moveRepo(oldOriginRaw, newOriginRaw, options2 = {}) {
     console.log(chalk84.yellow("Move cancelled; no changes made."));
     return;
   }
-  await orm.update(items).set({ origin: newOrigin }).where(eq29(items.origin, oldOrigin));
+  await orm.update(items).set({ origin: newOrigin }).where(eq30(items.origin, oldOrigin));
   console.log(
     chalk84.green(
       `Moved ${pluralItems(cnt)} from "${oldOrigin}" to "${newOrigin}".`
@@ -12587,10 +12970,10 @@ async function start(id) {
 
 // src/commands/backlog/stop/index.ts
 import chalk96 from "chalk";
-import { and as and11, eq as eq30 } from "drizzle-orm";
+import { and as and12, eq as eq31 } from "drizzle-orm";
 async function stop() {
   const { orm } = await getReady();
-  const stopped = await orm.update(items).set({ status: "todo", currentPhase: 1 }).where(and11(eq30(items.status, "in-progress"), eq30(items.origin, getOrigin()))).returning({ id: items.id, name: items.name });
+  const stopped = await orm.update(items).set({ status: "todo", currentPhase: 1 }).where(and12(eq31(items.status, "in-progress"), eq31(items.origin, getOrigin()))).returning({ id: items.id, name: items.name });
   if (stopped.length === 0) {
     console.log(chalk96.yellow("No in-progress items to stop."));
     return;
@@ -12707,13 +13090,13 @@ async function findSubtask(id, index3) {
 }
 
 // src/commands/backlog/updateSubtask.ts
-import { and as and12, eq as eq31 } from "drizzle-orm";
+import { and as and13, eq as eq32 } from "drizzle-orm";
 async function updateSubtask(orm, itemId2, idx, fields) {
   const set = {};
   if (fields.title !== void 0) set.title = fields.title;
   if (fields.description !== void 0) set.description = fields.description;
   if (fields.status !== void 0) set.status = fields.status;
-  const [row] = await orm.update(itemSubtasks).set(set).where(and12(eq31(itemSubtasks.itemId, itemId2), eq31(itemSubtasks.idx, idx))).returning({ title: itemSubtasks.title });
+  const [row] = await orm.update(itemSubtasks).set(set).where(and13(eq32(itemSubtasks.itemId, itemId2), eq32(itemSubtasks.idx, idx))).returning({ title: itemSubtasks.title });
   return row?.title;
 }
 
@@ -12768,16 +13151,16 @@ async function editSubtask(id, index3, options2) {
 import chalk102 from "chalk";
 
 // src/commands/backlog/deleteSubtask.ts
-import { and as and13, asc as asc8, eq as eq32 } from "drizzle-orm";
+import { and as and14, asc as asc9, eq as eq33 } from "drizzle-orm";
 async function deleteSubtask(orm, itemId2, idx) {
-  const [row] = await orm.delete(itemSubtasks).where(and13(eq32(itemSubtasks.itemId, itemId2), eq32(itemSubtasks.idx, idx))).returning({ title: itemSubtasks.title });
+  const [row] = await orm.delete(itemSubtasks).where(and14(eq33(itemSubtasks.itemId, itemId2), eq33(itemSubtasks.idx, idx))).returning({ title: itemSubtasks.title });
   if (!row) return void 0;
-  const remaining = await orm.select({ idx: itemSubtasks.idx }).from(itemSubtasks).where(eq32(itemSubtasks.itemId, itemId2)).orderBy(asc8(itemSubtasks.idx));
+  const remaining = await orm.select({ idx: itemSubtasks.idx }).from(itemSubtasks).where(eq33(itemSubtasks.itemId, itemId2)).orderBy(asc9(itemSubtasks.idx));
   for (let i = 0; i < remaining.length; i++) {
     const oldIdx = remaining[i].idx;
     if (oldIdx === i) continue;
     await orm.update(itemSubtasks).set({ idx: i }).where(
-      and13(eq32(itemSubtasks.itemId, itemId2), eq32(itemSubtasks.idx, oldIdx))
+      and14(eq33(itemSubtasks.itemId, itemId2), eq33(itemSubtasks.idx, oldIdx))
     );
   }
   return row.title;
@@ -12846,20 +13229,20 @@ function registerSubtaskCommands(cmd) {
 
 // src/commands/backlog/movePhase.ts
 import chalk104 from "chalk";
-import { count as count6, eq as eq35 } from "drizzle-orm";
+import { count as count6, eq as eq36 } from "drizzle-orm";
 
 // src/commands/backlog/reorderPhaseRows.ts
-import { and as and15, asc as asc10, eq as eq34 } from "drizzle-orm";
+import { and as and16, asc as asc11, eq as eq35 } from "drizzle-orm";
 
 // src/commands/backlog/reindexPhases.ts
-import { and as and14, asc as asc9, count as count5, eq as eq33 } from "drizzle-orm";
+import { and as and15, asc as asc10, count as count5, eq as eq34 } from "drizzle-orm";
 async function reindexPhases(db, itemId2) {
-  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq33(planPhases.itemId, itemId2)).orderBy(asc9(planPhases.idx));
+  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq34(planPhases.itemId, itemId2)).orderBy(asc10(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(and14(eq33(planTasks.itemId, itemId2), eq33(planTasks.phaseIdx, oldIdx)));
-    await db.update(planPhases).set({ idx: i }).where(and14(eq33(planPhases.itemId, itemId2), eq33(planPhases.idx, oldIdx)));
+    await db.update(planTasks).set({ phaseIdx: i }).where(and15(eq34(planTasks.itemId, itemId2), eq34(planTasks.phaseIdx, oldIdx)));
+    await db.update(planPhases).set({ idx: i }).where(and15(eq34(planPhases.itemId, itemId2), eq34(planPhases.idx, oldIdx)));
   }
 }
 async function adjustCurrentPhase(db, item, removedIdx) {
@@ -12867,24 +13250,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(eq33(items.id, item.id));
+    await db.update(items).set({ currentPhase: currentPhase - 1 }).where(eq34(items.id, item.id));
     return;
   }
   if (removedIdx !== currentIdx) return;
-  const [row] = await db.select({ cnt: count5() }).from(planPhases).where(eq33(planPhases.itemId, item.id));
+  const [row] = await db.select({ cnt: count5() }).from(planPhases).where(eq34(planPhases.itemId, item.id));
   const cnt = row?.cnt ?? 0;
-  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq33(items.id, item.id));
+  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq34(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(and15(eq34(planPhases.itemId, itemId2), eq34(planPhases.idx, fromIdx)));
-    const tasks = await tx.select({ idx: planTasks.idx, task: planTasks.task }).from(planTasks).where(and15(eq34(planTasks.itemId, itemId2), eq34(planTasks.phaseIdx, fromIdx))).orderBy(asc10(planTasks.idx));
+    const [phaseRow] = await tx.select({ name: planPhases.name, manualChecks: planPhases.manualChecks }).from(planPhases).where(and16(eq35(planPhases.itemId, itemId2), eq35(planPhases.idx, fromIdx)));
+    const tasks = await tx.select({ idx: planTasks.idx, task: planTasks.task }).from(planTasks).where(and16(eq35(planTasks.itemId, itemId2), eq35(planTasks.phaseIdx, fromIdx))).orderBy(asc11(planTasks.idx));
     await tx.delete(planTasks).where(
-      and15(eq34(planTasks.itemId, itemId2), eq34(planTasks.phaseIdx, fromIdx))
+      and16(eq35(planTasks.itemId, itemId2), eq35(planTasks.phaseIdx, fromIdx))
     );
-    await tx.delete(planPhases).where(and15(eq34(planPhases.itemId, itemId2), eq34(planPhases.idx, fromIdx)));
+    await tx.delete(planPhases).where(and16(eq35(planPhases.itemId, itemId2), eq35(planPhases.idx, fromIdx)));
     await reindexPhases(tx, itemId2);
     await shiftPhasesUp(tx, itemId2, toIdx);
     await tx.insert(planPhases).values({
@@ -12925,7 +13308,7 @@ async function movePhase(id, from, to) {
   if (!found) return;
   const { orm, item } = found;
   const itemId2 = item.id;
-  const [row] = await orm.select({ cnt: count6() }).from(planPhases).where(eq35(planPhases.itemId, itemId2));
+  const [row] = await orm.select({ cnt: count6() }).from(planPhases).where(eq36(planPhases.itemId, itemId2));
   const phaseCount = row?.cnt ?? 0;
   const fromIdx = toIndex(from, phaseCount);
   if (fromIdx === void 0) return;
@@ -12941,22 +13324,22 @@ async function movePhase(id, from, to) {
 import chalk106 from "chalk";
 
 // src/commands/backlog/applyPhaseUpdate.ts
-import { and as and16, eq as eq36 } from "drizzle-orm";
+import { and as and17, eq as eq37 } 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(
-        and16(eq36(planPhases.itemId, itemId2), eq36(planPhases.idx, phaseIdx))
+        and17(eq37(planPhases.itemId, itemId2), eq37(planPhases.idx, phaseIdx))
       );
     }
     if (fields.manualCheck) {
       await tx.update(planPhases).set({ manualChecks: JSON.stringify(fields.manualCheck) }).where(
-        and16(eq36(planPhases.itemId, itemId2), eq36(planPhases.idx, phaseIdx))
+        and17(eq37(planPhases.itemId, itemId2), eq37(planPhases.idx, phaseIdx))
       );
     }
     if (fields.task) {
       await tx.delete(planTasks).where(
-        and16(eq36(planTasks.itemId, itemId2), eq36(planTasks.phaseIdx, phaseIdx))
+        and17(eq37(planTasks.itemId, itemId2), eq37(planTasks.phaseIdx, phaseIdx))
       );
       if (fields.task.length) {
         await tx.insert(planTasks).values(
@@ -12974,14 +13357,14 @@ async function applyPhaseUpdate(orm, itemId2, phaseIdx, fields) {
 
 // src/commands/backlog/findPhase.ts
 import chalk105 from "chalk";
-import { and as and17, count as count7, eq as eq37 } from "drizzle-orm";
+import { and as and18, count as count7, eq as eq38 } from "drizzle-orm";
 async function findPhase(id, phase) {
   const found = await findOneItem(id);
   if (!found) return void 0;
   const { orm, item } = found;
   const itemId2 = item.id;
   const phaseIdx = Number.parseInt(phase, 10) - 1;
-  const [row] = await orm.select({ cnt: count7() }).from(planPhases).where(and17(eq37(planPhases.itemId, itemId2), eq37(planPhases.idx, phaseIdx)));
+  const [row] = await orm.select({ cnt: count7() }).from(planPhases).where(and18(eq38(planPhases.itemId, itemId2), eq38(planPhases.idx, phaseIdx)));
   if (!row || row.cnt === 0) {
     console.log(
       chalk105.red(
@@ -13137,14 +13520,14 @@ async function updatePhase(id, phase, options2) {
 }
 
 // src/commands/backlog/registerUpdatePhaseCommand.ts
-function collect2(value, previous) {
+function collect(value, previous) {
   return [...previous, value];
 }
 function registerUpdatePhaseCommand(cmd) {
-  cmd.command("update-phase <id> <phase>").alias("edit-phase").description("Modify a plan phase on a backlog item").option("--name <name>", "New phase name").option("--task <task...>", "Replace tasks (repeatable)").option("--manual-check <check...>", "Replace manual checks (repeatable)").option("--add-task <text>", "Append one task (repeatable)", collect2, []).option("--edit-task <n> <text...>", "Replace task n (1-based) in place").option("--remove-task <n>", "Remove task n (1-based)").option(
+  cmd.command("update-phase <id> <phase>").alias("edit-phase").description("Modify a plan phase on a backlog item").option("--name <name>", "New phase name").option("--task <task...>", "Replace tasks (repeatable)").option("--manual-check <check...>", "Replace manual checks (repeatable)").option("--add-task <text>", "Append one task (repeatable)", collect, []).option("--edit-task <n> <text...>", "Replace task n (1-based) in place").option("--remove-task <n>", "Remove task n (1-based)").option(
     "--add-check <text>",
     "Append one manual check (repeatable)",
-    collect2,
+    collect,
     []
   ).option(
     "--edit-check <n> <text...>",
@@ -13154,16 +13537,16 @@ function registerUpdatePhaseCommand(cmd) {
 
 // src/commands/backlog/removePhase.ts
 import chalk107 from "chalk";
-import { and as and18, eq as eq38 } from "drizzle-orm";
+import { and as and19, eq as eq39 } 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(
-      and18(eq38(planTasks.itemId, itemId2), eq38(planTasks.phaseIdx, phaseIdx))
+      and19(eq39(planTasks.itemId, itemId2), eq39(planTasks.phaseIdx, phaseIdx))
     );
-    await tx.delete(planPhases).where(and18(eq38(planPhases.itemId, itemId2), eq38(planPhases.idx, phaseIdx)));
+    await tx.delete(planPhases).where(and19(eq39(planPhases.itemId, itemId2), eq39(planPhases.idx, phaseIdx)));
     await reindexPhases(tx, itemId2);
     await adjustCurrentPhase(tx, item, phaseIdx);
   });
@@ -13176,7 +13559,7 @@ async function removePhase(id, phase) {
 
 // src/commands/backlog/update/update.ts
 import chalk111 from "chalk";
-import { eq as eq39 } from "drizzle-orm";
+import { eq as eq40 } from "drizzle-orm";
 
 // src/commands/backlog/update/buildUpdateValues.ts
 import chalk108 from "chalk";
@@ -13287,14 +13670,14 @@ async function update(id, options2) {
   if (!built) return;
   const { orm } = found;
   const itemId2 = found.item.id;
-  await orm.update(items).set(built.set).where(eq39(items.id, itemId2));
+  await orm.update(items).set(built.set).where(eq40(items.id, itemId2));
   console.log(
     chalk111.green(`Updated ${built.fields} on item ${formatItemId(itemId2)}.`)
   );
 }
 
 // src/commands/backlog/registerUpdateCommands.ts
-function collect3(value, previous) {
+function collect2(value, previous) {
   return [...previous, value];
 }
 function registerUpdateCommands(cmd) {
@@ -13304,7 +13687,7 @@ function registerUpdateCommands(cmd) {
   ).option("--type <type>", "New type (story or bug)").option("--ac <criterion...>", "Replace acceptance criteria (repeatable)").option(
     "--add-ac <text>",
     "Append one acceptance criterion (repeatable)",
-    collect3,
+    collect2,
     []
   ).option(
     "--edit-ac <n> <text...>",
@@ -13489,9 +13872,9 @@ var UNPARSEABLE = { ok: false, error: "unable to parse" };
 function groupByOperator(tokens) {
   const groups = [[]];
   for (let i = 0; i < tokens.length; i++) {
-    const step = handleToken(tokens, i, groups);
-    if (!step.ok) return step;
-    i = step.nextIndex;
+    const step2 = handleToken(tokens, i, groups);
+    if (!step2.ok) return step2;
+    i = step2.nextIndex;
   }
   return { ok: true, groups };
 }
@@ -17365,9 +17748,9 @@ function registerGithub(program2) {
 }
 
 // src/commands/handover/countPendingHandovers.ts
-import { and as and19, eq as eq40, isNull, sql as sql18 } from "drizzle-orm";
+import { and as and20, eq as eq41, isNull, sql as sql18 } from "drizzle-orm";
 async function countPendingHandovers(orm, origin) {
-  const [row] = await orm.select({ count: sql18`count(*)::int` }).from(handovers).where(and19(eq40(handovers.origin, origin), isNull(handovers.recalledAt)));
+  const [row] = await orm.select({ count: sql18`count(*)::int` }).from(handovers).where(and20(eq41(handovers.origin, origin), isNull(handovers.recalledAt)));
   return row?.count ?? 0;
 }
 
@@ -17507,13 +17890,13 @@ async function load2(options2 = {}) {
 }
 
 // src/commands/handover/listPendingHandovers.ts
-import { and as and20, desc as desc4, eq as eq41, isNull as isNull2 } from "drizzle-orm";
+import { and as and21, desc as desc4, eq as eq42, isNull as isNull2 } from "drizzle-orm";
 async function listPendingHandovers(orm, origin) {
   return orm.select({
     id: handovers.id,
     summary: handovers.summary,
     createdAt: handovers.createdAt
-  }).from(handovers).where(and20(eq41(handovers.origin, origin), isNull2(handovers.recalledAt))).orderBy(desc4(handovers.createdAt), desc4(handovers.id));
+  }).from(handovers).where(and21(eq42(handovers.origin, origin), isNull2(handovers.recalledAt))).orderBy(desc4(handovers.createdAt), desc4(handovers.id));
 }
 
 // src/commands/handover/printPendingHandovers.ts
@@ -17526,17 +17909,17 @@ async function printPendingHandovers() {
 }
 
 // src/commands/handover/recallHandover.ts
-import { and as and21, desc as desc5, eq as eq42, isNull as isNull3 } from "drizzle-orm";
+import { and as and22, desc as desc5, eq as eq43, isNull as isNull3 } from "drizzle-orm";
 async function recallHandover(orm, origin, id) {
   const [row] = await orm.select().from(handovers).where(
-    and21(
-      eq42(handovers.origin, origin),
+    and22(
+      eq43(handovers.origin, origin),
       isNull3(handovers.recalledAt),
-      ...id === void 0 ? [] : [eq42(handovers.id, id)]
+      ...id === void 0 ? [] : [eq43(handovers.id, id)]
     )
   ).orderBy(desc5(handovers.createdAt), desc5(handovers.id)).limit(1);
   if (!row) return void 0;
-  await orm.update(handovers).set({ recalledAt: /* @__PURE__ */ new Date() }).where(eq42(handovers.id, row.id));
+  await orm.update(handovers).set({ recalledAt: /* @__PURE__ */ new Date() }).where(eq43(handovers.id, row.id));
   return row.content;
 }
 
@@ -17924,16 +18307,16 @@ function* durabilityProbes() {
 async function checkDurability(cwd) {
   if (!existsSync44(cwd)) return { durable: true };
   const probes = durabilityProbes();
-  let step = probes.next();
-  while (!step.done) step = probes.next(await gitResult(cwd, step.value));
-  return step.value;
+  let step2 = probes.next();
+  while (!step2.done) step2 = probes.next(await gitResult(cwd, step2.value));
+  return step2.value;
 }
 function checkDurabilitySync(cwd) {
   if (!existsSync44(cwd)) return { durable: true };
   const probes = durabilityProbes();
-  let step = probes.next();
-  while (!step.done) step = probes.next(gitSyncResult(cwd, step.value));
-  return step.value;
+  let step2 = probes.next();
+  while (!step2.done) step2 = probes.next(gitSyncResult(cwd, step2.value));
+  return step2.value;
 }
 
 // src/commands/sessions/daemon/worktree/worktreeConfigFor.ts
@@ -19552,20 +19935,20 @@ function resolveThread(threadId) {
   }
 }
 function requireCache(prNumber) {
-  const cache4 = loadCommentsCache(prNumber);
-  if (!cache4) {
+  const cache5 = loadCommentsCache(prNumber);
+  if (!cache5) {
     console.error(
       `Error: No cached comments found for PR #${prNumber}. Run "assist prs list-comments" first.`
     );
     process.exit(1);
   }
-  return cache4;
+  return cache5;
 }
 function findLineComment(comments3, commentId) {
   return comments3.find((c) => c.type === "line" && c.id === commentId);
 }
-function requireLineComment(cache4, commentId) {
-  const comment3 = findLineComment(cache4.comments, commentId);
+function requireLineComment(cache5, commentId) {
+  const comment3 = findLineComment(cache5.comments, commentId);
   if (!comment3 || comment3.type !== "line" || !comment3.threadId) {
     console.error(
       `Error: Comment #${commentId} not found or has no thread ID.`
@@ -19574,8 +19957,8 @@ function requireLineComment(cache4, commentId) {
   }
   return comment3;
 }
-function cleanupCacheIfDone(cache4, prNumber, commentId) {
-  const hasRemaining = cache4.comments.some(
+function cleanupCacheIfDone(cache5, prNumber, commentId) {
+  const hasRemaining = cache5.comments.some(
     (c) => c.type === "line" && c.id !== commentId
   );
   if (!hasRemaining) deleteCommentsCache(prNumber);
@@ -19583,13 +19966,13 @@ function cleanupCacheIfDone(cache4, prNumber, commentId) {
 function resolveCommentWithReply(commentId, message2) {
   const prNumber = getCurrentPrNumber();
   const { org, repo } = getRepoInfo();
-  const cache4 = requireCache(prNumber);
-  const comment3 = requireLineComment(cache4, commentId);
+  const cache5 = requireCache(prNumber);
+  const comment3 = requireLineComment(cache5, commentId);
   replyToComment(org, repo, prNumber, commentId, message2);
   console.log("Reply posted successfully.");
   resolveThread(comment3.threadId);
   console.log("Thread resolved successfully.");
-  cleanupCacheIfDone(cache4, prNumber, commentId);
+  cleanupCacheIfDone(cache5, prNumber, commentId);
 }
 
 // src/commands/prs/fixed.ts
@@ -20178,7 +20561,7 @@ var prsConfigHelp = [
 ];
 
 // src/commands/registerPrsEdit.ts
-function collect4(value, previous) {
+function collect3(value, previous) {
   return previous.concat([value]);
 }
 function registerPrsEdit(prsCommand) {
@@ -20187,7 +20570,7 @@ function registerPrsEdit(prsCommand) {
   ).option("-t, --title <title>", "New title for the pull request").option("--what <what>", "Replace the ## What section").option("--why <why>", "Replace the ## Why section").option("--how <how>", "Replace the ## How section").option(
     "--resolves <key>",
     "Jira issue key resolved by this PR, appended to ## Why (repeatable)",
-    collect4,
+    collect3,
     []
   ).action(edit);
 }
@@ -20288,7 +20671,7 @@ ${confirm}
 }
 
 // src/commands/registerPrsRaise.ts
-function collect5(value, previous) {
+function collect4(value, previous) {
   return previous.concat([value]);
 }
 function registerPrsRaise(prsCommand) {
@@ -20297,20 +20680,20 @@ function registerPrsRaise(prsCommand) {
   ).option("-t, --title <title>", "Title for the pull request").option("--what <what>", "What the change does (## What section)").option("--why <why>", "Why the change is needed (## Why section)").option("--how <how>", "How the change works (optional ## How section)").option(
     "--resolves <key>",
     "Jira issue key resolved by this PR, appended to ## Why (repeatable)",
-    collect5,
+    collect4,
     []
   ).option(
     "--force",
     "Overwrite the title and body of an existing pull request"
-  ).option("-B, --base <branch>", "Branch into which the pull request merges").option("-H, --head <branch>", "Branch that contains the commits").option("-d, --draft", "Mark the pull request as a draft").option("-w, --web", "Open the browser to create the pull request").option("-l, --label <label>", "Add a label (repeatable)", collect5, []).option(
+  ).option("-B, --base <branch>", "Branch into which the pull request merges").option("-H, --head <branch>", "Branch that contains the commits").option("-d, --draft", "Mark the pull request as a draft").option("-w, --web", "Open the browser to create the pull request").option("-l, --label <label>", "Add a label (repeatable)", collect4, []).option(
     "-a, --assignee <login>",
     "Assign a person by login (repeatable)",
-    collect5,
+    collect4,
     []
   ).option(
     "-r, --reviewer <handle>",
     "Request a review (repeatable)",
-    collect5,
+    collect4,
     []
   ).option("-m, --milestone <name>", "Add the pull request to a milestone").addHelpText("after", () => raiseHelpText()).action(raise);
 }
@@ -27822,10 +28205,10 @@ function applyReviewPause(session, activity2) {
 }
 
 // src/shared/db/getPhaseActiveMs.ts
-import { and as and22, eq as eq43 } from "drizzle-orm";
+import { and as and23, eq as eq44 } from "drizzle-orm";
 async function getPhaseActiveMs(db, itemId2, phaseIdx) {
   const [row] = await db.select({ activeMs: phaseUsage.activeMs }).from(phaseUsage).where(
-    and22(eq43(phaseUsage.itemId, itemId2), eq43(phaseUsage.phaseIdx, phaseIdx))
+    and23(eq44(phaseUsage.itemId, itemId2), eq44(phaseUsage.phaseIdx, phaseIdx))
   );
   return row?.activeMs ?? 0;
 }
@@ -28336,17 +28719,17 @@ async function recordPhaseTranscriptUsage(db, itemId2, phaseIdx, responses) {
 }
 
 // src/shared/db/recordWindowTokens.ts
-import { and as and23, eq as eq44, sql as sql24 } from "drizzle-orm";
+import { and as and24, eq as eq45, sql as sql24 } from "drizzle-orm";
 async function recordWindowTokens(db, window, resetsAt, tokensUp, tokensDown) {
   if (tokensUp <= 0 && tokensDown <= 0) return;
   await db.update(usagePeaks).set({
     tokensUp: sql24`${usagePeaks.tokensUp} + ${tokensUp}`,
     tokensDown: sql24`${usagePeaks.tokensDown} + ${tokensDown}`
   }).where(
-    and23(
-      eq44(usagePeaks.window, window),
-      eq44(usagePeaks.resetsAt, resetsAt),
-      eq44(usagePeaks.segment, 0)
+    and24(
+      eq45(usagePeaks.window, window),
+      eq45(usagePeaks.resetsAt, resetsAt),
+      eq45(usagePeaks.segment, 0)
     )
   );
 }