@staff0rd/assist 0.196.1 → 0.198.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.196.1",
+  version: "0.198.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -928,10 +928,10 @@ function writeSignal(event, data) {
 
 // src/commands/backlog/readSignal.ts
 function readSignal() {
-  const path52 = getSignalPath();
-  if (!existsSync5(path52)) return void 0;
+  const path53 = getSignalPath();
+  if (!existsSync5(path53)) return void 0;
   try {
-    return JSON.parse(readFileSync5(path52, "utf-8"));
+    return JSON.parse(readFileSync5(path53, "utf-8"));
   } catch {
     return void 0;
   }
@@ -1676,10 +1676,10 @@ import { stringify as stringifyYaml } from "yaml";
 // src/shared/loadRawYaml.ts
 import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
 import { parse as parseYaml2 } from "yaml";
-function loadRawYaml(path52) {
-  if (!existsSync8(path52)) return {};
+function loadRawYaml(path53) {
+  if (!existsSync8(path53)) return {};
   try {
-    const content = readFileSync7(path52, "utf-8");
+    const content = readFileSync7(path53, "utf-8");
     return parseYaml2(content) || {};
   } catch {
     return {};
@@ -1845,6 +1845,17 @@ function loadConfig() {
   const merged = { ...globalRaw, ...projectRaw };
   return assistConfigSchema.parse(merged);
 }
+function loadConfigFrom(startDir) {
+  const found = findConfigUp(startDir);
+  const configPath = found ?? join8(startDir, "assist.yml");
+  const globalRaw = loadRawYaml(getGlobalConfigPath());
+  const projectRaw = loadRawYaml(configPath);
+  const merged = { ...globalRaw, ...projectRaw };
+  return {
+    config: assistConfigSchema.parse(merged),
+    configDir: dirname2(configPath)
+  };
+}
 function loadProjectConfig() {
   return loadRawYaml(getConfigPath());
 }
@@ -2588,9 +2599,9 @@ function getSetupHandlers(hasVite, hasTypescript, hasOpenColor) {
 }
 
 // src/commands/verify/init/index.ts
-async function runSelectedSetups(selected, packageJsonPath, writer, handlers) {
+async function runSelectedSetups(selected, packageJsonPath, writer, handlers2) {
   for (const choice of selected) {
-    await handlers[choice]?.(packageJsonPath, writer);
+    await handlers2[choice]?.(packageJsonPath, writer);
   }
   console.log(chalk33.green(`
 Added ${selected.length} verify script(s):`));
@@ -2621,12 +2632,12 @@ async function init2() {
   const selected = await promptForScripts(getAvailableOptions(setup2));
   if (!selected) return;
   const writer = setup2.hasConfigScripts ? setupVerifyRunEntry : (name, cmd) => setupVerifyScript(packageJsonPath, name, cmd);
-  const handlers = getSetupHandlers(
+  const handlers2 = getSetupHandlers(
     setup2.hasVite,
     setup2.hasTypescript,
     setup2.hasOpenColor
   );
-  await runSelectedSetups(selected, packageJsonPath, writer, handlers);
+  await runSelectedSetups(selected, packageJsonPath, writer, handlers2);
 }
 
 // src/commands/vscode/init/index.ts
@@ -2746,14 +2757,14 @@ function applySelections(selected, setup2) {
   removeVscodeFromGitignore();
   ensureVscodeFolder();
   const launchType = setup2.hasVite ? "vite" : "tsup";
-  const handlers = {
+  const handlers2 = {
     launch: () => createLaunchJson(launchType),
     settings: () => {
       createSettingsJson();
       createExtensionsJson();
     }
   };
-  for (const choice of selected) handlers[choice]?.();
+  for (const choice of selected) handlers2[choice]?.();
 }
 async function promptForOptions(options2) {
   console.log(chalk35.bold("Available VS Code configurations to add:\n"));
@@ -5047,9 +5058,9 @@ var __dirname4 = dirname15(__filename2);
 function packageRoot() {
   return __dirname4;
 }
-function readLines(path52) {
-  if (!existsSync20(path52)) return [];
-  return readFileSync16(path52, "utf-8").split("\n").filter((line) => line.trim() !== "");
+function readLines(path53) {
+  if (!existsSync20(path53)) return [];
+  return readFileSync16(path53, "utf-8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
 var cachedWrites;
@@ -5494,14 +5505,14 @@ function showProgress(p, label2) {
   const pct = Math.round(p.done / p.total * 100);
   process.stderr.write(`\r\x1B[K[${pct}%] Scanning ${label2}...`);
 }
-async function resolveCommand(cli, path52, description, depth, p) {
-  showProgress(p, path52.join(" "));
-  const subHelp = await runHelp([cli, ...path52]);
+async function resolveCommand(cli, path53, description, depth, p) {
+  showProgress(p, path53.join(" "));
+  const subHelp = await runHelp([cli, ...path53]);
   if (!subHelp || !hasSubcommands(subHelp)) {
-    return [{ path: path52, description }];
+    return [{ path: path53, description }];
   }
-  const children = await discoverAt(cli, path52, depth + 1, p);
-  return children.length > 0 ? children : [{ path: path52, description }];
+  const children = await discoverAt(cli, path53, depth + 1, p);
+  return children.length > 0 ? children : [{ path: path53, description }];
 }
 async function discoverAt(cli, parentPath, depth, p) {
   if (depth > SAFETY_DEPTH) return [];
@@ -5649,9 +5660,9 @@ function logPath(cli) {
   return join20(homedir5(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
-  const path52 = logPath(cli);
-  if (!existsSync22(path52)) return void 0;
-  return readFileSync18(path52, "utf-8");
+  const path53 = logPath(cli);
+  if (!existsSync22(path53)) return void 0;
+  return readFileSync18(path53, "utf-8");
 }
 function writeCache(cli, output) {
   const dir = join20(homedir5(), ".assist");
@@ -6293,8 +6304,8 @@ function stepIntoNested(container, key, nextKey) {
   }
   return ensureObject(container, resolved);
 }
-function setNestedValue(obj, path52, value) {
-  const keys = path52.split(".");
+function setNestedValue(obj, path53, value) {
+  const keys = path53.split(".");
   const result = { ...obj };
   let current = result;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -6374,9 +6385,9 @@ function isTraversable(value) {
 function stepInto(current, key) {
   return isTraversable(current) ? current[key] : void 0;
 }
-function getNestedValue(obj, path52) {
+function getNestedValue(obj, path53) {
   let current = obj;
-  for (const key of path52.split(".")) current = stepInto(current, key);
+  for (const key of path53.split(".")) current = stepInto(current, key);
   return current;
 }
 
@@ -7717,10 +7728,10 @@ function getStorePath(filename) {
   return join27(getStoreDir(), filename);
 }
 function loadJson(filename) {
-  const path52 = getStorePath(filename);
-  if (existsSync29(path52)) {
+  const path53 = getStorePath(filename);
+  if (existsSync29(path53)) {
     try {
-      return JSON.parse(readFileSync25(path52, "utf-8"));
+      return JSON.parse(readFileSync25(path53, "utf-8"));
     } catch {
       return {};
     }
@@ -8167,7 +8178,7 @@ function validateLine(line) {
     process.exit(1);
   }
 }
-function comment2(path52, line, body) {
+function comment2(path53, line, body) {
   validateBody(body);
   validateLine(line);
   try {
@@ -8187,7 +8198,7 @@ function comment2(path52, line, body) {
           "-f",
           `body=${body}`,
           "-f",
-          `path=${path52}`,
+          `path=${path53}`,
           "-F",
           `line=${line}`
         ],
@@ -8196,7 +8207,7 @@ function comment2(path52, line, body) {
       if (result.status !== 0) {
         throw new Error(result.stderr || result.stdout);
       }
-      console.log(`Added review comment on ${path52}:${line}`);
+      console.log(`Added review comment on ${path53}:${line}`);
     } finally {
       unlinkSync6(queryFile);
     }
@@ -8695,8 +8706,8 @@ function registerPrs(program2) {
   prsCommand.command("wontfix <comment-id> <reason>").description("Reply with reason and resolve thread").action((commentId, reason) => {
     wontfix(Number.parseInt(commentId, 10), reason);
   });
-  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path52, line, body) => {
-    comment2(path52, Number.parseInt(line, 10), body);
+  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path53, line, body) => {
+    comment2(path53, Number.parseInt(line, 10), body);
   });
 }
 
@@ -8948,10 +8959,10 @@ function resolveOpSecret(reference) {
 }
 
 // src/commands/ravendb/ravenFetch.ts
-async function ravenFetch(connection, path52) {
+async function ravenFetch(connection, path53) {
   const apiKey = resolveOpSecret(connection.apiKeyRef);
   let accessToken = await getAccessToken(apiKey);
-  const url = `${connection.url}${path52}`;
+  const url = `${connection.url}${path53}`;
   const headers = {
     Authorization: `Bearer ${accessToken}`,
     "Content-Type": "application/json"
@@ -9041,16 +9052,16 @@ import chalk112 from "chalk";
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
   const db = encodeURIComponent(opts.db);
-  let path52;
+  let path53;
   if (opts.collection) {
-    path52 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
+    path53 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
   } else {
-    path52 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
+    path53 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
   }
   if (opts.query) {
-    path52 += `&query=${encodeURIComponent(opts.query)}`;
+    path53 += `&query=${encodeURIComponent(opts.query)}`;
   }
-  return path52;
+  return path53;
 }
 
 // src/commands/ravendb/fetchAllPages.ts
@@ -9059,7 +9070,7 @@ async function fetchAllPages(connection, opts) {
   let start3 = 0;
   while (true) {
     const effectivePageSize = opts.limit !== void 0 ? Math.min(opts.pageSize, opts.limit - allResults.length) : opts.pageSize;
-    const path52 = buildQueryPath({
+    const path53 = buildQueryPath({
       db: connection.database,
       collection: opts.collection,
       start: start3,
@@ -9067,7 +9078,7 @@ async function fetchAllPages(connection, opts) {
       sort: opts.sort,
       query: opts.query
     });
-    const data = await ravenFetch(connection, path52);
+    const data = await ravenFetch(connection, path53);
     const results = data.Results ?? [];
     const totalResults = data.TotalResults ?? 0;
     if (results.length === 0) break;
@@ -10238,8 +10249,8 @@ function findRootParent(file, importedBy, visited) {
 function clusterFiles(graph) {
   const clusters = /* @__PURE__ */ new Map();
   for (const file of graph.files) {
-    const basename9 = path39.basename(file, path39.extname(file));
-    if (basename9 === "index") continue;
+    const basename10 = path39.basename(file, path39.extname(file));
+    if (basename10 === "index") continue;
     const importers = graph.importedBy.get(file);
     if (!importers || importers.size !== 1) continue;
     const parent = [...importers][0];
@@ -10689,8 +10700,8 @@ import chalk129 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
 import chalk126 from "chalk";
-async function fetchSeq(conn, path52, params) {
-  const url = `${conn.url}${path52}?${params}`;
+async function fetchSeq(conn, path53, params) {
+  const url = `${conn.url}${path53}?${params}`;
   const response = await fetch(url, {
     headers: {
       Accept: "application/json",
@@ -12340,11 +12351,11 @@ function findLinkIndex() {
 function parseLinkArgs() {
   const idx = findLinkIndex();
   if (idx === -1) return null;
-  const path52 = process.argv[idx + 1];
+  const path53 = process.argv[idx + 1];
   const rest = process.argv.slice(idx + 2);
   const { value: prefix2 } = extractOption(rest, "--prefix");
   if (!prefix2) return null;
-  return { path: path52, prefix: prefix2 };
+  return { path: path53, prefix: prefix2 };
 }
 function hasDuplicateLink(runList, linkPath) {
   return runList.some(
@@ -12590,11 +12601,319 @@ function screenshot(processName) {
   }
 }
 
+// src/commands/sessions/summarise/index.ts
+import * as fs27 from "fs";
+import chalk134 from "chalk";
+
+// src/commands/sessions/web/discoverSessions.ts
+import * as fs24 from "fs";
+import * as os from "os";
+import * as path47 from "path";
+
+// src/commands/sessions/web/parseSessionFile.ts
+import * as fs23 from "fs";
+import * as path46 from "path";
+
+// src/commands/sessions/web/extractSessionMeta.ts
+function extractSessionMeta(lines) {
+  let sessionId = "";
+  let cwd = "";
+  let timestamp = "";
+  let name = "";
+  for (const line of lines) {
+    const entry = safeParse(line);
+    if (!entry) continue;
+    sessionId ||= typeof entry.sessionId === "string" ? entry.sessionId : "";
+    timestamp ||= typeof entry.timestamp === "string" ? entry.timestamp : "";
+    cwd ||= typeof entry.cwd === "string" ? entry.cwd : "";
+    if (entry.type === "user" && !entry.isMeta) {
+      name = extractName(entry);
+      break;
+    }
+  }
+  return { sessionId, cwd, timestamp, name };
+}
+function safeParse(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function extractName(entry) {
+  const msg = entry.message;
+  const content = msg?.content;
+  const text = typeof content === "string" ? content : Array.isArray(content) ? content.find((c) => c.type === "text")?.text ?? "" : "";
+  return text.replace(/<command-[^>]*>[^<]*<\/command-[^>]*>/g, "").trim().slice(0, 80);
+}
+
+// src/commands/sessions/web/parseSessionFile.ts
+async function parseSessionFile(filePath) {
+  let handle;
+  try {
+    handle = await fs23.promises.open(filePath, "r");
+    const buf = Buffer.alloc(16384);
+    const { bytesRead } = await handle.read(buf, 0, buf.length, 0);
+    const lines = buf.toString("utf8", 0, bytesRead).split("\n").filter(Boolean);
+    const meta = extractSessionMeta(lines);
+    if (!meta.sessionId) return null;
+    const timestamp = meta.timestamp || (await fs23.promises.stat(filePath)).mtime.toISOString();
+    const project = meta.cwd ? path46.basename(meta.cwd) : dirNameToProject(filePath);
+    return {
+      sessionId: meta.sessionId,
+      name: meta.name || `Session ${meta.sessionId.slice(0, 8)}`,
+      project,
+      cwd: meta.cwd,
+      timestamp
+    };
+  } catch {
+    return null;
+  } finally {
+    await handle?.close();
+  }
+}
+function dirNameToProject(filePath) {
+  const dirName = path46.basename(path46.dirname(filePath));
+  const parts = dirName.split("--");
+  return parts[parts.length - 1].replace(/-/g, "/");
+}
+
+// src/commands/sessions/web/discoverSessions.ts
+async function discoverSessionJsonlPaths() {
+  const projectsDir = path47.join(os.homedir(), ".claude", "projects");
+  let projectDirs;
+  try {
+    projectDirs = await fs24.promises.readdir(projectsDir);
+  } catch {
+    return [];
+  }
+  const paths = [];
+  await Promise.all(
+    projectDirs.map(async (dirName) => {
+      const dirPath = path47.join(projectsDir, dirName);
+      let entries;
+      try {
+        entries = await fs24.promises.readdir(dirPath);
+      } catch {
+        return;
+      }
+      const jsonlFiles = entries.filter((e) => e.endsWith(".jsonl"));
+      for (const file of jsonlFiles) {
+        paths.push(path47.join(dirPath, file));
+      }
+    })
+  );
+  return paths;
+}
+async function discoverSessions() {
+  const paths = await discoverSessionJsonlPaths();
+  const sessions = [];
+  await Promise.all(
+    paths.map(async (filePath) => {
+      const session = await parseSessionFile(filePath);
+      if (session) sessions.push(session);
+    })
+  );
+  sessions.sort(
+    (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+  );
+  return sessions;
+}
+
+// src/commands/sessions/summarise/shared.ts
+import * as fs25 from "fs";
+function writeSummary(jsonlPath, summary) {
+  fs25.writeFileSync(summaryPathFor(jsonlPath), `${summary.trim()}
+`, "utf8");
+}
+function hasSummary(jsonlPath) {
+  return fs25.existsSync(summaryPathFor(jsonlPath));
+}
+function summaryPathFor(jsonlPath) {
+  return jsonlPath.replace(/\.jsonl$/, ".summary");
+}
+
+// src/commands/sessions/summarise/summariseSession.ts
+import { execFileSync as execFileSync2 } from "child_process";
+
+// src/commands/sessions/summarise/iterateUserMessages.ts
+import * as fs26 from "fs";
+function* iterateUserMessages(filePath, maxBytes = 65536) {
+  let content;
+  try {
+    const fd = fs26.openSync(filePath, "r");
+    try {
+      const buf = Buffer.alloc(maxBytes);
+      const bytesRead = fs26.readSync(fd, buf, 0, buf.length, 0);
+      content = buf.toString("utf8", 0, bytesRead);
+    } finally {
+      fs26.closeSync(fd);
+    }
+  } catch {
+    return;
+  }
+  for (const line of content.split("\n")) {
+    if (!line) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (entry.type !== "user") continue;
+    const msg = entry.message;
+    const c = msg?.content;
+    if (typeof c === "string") {
+      yield c;
+    } else if (Array.isArray(c)) {
+      const text = c.filter((b) => b.type === "text").map((b) => b.text ?? "").join("\n");
+      if (text) yield text;
+    }
+  }
+}
+
+// src/commands/sessions/summarise/extractFirstUserMessage.ts
+function extractFirstUserMessage(filePath) {
+  for (const text of iterateUserMessages(filePath)) {
+    return truncate2(text);
+  }
+  return void 0;
+}
+function truncate2(text, maxChars = 500) {
+  const trimmed = text.trim();
+  if (trimmed.length <= maxChars) return trimmed;
+  return `${trimmed.slice(0, maxChars)}\u2026`;
+}
+
+// src/commands/sessions/summarise/scanSessionBacklogRefs.ts
+function scanSessionBacklogRefs(filePath) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const text of iterateUserMessages(filePath, Number.MAX_SAFE_INTEGER)) {
+    for (const id of extractBacklogIds(text)) {
+      ids.add(id);
+    }
+  }
+  return [...ids].sort((a, b) => a - b);
+}
+function extractBacklogIds(text) {
+  const ids = [];
+  for (const m of text.matchAll(/backlog\s+run\s+(\d+)/gi)) {
+    ids.push(Number.parseInt(m[1], 10));
+  }
+  for (const m of text.matchAll(/backlog\s+(?:item\s+)?#(\d+)/gi)) {
+    ids.push(Number.parseInt(m[1], 10));
+  }
+  for (const m of text.matchAll(/backlog\s+phase-done\s+(\d+)/gi)) {
+    ids.push(Number.parseInt(m[1], 10));
+  }
+  for (const m of text.matchAll(/backlog\s+comment\s+(\d+)/gi)) {
+    ids.push(Number.parseInt(m[1], 10));
+  }
+  for (const m of text.matchAll(/(?:^|[\s(])#(\d{1,4})(?=[\s).,;:!?]|$)/gm)) {
+    ids.push(Number.parseInt(m[1], 10));
+  }
+  return ids;
+}
+
+// src/commands/sessions/summarise/summariseSession.ts
+function summariseSession(jsonlPath) {
+  const firstMessage = extractFirstUserMessage(jsonlPath);
+  const backlogIds = scanSessionBacklogRefs(jsonlPath);
+  if (!firstMessage && backlogIds.length === 0) {
+    return void 0;
+  }
+  const prompt = buildPrompt2(firstMessage, backlogIds);
+  try {
+    const output = execFileSync2("claude", ["-p", "--model", "haiku", prompt], {
+      encoding: "utf8",
+      timeout: 3e4,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const summary = output.trim();
+    if (!summary) return void 0;
+    return summary.split("\n")[0].replace(/^["']|["']$/g, "").trim();
+  } catch {
+    return void 0;
+  }
+}
+function buildPrompt2(firstMessage, backlogIds) {
+  const parts = [
+    "Summarise this Claude Code session in ONE short sentence (under 100 chars).",
+    "Return ONLY the summary, no quotes or explanation."
+  ];
+  if (backlogIds.length > 0) {
+    const refs = backlogIds.map((id) => `#${id}`).join(", ");
+    parts.push(
+      `The session references backlog item(s) ${refs}. Start the summary with "Backlog ${refs} \u2014" if relevant.`
+    );
+  }
+  if (firstMessage) {
+    parts.push(`First user message:
+${firstMessage}`);
+  }
+  return parts.join("\n");
+}
+
+// src/commands/sessions/summarise/index.ts
+async function summarise3(options2) {
+  const files = await discoverSessionJsonlPaths();
+  if (files.length === 0) {
+    console.log(chalk134.yellow("No sessions found."));
+    return;
+  }
+  const toProcess = selectCandidates(files, options2);
+  if (toProcess.length === 0) {
+    console.log(chalk134.green("All sessions already summarised."));
+    return;
+  }
+  console.log(
+    chalk134.cyan(
+      `Summarising ${toProcess.length} session(s) (${files.length} total)\u2026`
+    )
+  );
+  const { succeeded, failed } = processSessions(toProcess);
+  console.log(
+    chalk134.green(`Done: ${succeeded} summarised`) + (failed > 0 ? chalk134.yellow(`, ${failed} skipped`) : "")
+  );
+}
+function selectCandidates(files, options2) {
+  const candidates = options2.force ? files : files.filter((f) => !hasSummary(f));
+  candidates.sort((a, b) => {
+    try {
+      return fs27.statSync(b).mtimeMs - fs27.statSync(a).mtimeMs;
+    } catch {
+      return 0;
+    }
+  });
+  const limit = options2.limit ? Number.parseInt(options2.limit, 10) : void 0;
+  return limit && limit > 0 ? candidates.slice(0, limit) : candidates;
+}
+function processSessions(files) {
+  let succeeded = 0;
+  let failed = 0;
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    process.stdout.write(chalk134.dim(`  [${i + 1}/${files.length}] `));
+    const summary = summariseSession(file);
+    if (summary) {
+      writeSummary(file, summary);
+      succeeded++;
+      process.stdout.write(`${chalk134.green("\u2713")} ${summary}
+`);
+    } else {
+      failed++;
+      process.stdout.write(` ${chalk134.yellow("skip")}
+`);
+    }
+  }
+  return { succeeded, failed };
+}
+
 // src/commands/sessions/web/index.ts
 import { WebSocketServer } from "ws";
 
 // src/commands/sessions/web/handleRequest.ts
-import { readFileSync as readFileSync34 } from "fs";
+import { readFileSync as readFileSync35 } from "fs";
 import { createRequire as createRequire2 } from "module";
 
 // src/commands/sessions/web/getHtml.ts
@@ -12629,7 +12948,7 @@ function createCssHandler(packageEntry) {
   return (_req, res) => {
     if (!cache) {
       const resolved = require3.resolve(packageEntry);
-      cache = readFileSync34(resolved, "utf-8");
+      cache = readFileSync35(resolved, "utf-8");
     }
     res.writeHead(200, { "Content-Type": "text/css" });
     res.end(cache);
@@ -12646,46 +12965,79 @@ var routes3 = {
 };
 var handleRequest3 = createFallbackHandler(routes3, htmlHandler2);
 
-// src/commands/sessions/web/handleSocket.ts
-function dispatch(ws, manager, data) {
-  switch (data.type) {
-    case "create": {
-      const id = manager.spawn(
-        data.prompt,
-        data.cwd
-      );
-      ws.send(JSON.stringify({ type: "created", sessionId: id }));
-      break;
-    }
-    case "input":
-      manager.writeToSession(data.sessionId, data.data);
-      break;
-    case "resize":
-      manager.resizeSession(
-        data.sessionId,
-        data.cols,
-        data.rows
-      );
-      break;
-    case "resume": {
-      const id = manager.resume(
-        data.sessionId,
-        data.cwd,
-        data.name
-      );
-      ws.send(JSON.stringify({ type: "created", sessionId: id }));
-      break;
-    }
-    case "dismiss":
-      manager.dismissSession(data.sessionId);
-      break;
-    case "history":
-      manager.getHistory().then((history) => {
-        ws.send(JSON.stringify({ type: "history", sessions: history }));
-      });
-      break;
+// src/commands/sessions/web/handleRunConfigs.ts
+function handleRunConfigs(ws, cwd) {
+  try {
+    const { config, configDir } = loadConfigFrom(cwd);
+    const configs = resolveRunConfigs(config.run, configDir);
+    ws.send(
+      JSON.stringify({
+        type: "run-configs",
+        configs: configs.map(({ name, params }) => ({ name, params }))
+      })
+    );
+  } catch {
+    ws.send(JSON.stringify({ type: "run-configs", configs: [] }));
   }
 }
+
+// src/commands/sessions/web/dispatchMessage.ts
+function sendCreated(ws, id) {
+  ws.send(JSON.stringify({ type: "created", sessionId: id }));
+}
+function handleCreate(ws, manager, data) {
+  sendCreated(
+    ws,
+    manager.spawn(
+      data.prompt,
+      data.cwd
+    )
+  );
+}
+function handleCreateRun(ws, manager, data) {
+  sendCreated(
+    ws,
+    manager.spawnRun(
+      data.runName,
+      data.runArgs ?? [],
+      data.cwd
+    )
+  );
+}
+function handleResume(ws, manager, data) {
+  sendCreated(
+    ws,
+    manager.resume(
+      data.sessionId,
+      data.cwd,
+      data.name
+    )
+  );
+}
+function runConfigs(ws, _manager, data) {
+  handleRunConfigs(ws, data.cwd);
+}
+function handleHistory(ws, manager) {
+  manager.getHistory().then((history) => {
+    ws.send(JSON.stringify({ type: "history", sessions: history }));
+  });
+}
+var handlers = {
+  create: handleCreate,
+  "create-run": handleCreateRun,
+  resume: handleResume,
+  "run-configs": runConfigs,
+  history: handleHistory,
+  input: (_ws, m, d) => m.writeToSession(d.sessionId, d.data),
+  resize: (_ws, m, d) => m.resizeSession(d.sessionId, d.cols, d.rows),
+  retry: (_ws, m, d) => m.retrySession(d.sessionId),
+  dismiss: (_ws, m, d) => m.dismissSession(d.sessionId)
+};
+function dispatchMessage(ws, manager, data) {
+  handlers[data.type]?.(ws, manager, data);
+}
+
+// src/commands/sessions/web/handleSocket.ts
 function handleSocket(ws, manager) {
   manager.addClient(ws);
   ws.on("message", (msg) => {
@@ -12695,42 +13047,58 @@ function handleSocket(ws, manager) {
     } catch {
       return;
     }
-    dispatch(ws, manager, data);
+    dispatchMessage(ws, manager, data);
   });
   ws.on("close", () => {
     manager.removeClient(ws);
   });
 }
 
-// src/commands/sessions/web/spawnClaude.ts
+// src/commands/sessions/web/repoPrefix.ts
+import * as path48 from "path";
+function repoPrefix(cwd) {
+  if (!cwd) return "";
+  return `${path48.basename(cwd)}/`;
+}
+
+// src/commands/sessions/web/spawnPty.ts
 import * as pty from "node-pty";
-function spawnClaude2(opts = {}) {
+function spawnPty(args, cwd) {
   const shell = process.platform === "win32" ? "cmd.exe" : process.env.SHELL ?? "bash";
-  const args = buildArgs(opts);
-  return pty.spawn(shell, args, {
+  const shellArgs = process.platform === "win32" ? ["/c", ...args] : ["-c", `exec ${args.map(shellEscape).join(" ")}`];
+  return pty.spawn(shell, shellArgs, {
     name: "xterm-256color",
     cols: 120,
     rows: 30,
-    cwd: opts.cwd ?? process.cwd(),
+    cwd: cwd ?? process.cwd(),
     env: { ...process.env }
   });
 }
-function buildArgs(opts) {
-  const claudeArgs = opts.resumeSessionId ? ["claude", "--resume", opts.resumeSessionId] : opts.prompt ? ["claude", opts.prompt] : ["claude"];
-  if (process.platform === "win32") {
-    return ["/c", ...claudeArgs];
-  }
-  return ["-c", `exec ${claudeArgs.map(shellEscape).join(" ")}`];
-}
 function shellEscape(s) {
   return `'${s.replace(/'/g, "'\\''")}'`;
 }
 
+// src/commands/sessions/web/spawnClaude.ts
+function spawnClaude2(opts = {}) {
+  return spawnPty(buildArgs(opts), opts.cwd);
+}
+function buildArgs(opts) {
+  if (opts.resumeSessionId) return ["claude", "--resume", opts.resumeSessionId];
+  if (opts.prompt) return ["claude", opts.prompt];
+  return ["claude"];
+}
+
+// src/commands/sessions/web/spawnRun.ts
+function spawnRun(opts) {
+  return spawnPty(["assist", "run", opts.name, ...opts.args ?? []], opts.cwd);
+}
+
 // src/commands/sessions/web/createSession.ts
 function createSession(id, prompt, cwd) {
   return {
     id,
-    name: prompt?.slice(0, 40) || `Session ${id}`,
+    name: `${repoPrefix(cwd)}${prompt?.slice(0, 40) || `Session ${id}`}`,
+    commandType: "claude",
     status: "running",
     startedAt: Date.now(),
     pty: spawnClaude2({ prompt, cwd }),
@@ -12739,10 +13107,27 @@ function createSession(id, prompt, cwd) {
     lastResizeAt: 0
   };
 }
+function createRunSession(id, runName, runArgs, cwd) {
+  return {
+    id,
+    name: `${repoPrefix(cwd)}run: ${runName}`,
+    commandType: "run",
+    status: "running",
+    startedAt: Date.now(),
+    pty: spawnRun({ name: runName, args: runArgs, cwd }),
+    scrollback: "",
+    idleTimer: null,
+    lastResizeAt: 0,
+    runName,
+    runArgs,
+    cwd
+  };
+}
 function resumeSession(id, sessionId, cwd, name) {
   return {
     id,
-    name: name ? `${name.slice(0, 36)} (R)` : `Resume ${sessionId.slice(0, 8)}`,
+    name: `${repoPrefix(cwd)}${name ? `${name.slice(0, 36)} (R)` : `Resume ${sessionId.slice(0, 8)}`}`,
+    commandType: "claude",
     status: "running",
     startedAt: Date.now(),
     pty: spawnClaude2({ resumeSessionId: sessionId, cwd }),
@@ -12752,112 +13137,23 @@ function resumeSession(id, sessionId, cwd, name) {
   };
 }
 
-// src/commands/sessions/web/discoverSessions.ts
-import * as fs24 from "fs";
-import * as os from "os";
-import * as path47 from "path";
-
-// src/commands/sessions/web/parseSessionFile.ts
-import * as fs23 from "fs";
-import * as path46 from "path";
-
-// src/commands/sessions/web/extractSessionMeta.ts
-function extractSessionMeta(lines) {
-  let sessionId = "";
-  let cwd = "";
-  let timestamp = "";
-  let name = "";
-  for (const line of lines) {
-    const entry = safeParse(line);
-    if (!entry) continue;
-    sessionId ||= typeof entry.sessionId === "string" ? entry.sessionId : "";
-    timestamp ||= typeof entry.timestamp === "string" ? entry.timestamp : "";
-    cwd ||= typeof entry.cwd === "string" ? entry.cwd : "";
-    if (entry.type === "user" && !entry.isMeta) {
-      name = extractName(entry);
-      break;
-    }
-  }
-  return { sessionId, cwd, timestamp, name };
-}
-function safeParse(line) {
-  try {
-    return JSON.parse(line);
-  } catch {
-    return null;
-  }
-}
-function extractName(entry) {
-  const msg = entry.message;
-  const content = msg?.content;
-  const text = typeof content === "string" ? content : Array.isArray(content) ? content.find((c) => c.type === "text")?.text ?? "" : "";
-  return text.replace(/<command-[^>]*>[^<]*<\/command-[^>]*>/g, "").trim().slice(0, 80);
+// src/commands/sessions/web/wsBroadcast.ts
+function wsSend(ws, msg) {
+  if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(msg));
 }
-
-// src/commands/sessions/web/parseSessionFile.ts
-async function parseSessionFile(filePath) {
-  let handle;
-  try {
-    handle = await fs23.promises.open(filePath, "r");
-    const buf = Buffer.alloc(16384);
-    const { bytesRead } = await handle.read(buf, 0, buf.length, 0);
-    const lines = buf.toString("utf8", 0, bytesRead).split("\n").filter(Boolean);
-    const meta = extractSessionMeta(lines);
-    if (!meta.sessionId) return null;
-    const timestamp = meta.timestamp || (await fs23.promises.stat(filePath)).mtime.toISOString();
-    const project = meta.cwd ? path46.basename(meta.cwd) : dirNameToProject(filePath);
-    return {
-      sessionId: meta.sessionId,
-      name: meta.name || `Session ${meta.sessionId.slice(0, 8)}`,
-      project,
-      cwd: meta.cwd,
-      timestamp
-    };
-  } catch {
-    return null;
-  } finally {
-    await handle?.close();
+function wsBroadcast(clients, msg) {
+  const json = JSON.stringify(msg);
+  for (const ws of clients) {
+    if (ws.readyState === ws.OPEN) ws.send(json);
   }
 }
-function dirNameToProject(filePath) {
-  const dirName = path46.basename(path46.dirname(filePath));
-  const parts = dirName.split("--");
-  return parts[parts.length - 1].replace(/-/g, "/");
-}
 
-// src/commands/sessions/web/discoverSessions.ts
-async function discoverSessions() {
-  const projectsDir = path47.join(os.homedir(), ".claude", "projects");
-  let projectDirs;
-  try {
-    projectDirs = await fs24.promises.readdir(projectsDir);
-  } catch {
-    return [];
+// src/commands/sessions/web/replayScrollback.ts
+function replayScrollback(sessions, ws) {
+  for (const s of sessions.values()) {
+    if (s.scrollback)
+      wsSend(ws, { type: "output", sessionId: s.id, data: s.scrollback });
   }
-  const sessions = [];
-  await Promise.all(
-    projectDirs.map(async (dirName) => {
-      const dirPath = path47.join(projectsDir, dirName);
-      let entries;
-      try {
-        entries = await fs24.promises.readdir(dirPath);
-      } catch {
-        return;
-      }
-      const jsonlFiles = entries.filter((e) => e.endsWith(".jsonl"));
-      await Promise.all(
-        jsonlFiles.map(async (file) => {
-          const filePath = path47.join(dirPath, file);
-          const session = await parseSessionFile(filePath);
-          if (session) sessions.push(session);
-        })
-      );
-    })
-  );
-  sessions.sort(
-    (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
-  );
-  return sessions;
 }
 
 // src/commands/sessions/web/scheduleIdle.ts
@@ -12873,17 +13169,6 @@ function clearIdle(session) {
   if (session.idleTimer) clearTimeout(session.idleTimer);
 }
 
-// src/commands/sessions/web/wsBroadcast.ts
-function wsSend(ws, msg) {
-  if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(msg));
-}
-function wsBroadcast(clients, msg) {
-  const json = JSON.stringify(msg);
-  for (const ws of clients) {
-    if (ws.readyState === ws.OPEN) ws.send(json);
-  }
-}
-
 // src/commands/sessions/web/wirePtyEvents.ts
 var MAX_SCROLLBACK = 256 * 1024;
 var RESIZE_GRACE_MS = 500;
@@ -12909,6 +13194,39 @@ function wirePtyEvents(session, clients, onStatusChange) {
   });
 }
 
+// src/commands/sessions/web/retrySession.ts
+function retrySession(session, clients, onStatusChange) {
+  if (session.commandType !== "run" || !session.runName) return false;
+  if (session.status !== "done") session.pty.kill();
+  clearIdle(session);
+  session.scrollback = "";
+  session.status = "running";
+  session.startedAt = Date.now();
+  session.pty = spawnRun({
+    name: session.runName,
+    args: session.runArgs,
+    cwd: session.cwd
+  });
+  wsBroadcast(clients, { type: "clear", sessionId: session.id });
+  wirePtyEvents(session, clients, onStatusChange);
+  scheduleIdle(session, () => onStatusChange(session, "waiting"));
+  return true;
+}
+
+// src/commands/sessions/web/toSessionInfo.ts
+function toSessionInfo({
+  id,
+  name,
+  commandType,
+  status: status2,
+  startedAt,
+  runName,
+  runArgs,
+  cwd
+}) {
+  return { id, name, commandType, status: status2, startedAt, runName, runArgs, cwd };
+}
+
 // src/commands/sessions/web/writeToSession.ts
 function writeToSession(sessions, id, data) {
   const s = sessions.get(id);
@@ -12947,39 +13265,34 @@ var SessionManager = class {
       cwd: this.repoCwd,
       sessions: this.listSessions()
     });
-    this.replayScrollback(ws);
-  }
-  replayScrollback(ws) {
-    for (const s of this.sessions.values()) {
-      if (s.scrollback)
-        wsSend(ws, { type: "output", sessionId: s.id, data: s.scrollback });
-    }
+    replayScrollback(this.sessions, ws);
   }
   removeClient(ws) {
     this.clients.delete(ws);
   }
-  spawn(prompt, cwd) {
-    const id = String(this.nextId++);
-    const session = createSession(id, prompt, cwd);
+  add(session) {
     this.wire(session);
-    return id;
+    return session.id;
+  }
+  spawn(prompt, cwd) {
+    return this.add(createSession(String(this.nextId++), prompt, cwd));
+  }
+  spawnRun(runName, runArgs, cwd) {
+    return this.add(
+      createRunSession(String(this.nextId++), runName, runArgs, cwd)
+    );
   }
   resume(sessionId, cwd, name) {
-    const id = String(this.nextId++);
-    const session = resumeSession(id, sessionId, cwd, name);
-    this.wire(session);
-    return id;
+    return this.add(resumeSession(String(this.nextId++), sessionId, cwd, name));
   }
+  onStatusChange = (s, status2) => {
+    s.status = status2;
+    this.notify();
+  };
   wire(session) {
     this.sessions.set(session.id, session);
-    wirePtyEvents(session, this.clients, (s, status2) => {
-      s.status = status2;
-      this.notify();
-    });
-    scheduleIdle(session, () => {
-      session.status = "waiting";
-      this.notify();
-    });
+    wirePtyEvents(session, this.clients, this.onStatusChange);
+    scheduleIdle(session, () => this.onStatusChange(session, "waiting"));
     this.notify();
   }
   writeToSession(id, data) {
@@ -12988,18 +13301,15 @@ var SessionManager = class {
   resizeSession(id, cols, rows) {
     resizeSession(this.sessions, id, cols, rows);
   }
+  retrySession(id) {
+    const s = this.sessions.get(id);
+    if (s && retrySession(s, this.clients, this.onStatusChange)) this.notify();
+  }
   dismissSession(id) {
     if (dismissSession(this.sessions, id)) this.notify();
   }
   listSessions() {
-    return [...this.sessions.values()].map(
-      ({ id, name, status: status2, startedAt }) => ({
-        id,
-        name,
-        status: status2,
-        startedAt
-      })
-    );
+    return [...this.sessions.values()].map(toSessionInfo);
   }
   async getHistory() {
     return discoverSessions();
@@ -13033,13 +13343,14 @@ async function web3(options2) {
 function registerSessions(program2) {
   const cmd = program2.command("sessions").description("Web dashboard for Claude Code sessions").action(() => web3({ port: "3100" }));
   cmd.command("web").description("Start the sessions web dashboard").option("-p, --port <number>", "Port to listen on", "3100").action(web3);
+  cmd.command("summarise").description("Generate one-line summaries for Claude sessions").option("-f, --force", "Re-generate all summaries, even existing ones").option("-n, --limit <count>", "Maximum number of sessions to summarise").action(summarise3);
 }
 
 // src/commands/statusLine.ts
-import chalk135 from "chalk";
+import chalk136 from "chalk";
 
 // src/commands/buildLimitsSegment.ts
-import chalk134 from "chalk";
+import chalk135 from "chalk";
 var FIVE_HOUR_SECONDS = 5 * 3600;
 var SEVEN_DAY_SECONDS = 7 * 86400;
 function formatTimeLeft(resetsAt) {
@@ -13062,10 +13373,10 @@ function projectUsage(pct, resetsAt, windowSeconds) {
 function colorizeRateLimit(pct, resetsAt, windowSeconds) {
   const label2 = `${Math.round(pct)}%`;
   const projected = projectUsage(pct, resetsAt, windowSeconds);
-  if (projected == null) return chalk134.green(label2);
-  if (projected > 100) return chalk134.red(label2);
-  if (projected > 75) return chalk134.yellow(label2);
-  return chalk134.green(label2);
+  if (projected == null) return chalk135.green(label2);
+  if (projected > 100) return chalk135.red(label2);
+  if (projected > 75) return chalk135.yellow(label2);
+  return chalk135.green(label2);
 }
 function formatLimit(pct, resetsAt, windowSeconds, fallbackLabel) {
   const timeLabel = resetsAt ? formatTimeLeft(resetsAt) : fallbackLabel;
@@ -13091,14 +13402,14 @@ function buildLimitsSegment(rateLimits) {
 }
 
 // src/commands/statusLine.ts
-chalk135.level = 3;
+chalk136.level = 3;
 function formatNumber(num) {
   return num.toLocaleString("en-US");
 }
 function colorizePercent(pct) {
   const label2 = `${Math.round(pct)}%`;
-  if (pct > 80) return chalk135.red(label2);
-  if (pct > 40) return chalk135.yellow(label2);
+  if (pct > 80) return chalk136.red(label2);
+  if (pct > 40) return chalk136.yellow(label2);
   return label2;
 }
 async function statusLine() {
@@ -13113,29 +13424,29 @@ async function statusLine() {
 }
 
 // src/commands/sync.ts
-import * as fs27 from "fs";
+import * as fs30 from "fs";
 import * as os2 from "os";
-import * as path50 from "path";
+import * as path51 from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 
 // src/commands/sync/syncClaudeMd.ts
-import * as fs25 from "fs";
-import * as path48 from "path";
-import chalk136 from "chalk";
+import * as fs28 from "fs";
+import * as path49 from "path";
+import chalk137 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
-  const source = path48.join(claudeDir, "CLAUDE.md");
-  const target = path48.join(targetBase, "CLAUDE.md");
-  const sourceContent = fs25.readFileSync(source, "utf-8");
-  if (fs25.existsSync(target)) {
-    const targetContent = fs25.readFileSync(target, "utf-8");
+  const source = path49.join(claudeDir, "CLAUDE.md");
+  const target = path49.join(targetBase, "CLAUDE.md");
+  const sourceContent = fs28.readFileSync(source, "utf-8");
+  if (fs28.existsSync(target)) {
+    const targetContent = fs28.readFileSync(target, "utf-8");
     if (sourceContent !== targetContent) {
       console.log(
-        chalk136.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
+        chalk137.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
       );
       console.log();
       printDiff(targetContent, sourceContent);
       const confirm = options2?.yes || await promptConfirm(
-        chalk136.red("Overwrite existing CLAUDE.md?"),
+        chalk137.red("Overwrite existing CLAUDE.md?"),
         false
       );
       if (!confirm) {
@@ -13144,21 +13455,21 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs25.copyFileSync(source, target);
+  fs28.copyFileSync(source, target);
   console.log("Copied CLAUDE.md to ~/.claude/CLAUDE.md");
 }
 
 // src/commands/sync/syncSettings.ts
-import * as fs26 from "fs";
-import * as path49 from "path";
-import chalk137 from "chalk";
+import * as fs29 from "fs";
+import * as path50 from "path";
+import chalk138 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
-  const source = path49.join(claudeDir, "settings.json");
-  const target = path49.join(targetBase, "settings.json");
-  const sourceContent = fs26.readFileSync(source, "utf-8");
+  const source = path50.join(claudeDir, "settings.json");
+  const target = path50.join(targetBase, "settings.json");
+  const sourceContent = fs29.readFileSync(source, "utf-8");
   const mergedContent = JSON.stringify(JSON.parse(sourceContent), null, "	");
-  if (fs26.existsSync(target)) {
-    const targetContent = fs26.readFileSync(target, "utf-8");
+  if (fs29.existsSync(target)) {
+    const targetContent = fs29.readFileSync(target, "utf-8");
     const normalizedTarget = JSON.stringify(
       JSON.parse(targetContent),
       null,
@@ -13167,14 +13478,14 @@ async function syncSettings(claudeDir, targetBase, options2) {
     if (mergedContent !== normalizedTarget) {
       if (!options2?.yes) {
         console.log(
-          chalk137.yellow(
+          chalk138.yellow(
             "\n\u26A0\uFE0F  Warning: settings.json differs from existing file"
           )
         );
         console.log();
         printDiff(targetContent, mergedContent);
         const confirm = await promptConfirm(
-          chalk137.red("Overwrite existing settings.json?"),
+          chalk138.red("Overwrite existing settings.json?"),
           false
         );
         if (!confirm) {
@@ -13184,29 +13495,29 @@ async function syncSettings(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs26.writeFileSync(target, mergedContent);
+  fs29.writeFileSync(target, mergedContent);
   console.log("Copied settings.json to ~/.claude/settings.json");
 }
 
 // src/commands/sync.ts
 var __filename4 = fileURLToPath7(import.meta.url);
-var __dirname7 = path50.dirname(__filename4);
+var __dirname7 = path51.dirname(__filename4);
 async function sync(options2) {
   const config = loadConfig();
   const yes = options2?.yes ?? config.sync.autoConfirm;
-  const claudeDir = path50.join(__dirname7, "..", "claude");
-  const targetBase = path50.join(os2.homedir(), ".claude");
+  const claudeDir = path51.join(__dirname7, "..", "claude");
+  const targetBase = path51.join(os2.homedir(), ".claude");
   syncCommands(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase, { yes });
   await syncClaudeMd(claudeDir, targetBase, { yes });
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path50.join(claudeDir, "commands");
-  const targetDir = path50.join(targetBase, "commands");
-  fs27.mkdirSync(targetDir, { recursive: true });
-  const files = fs27.readdirSync(sourceDir);
+  const sourceDir = path51.join(claudeDir, "commands");
+  const targetDir = path51.join(targetBase, "commands");
+  fs30.mkdirSync(targetDir, { recursive: true });
+  const files = fs30.readdirSync(sourceDir);
   for (const file of files) {
-    fs27.copyFileSync(path50.join(sourceDir, file), path50.join(targetDir, file));
+    fs30.copyFileSync(path51.join(sourceDir, file), path51.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
@@ -13214,15 +13525,15 @@ function syncCommands(claudeDir, targetBase) {
 
 // src/commands/update.ts
 import { execSync as execSync42 } from "child_process";
-import * as path51 from "path";
+import * as path52 from "path";
 function isGlobalNpmInstall(dir) {
   try {
-    const resolved = path51.resolve(dir);
-    if (resolved.split(path51.sep).includes("node_modules")) {
+    const resolved = path52.resolve(dir);
+    if (resolved.split(path52.sep).includes("node_modules")) {
       return true;
     }
     const globalPrefix = execSync42("npm prefix -g", { stdio: "pipe" }).toString().trim();
-    return resolved.toLowerCase().startsWith(path51.resolve(globalPrefix).toLowerCase());
+    return resolved.toLowerCase().startsWith(path52.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
   }