@lazyingart/agintiflow 0.20.43 → 0.20.45

package/README.md

@@ -138,12 +138,16 @@ 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"
+aginti chat
+# then in chat: /review [focus]
 aginti --profile code "write a small Python CLI app with tests"
 aginti --latex "draw a figure, write a short LaTeX report, and compile the PDF"
 aginti "set up this project and run the tests"
@@ -151,6 +155,10 @@ 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 or activate the focused button, Up/Down to move, Tab to switch to Delete/Cancel, and a second Delete/Cancel confirmation before deleting the project pointer and central `~/.agintiflow/sessions/<session-id>` data.
+
+In interactive chat, `/review [focus]` starts a bounded repository review. It begins from git status/diff and project instructions, reads manifests/entry points/tests/changed files first, avoids generated or binary folders, limits discovery passes, and reports findings before any summary.
+
 Run from a source checkout:
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.43",
+  "version": "0.20.45",
   "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

@@ -260,7 +260,7 @@ try {
   }
   const helpResult = await runChat("/help\n/exit\n");
   const misspelledAuxiliary = "/auxil" + "liary";
-  if (!helpResult.stdout.includes("/auxiliary") || helpResult.stdout.includes(misspelledAuxiliary)) {
+  if (!helpResult.stdout.includes("/auxiliary") || !helpResult.stdout.includes("/review") || helpResult.stdout.includes(misspelledAuxiliary)) {
     throw new Error("interactive help did not expose only the correctly spelled /auxiliary command");
   }
   const zhHelpResult = await runCli(["chat", "--language", "zh-Hans"], "/help\n/exit\n");
@@ -271,6 +271,10 @@ try {
   if (!skillsResult.stdout.includes("website-app") || !skillsResult.stdout.includes("Website And App Builder")) {
     throw new Error("interactive /skills did not show matching built-in skills");
   }
+  const reviewResult = await runChat("/review changed files only\n/exit\n");
+  if (!reviewResult.stdout.includes("Review focus: changed files only") || !reviewResult.stdout.includes("Mock run complete")) {
+    throw new Error("interactive /review did not launch the bounded review workflow");
+  }
   const abbreviatedSkillsResult = await runChat("/sk website\n/ex\n");
   if (abbreviatedSkillsResult.stdout.includes("Unknown command") || !abbreviatedSkillsResult.stdout.includes("website-app")) {
     throw new Error("interactive slash command prefix did not auto-select the first matching command");
@@ -347,6 +351,7 @@ try {
           "instructions-command",
           "auxiliary-command-spelling",
           "skills-command",
+          "review-command",
           "slash-prefix-autoselect",
           "slash-prefix-canonical-history",
           "instructions-chat-edit",

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/skills/code-review/SKILL.md

@@ -20,5 +20,12 @@ tools:
 
 Prioritize findings over summary. Inspect changed files, neighboring code, tests, and runtime assumptions. Report concrete risks with file paths, reproduction evidence, and suggested fixes.
 
-If no findings are found, say that clearly and name residual risk or missing test coverage. Do not rewrite code during a review unless the user asks for fixes.
+Use a bounded review loop:
+
+1. Start with git status/diff and project instructions or manifests.
+2. Read high-signal files first: changed files, entry points, tests, package/build configs, and nearby code needed to prove a risk.
+3. Avoid full-tree reads and generated/vendor/cache/binary folders such as `.git`, `node_modules`, `dist`, `build`, `target`, `coverage`, `.venv`, `__pycache__`, `.aginti-sessions`, `.sessions`, and artifacts.
+4. Cap discovery at two passes unless a concrete finding needs one more neighboring file.
+5. Run focused non-destructive checks when useful; do not install dependencies or run long broad suites for a review unless clearly justified.
 
+If no findings are found, say that clearly and name residual risk or missing test coverage. Do not rewrite code during a review unless the user asks for fixes.

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,222 @@ function printAuthWizardResult(result) {
   }
 }
 
+const removeSessionAnsi = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  red: "\x1b[31m",
+  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, danger = false) {
+  const text = ` ${label} `;
+  if (disabled) return removeSessionColor(text, removeSessionAnsi.dim);
+  const codes = [];
+  if (danger) codes.push(removeSessionAnsi.red, removeSessionAnsi.bold);
+  if (focused) codes.push(removeSessionAnsi.inverse, removeSessionAnsi.bold);
+  return codes.length > 0 ? removeSessionColor(text, ...codes) : 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("Delete", state.confirmFocus === "yes", false, true)}  ${buttonLabel("Cancel", state.confirmFocus === "cancel")}`
+      : `Actions: ${buttonLabel(`Delete ${selectedCount}`, state.focus === "ok", selectedCount === 0, true)}  ${buttonLabel("Cancel", state.focus === "cancel")}`;
+  const guidance =
+    state.phase === "confirm"
+      ? "Left/Right switches choice. Enter/Space confirms. Esc/q cancels."
+      : "Space toggles or activates focused button. Up/Down moves. Tab changes focus. 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" || name === "space") 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") {
+        if (state.focus === "list") toggleCurrent();
+        else if (state.focus === "cancel") return cleanup(null);
+        else openConfirm();
+      }
+      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 +854,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 +1004,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/interactive-cli.js

@@ -69,6 +69,7 @@ const SLASH_COMMANDS = [
   "/new",
   "/resume",
   "/sessions",
+  "/review",
   "/rename",
   "/skills",
   "/skill",
@@ -635,6 +636,7 @@ function printHelp() {
       `  ${command("/auxiliary [status|grsai|venice|model [provider/model]|on|off|image]", "Manage optional auxiliary skills, including image generation.", "helpAuxiliary")}`,
       `  ${command("/new", "Start a fresh session on the next message.", "helpNew")}`,
       `  ${command("/resume <session-id>", "Continue a saved session.", "helpResume")}`,
+      `  ${command("/review [focus]", "Run a bounded repo/diff review with controlled context gathering.", "helpReview")}`,
       `  ${command("/rename [title|auto]", "Rename the current session.", "helpRename")}`,
       `  ${command("/sessions", "List recent sessions in this project.", "helpSessions")}`,
       `  ${command("/skills [query]", "List Markdown skills selected for a topic.", "helpSkills")}`,
@@ -2454,6 +2456,29 @@ async function promptAndSaveProviderKey(provider = "", state = null) {
   applyAuthWizardResult(result, state);
 }
 
+function buildReviewPrompt(focus = "") {
+  const target = String(focus || "").trim();
+  return [
+    target ? `Review focus: ${target}` : "Review focus: current repository state, especially local changes if any.",
+    "",
+    "Run a bounded, evidence-based code review of this workspace. Default to read-only review; do not edit files unless the review focus explicitly asks for fixes.",
+    "",
+    "Review operating loop:",
+    "1. Start with `git status --short`, `git diff --stat`, and project metadata. If git is unavailable, say so and continue from manifests.",
+    "2. Read only the highest-signal context first: AGINTI.md/AGENTS.md/README, package/build manifests, entry points, tests, and files changed in git diff.",
+    "3. Use `inspect_project`, `search_files`, and targeted `read_file`; avoid full-tree dumps. Prefer precise symbol/error searches over opening many files.",
+    "4. Exclude generated, vendored, binary, cache, and large artifact paths: .git, node_modules, vendor, dist, build, out, target, coverage, .next, .turbo, .venv, __pycache__, .pytest_cache, .aginti-sessions, .sessions, artifacts, images/videos/PDFs unless directly relevant.",
+    "5. Context budget: at most two discovery passes; at most 12 primary files read initially; expand only when a concrete risk requires neighboring code.",
+    "6. Check likely validation commands from manifests, but run only focused non-destructive checks when useful. Do not install packages or run long broad suites unless clearly justified.",
+    "7. Stop when you have enough evidence. Do not keep scanning just because more files exist.",
+    "",
+    "Final answer format:",
+    "- Findings first, ordered by severity, with file/line references or exact evidence. Focus on bugs, regressions, security issues, data loss, broken UX/API behavior, and missing tests.",
+    "- If no findings, state that clearly and list residual risks or unrun checks.",
+    "- Then include a short `Files inspected` and `Checks run` section. Keep summary secondary and concise.",
+  ].join("\n");
+}
+
 async function handleCommand(line, state, packageDir) {
   const [rawCommand, ...rest] = line.slice(1).trim().split(/\s+/);
   const command = resolveSlashCommand(rawCommand);
@@ -2605,6 +2630,19 @@ async function handleCommand(line, state, packageDir) {
     }
     return true;
   }
+  if (command === "review") {
+    const previousProfile = state.taskProfile;
+    const previousMaxSteps = state.maxSteps;
+    try {
+      state.taskProfile = "review";
+      state.maxSteps = Math.max(state.maxSteps, 32);
+      await runPrompt(buildReviewPrompt(value), state, packageDir);
+    } finally {
+      state.taskProfile = previousProfile;
+      state.maxSteps = previousMaxSteps;
+    }
+    return true;
+  }
   if (command === "rename") {
     if (!state.sessionId) {
       printAgentMessage("No active session to rename. Start or resume a session first.");

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 || "");

package/src/task-profiles.js

@@ -20,6 +20,13 @@ export const TASK_PROFILES = {
       "Bias toward senior large-repo engineering while still answering ordinary side questions. Inspect_project first unless context is already known, read AGINTI/AGENTS/README/manifests, locate entry points and tests, make a small explicit change plan, patch in coherent batches, run the narrowest relevant checks first, escalate to broader checks when stable, and summarize files changed, checks, tradeoffs, and remaining risks.",
     tools: ["inspect_project", "search_files", "read_file", "apply_patch", "shell", "sandbox", "canvas"],
   },
+  review: {
+    id: "review",
+    label: "Code review",
+    prompt:
+      "Bias toward bounded code review rather than implementation. Start with git status/diff and project instructions, then inspect manifests, entry points, tests, changed files, and only the neighboring code needed to prove or disprove concrete risks. Avoid full-tree scans, generated/vendor/cache/binary folders, and infinite context gathering. Do not edit files unless explicitly asked for fixes. Findings must come first, ordered by severity with file/line evidence; if no findings are found, say so and name residual risks and checks not run.",
+    tools: ["inspect_project", "search_files", "read_file", "shell", "web_search"],
+  },
   writing: {
     id: "writing",
     label: "Book/script writing",
@@ -331,6 +338,12 @@ const PROFILE_ALIASES = {
   etl: "data",
   dataframe: "data",
   qa: "qa",
+  review: "review",
+  reviews: "review",
+  "code-review": "review",
+  "code-audit": "review",
+  codereview: "review",
+  codeaudit: "review",
   test: "qa",
   testing: "qa",
   ci: "qa",
@@ -412,6 +425,7 @@ export function getTaskProfile(value = "auto") {
 export function defaultMaxStepsForProfile(value = "auto") {
   const profile = normalizeTaskProfile(value);
   if (profile === "code") return 36;
+  if (profile === "review") return 32;
   if (profile === "large-codebase") return 36;
   if (profile === "qa") return 40;
   if (profile === "app") return 40;