@lazyingart/agintiflow 0.20.42 → 0.20.44

package/README.md

@@ -138,8 +138,11 @@ 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
 aginti resume latest
 aginti resume <session-id> "continue with a short follow-up"
 aginti queue <session-id> "extra instruction for the running agent"
@@ -148,6 +151,10 @@ aginti --latex "draw a figure, write a short LaTeX report, and compile the PDF"
 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.42",
+  "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-cli-chat.js

@@ -235,6 +235,11 @@ try {
   if (classifyEscapeAction({ active: true, pendingAsap: [] }) !== "abort") {
     throw new Error("active Esc should abort when no ASAP pipe messages are pending");
   }
+  await runChat("/exit\n");
+  const idleSessionEntries = await fs.readdir(path.join(agintiflowHome, "sessions"), { withFileTypes: true }).catch(() => []);
+  if (idleSessionEntries.some((entry) => entry.isDirectory())) {
+    throw new Error("idle interactive chat created a session before any user task");
+  }
   if (
     canonicalSlashPromptBuffer("/ve") !== "/venice" ||
     canonicalSlashPromptBuffer("/v") !== "/venice" ||

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 } 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-"));
@@ -58,6 +64,67 @@ try {
     "project session pointer was not created"
   );
 
+  const nestedCwd = path.join(legacyProject, "nested");
+  await fs.mkdir(nestedCwd, { recursive: true });
+  const otherCwdStore = new SessionStore(paths.globalSessionsDir, "other-cwd-smoke", sessionStoreOptions(legacyProject, "other-cwd-smoke"));
+  await otherCwdStore.saveState({
+    sessionId: "other-cwd-smoke",
+    createdAt: "2026-01-01T00:02:00.000Z",
+    updatedAt: "2026-01-01T00:03:00.000Z",
+    provider: "mock",
+    model: "mock-agent",
+    goal: "nested cwd smoke",
+    projectRoot: legacyProject,
+    commandCwd: nestedCwd,
+    chat: [],
+  });
+  const cwdFiltered = await listProjectSessions(legacyProject, { limit: 10, commandCwd: legacyProject });
+  assert(!cwdFiltered.some((session) => session.sessionId === "other-cwd-smoke"), "default cwd filtering included a different cwd session");
+  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(
       {
@@ -68,6 +135,10 @@ try {
           "session-inbox-asap-priority",
           "legacy-session-migration",
           "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 [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,12 +603,219 @@ 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 [verb = "list", sessionId = "", ...rest] = 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 sessions = await listProjectSessions(process.cwd(), 80);
+    const allSessions = normalizedArgv.includes("--all-sessions");
+    const sessions = await listProjectSessions(process.cwd(), { limit: 80, allSessions });
     if (sessions.length === 0) {
-      console.log("No project-local sessions found.");
+      console.log(allSessions ? "No sessions found." : "No sessions found for this cwd.");
       return;
     }
     for (const session of sessions) {
@@ -636,39 +846,86 @@ 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);
 }
 
-async function promptSelectSession(sessions) {
-  if (!process.stdin.isTTY || !process.stdout.isTTY) return sessions[0]?.sessionId || "";
-  console.log("Select a session to resume:");
-  sessions.slice(0, 20).forEach((session, index) => {
+function sessionSearchText(session) {
+  return [
+    session.sessionId,
+    session.provider,
+    session.model,
+    session.updatedAt,
+    session.title,
+    session.goal,
+    session.projectRoot,
+    session.commandCwd,
+  ]
+    .filter(Boolean)
+    .join(" ")
+    .toLowerCase();
+}
+
+function filterSessions(sessions, filterText = "") {
+  const needle = String(filterText || "").trim().toLowerCase();
+  if (!needle) return sessions;
+  return sessions.filter((session) => sessionSearchText(session).includes(needle));
+}
+
+function printSessionChoices(sessions, { filterText = "", allSessions = false, maxShown = 20 } = {}) {
+  const scope = allSessions ? "all sessions" : `cwd ${process.cwd()}`;
+  const shown = sessions.slice(0, maxShown);
+  console.log(`Select a session to resume (${scope}${filterText ? `, filter="${filterText}"` : ""}):`);
+  if (shown.length === 0) {
+    console.log("No matching sessions. Type /text to change the filter, / to clear it, or q to quit.");
+    return;
+  }
+  shown.forEach((session, index) => {
     const title = session.title || session.goal || "(untitled)";
     console.log(
       `${index + 1}. ${session.sessionId} ${session.provider || "unknown"}/${session.model || "unknown"} ${session.updatedAt || ""} ${title.slice(0, 90)}`
     );
   });
+  if (sessions.length > shown.length) console.log(`... ${sessions.length - shown.length} more hidden by display limit; type /text to narrow.`);
+  console.log("Type a number to select, /text to filter, / to clear, or q to quit.");
+}
+
+async function promptSelectSession(sessions, { allSessions = false } = {}) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return sessions[0]?.sessionId || "";
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  let filterText = "";
   try {
-    const answer = await rl.question("Session number: ");
-    const index = Number(answer.trim()) - 1;
-    return sessions[index]?.sessionId || "";
+    while (true) {
+      const filtered = filterSessions(sessions, filterText);
+      printSessionChoices(filtered, { filterText, allSessions });
+      const answer = (await rl.question("Session number/filter: ")).trim();
+      if (!answer || answer.toLowerCase() === "q" || answer.toLowerCase() === "quit") return "";
+      if (answer.startsWith("/")) {
+        filterText = answer.slice(1).trim();
+        continue;
+      }
+      const index = Number(answer) - 1;
+      if (Number.isInteger(index) && index >= 0 && index < Math.min(filtered.length, 20)) {
+        return filtered[index]?.sessionId || "";
+      }
+      console.log("Invalid selection. Type a shown number, /text to filter, or q to quit.");
+    }
   } finally {
     rl.close();
   }
 }
 
-async function resolveResumeSessionId(sessionId) {
+async function resolveResumeSessionId(sessionId, { allSessions = false } = {}) {
   if (sessionId && sessionId !== "latest") return sessionId;
-  const sessions = await listProjectSessions(process.cwd(), 50);
+  const sessions = await listProjectSessions(process.cwd(), { limit: 1000, allSessions });
   if (sessionId === "latest" || sessions.length <= 1 || !process.stdin.isTTY || !process.stdout.isTTY) {
     if (sessions[0]?.sessionId) return sessions[0].sessionId;
   } else {
-    const selected = await promptSelectSession(sessions);
+    const selected = await promptSelectSession(sessions, { allSessions });
     if (selected) return selected;
+    return "";
   }
-  throw new Error("No project-local sessions found. Run `aginti sessions list` to check this folder.");
+  throw new Error(allSessions ? "No sessions found." : "No sessions found for this cwd. Use `aginti resume --all-sessions` to browse all sessions.");
 }
 
 async function handleQueueCommand(argv) {
@@ -739,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;
@@ -837,14 +1104,18 @@ export async function main(argv = process.argv.slice(2)) {
   }
 
   if (argv[0] === "resume") {
-    let sessionId = argv[1] || "";
-    const prompt = argv.slice(2).join(" ").trim();
+    const resumeArgv = argv.slice(1);
+    const allSessions = resumeArgv.includes("--all-sessions");
+    const positional = resumeArgv.filter((arg) => arg !== "--all-sessions");
+    let sessionId = positional[0] || "";
+    const prompt = positional.slice(1).join(" ").trim();
     try {
-      sessionId = await resolveResumeSessionId(sessionId);
+      sessionId = await resolveResumeSessionId(sessionId, { allSessions });
     } catch (error) {
       console.error(error instanceof Error ? error.message : String(error));
       process.exit(1);
     }
+    if (!sessionId) return;
     if (!prompt) {
       await startInteractiveCli(agentDefaults({ ...parseArgs([]), resume: sessionId }), {
         packageDir,

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,
@@ -484,11 +485,34 @@ export async function setProviderKey(projectRoot, provider, value) {
   };
 }
 
-export async function listProjectSessions(projectRoot = process.cwd(), limit = 50) {
+function normalizeSessionListOptions(projectRoot, limitOrOptions = 50) {
+  const options = typeof limitOrOptions === "object" && limitOrOptions !== null ? limitOrOptions : { limit: limitOrOptions };
+  const root = resolveProjectRoot(projectRoot);
+  const commandCwd = options.commandCwd === false ? "" : path.resolve(options.commandCwd || root);
+  return {
+    limit: Math.min(Math.max(Number(options.limit) || 50, 1), 1000),
+    commandCwd,
+    allSessions: Boolean(options.allSessions),
+  };
+}
+
+function sessionMatchesCommandCwd(session, commandCwd = "") {
+  if (!commandCwd) return true;
+  const value = session.commandCwd || session.projectRoot || "";
+  if (!value) return false;
+  return path.resolve(value) === path.resolve(commandCwd);
+}
+
+export async function listProjectSessions(projectRoot = process.cwd(), limitOrOptions = 50) {
+  const options = normalizeSessionListOptions(projectRoot, limitOrOptions);
   const paths = await ensureProjectSessionStorage(projectRoot);
   const indexed = (() => {
     try {
-      return listSessionIndex({ projectRoot: paths.root, limit: Math.max(limit, 100) });
+      return listSessionIndex({
+        projectRoot: options.allSessions ? "" : paths.root,
+        commandCwd: options.allSessions ? "" : options.commandCwd,
+        limit: Math.max(options.limit, 100),
+      });
     } catch {
       return [];
     }
@@ -521,6 +545,7 @@ export async function listProjectSessions(projectRoot = process.cwd(), limit = 5
       updatedAt: state?.updatedAt || pointer.updatedAt || byId.get(sessionId)?.updatedAt || state?.createdAt || "",
       stepsCompleted: state?.stepsCompleted || 0,
     };
+    if (!options.allSessions && !sessionMatchesCommandCwd(record, options.commandCwd)) continue;
     byId.set(sessionId, record);
     try {
       upsertSessionIndex({
@@ -534,7 +559,119 @@ export async function listProjectSessions(projectRoot = process.cwd(), limit = 5
   }
 
   const sessions = [...byId.values()];
-  return sessions.sort((a, b) => String(b.updatedAt).localeCompare(String(a.updatedAt))).slice(0, limit);
+  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) {

package/src/session-index.js

@@ -120,16 +120,26 @@ export function deleteSessionIndex(sessionId) {
   return result.changes > 0;
 }
 
-export function listSessionIndex({ projectRoot = "", limit = 100 } = {}) {
+export function listSessionIndex({ projectRoot = "", commandCwd = "", limit = 100 } = {}) {
   const db = ensureIndexDb();
   const maxRows = Math.min(Math.max(Number(limit) || 100, 1), 1000);
   const columns = `session_id AS sessionId, project_root AS projectRoot, command_cwd AS commandCwd, project_sessions_dir AS projectSessionsDir,
     session_dir AS sessionDir, provider, model, goal, title, status,
     created_at AS createdAt, updated_at AS updatedAt, ended_at AS endedAt, result, error`;
+  const clauses = [];
+  const params = [];
   if (projectRoot) {
+    clauses.push("project_root = ?");
+    params.push(path.resolve(projectRoot));
+  }
+  if (commandCwd) {
+    clauses.push("command_cwd = ?");
+    params.push(path.resolve(commandCwd));
+  }
+  if (clauses.length > 0) {
     return db
-      .prepare(`SELECT ${columns} FROM sessions WHERE project_root = ? ORDER BY updated_at DESC LIMIT ?`)
-      .all(path.resolve(projectRoot), maxRows);
+      .prepare(`SELECT ${columns} FROM sessions WHERE ${clauses.join(" AND ")} ORDER BY updated_at DESC LIMIT ?`)
+      .all(...params, maxRows);
   }
   return db.prepare(`SELECT ${columns} FROM sessions ORDER BY updated_at DESC LIMIT ?`).all(maxRows);
 }