@lazyingart/agintiflow 0.20.41 → 0.20.43

package/README.md

@@ -140,6 +140,7 @@ aginti sessions show <session-id>
 aginti sessions rename <session-id> "friendly title"
 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 +149,8 @@ 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.
+
 Run from a source checkout:
 
 ```bash

package/demos/README.md

@@ -4,3 +4,4 @@ This folder stores shareable screenshots and visual demos used by the repository
 
 - `agintiflow-cli-launch.png`: interactive CLI launch screen with the AgInTi Flow terminal banner, Docker workspace status, and input panel.
 - `agintiflow-cli-launch.jpg`: optimized README/web preview derived from the same screenshot.
+- `archive/`: previous CLI launch screenshots kept before replacing the active README preview.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.41",
+  "version": "0.20.43",
   "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,7 @@
 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, listProjectSessions, 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 +58,25 @@ 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");
+
   console.log(
     JSON.stringify(
       {
@@ -68,6 +87,8 @@ try {
           "session-inbox-asap-priority",
           "legacy-session-migration",
           "global-session-store",
+          "cwd-session-filter",
+          "all-sessions-list",
         ],
       },
       null,

package/src/cli.js

@@ -378,7 +378,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 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(", ")}`);
 }
@@ -601,11 +601,13 @@ function printAuthWizardResult(result) {
 }
 
 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 === "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) {
@@ -640,35 +642,82 @@ async function handleSessionsCommand(argv) {
   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) {
@@ -837,14 +886,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

@@ -484,11 +484,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 +544,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 +558,7 @@ 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);
 }
 
 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);
 }