@lazyingart/agintiflow 0.20.43 → 0.20.44

package/README.md

@@ -138,6 +138,8 @@ aginti update
 aginti sessions list
 aginti sessions show <session-id>
 aginti sessions rename <session-id> "friendly title"
+aginti --remove-empty-sessions
+aginti --remove-sessions
 aginti storage migrate
 aginti resume
 aginti resume --all-sessions
@@ -151,6 +153,8 @@ aginti "set up this project and run the tests"
 
 Bare `aginti resume` lists sessions for the current cwd by default. Use `--all-sessions` to browse the global session index; in the interactive selector, type a number to resume, `q` to quit, `/text` to filter the visible list, or `/` to clear the filter.
 
+Session cleanup is cwd-scoped by default. `aginti --remove-empty-sessions` shows only empty sessions and preselects them; `aginti --remove-sessions` shows all cwd sessions with nothing preselected. The cleanup selector uses Space to select, Up/Down to move, Tab to switch to OK/Cancel, and a second Yes/Cancel confirmation before deleting the project pointer and central `~/.agintiflow/sessions/<session-id>` data.
+
 Run from a source checkout:
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.43",
+  "version": "0.20.44",
   "type": "module",
   "description": "AgInTiFlow is a web-first coding agent and CLI with DeepSeek routing, sandboxed tools, model providers, canvas artifacts, and optional wrappers.",
   "license": "Apache-2.0",

package/scripts/smoke-inbox.js

@@ -2,7 +2,13 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { ensureProjectSessionStorage, listProjectSessions, sessionStoreOptions } from "../src/project.js";
+import {
+  ensureProjectSessionStorage,
+  listProjectSessionRemovalCandidates,
+  listProjectSessions,
+  removeProjectSessions,
+  sessionStoreOptions,
+} from "../src/project.js";
 import { SessionStore } from "../src/session-store.js";
 
 const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "agintiflow-inbox-"));
@@ -77,6 +83,48 @@ try {
   const allSessions = await listProjectSessions(legacyProject, { limit: 10, allSessions: true });
   assert(allSessions.some((session) => session.sessionId === "other-cwd-smoke"), "--all-sessions mode did not include a different cwd session");
 
+  const emptyStore = new SessionStore(paths.globalSessionsDir, "empty-session-smoke", sessionStoreOptions(legacyProject, "empty-session-smoke"));
+  await emptyStore.saveState({
+    sessionId: "empty-session-smoke",
+    createdAt: "2026-01-01T00:04:00.000Z",
+    updatedAt: "2026-01-01T00:04:00.000Z",
+    provider: "mock",
+    model: "mock-agent",
+    projectRoot: legacyProject,
+    commandCwd: legacyProject,
+    chat: [],
+    stepsCompleted: 0,
+  });
+  const nonEmptyStore = new SessionStore(paths.globalSessionsDir, "nonempty-session-smoke", sessionStoreOptions(legacyProject, "nonempty-session-smoke"));
+  await nonEmptyStore.saveState({
+    sessionId: "nonempty-session-smoke",
+    createdAt: "2026-01-01T00:05:00.000Z",
+    updatedAt: "2026-01-01T00:05:00.000Z",
+    provider: "mock",
+    model: "mock-agent",
+    goal: "keep this non-empty session",
+    projectRoot: legacyProject,
+    commandCwd: legacyProject,
+    chat: [{ role: "user", content: "hello" }],
+    stepsCompleted: 1,
+  });
+  const removalCandidates = await listProjectSessionRemovalCandidates(legacyProject, { limit: 20, commandCwd: legacyProject });
+  assert(removalCandidates.find((session) => session.sessionId === "empty-session-smoke")?.isEmpty, "empty session was not detected");
+  assert(removalCandidates.find((session) => session.sessionId === "nonempty-session-smoke")?.isEmpty === false, "non-empty session was classified as empty");
+  const emptyOnly = await listProjectSessionRemovalCandidates(legacyProject, { limit: 20, commandCwd: legacyProject, emptyOnly: true });
+  assert(emptyOnly.some((session) => session.sessionId === "empty-session-smoke"), "empty-only removal list omitted the empty session");
+  assert(!emptyOnly.some((session) => session.sessionId === "nonempty-session-smoke"), "empty-only removal list included a non-empty session");
+  const removed = await removeProjectSessions(legacyProject, ["empty-session-smoke"]);
+  assert(removed.removed.length === 1, "empty session removal did not report one removed session");
+  assert(
+    !(await fs.stat(path.join(paths.globalSessionsDir, "empty-session-smoke", "state.json")).then((stat) => stat.isFile()).catch(() => false)),
+    "empty session global state was not removed"
+  );
+  assert(
+    !(await fs.stat(path.join(paths.sessionsDir, "empty-session-smoke", "session.json")).then((stat) => stat.isFile()).catch(() => false)),
+    "empty session project pointer was not removed"
+  );
+
   console.log(
     JSON.stringify(
       {
@@ -89,6 +137,8 @@ try {
           "global-session-store",
           "cwd-session-filter",
           "all-sessions-list",
+          "empty-session-detection",
+          "empty-session-removal",
         ],
       },
       null,

package/src/cli.js

@@ -17,8 +17,10 @@ import {
   doctorReport,
   ensureProjectSessionStorage,
   initProject,
+  listProjectSessionRemovalCandidates,
   listProjectSessions,
   renameProjectSession,
+  removeProjectSessions,
   providerKeyStatus,
   setProviderKey,
   showProjectSession,
@@ -34,6 +36,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import readline from "node:readline/promises";
+import * as readlineRaw from "node:readline";
 
 const packageDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const packageJson = JSON.parse(await fs.readFile(path.join(packageDir, "package.json"), "utf8"));
@@ -378,7 +381,7 @@ export function parseArgs(argv) {
 
 function printUsage() {
   console.log(
-    'Usage: aginti [chat] OR aginti web [--port 3210] OR aginti update OR aginti models OR aginti skills [query] OR aginti auth [deepseek|openai|qwen|venice|grsai] OR aginti resume [--all-sessions] [latest|<session-id>] ["prompt"] OR aginti queue <session-id> "message" OR aginti [--no-auto-update] [--language en|ja|zh-Hans|zh-Hant|ko|fr|es|ar|vi|de|ru] [--image] [--latex] [--routing smart|fast|complex|manual] [--provider deepseek|openai|qwen|venice|mock] [--model MODEL] [--route-model MODEL] [--main-model MODEL] [--spare-model MODEL --spare-reasoning medium] [--aux-provider grsai|venice --aux-model MODEL] [--sandbox-mode host|docker-readonly|docker-workspace] [--package-install-policy block|prompt|allow] [--approve-package-installs] [--allow-shell|--no-shell] [--allow-file-tools|--no-file-tools] [--web-search|--no-web-search] [--parallel-scouts|--no-parallel-scouts --scout-count 1..10] [--allow-auxiliary-tools|--no-auxiliary-tools] [--allow-wrappers --wrapper codex --wrapper-model gpt-5.5] [--list-models|--list-routes] "your task"'
+    'Usage: aginti [chat] OR aginti web [--port 3210] OR aginti update OR aginti models OR aginti skills [query] OR aginti auth [deepseek|openai|qwen|venice|grsai] OR aginti resume [--all-sessions] [latest|<session-id>] ["prompt"] OR aginti --remove-empty-sessions OR aginti --remove-sessions OR aginti queue <session-id> "message" OR aginti [--no-auto-update] [--language en|ja|zh-Hans|zh-Hant|ko|fr|es|ar|vi|de|ru] [--image] [--latex] [--routing smart|fast|complex|manual] [--provider deepseek|openai|qwen|venice|mock] [--model MODEL] [--route-model MODEL] [--main-model MODEL] [--spare-model MODEL --spare-reasoning medium] [--aux-provider grsai|venice --aux-model MODEL] [--sandbox-mode host|docker-readonly|docker-workspace] [--package-install-policy block|prompt|allow] [--approve-package-installs] [--allow-shell|--no-shell] [--allow-file-tools|--no-file-tools] [--web-search|--no-web-search] [--parallel-scouts|--no-parallel-scouts --scout-count 1..10] [--allow-auxiliary-tools|--no-auxiliary-tools] [--allow-wrappers --wrapper codex --wrapper-model gpt-5.5] [--list-models|--list-routes] "your task"'
   );
   console.log(`Languages: ${["en", "ja", "zh-Hans", "zh-Hant", "ko", "fr", "es", "ar", "vi", "de", "ru"].map((code) => `${code}=${languageLabel(code)}`).join(", ")}`);
 }
@@ -600,9 +603,214 @@ function printAuthWizardResult(result) {
   }
 }
 
+const removeSessionAnsi = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  inverse: "\x1b[7m",
+};
+
+function removeSessionColor(text, ...codes) {
+  return `${codes.join("")}${text}${removeSessionAnsi.reset}`;
+}
+
+function stripAnsi(text) {
+  return String(text || "").replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+function ellipsize(text, width) {
+  const value = String(text || "").replace(/\s+/g, " ").trim();
+  if (value.length <= width) return value.padEnd(width, " ");
+  return `${value.slice(0, Math.max(0, width - 1))}…`;
+}
+
+function buttonLabel(label, focused, disabled = false) {
+  const text = ` ${label} `;
+  if (disabled) return removeSessionColor(text, removeSessionAnsi.dim);
+  return focused ? removeSessionColor(text, removeSessionAnsi.inverse, removeSessionAnsi.bold) : text;
+}
+
+function renderSessionRemovalWizard(state) {
+  const width = Math.min(Math.max(process.stdout.columns || 100, 80), 128);
+  const rows = process.stdout.rows || 28;
+  const bodyWidth = width - 4;
+  const visibleCount = Math.max(5, Math.min(state.items.length || 1, rows - 11));
+  if (state.cursor < state.scroll) state.scroll = state.cursor;
+  if (state.cursor >= state.scroll + visibleCount) state.scroll = state.cursor - visibleCount + 1;
+  const shown = state.items.slice(state.scroll, state.scroll + visibleCount);
+  const selectedCount = state.selected.size;
+  const border = "─".repeat(width - 2);
+  const line = (content = "") => {
+    const value = String(content || "");
+    const clipped = stripAnsi(value).length > bodyWidth ? ellipsize(stripAnsi(value), bodyWidth) : value;
+    return `│ ${clipped}${" ".repeat(Math.max(0, bodyWidth - stripAnsi(clipped).length))} │`;
+  };
+  const listRows = shown.map((session, offset) => {
+    const index = state.scroll + offset;
+    const checked = state.selected.has(session.sessionId) ? "[x]" : "[ ]";
+    const cursor = index === state.cursor ? ">" : " ";
+    const badge = session.isEmpty ? "empty" : "work";
+    const title = session.title || session.goal || "(no title)";
+    const meta = `${session.provider || "unknown"}/${session.model || "unknown"} chat=${session.chatCount} steps=${session.stepsCompleted} files=${session.artifactFileCount}`;
+    const row = `${cursor} ${checked} ${badge.padEnd(5)} ${session.sessionId} ${meta} ${title}`;
+    const clipped = ellipsize(row, bodyWidth);
+    return state.focus === "list" && index === state.cursor ? line(removeSessionColor(clipped, removeSessionAnsi.inverse)) : line(clipped);
+  });
+  const footer =
+    state.phase === "confirm"
+      ? `Confirm deletion: ${buttonLabel("Yes, delete", state.confirmFocus === "yes")}  ${buttonLabel("Cancel", state.confirmFocus === "cancel")}`
+      : `Actions: ${buttonLabel(`OK delete ${selectedCount}`, state.focus === "ok", selectedCount === 0)}  ${buttonLabel("Cancel", state.focus === "cancel")}`;
+  const guidance =
+    state.phase === "confirm"
+      ? "Left/Right switches choice. Enter confirms. Esc/q cancels."
+      : "Space toggles. Up/Down moves. Tab changes focus. Enter opens confirm. Esc/q cancels.";
+  const lines = [
+    `╭${border}╮`,
+    line(state.title),
+    line(state.subtitle),
+    line(`Showing ${state.items.length === 0 ? 0 : state.scroll + 1}-${Math.min(state.items.length, state.scroll + visibleCount)} of ${state.items.length}; selected ${selectedCount}`),
+    `├${border}┤`,
+    ...listRows,
+    `├${border}┤`,
+    line(footer),
+    line(state.message || guidance),
+    `╰${border}╯`,
+  ];
+  process.stdout.write(`\x1b[H\x1b[2J${lines.join("\n")}`);
+}
+
+async function promptRemoveSessions(candidates, { defaultSelectedIds = [], title = "Remove sessions", subtitle = "" } = {}) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY || typeof process.stdin.setRawMode !== "function") {
+    console.log("Interactive terminal required; no sessions removed.");
+    return null;
+  }
+  const state = {
+    items: candidates,
+    selected: new Set(defaultSelectedIds),
+    cursor: 0,
+    scroll: 0,
+    focus: "list",
+    phase: "select",
+    confirmFocus: "cancel",
+    message: "",
+    title,
+    subtitle,
+  };
+  return await new Promise((resolve) => {
+    const input = process.stdin;
+    const output = process.stdout;
+    const cleanup = (value) => {
+      input.off("keypress", onKeypress);
+      if (input.isTTY) input.setRawMode(false);
+      input.pause();
+      output.write("\x1b[?25h\x1b[?1049l");
+      resolve(value);
+    };
+    const moveCursor = (delta) => {
+      state.focus = "list";
+      state.cursor = Math.min(Math.max(state.cursor + delta, 0), Math.max(0, state.items.length - 1));
+      state.message = "";
+    };
+    const toggleCurrent = () => {
+      const session = state.items[state.cursor];
+      if (!session) return;
+      if (state.selected.has(session.sessionId)) state.selected.delete(session.sessionId);
+      else state.selected.add(session.sessionId);
+      state.message = `${state.selected.size} session(s) selected.`;
+    };
+    const openConfirm = () => {
+      if (state.selected.size === 0) {
+        state.message = "Select at least one session before confirming.";
+        return;
+      }
+      state.phase = "confirm";
+      state.confirmFocus = "cancel";
+      state.message = "Second confirmation required before deleting session data.";
+    };
+    function onKeypress(char, key = {}) {
+      if (key.ctrl && key.name === "c") return cleanup(null);
+      const name = key.name || char;
+      if (name === "escape" || name === "q") return cleanup(null);
+      if (state.phase === "confirm") {
+        if (name === "left" || name === "right" || name === "tab") state.confirmFocus = state.confirmFocus === "yes" ? "cancel" : "yes";
+        else if (name === "return" || name === "enter") return cleanup(state.confirmFocus === "yes" ? [...state.selected] : null);
+        renderSessionRemovalWizard(state);
+        return;
+      }
+      if (name === "up") moveCursor(-1);
+      else if (name === "down") moveCursor(1);
+      else if (name === "pageup") moveCursor(-8);
+      else if (name === "pagedown") moveCursor(8);
+      else if (name === "space") toggleCurrent();
+      else if (name === "tab") state.focus = state.focus === "list" ? "ok" : state.focus === "ok" ? "cancel" : "list";
+      else if (name === "left" || name === "right") state.focus = state.focus === "cancel" ? "ok" : "cancel";
+      else if (name === "return" || name === "enter") {
+        if (state.focus === "cancel") return cleanup(null);
+        openConfirm();
+      }
+      renderSessionRemovalWizard(state);
+    }
+    readlineRaw.emitKeypressEvents(input);
+    input.setRawMode(true);
+    input.resume();
+    output.write("\x1b[?1049h\x1b[?25l");
+    input.on("keypress", onKeypress);
+    renderSessionRemovalWizard(state);
+  });
+}
+
+function printRemovalPreview(candidates) {
+  for (const session of candidates) {
+    const title = session.title || session.goal || "(no title)";
+    const status = session.isEmpty ? "empty" : "work";
+    console.log(`${status.padEnd(5)} ${session.sessionId} ${session.updatedAt || ""} ${title.slice(0, 90)}`);
+  }
+}
+
+async function handleRemoveSessionsCommand({ emptyOnly = false } = {}) {
+  const candidates = await listProjectSessionRemovalCandidates(process.cwd(), {
+    limit: 1000,
+    emptyOnly,
+  });
+  if (candidates.length === 0) {
+    console.log(emptyOnly ? "No empty sessions found for this cwd." : "No sessions found for this cwd.");
+    return;
+  }
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    printRemovalPreview(candidates);
+    console.log("No sessions removed because this command needs an interactive terminal.");
+    return;
+  }
+  const defaultSelectedIds = emptyOnly ? candidates.map((session) => session.sessionId) : [];
+  const selected = await promptRemoveSessions(candidates, {
+    defaultSelectedIds,
+    title: emptyOnly ? "Remove empty AgInTiFlow sessions in this cwd" : "Remove AgInTiFlow sessions in this cwd",
+    subtitle: emptyOnly
+      ? "Only empty sessions are shown and selected by default."
+      : "All cwd sessions are shown; nothing is selected by default.",
+  });
+  if (!selected || selected.length === 0) {
+    console.log("No sessions removed.");
+    return;
+  }
+  const allowedIds = new Set(candidates.map((session) => session.sessionId));
+  const safeSelected = selected.filter((sessionId) => allowedIds.has(sessionId));
+  const result = await removeProjectSessions(process.cwd(), safeSelected);
+  console.log(`Removed ${result.removed.length} session(s) from this cwd:`);
+  for (const item of result.removed) console.log(`- ${item.sessionId}`);
+}
+
 async function handleSessionsCommand(argv) {
   const normalizedArgv = argv[0] === "--all-sessions" ? ["list", ...argv] : argv;
   const [verb = "list", sessionId = "", ...rest] = normalizedArgv;
+  if (verb === "remove-empty" || verb === "delete-empty") {
+    await handleRemoveSessionsCommand({ emptyOnly: true });
+    return;
+  }
+  if (verb === "remove" || verb === "delete") {
+    await handleRemoveSessionsCommand({ emptyOnly: false });
+    return;
+  }
   if (verb === "list") {
     const allSessions = normalizedArgv.includes("--all-sessions");
     const sessions = await listProjectSessions(process.cwd(), { limit: 80, allSessions });
@@ -638,7 +846,7 @@ async function handleSessionsCommand(argv) {
     return;
   }
 
-  console.error('Usage: aginti sessions list OR aginti sessions show <session-id> OR aginti sessions rename <session-id> "title"');
+  console.error('Usage: aginti sessions list OR aginti sessions show <session-id> OR aginti sessions rename <session-id> "title" OR aginti sessions remove-empty OR aginti sessions remove');
   process.exit(1);
 }
 
@@ -788,6 +996,16 @@ export async function main(argv = process.argv.slice(2)) {
   });
   if (autoUpdateResult.restarted) process.exit(autoUpdateResult.exitCode ?? 0);
 
+  if (argv.includes("--remove-empty-sessions") || argv[0] === "remove-empty-sessions") {
+    await handleRemoveSessionsCommand({ emptyOnly: true });
+    return;
+  }
+
+  if (argv.includes("--remove-sessions") || argv[0] === "remove-sessions") {
+    await handleRemoveSessionsCommand({ emptyOnly: false });
+    return;
+  }
+
   if (argv[0] === "init") {
     printInitResult(await initProject(process.cwd()));
     return;

package/src/project.js

@@ -9,6 +9,7 @@ import { platformInfo, platformLabel, platformSetupHints } from "./platform.js";
 import {
   LEGACY_PROJECT_SESSIONS_DIR_NAME,
   PROJECT_SESSIONS_DIR_NAME,
+  deleteSessionIndex,
   globalSessionPaths,
   isSafeSessionId,
   listSessionIndex,
@@ -561,6 +562,118 @@ export async function listProjectSessions(projectRoot = process.cwd(), limitOrOp
   return sessions.sort((a, b) => String(b.updatedAt).localeCompare(String(a.updatedAt))).slice(0, options.limit);
 }
 
+async function readJsonFile(filePath, fallback = {}) {
+  try {
+    return JSON.parse(await fsp.readFile(filePath, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+async function readJsonLines(filePath) {
+  try {
+    const raw = await fsp.readFile(filePath, "utf8");
+    return raw
+      .split("\n")
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((line) => JSON.parse(line));
+  } catch {
+    return [];
+  }
+}
+
+async function countFilesRecursive(dirPath, limit = 200) {
+  let count = 0;
+  async function walk(current) {
+    if (count >= limit) return;
+    const entries = await fsp.readdir(current, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+      if (count >= limit) return;
+      const child = path.join(current, entry.name);
+      if (entry.isDirectory()) await walk(child);
+      else if (entry.isFile()) count += 1;
+    }
+  }
+  await walk(dirPath);
+  return count;
+}
+
+function isMeaningfulSessionEvent(event = {}) {
+  const type = String(event.type || "");
+  if (!type) return false;
+  return /^(agent|assistant|browser|canvas|conversation|file|image|model|patch|plan|run|shell|tool|workspace|write)[.:_-]/.test(type);
+}
+
+export async function listProjectSessionRemovalCandidates(projectRoot = process.cwd(), options = {}) {
+  const paths = await ensureProjectSessionStorage(projectRoot);
+  const sessions = await listProjectSessions(projectRoot, {
+    limit: options.limit || 1000,
+    commandCwd: options.commandCwd,
+    allSessions: options.allSessions,
+  });
+  const candidates = [];
+  for (const session of sessions) {
+    const safeId = String(session.sessionId || "");
+    if (!isSafeSessionId(safeId)) continue;
+    const pointerPath = path.join(paths.sessionsDir, safeId, "session.json");
+    const pointer = await readJsonFile(pointerPath, {});
+    const sessionDir = session.sessionDir || pointer.sessionDir || path.join(paths.globalSessionsDir, safeId);
+    const state = await readJsonFile(path.join(sessionDir, "state.json"), {});
+    const events = await readJsonLines(path.join(sessionDir, "events.jsonl"));
+    const chat = Array.isArray(state.chat) ? state.chat : [];
+    const goal = String(state.goal || pointer.goal || session.goal || "").trim();
+    const title = String(state.title || pointer.title || session.title || "").trim();
+    const stepsCompleted = Number(state.stepsCompleted || 0);
+    const artifactsDir = state.artifactsDir || pointer.artifactsDir || path.join(sessionDir, "artifacts");
+    const artifactFileCount = await countFilesRecursive(artifactsDir);
+    const meaningfulEventCount = events.filter(isMeaningfulSessionEvent).length;
+    const isEmpty =
+      !goal &&
+      !title &&
+      chat.length === 0 &&
+      stepsCompleted === 0 &&
+      artifactFileCount === 0 &&
+      meaningfulEventCount === 0;
+    candidates.push({
+      ...session,
+      sessionId: safeId,
+      sessionDir,
+      pointerPath,
+      chatCount: chat.length,
+      eventCount: events.length,
+      meaningfulEventCount,
+      artifactFileCount,
+      stepsCompleted,
+      isEmpty,
+    });
+  }
+  return options.emptyOnly ? candidates.filter((session) => session.isEmpty) : candidates;
+}
+
+export async function removeProjectSessions(projectRoot = process.cwd(), sessionIds = []) {
+  const paths = await ensureProjectSessionStorage(projectRoot);
+  const removed = [];
+  for (const rawId of sessionIds) {
+    const safeId = String(rawId || "");
+    if (!isSafeSessionId(safeId)) throw new Error(`Invalid session id: ${rawId}`);
+    const pointerDir = path.join(paths.sessionsDir, safeId);
+    const pointer = await readJsonFile(path.join(pointerDir, "session.json"), {});
+    const sessionDir = pointer.sessionDir || path.join(paths.globalSessionsDir, safeId);
+    const legacyDir = path.join(paths.legacySessionsDir, safeId);
+    await fsp.rm(sessionDir, { recursive: true, force: true });
+    await fsp.rm(pointerDir, { recursive: true, force: true });
+    await fsp.rm(legacyDir, { recursive: true, force: true }).catch(() => {});
+    try {
+      deleteSessionIndex(safeId);
+    } catch {
+      // The on-disk session and pointer are already removed; stale index cleanup can be retried later.
+    }
+    removed.push({ sessionId: safeId, sessionDir, pointerDir });
+  }
+  return { ok: true, removed };
+}
+
 export async function showProjectSession(projectRoot, sessionId) {
   const paths = await ensureProjectSessionStorage(projectRoot);
   const safeId = String(sessionId || "");