@staff0rd/assist 0.402.0 → 0.403.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.402.0",
+  version: "0.403.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -1577,6 +1577,95 @@ function stageAndCommit(files, message) {
   return commitStaged(message);
 }
 
+// src/commands/sessions/summarise/iterateUserMessages.ts
+import * as fs from "fs";
+
+// src/commands/sessions/summarise/parseUserLine.ts
+function parseUserLine(line) {
+  let entry;
+  try {
+    entry = JSON.parse(line);
+  } catch {
+    return void 0;
+  }
+  if (entry.type !== "user") return void 0;
+  const msg = entry.message;
+  const c = msg?.content;
+  let text17;
+  if (typeof c === "string") {
+    text17 = c;
+  } else if (Array.isArray(c)) {
+    const collected = c.filter((b) => b.type === "text").map((b) => b.text ?? "").join("\n");
+    text17 = collected || void 0;
+  }
+  if (!text17) return void 0;
+  return {
+    text: text17,
+    entrypoint: typeof entry.entrypoint === "string" ? entry.entrypoint : void 0
+  };
+}
+
+// src/commands/sessions/summarise/iterateUserMessages.ts
+function* iterateUserMessages(filePath, maxBytes = 65536) {
+  let content;
+  try {
+    const fd = fs.openSync(filePath, "r");
+    try {
+      const buf = Buffer.alloc(maxBytes);
+      const bytesRead = fs.readSync(fd, buf, 0, buf.length, 0);
+      content = buf.toString("utf8", 0, bytesRead);
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch {
+    return;
+  }
+  for (const line of content.split("\n")) {
+    if (!line) continue;
+    const entry = parseUserLine(line);
+    if (entry) yield entry.text;
+  }
+}
+
+// src/commands/sessions/summarise/scanSessionBacklogRefs.ts
+function scanSessionBacklogRefs(filePath) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const text17 of iterateUserMessages(filePath, Number.MAX_SAFE_INTEGER)) {
+    for (const id of extractBacklogIds(text17)) {
+      ids.add(id);
+    }
+  }
+  return [...ids].sort((a, b) => a - b);
+}
+function extractBacklogIds(text17) {
+  const ids = [];
+  for (const m of text17.matchAll(/backlog\s+run\s+a(\d+)/gi)) {
+    ids.push(Number.parseInt(m[1], 10));
+  }
+  for (const m of text17.matchAll(/backlog\s+(?:item\s+)?a(\d+)/gi)) {
+    ids.push(Number.parseInt(m[1], 10));
+  }
+  for (const m of text17.matchAll(/backlog\s+phase-done\s+a(\d+)/gi)) {
+    ids.push(Number.parseInt(m[1], 10));
+  }
+  for (const m of text17.matchAll(/backlog\s+comment\s+a(\d+)/gi)) {
+    ids.push(Number.parseInt(m[1], 10));
+  }
+  for (const m of text17.matchAll(/(?:^|[\s(])a(\d{1,4})(?=[\s).,;:!?]|$)/gm)) {
+    ids.push(Number.parseInt(m[1], 10));
+  }
+  return ids;
+}
+
+// src/shared/findBacklogRefs.ts
+function findBacklogRefs(text17) {
+  return [...new Set(extractBacklogIds(text17))];
+}
+function backlogRefError(subject, context, ids) {
+  const refs = ids.map((id) => `a${id}`).join(", ");
+  return `Error: ${subject} must not reference assist backlog items (found ${refs}). Do not include assist references or backlog numbers in ${context} \u2014 the backlog item links to your work, not the other way around.`;
+}
+
 // src/commands/commit/validateMessage.ts
 var MAX_MESSAGE_LENGTH = 50;
 var CONVENTIONAL_COMMIT_REGEX = /^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(!)?(\(.+\))?!?: .+$/;
@@ -1585,6 +1674,13 @@ function validateMessage(message, config) {
     console.error("Error: Commit message must not reference Claude");
     process.exit(1);
   }
+  const backlogIds = findBacklogRefs(message);
+  if (backlogIds.length > 0) {
+    console.error(
+      backlogRefError("Commit message", "commit messages", backlogIds)
+    );
+    process.exit(1);
+  }
   if (config.commit?.conventional && !CONVENTIONAL_COMMIT_REGEX.test(message)) {
     console.error(
       "Error: Commit message must follow conventional commit format (e.g., 'feat: add feature', 'fix(scope): fix bug')"
@@ -1700,18 +1796,18 @@ async function promptMultiselect(message, options2) {
 }
 
 // src/shared/readPackageJson.ts
-import * as fs from "fs";
+import * as fs2 from "fs";
 import * as path from "path";
 import chalk5 from "chalk";
 function findPackageJson() {
   const packageJsonPath = path.join(process.cwd(), "package.json");
-  if (fs.existsSync(packageJsonPath)) {
+  if (fs2.existsSync(packageJsonPath)) {
     return packageJsonPath;
   }
   return null;
 }
 function readPackageJson(filePath) {
-  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  return JSON.parse(fs2.readFileSync(filePath, "utf8"));
 }
 function requirePackageJson() {
   const packageJsonPath = findPackageJson();
@@ -1726,8 +1822,8 @@ function findPackageJsonWithVerifyScripts(startDir) {
   let currentDir = startDir;
   while (true) {
     const packageJsonPath = path.join(currentDir, "package.json");
-    if (fs.existsSync(packageJsonPath)) {
-      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    if (fs2.existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf8"));
       const scripts = packageJson.scripts || {};
       const verifyScripts = Object.keys(scripts).filter(
         (name) => name.startsWith("verify:")
@@ -2389,28 +2485,28 @@ async function init3(options2 = {}) {
 import chalk23 from "chalk";
 
 // src/commands/vscode/init/createLaunchJson.ts
-import * as fs2 from "fs";
+import * as fs3 from "fs";
 import * as path8 from "path";
 import chalk20 from "chalk";
 function ensureVscodeFolder() {
   const vscodeDir = path8.join(process.cwd(), ".vscode");
-  if (!fs2.existsSync(vscodeDir)) {
-    fs2.mkdirSync(vscodeDir);
+  if (!fs3.existsSync(vscodeDir)) {
+    fs3.mkdirSync(vscodeDir);
     console.log(chalk20.dim("Created .vscode folder"));
   }
 }
 function removeVscodeFromGitignore() {
   const gitignorePath = path8.join(process.cwd(), ".gitignore");
-  if (!fs2.existsSync(gitignorePath)) {
+  if (!fs3.existsSync(gitignorePath)) {
     return;
   }
-  const content = fs2.readFileSync(gitignorePath, "utf8");
+  const content = fs3.readFileSync(gitignorePath, "utf8");
   const lines = content.split("\n");
   const filteredLines = lines.filter(
     (line) => !line.trim().toLowerCase().includes(".vscode")
   );
   if (filteredLines.length !== lines.length) {
-    fs2.writeFileSync(gitignorePath, filteredLines.join("\n"));
+    fs3.writeFileSync(gitignorePath, filteredLines.join("\n"));
     console.log(chalk20.dim("Removed .vscode references from .gitignore"));
   }
 }
@@ -2428,20 +2524,20 @@ function createLaunchJson(type) {
     ]
   };
   const launchPath = path8.join(process.cwd(), ".vscode", "launch.json");
-  fs2.writeFileSync(launchPath, `${JSON.stringify(launchConfig, null, "	")}
+  fs3.writeFileSync(launchPath, `${JSON.stringify(launchConfig, null, "	")}
 `);
   console.log(chalk20.green("Created .vscode/launch.json"));
 }
 
 // src/commands/vscode/init/detectVscodeSetup.ts
-import * as fs3 from "fs";
+import * as fs4 from "fs";
 import * as path9 from "path";
 function detectVscodeSetup(pkg) {
   const vscodeDir = path9.join(process.cwd(), ".vscode");
   return {
-    hasVscodeFolder: fs3.existsSync(vscodeDir),
-    hasLaunchJson: fs3.existsSync(path9.join(vscodeDir, "launch.json")),
-    hasSettingsJson: fs3.existsSync(path9.join(vscodeDir, "settings.json")),
+    hasVscodeFolder: fs4.existsSync(vscodeDir),
+    hasLaunchJson: fs4.existsSync(path9.join(vscodeDir, "launch.json")),
+    hasSettingsJson: fs4.existsSync(path9.join(vscodeDir, "settings.json")),
     hasVite: !!pkg.devDependencies?.vite || !!pkg.dependencies?.vite,
     hasTsup: !!pkg.devDependencies?.tsup || !!pkg.dependencies?.tsup
   };
@@ -2473,16 +2569,16 @@ function getAvailableOptions2(setup2) {
 }
 
 // src/commands/vscode/init/createSettingsJson.ts
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 import * as path10 from "path";
 import chalk21 from "chalk";
 
 // src/commands/vscode/init/readVscodeJson.ts
-import * as fs4 from "fs";
+import * as fs5 from "fs";
 function readVscodeJson(filePath) {
-  if (!fs4.existsSync(filePath)) return {};
+  if (!fs5.existsSync(filePath)) return {};
   try {
-    return JSON.parse(fs4.readFileSync(filePath, "utf8"));
+    return JSON.parse(fs5.readFileSync(filePath, "utf8"));
   } catch {
     return {};
   }
@@ -2501,7 +2597,7 @@ function createSettingsJson() {
       "source.fixAll.oxc": "explicit"
     }
   };
-  fs5.writeFileSync(settingsPath, `${JSON.stringify(settings, null, "	")}
+  fs6.writeFileSync(settingsPath, `${JSON.stringify(settings, null, "	")}
 `);
   console.log(chalk21.green("Created .vscode/settings.json"));
 }
@@ -2512,7 +2608,7 @@ function existingCodeActions(actions) {
 }
 
 // src/commands/vscode/init/createExtensionsJson.ts
-import * as fs6 from "fs";
+import * as fs7 from "fs";
 import * as path11 from "path";
 import chalk22 from "chalk";
 function createExtensionsJson() {
@@ -2521,7 +2617,7 @@ function createExtensionsJson() {
   const previous = Array.isArray(existing.recommendations) ? existing.recommendations : [];
   const recommendations = previous.includes("oxc.oxc-vscode") ? previous : [...previous, "oxc.oxc-vscode"];
   const extensions = { ...existing, recommendations };
-  fs6.writeFileSync(
+  fs7.writeFileSync(
     extensionsPath,
     `${JSON.stringify(extensions, null, "	")}
 `
@@ -2578,20 +2674,20 @@ import path17 from "path";
 import chalk25 from "chalk";
 
 // src/commands/lint/lint/checkFileNames.ts
-import fs8 from "fs";
+import fs9 from "fs";
 import path13 from "path";
 
 // src/shared/findSourceFiles.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import path12 from "path";
 var EXTENSIONS = [".ts", ".tsx"];
 function findSourceFiles(dir, options2 = {}) {
   const { includeTests = true } = options2;
   const results = [];
-  if (!fs7.existsSync(dir)) {
+  if (!fs8.existsSync(dir)) {
     return results;
   }
-  const entries = fs7.readdirSync(dir, { withFileTypes: true });
+  const entries = fs8.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     const fullPath = path12.join(dir, entry.name);
     if (entry.isDirectory() && entry.name !== "node_modules") {
@@ -2641,7 +2737,7 @@ function checkFileNames() {
     const nameWithoutExt = fileName.replace(/\.(ts|tsx)$/, "");
     if (/\.(stories|test)\.(ts|tsx)$/.test(fileName)) continue;
     if (/^[A-Z]/.test(nameWithoutExt)) {
-      const content = fs8.readFileSync(filePath, "utf8");
+      const content = fs9.readFileSync(filePath, "utf8");
       if (!hasClassOrComponent(content) && !hasMatchingTypeExport(content, nameWithoutExt)) {
         violations.push({
           filePath,
@@ -2658,7 +2754,7 @@ function checkFileNames() {
 import chalk24 from "chalk";
 
 // src/commands/lint/lint/applyMoves.ts
-import fs9 from "fs";
+import fs10 from "fs";
 import path15 from "path";
 
 // src/commands/lint/lint/renameExports.ts
@@ -2694,8 +2790,8 @@ function isCaseOnly(a, b) {
 }
 function moveCaseInsensitive(absSource, absDest) {
   const tmp = `${absSource}.tmp`;
-  fs9.renameSync(absSource, tmp);
-  fs9.renameSync(tmp, absDest);
+  fs10.renameSync(absSource, tmp);
+  fs10.renameSync(tmp, absDest);
 }
 function applyMoves(project, moves, cwd, emit4) {
   for (const { sourcePath, destPath } of moves) {
@@ -2715,19 +2811,19 @@ function applyMoves(project, moves, cwd, emit4) {
   for (const { sourcePath, destPath } of moves) {
     const absSource = path15.resolve(sourcePath);
     const absDest = path15.resolve(destPath);
-    if (isCaseOnly(absSource, absDest) && fs9.existsSync(absSource)) {
+    if (isCaseOnly(absSource, absDest) && fs10.existsSync(absSource)) {
       moveCaseInsensitive(absSource, absDest);
     }
   }
 }
 
 // src/commands/lint/lint/createLintProject.ts
-import fs10 from "fs";
+import fs11 from "fs";
 import path16 from "path";
 import { Project } from "ts-morph";
 function createLintProject() {
   const tsConfigPath = path16.resolve("tsconfig.json");
-  const project = fs10.existsSync(tsConfigPath) ? new Project({
+  const project = fs11.existsSync(tsConfigPath) ? new Project({
     tsConfigFilePath: tsConfigPath,
     skipAddingFilesFromTsConfig: true
   }) : new Project();
@@ -2784,7 +2880,7 @@ function runFileNameCheck(fix = false) {
 }
 
 // src/commands/lint/lint/runImportExtensionCheck.ts
-import fs11 from "fs";
+import fs12 from "fs";
 
 // src/commands/lint/shared.ts
 import chalk26 from "chalk";
@@ -2810,7 +2906,7 @@ ${checkName} failed:
 
 // src/commands/lint/lint/runImportExtensionCheck.ts
 function checkForImportExtensions(filePath) {
-  const content = fs11.readFileSync(filePath, "utf8");
+  const content = fs12.readFileSync(filePath, "utf8");
   const lines = content.split("\n");
   const violations = [];
   const importExtensionPattern = /from\s+["']\..*\.(js|ts)["']/;
@@ -2844,9 +2940,9 @@ function runImportExtensionCheck() {
 }
 
 // src/commands/lint/lint/runStaticImportCheck.ts
-import fs12 from "fs";
+import fs13 from "fs";
 function checkForDynamicImports(filePath) {
-  const content = fs12.readFileSync(filePath, "utf8");
+  const content = fs13.readFileSync(filePath, "utf8");
   const lines = content.split("\n");
   const violations = [];
   const requirePattern = /\brequire\s*\(/;
@@ -2896,7 +2992,7 @@ import { basename as basename2, resolve as resolve5 } from "path";
 
 // src/commands/verify/blockComments/findComments.ts
 import { execSync as execSync10 } from "child_process";
-import fs14 from "fs";
+import fs15 from "fs";
 import { minimatch } from "minimatch";
 import { Project as Project2 } from "ts-morph";
 
@@ -2930,7 +3026,7 @@ function isHashCommentFile(filePath) {
 }
 
 // src/commands/verify/blockComments/collectFileComments.ts
-import fs13 from "fs";
+import fs14 from "fs";
 
 // src/shared/isBicepFile.ts
 var BICEP_EXTENSIONS = [".bicep", ".bicepparam"];
@@ -3085,7 +3181,7 @@ function toFindings(file, lines, raw, exempt) {
   return findings;
 }
 function collectFileComments(file, lines, project) {
-  const read = () => fs13.readFileSync(file, "utf8");
+  const read = () => fs14.readFileSync(file, "utf8");
   if (isYamlFile(file))
     return toFindings(file, lines, collectYamlComments(read()), false);
   if (isDockerfile(file) || isEnvFile(file) || isShellFile(file))
@@ -3152,7 +3248,7 @@ function shouldScan(file, ignoreGlobs) {
   if (!SCANNED_EXTENSIONS.some((ext) => file.endsWith(ext)) && !isHashCommentFile(file))
     return false;
   if (ignoreGlobs.some((glob) => minimatch(file, glob))) return false;
-  return fs14.existsSync(file);
+  return fs15.existsSync(file);
 }
 function findComments(options2) {
   const diff2 = execSync10("git diff HEAD", {
@@ -4230,7 +4326,7 @@ function detectPlatform() {
 
 // src/commands/notify/showNotification/showWindowsNotificationFromWsl.ts
 import { spawn as spawn2 } from "child_process";
-import fs15 from "fs";
+import fs16 from "fs";
 import { createRequire } from "module";
 import path21 from "path";
 var require2 = createRequire(import.meta.url);
@@ -4242,7 +4338,7 @@ function showWindowsNotificationFromWsl(options2) {
   const { title, message, sound } = options2;
   const snoreToastPath = getSnoreToastPath();
   try {
-    fs15.chmodSync(snoreToastPath, 493);
+    fs16.chmodSync(snoreToastPath, 493);
   } catch {
   }
   const args = ["-t", title, "-m", message];
@@ -6684,12 +6780,12 @@ import chalk42 from "chalk";
 import * as path24 from "path";
 
 // src/commands/sessions/shared/discoverSessions.ts
-import * as fs17 from "fs";
+import * as fs18 from "fs";
 import * as os2 from "os";
 import * as path23 from "path";
 
 // src/commands/sessions/shared/parseSessionFile.ts
-import * as fs16 from "fs";
+import * as fs17 from "fs";
 import * as path22 from "path";
 
 // src/commands/sessions/shared/deriveHistoryFields.ts
@@ -6787,10 +6883,10 @@ function matchMarker(text17, tag) {
 async function parseSessionFile(filePath, origin = "wsl") {
   let handle;
   try {
-    handle = await fs16.promises.open(filePath, "r");
+    handle = await fs17.promises.open(filePath, "r");
     const meta = extractSessionMeta(await readHeadLines(handle));
     if (!meta.sessionId) return null;
-    const timestamp6 = meta.timestamp || (await fs16.promises.stat(filePath)).mtime.toISOString();
+    const timestamp6 = meta.timestamp || (await fs17.promises.stat(filePath)).mtime.toISOString();
     return {
       sessionId: meta.sessionId,
       name: meta.name || `Session ${meta.sessionId.slice(0, 8)}`,
@@ -6836,7 +6932,7 @@ async function discoverSessionJsonlPaths() {
     sessionRoots().map(async ({ dir, origin }) => {
       let projectDirs;
       try {
-        projectDirs = await fs17.promises.readdir(dir);
+        projectDirs = await fs18.promises.readdir(dir);
       } catch {
         return;
       }
@@ -6845,7 +6941,7 @@ async function discoverSessionJsonlPaths() {
           const dirPath = path23.join(dir, dirName);
           let entries;
           try {
-            entries = await fs17.promises.readdir(dirPath);
+            entries = await fs18.promises.readdir(dirPath);
           } catch {
             return;
           }
@@ -7618,9 +7714,9 @@ function startWebServer(label2, port, handler, initialPath, open = true) {
 // src/commands/sessions/daemon/ensureDaemonRunning.ts
 import { spawn as spawn4 } from "child_process";
 import {
-  closeSync,
+  closeSync as closeSync2,
   mkdirSync as mkdirSync10,
-  openSync,
+  openSync as openSync2,
   statSync,
   unlinkSync as unlinkSync5,
   writeSync
@@ -7660,9 +7756,9 @@ function acquireSpawnLock() {
 }
 function tryCreateLock() {
   try {
-    const fd = openSync(daemonPaths.spawnLock, "wx");
+    const fd = openSync2(daemonPaths.spawnLock, "wx");
     writeSync(fd, String(process.pid));
-    closeSync(fd);
+    closeSync2(fd);
     return true;
   } catch {
     return false;
@@ -7682,7 +7778,7 @@ function releaseSpawnLock() {
   }
 }
 function spawnDaemon(reason) {
-  const log = openSync(daemonPaths.log, "a");
+  const log = openSync2(daemonPaths.log, "a");
   const child = spawn4(process.execPath, [process.argv[1], "daemon", "run"], {
     detached: true,
     stdio: ["ignore", log, log],
@@ -12773,13 +12869,13 @@ import chalk119 from "chalk";
 import chalk112 from "chalk";
 
 // src/commands/complexity/shared/index.ts
-import fs19 from "fs";
+import fs20 from "fs";
 import path27 from "path";
 import chalk111 from "chalk";
 import ts5 from "typescript";
 
 // src/commands/complexity/findSourceFiles.ts
-import fs18 from "fs";
+import fs19 from "fs";
 import path26 from "path";
 import { minimatch as minimatch5 } from "minimatch";
 function applyIgnoreGlobs(files, extraIgnore = []) {
@@ -12788,11 +12884,11 @@ function applyIgnoreGlobs(files, extraIgnore = []) {
   return files.filter((f) => !ignore3.some((glob) => minimatch5(f, glob)));
 }
 function walk(dir, results) {
-  if (!fs18.existsSync(dir)) {
+  if (!fs19.existsSync(dir)) {
     return;
   }
   const extensions = [".ts", ".tsx"];
-  const entries = fs18.readdirSync(dir, { withFileTypes: true });
+  const entries = fs19.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     const fullPath = path26.join(dir, entry.name);
     if (entry.isDirectory()) {
@@ -12813,10 +12909,10 @@ function findSourceFiles2(pattern2, baseDir = ".", extraIgnore = []) {
       extraIgnore
     );
   }
-  if (fs18.existsSync(pattern2) && fs18.statSync(pattern2).isFile()) {
+  if (fs19.existsSync(pattern2) && fs19.statSync(pattern2).isFile()) {
     return [pattern2];
   }
-  if (fs18.existsSync(pattern2) && fs18.statSync(pattern2).isDirectory()) {
+  if (fs19.existsSync(pattern2) && fs19.statSync(pattern2).isDirectory()) {
     walk(pattern2, results);
     return applyIgnoreGlobs(results, extraIgnore);
   }
@@ -13014,7 +13110,7 @@ function countSloc(content) {
 
 // src/commands/complexity/shared/index.ts
 function createSourceFromFile(filePath) {
-  const content = fs19.readFileSync(filePath, "utf8");
+  const content = fs20.readFileSync(filePath, "utf8");
   return ts5.createSourceFile(
     path27.basename(filePath),
     content,
@@ -13174,7 +13270,7 @@ function printMaintainabilityFormula() {
 }
 
 // src/commands/complexity/maintainability/collectFileMetrics.ts
-import fs20 from "fs";
+import fs21 from "fs";
 
 // src/commands/complexity/maintainability/calculateMaintainabilityIndex.ts
 function calculateMaintainabilityIndex(halsteadVolume, cyclomaticComplexity, sloc2) {
@@ -13189,7 +13285,7 @@ function calculateMaintainabilityIndex(halsteadVolume, cyclomaticComplexity, slo
 function collectFileMetrics(files) {
   const fileMetrics = /* @__PURE__ */ new Map();
   for (const file of files) {
-    const content = fs20.readFileSync(file, "utf8");
+    const content = fs21.readFileSync(file, "utf8");
     fileMetrics.set(file, {
       sloc: countSloc(content),
       functions: [],
@@ -13245,14 +13341,14 @@ async function maintainability(pattern2 = "**/*.ts", options2 = {}) {
 }
 
 // src/commands/complexity/sloc.ts
-import fs21 from "fs";
+import fs22 from "fs";
 import chalk118 from "chalk";
 async function sloc(pattern2 = "**/*.ts", options2 = {}) {
   withSourceFiles(pattern2, (files) => {
     const results = [];
     let hasViolation = false;
     for (const file of files) {
-      const content = fs21.readFileSync(file, "utf8");
+      const content = fs22.readFileSync(file, "utf8");
       const lines = countSloc(content);
       results.push({ file, lines });
       if (options2.threshold !== void 0 && lines > options2.threshold) {
@@ -14147,7 +14243,7 @@ function registerDevlog(program2) {
 }
 
 // src/commands/dotnet/checkBuildLocks.ts
-import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync5 } from "fs";
+import { closeSync as closeSync3, openSync as openSync3, readdirSync as readdirSync5 } from "fs";
 import { join as join37 } from "path";
 import chalk131 from "chalk";
 
@@ -14178,8 +14274,8 @@ function isLockedDll(debugDir) {
     if (!file.toLowerCase().endsWith(".dll")) continue;
     const dllPath = join37(debugDir, file);
     try {
-      const fd = openSync2(dllPath, "r+");
-      closeSync2(fd);
+      const fd = openSync3(dllPath, "r+");
+      closeSync3(fd);
     } catch {
       return dllPath;
     }
@@ -14779,7 +14875,7 @@ function registerDotnet(program2) {
 }
 
 // src/commands/editHook/index.ts
-import fs22 from "fs";
+import fs23 from "fs";
 
 // src/commands/editHook/extractComments.ts
 var SOURCE_EXTENSIONS = [
@@ -14959,7 +15055,7 @@ function tryParseInput2(raw) {
 function readExisting(filePath) {
   if (!filePath) return void 0;
   try {
-    return fs22.readFileSync(filePath, "utf8");
+    return fs23.readFileSync(filePath, "utf8");
   } catch {
     return void 0;
   }
@@ -16860,14 +16956,15 @@ ${resolves}` : baseWhy);
   return serializePrBody(parsed);
 }
 
-// src/commands/prs/validatePrContent.ts
+// src/commands/prs/findWallOfText.ts
 var MAX_PARAGRAPH_CHARS = 600;
 var MAX_PARAGRAPH_SENTENCES = 4;
-function isListLine(line) {
-  return /^\s*([-*+]|\d+[.)])\s/.test(line);
-}
-function countSentences(paragraph) {
-  return paragraph.match(/[.!?]+(\s|$)/g)?.length ?? 0;
+function findWallOfText(body) {
+  const wall = splitParagraphs(body).find((p) => isWallOfText(p.lines));
+  if (!wall) {
+    return void 0;
+  }
+  return { section: wall.section, chars: wall.lines.join(" ").trim().length };
 }
 function splitParagraphs(body) {
   const paragraphs = [];
@@ -16900,6 +16997,14 @@ function isWallOfText(lines) {
   const text17 = lines.join(" ").trim();
   return text17.length > MAX_PARAGRAPH_CHARS || countSentences(text17) > MAX_PARAGRAPH_SENTENCES;
 }
+function countSentences(paragraph) {
+  return paragraph.match(/[.!?]+(\s|$)/g)?.length ?? 0;
+}
+function isListLine(line) {
+  return /^\s*([-*+]|\d+[.)])\s/.test(line);
+}
+
+// src/commands/prs/validatePrContent.ts
 function validatePrContent(title, body) {
   if (title.toLowerCase().includes("claude")) {
     console.error("Error: PR title must not reference Claude");
@@ -16909,11 +17014,20 @@ function validatePrContent(title, body) {
     console.error("Error: PR body must not reference Claude");
     process.exit(1);
   }
-  const wall = splitParagraphs(body).find((p) => isWallOfText(p.lines));
+  const titleBacklogIds = findBacklogRefs(title);
+  if (titleBacklogIds.length > 0) {
+    console.error(backlogRefError("PR title", "PRs", titleBacklogIds));
+    process.exit(1);
+  }
+  const bodyBacklogIds = findBacklogRefs(body);
+  if (bodyBacklogIds.length > 0) {
+    console.error(backlogRefError("PR body", "PRs", bodyBacklogIds));
+    process.exit(1);
+  }
+  const wall = findWallOfText(body);
   if (wall) {
-    const chars = wall.lines.join(" ").trim().length;
     console.error(
-      `Error: the "${wall.section}" section contains a wall-of-text paragraph (${chars} chars). Be concise \u2014 split it into bullet points or trim it.`
+      `Error: the "${wall.section}" section contains a wall-of-text paragraph (${wall.chars} chars). Be concise \u2014 split it into bullet points or trim it.`
     );
     process.exit(1);
   }
@@ -18116,17 +18230,17 @@ Refactor check failed:
 
 // src/commands/refactor/check/getViolations/index.ts
 import { execSync as execSync49 } from "child_process";
-import fs24 from "fs";
+import fs25 from "fs";
 import { minimatch as minimatch6 } from "minimatch";
 
 // src/commands/refactor/check/getViolations/getIgnoredFiles.ts
-import fs23 from "fs";
+import fs24 from "fs";
 var REFACTOR_YML_PATH = "refactor.yml";
 function parseRefactorYml() {
-  if (!fs23.existsSync(REFACTOR_YML_PATH)) {
+  if (!fs24.existsSync(REFACTOR_YML_PATH)) {
     return [];
   }
-  const content = fs23.readFileSync(REFACTOR_YML_PATH, "utf8");
+  const content = fs24.readFileSync(REFACTOR_YML_PATH, "utf8");
   const entries = [];
   const lines = content.split("\n");
   let currentEntry = {};
@@ -18156,7 +18270,7 @@ function getIgnoredFiles() {
 
 // src/commands/refactor/check/getViolations/index.ts
 function countLines(filePath) {
-  const content = fs24.readFileSync(filePath, "utf8");
+  const content = fs25.readFileSync(filePath, "utf8");
   return content.split("\n").length;
 }
 function getGitFiles(options2) {
@@ -18914,12 +19028,12 @@ import chalk170 from "chalk";
 import { Project as Project4 } from "ts-morph";
 
 // src/commands/refactor/extract/findTsConfig.ts
-import fs25 from "fs";
+import fs26 from "fs";
 import path39 from "path";
 import { Project as Project3 } from "ts-morph";
 function findTsConfig(sourcePath) {
   const rootConfig = path39.resolve("tsconfig.json");
-  if (!fs25.existsSync(rootConfig)) return rootConfig;
+  if (!fs26.existsSync(rootConfig)) return rootConfig;
   const tried = /* @__PURE__ */ new Set();
   const candidates = [rootConfig, ...readReferences(rootConfig)];
   for (const candidate of candidates) {
@@ -18927,7 +19041,7 @@ function findTsConfig(sourcePath) {
     tried.add(candidate);
     if (projectIncludes(candidate, sourcePath)) return candidate;
   }
-  const siblings = fs25.readdirSync(path39.dirname(rootConfig)).filter((f) => /^tsconfig.*\.json$/.test(f)).map((f) => path39.resolve(path39.dirname(rootConfig), f));
+  const siblings = fs26.readdirSync(path39.dirname(rootConfig)).filter((f) => /^tsconfig.*\.json$/.test(f)).map((f) => path39.resolve(path39.dirname(rootConfig), f));
   for (const sibling of siblings) {
     if (tried.has(sibling)) continue;
     tried.add(sibling);
@@ -18936,8 +19050,8 @@ function findTsConfig(sourcePath) {
   return rootConfig;
 }
 function readReferences(configPath) {
-  if (!fs25.existsSync(configPath)) return [];
-  const raw = fs25.readFileSync(configPath, "utf8");
+  if (!fs26.existsSync(configPath)) return [];
+  const raw = fs26.readFileSync(configPath, "utf8");
   const stripped = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
   let parsed;
   try {
@@ -18949,8 +19063,8 @@ function readReferences(configPath) {
   const cwd = path39.dirname(configPath);
   return parsed.references.map((ref) => {
     const refPath = path39.resolve(cwd, ref.path);
-    return fs25.statSync(refPath, { throwIfNoEntry: false })?.isDirectory() ? path39.join(refPath, "tsconfig.json") : refPath;
-  }).filter((p) => fs25.existsSync(p));
+    return fs26.statSync(refPath, { throwIfNoEntry: false })?.isDirectory() ? path39.join(refPath, "tsconfig.json") : refPath;
+  }).filter((p) => fs26.existsSync(p));
 }
 function projectIncludes(configPath, sourcePath) {
   try {
@@ -19000,25 +19114,25 @@ async function extract(file, functionName, destination, options2 = {}) {
 }
 
 // src/commands/refactor/ignore.ts
-import fs26 from "fs";
+import fs27 from "fs";
 import chalk172 from "chalk";
 var REFACTOR_YML_PATH2 = "refactor.yml";
 function ignore2(file) {
-  if (!fs26.existsSync(file)) {
+  if (!fs27.existsSync(file)) {
     console.error(chalk172.red(`Error: File does not exist: ${file}`));
     process.exit(1);
   }
-  const content = fs26.readFileSync(file, "utf8");
+  const content = fs27.readFileSync(file, "utf8");
   const lineCount = content.split("\n").length;
   const maxLines = lineCount + 10;
   const entry = `- file: ${file}
   maxLines: ${maxLines}
 `;
-  if (fs26.existsSync(REFACTOR_YML_PATH2)) {
-    const existing = fs26.readFileSync(REFACTOR_YML_PATH2, "utf8");
-    fs26.writeFileSync(REFACTOR_YML_PATH2, existing + entry);
+  if (fs27.existsSync(REFACTOR_YML_PATH2)) {
+    const existing = fs27.readFileSync(REFACTOR_YML_PATH2, "utf8");
+    fs27.writeFileSync(REFACTOR_YML_PATH2, existing + entry);
   } else {
-    fs26.writeFileSync(REFACTOR_YML_PATH2, entry);
+    fs27.writeFileSync(REFACTOR_YML_PATH2, entry);
   }
   console.log(
     chalk172.green(
@@ -19028,12 +19142,12 @@ function ignore2(file) {
 }
 
 // src/commands/refactor/rename/index.ts
-import fs29 from "fs";
+import fs30 from "fs";
 import path46 from "path";
 import chalk175 from "chalk";
 
 // src/commands/refactor/rename/applyRename.ts
-import fs28 from "fs";
+import fs29 from "fs";
 import path43 from "path";
 import chalk173 from "chalk";
 
@@ -19041,7 +19155,7 @@ import chalk173 from "chalk";
 import path42 from "path";
 
 // src/commands/refactor/restructure/computeRewrites/applyRewrites.ts
-import fs27 from "fs";
+import fs28 from "fs";
 function getOrCreateList(map, key) {
   const list5 = map.get(key) ?? [];
   if (!map.has(key)) map.set(key, list5);
@@ -19060,7 +19174,7 @@ function rewriteSpecifier(content, oldSpecifier, newSpecifier) {
   return content.replace(pattern2, `$1${newSpecifier}$2`);
 }
 function applyFileRewrites(file, fileRewrites) {
-  let content = fs27.readFileSync(file, "utf8");
+  let content = fs28.readFileSync(file, "utf8");
   for (const { oldSpecifier, newSpecifier } of fileRewrites) {
     content = rewriteSpecifier(content, oldSpecifier, newSpecifier);
   }
@@ -19139,12 +19253,12 @@ function computeRewrites(moves, edges, allProjectFiles) {
 function applyRename(rewrites, sourcePath, destPath, cwd) {
   const updatedContents = applyRewrites(rewrites);
   for (const [file, content] of updatedContents) {
-    fs28.writeFileSync(file, content, "utf8");
+    fs29.writeFileSync(file, content, "utf8");
     console.log(chalk173.cyan(`  Updated imports in ${path43.relative(cwd, file)}`));
   }
   const destDir = path43.dirname(destPath);
-  if (!fs28.existsSync(destDir)) fs28.mkdirSync(destDir, { recursive: true });
-  fs28.renameSync(sourcePath, destPath);
+  if (!fs29.existsSync(destDir)) fs29.mkdirSync(destDir, { recursive: true });
+  fs29.renameSync(sourcePath, destPath);
   console.log(
     chalk173.white(
       `  Moved ${path43.relative(cwd, sourcePath)} \u2192 ${path43.relative(cwd, destPath)}`
@@ -19252,11 +19366,11 @@ async function rename(source, destination, options2 = {}) {
   const cwd = process.cwd();
   const relSource = path46.relative(cwd, sourcePath);
   const relDest = path46.relative(cwd, destPath);
-  if (!fs29.existsSync(sourcePath)) {
+  if (!fs30.existsSync(sourcePath)) {
     console.log(chalk175.red(`File not found: ${source}`));
     process.exit(1);
   }
-  if (destPath !== sourcePath && fs29.existsSync(destPath)) {
+  if (destPath !== sourcePath && fs30.existsSync(destPath)) {
     console.log(chalk175.red(`Destination already exists: ${destination}`));
     process.exit(1);
   }
@@ -19481,27 +19595,27 @@ Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports r
 }
 
 // src/commands/refactor/restructure/executePlan.ts
-import fs30 from "fs";
+import fs31 from "fs";
 import path51 from "path";
 import chalk178 from "chalk";
 function executePlan(plan2) {
   const updatedContents = applyRewrites(plan2.rewrites);
   for (const [file, content] of updatedContents) {
-    fs30.writeFileSync(file, content, "utf8");
+    fs31.writeFileSync(file, content, "utf8");
     console.log(
       chalk178.cyan(`  Rewrote imports in ${path51.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan2.newDirectories) {
-    fs30.mkdirSync(dir, { recursive: true });
+    fs31.mkdirSync(dir, { recursive: true });
     console.log(chalk178.green(`  Created ${path51.relative(process.cwd(), dir)}/`));
   }
   for (const move2 of plan2.moves) {
     const targetDir = path51.dirname(move2.to);
-    if (!fs30.existsSync(targetDir)) {
-      fs30.mkdirSync(targetDir, { recursive: true });
+    if (!fs31.existsSync(targetDir)) {
+      fs31.mkdirSync(targetDir, { recursive: true });
     }
-    fs30.renameSync(move2.from, move2.to);
+    fs31.renameSync(move2.from, move2.to);
     console.log(
       chalk178.white(
         `  Moved ${path51.relative(process.cwd(), move2.from)} \u2192 ${path51.relative(process.cwd(), move2.to)}`
@@ -19513,10 +19627,10 @@ function executePlan(plan2) {
 function removeEmptyDirectories(dirs) {
   const unique = [...new Set(dirs)];
   for (const dir of unique) {
-    if (!fs30.existsSync(dir)) continue;
-    const entries = fs30.readdirSync(dir);
+    if (!fs31.existsSync(dir)) continue;
+    const entries = fs31.readdirSync(dir);
     if (entries.length === 0) {
-      fs30.rmdirSync(dir);
+      fs31.rmdirSync(dir);
       console.log(
         chalk178.dim(
           `  Removed empty directory ${path51.relative(process.cwd(), dir)}`
@@ -19530,18 +19644,18 @@ function removeEmptyDirectories(dirs) {
 import path53 from "path";
 
 // src/commands/refactor/restructure/planFileMoves/shared.ts
-import fs31 from "fs";
+import fs32 from "fs";
 function emptyResult() {
   return { moves: [], directories: [], warnings: [] };
 }
 function checkDirConflict(result, label2, dir) {
-  if (!fs31.existsSync(dir)) return false;
+  if (!fs32.existsSync(dir)) return false;
   result.warnings.push(`Skipping ${label2}: directory ${dir} already exists`);
   return true;
 }
 
 // src/commands/refactor/restructure/planFileMoves/planDirectoryMoves.ts
-import fs32 from "fs";
+import fs33 from "fs";
 import path52 from "path";
 function collectEntry(results, dir, entry) {
   const full = path52.join(dir, entry.name);
@@ -19549,9 +19663,9 @@ function collectEntry(results, dir, entry) {
   results.push(...items2);
 }
 function listFilesRecursive(dir) {
-  if (!fs32.existsSync(dir)) return [];
+  if (!fs33.existsSync(dir)) return [];
   const results = [];
-  for (const entry of fs32.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs33.readdirSync(dir, { withFileTypes: true })) {
     collectEntry(results, dir, entry);
   }
   return results;
@@ -24231,14 +24345,14 @@ function createAssistSession(id, assistArgs, cwd, meta) {
 import { randomUUID as randomUUID4 } from "crypto";
 
 // src/commands/sessions/daemon/readDesignSystemPrompt.ts
-import * as fs33 from "fs";
+import * as fs34 from "fs";
 import * as path56 from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 var __filename4 = fileURLToPath8(import.meta.url);
 var __dirname6 = path56.dirname(__filename4);
 function readDesignSystemPrompt() {
   const promptPath = path56.join(__dirname6, "..", "claude", "system-prompt.md");
-  return fs33.readFileSync(promptPath, "utf8");
+  return fs34.readFileSync(promptPath, "utf8");
 }
 
 // src/commands/sessions/daemon/spawnClaude.ts
@@ -24617,7 +24731,7 @@ async function recordWindowTokens(db, window, resetsAt, tokensUp, tokensDown) {
 }
 
 // src/commands/sessions/shared/transcriptUsage.ts
-import * as fs34 from "fs";
+import * as fs35 from "fs";
 function transcriptUsage(lines) {
   const byId = /* @__PURE__ */ new Map();
   for (const line of lines) {
@@ -24641,7 +24755,7 @@ function transcriptUsage(lines) {
   return [...byId.values()];
 }
 async function readTranscriptUsage(transcriptPath) {
-  const content = await fs34.promises.readFile(transcriptPath, "utf8");
+  const content = await fs35.promises.readFile(transcriptPath, "utf8");
   return transcriptUsage(content.split("\n"));
 }
 
@@ -26099,7 +26213,7 @@ import * as net3 from "net";
 import { createInterface as createInterface9 } from "readline";
 
 // src/commands/sessions/shared/parseTranscript.ts
-import * as fs35 from "fs";
+import * as fs36 from "fs";
 
 // src/commands/sessions/shared/toolTarget.ts
 function toolTarget(input) {
@@ -26151,7 +26265,7 @@ async function parseTranscript(sessionId) {
   const filePath = await findSessionJsonlPath(sessionId);
   if (!filePath) return [];
   try {
-    const raw = await fs35.promises.readFile(filePath, "utf8");
+    const raw = await fs36.promises.readFile(filePath, "utf8");
     return parseTranscriptLines(raw.split("\n"));
   } catch {
     return [];
@@ -26484,13 +26598,13 @@ import * as fs38 from "fs";
 import chalk196 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
-import * as fs36 from "fs";
+import * as fs37 from "fs";
 function writeSummary(jsonlPath2, summary) {
-  fs36.writeFileSync(summaryPathFor(jsonlPath2), `${summary.trim()}
+  fs37.writeFileSync(summaryPathFor(jsonlPath2), `${summary.trim()}
 `, "utf8");
 }
 function hasSummary(jsonlPath2) {
-  return fs36.existsSync(summaryPathFor(jsonlPath2));
+  return fs37.existsSync(summaryPathFor(jsonlPath2));
 }
 function summaryPathFor(jsonlPath2) {
   return jsonlPath2.replace(/\.jsonl$/, ".summary");
@@ -26499,56 +26613,6 @@ function summaryPathFor(jsonlPath2) {
 // src/commands/sessions/summarise/summariseSession.ts
 import { execFileSync as execFileSync12 } from "child_process";
 
-// src/commands/sessions/summarise/iterateUserMessages.ts
-import * as fs37 from "fs";
-
-// src/commands/sessions/summarise/parseUserLine.ts
-function parseUserLine(line) {
-  let entry;
-  try {
-    entry = JSON.parse(line);
-  } catch {
-    return void 0;
-  }
-  if (entry.type !== "user") return void 0;
-  const msg = entry.message;
-  const c = msg?.content;
-  let text17;
-  if (typeof c === "string") {
-    text17 = c;
-  } else if (Array.isArray(c)) {
-    const collected = c.filter((b) => b.type === "text").map((b) => b.text ?? "").join("\n");
-    text17 = collected || void 0;
-  }
-  if (!text17) return void 0;
-  return {
-    text: text17,
-    entrypoint: typeof entry.entrypoint === "string" ? entry.entrypoint : void 0
-  };
-}
-
-// src/commands/sessions/summarise/iterateUserMessages.ts
-function* iterateUserMessages(filePath, maxBytes = 65536) {
-  let content;
-  try {
-    const fd = fs37.openSync(filePath, "r");
-    try {
-      const buf = Buffer.alloc(maxBytes);
-      const bytesRead = fs37.readSync(fd, buf, 0, buf.length, 0);
-      content = buf.toString("utf8", 0, bytesRead);
-    } finally {
-      fs37.closeSync(fd);
-    }
-  } catch {
-    return;
-  }
-  for (const line of content.split("\n")) {
-    if (!line) continue;
-    const entry = parseUserLine(line);
-    if (entry) yield entry.text;
-  }
-}
-
 // src/commands/sessions/summarise/extractFirstUserMessage.ts
 function extractFirstUserMessage(filePath) {
   for (const text17 of iterateUserMessages(filePath)) {
@@ -26562,36 +26626,6 @@ function truncate3(text17, maxChars = 500) {
   return `${trimmed.slice(0, maxChars)}\u2026`;
 }
 
-// src/commands/sessions/summarise/scanSessionBacklogRefs.ts
-function scanSessionBacklogRefs(filePath) {
-  const ids = /* @__PURE__ */ new Set();
-  for (const text17 of iterateUserMessages(filePath, Number.MAX_SAFE_INTEGER)) {
-    for (const id of extractBacklogIds(text17)) {
-      ids.add(id);
-    }
-  }
-  return [...ids].sort((a, b) => a - b);
-}
-function extractBacklogIds(text17) {
-  const ids = [];
-  for (const m of text17.matchAll(/backlog\s+run\s+a(\d+)/gi)) {
-    ids.push(Number.parseInt(m[1], 10));
-  }
-  for (const m of text17.matchAll(/backlog\s+(?:item\s+)?a(\d+)/gi)) {
-    ids.push(Number.parseInt(m[1], 10));
-  }
-  for (const m of text17.matchAll(/backlog\s+phase-done\s+a(\d+)/gi)) {
-    ids.push(Number.parseInt(m[1], 10));
-  }
-  for (const m of text17.matchAll(/backlog\s+comment\s+a(\d+)/gi)) {
-    ids.push(Number.parseInt(m[1], 10));
-  }
-  for (const m of text17.matchAll(/(?:^|[\s(])a(\d{1,4})(?=[\s).,;:!?]|$)/gm)) {
-    ids.push(Number.parseInt(m[1], 10));
-  }
-  return ids;
-}
-
 // src/commands/sessions/summarise/summariseSession.ts
 function summariseSession(jsonlPath2) {
   const firstMessage = extractFirstUserMessage(jsonlPath2);