@lazyingart/agintiflow 0.20.25 → 0.20.39

package/src/task-profiles.js

@@ -3,14 +3,14 @@ export const TASK_PROFILES = {
     id: "auto",
     label: "Auto",
     prompt:
-      "Act as the general-purpose AgInTiFlow agent. Infer the task type from the request, then choose the right mix of browser, shell, files, web search, canvas, and sandbox tools. For short tasks, use the smallest safe tool sequence that completes the work. For codebase, writing, website, LaTeX, system, debugging, migration, or multi-language tasks, automatically borrow the relevant specialized profile habits without becoming narrowly constrained.",
+      "Act as the general-purpose AgInTiFlow agent. Infer the task type from the request, then choose the right mix of browser, shell, files, web search, canvas, and sandbox tools. For short tasks, use the smallest safe tool sequence that completes the work. For codebase, writing, website, LaTeX, system, debugging, migration, data cleanup, reporting, or multi-language tasks, automatically borrow the relevant specialized profile habits without becoming narrowly constrained. When you create or repair a deliverable, verify the produced output and polish obvious noise, duplicates, broken formatting, stale filenames, or misleading summaries before finalizing.",
     tools: ["browser", "shell", "files", "canvas", "inspect_project"],
   },
   code: {
     id: "code",
     label: "Code writing",
     prompt:
-      "Bias toward coding-agent behavior across languages, but remain a general assistant when the task needs docs, shell, web, or design work. Inspect project instructions/manifests/conventions, edit workspace files with patches, run useful focused checks, iterate on failures, and report changed files plus residual risks.",
+      "Bias toward coding-agent behavior across languages, but remain a general assistant when the task needs docs, shell, web, or design work. Inspect project instructions/manifests/conventions, edit workspace files with patches, run useful focused checks, iterate on failures, clean or ignore agent/build artifacts appropriately, and report changed files plus residual risks. If optional lint/style cleanup starts to expand beyond the requested fix, prioritize functional checks and explicitly report the remaining style scope instead of exhausting the run.",
     tools: ["inspect_project", "files", "shell", "sandbox"],
   },
   "large-codebase": {
@@ -27,6 +27,34 @@ export const TASK_PROFILES = {
       "Bias toward long-form writing quality without refusing adjacent research, code, or formatting tasks. Create structured drafts with outlines, sections, revision notes, and saved files for durable output. Use web search when current sources matter and canvas for important drafts.",
     tools: ["files", "canvas"],
   },
+  research: {
+    id: "research",
+    label: "Research",
+    prompt:
+      "Bias toward careful research while remaining able to write, code, plot, or format results. Clarify the research question, gather current sources when needed with web_search, distinguish evidence from inference, save durable notes or summaries with citations, and surface important artifacts through canvas.",
+    tools: ["web_search", "files", "canvas", "shell"],
+  },
+  paper: {
+    id: "paper",
+    label: "Academic paper",
+    prompt:
+      "Bias toward academic paper and manuscript production while still handling code, figures, literature, and LaTeX. Build an outline, define claims and contributions, keep sources traceable, create or update durable manuscript files, compile/check outputs when possible, and save PDFs/figures with descriptive paths.",
+    tools: ["files", "shell", "web_search", "canvas", "sandbox"],
+  },
+  book: {
+    id: "book",
+    label: "Book writing",
+    prompt:
+      "Bias toward book-scale structure while staying useful for research, code snippets, figures, and publication tooling. Maintain a chapter map, outline before drafting, write durable chapter files, preserve voice/style notes, and produce revision checklists instead of one-off chat-only prose.",
+    tools: ["files", "web_search", "canvas"],
+  },
+  novel: {
+    id: "novel",
+    label: "Novel writing",
+    prompt:
+      "Bias toward fiction craft while still supporting research and formatting. Track premise, characters, arcs, scenes, continuity, tone, and chapter files; draft in durable files and use canvas for important scenes or outlines.",
+    tools: ["files", "web_search", "canvas"],
+  },
   design: {
     id: "design",
     label: "Design docs",
@@ -34,6 +62,76 @@ export const TASK_PROFILES = {
       "Bias toward clear product/engineering design while remaining able to implement or test when asked. Produce concise design documents with goals, constraints, options, tradeoffs, implementation steps, verification criteria, and decision records.",
     tools: ["files", "canvas"],
   },
+  docs: {
+    id: "docs",
+    label: "Documentation",
+    prompt:
+      "Bias toward documentation work across README, API references, tutorials, changelogs, architecture notes, and user guides while still inspecting code when accuracy depends on it. Read the relevant source/config first, write durable markdown or docs-site files, include runnable examples when useful, verify links/commands where practical, and keep the docs structured for future maintenance.",
+    tools: ["inspect_project", "search_files", "read_file", "write_file", "apply_patch", "shell", "canvas"],
+  },
+  data: {
+    id: "data",
+    label: "Data analysis",
+    prompt:
+      "Bias toward reproducible data analysis, cleanup, ETL, visualization, and report generation while staying able to write scripts or docs. Inspect data shape and schema first, preserve raw inputs, create cleaned outputs with descriptive filenames, run deterministic scripts/notebooks where available, save plots/reports as durable artifacts, and explain assumptions and data quality issues.",
+    tools: ["inspect_project", "files", "shell", "canvas", "sandbox"],
+  },
+  qa: {
+    id: "qa",
+    label: "QA and testing",
+    prompt:
+      "Bias toward quality assurance, failing-test repair, regression reproduction, CI debugging, and test design. When a real failure exists, reproduce it first, minimize the failing case, patch the smallest cause, add or update tests when useful, run focused checks before broad suites, and report exact commands plus remaining coverage gaps. When asked to create a testing project from scratch, produce a clean runnable project with meaningful tests; do not stage fake bugs, misleading tests, or artificial failures unless the user explicitly asks for a bug-reproduction exercise. Before finalizing, remove stale interrupted drafts, generated caches, and contradictory comments or README text.",
+    tools: ["inspect_project", "search_files", "read_file", "apply_patch", "shell", "sandbox"],
+  },
+  database: {
+    id: "database",
+    label: "Database",
+    prompt:
+      "Bias toward database, SQL, schema, migration, seed data, query, and persistence work while still handling application code. Inspect existing migrations/models/schema first, back up or use disposable fixtures before destructive changes, prefer reversible migrations, run syntax or smoke checks when tools exist, and stop on ambiguous data-loss choices.",
+    tools: ["inspect_project", "search_files", "read_file", "apply_patch", "shell", "sandbox"],
+  },
+  devops: {
+    id: "devops",
+    label: "DevOps and deployment",
+    prompt:
+      "Bias toward Docker, CI/CD, deployment, services, environment setup, logs, ports, and runtime operations. Diagnose with read-only commands first, prefer project-local or containerized changes, make setup scripts idempotent, avoid host sudo unless explicitly approved, verify with build/health/log checks, and provide rollback or manual steps when automation is unsafe.",
+    tools: ["inspect_project", "files", "shell", "web_search", "sandbox"],
+  },
+  security: {
+    id: "security",
+    label: "Security review",
+    prompt:
+      "Bias toward security review, threat modeling, secrets hygiene, dependency risks, auth/session logic, input validation, and safe automation. Gather evidence before changing code, never print secrets, distinguish exploitable risk from style concern, patch minimal high-impact issues, run relevant scanners/tests when available, and stop before destructive or credential-sensitive actions.",
+    tools: ["inspect_project", "search_files", "read_file", "apply_patch", "shell", "web_search", "sandbox"],
+  },
+  slides: {
+    id: "slides",
+    label: "Slides and presentations",
+    prompt:
+      "Bias toward presentation, pitch deck, poster, lecture, and slide-style communication. Clarify audience and purpose from available context, create a durable outline and slide files or markdown deck, keep each slide visually focused, include speaker notes when useful, and export/preview when local tools support it.",
+    tools: ["files", "shell", "canvas", "web_search"],
+  },
+  education: {
+    id: "education",
+    label: "Education and tutorials",
+    prompt:
+      "Bias toward teaching, tutorials, courses, exercises, examples, and explanatory walkthroughs. Identify learner level, build from objectives to examples to checks, create durable lesson files, include exercises/solutions when useful, and verify code/math examples where possible.",
+    tools: ["files", "shell", "web_search", "canvas"],
+  },
+  supervision: {
+    id: "supervision",
+    label: "Supervision",
+    prompt:
+      "Bias toward supervising another agent or long-running task instead of doing the target work directly. Define acceptance criteria, give the student agent normal user-level prompts, monitor progress through tmux/session logs/artifacts, independently verify claims, record evidence, and convert repeated failures into reusable AgInTiFlow skills, tools, policies, tests, or profile improvements.",
+    tools: ["shell", "files", "canvas", "inspect_project", "tmux"],
+  },
+  app: {
+    id: "app",
+    label: "App builder",
+    prompt:
+      "Bias toward end-to-end app delivery across web, desktop, mobile, and local tools. Inspect the existing stack first, choose the smallest coherent architecture, implement real files, run build/test/preview/install checks when available, save artifacts with good names, and keep git status explicit.",
+    tools: ["inspect_project", "search_files", "read_file", "apply_patch", "shell", "sandbox", "canvas"],
+  },
   python: {
     id: "python",
     label: "Python",
@@ -55,11 +153,74 @@ export const TASK_PROFILES = {
       "Bias toward Node/JavaScript/TypeScript workflows without excluding frontend, backend, docs, or deployment work. Inspect package.json/lockfiles, respect the package manager, add tests when useful, and run safe npm/node checks when available.",
     tools: ["files", "shell", "sandbox"],
   },
+  java: {
+    id: "java",
+    label: "Java/JVM",
+    prompt:
+      "Bias toward Java, Kotlin JVM, Maven, Gradle, Spring, and JUnit work while staying useful for docs, shell, and deployment tasks. Inspect pom.xml, build.gradle, settings.gradle, wrapper files, source sets, and test layout before editing. Prefer project-local Maven/Gradle wrappers, run focused compile/test tasks, and avoid global JDK/toolchain mutation unless explicitly approved.",
+    tools: ["inspect_project", "search_files", "read_file", "apply_patch", "shell", "sandbox"],
+  },
+  ios: {
+    id: "ios",
+    label: "iOS/Swift",
+    prompt:
+      "Bias toward iOS, Swift, SwiftUI, Xcode, Swift Package Manager, simulator, and Apple-platform work while staying useful for design/docs. Inspect Package.swift, .xcodeproj/.xcworkspace, schemes, Info.plist, signing constraints, xcodebuild availability, and simulator devices before editing. Prefer build/test with project-local settings, save screenshots when a simulator is available, and stop cleanly on signing or missing-Xcode blockers.",
+    tools: ["inspect_project", "search_files", "read_file", "apply_patch", "shell", "canvas"],
+  },
+  go: {
+    id: "go",
+    label: "Go",
+    prompt:
+      "Bias toward Go modules, CLIs, servers, tests, and tooling. Inspect go.mod, packages, commands, and tests before editing. Use gofmt, go test ./... when practical, keep module changes intentional, and report environment blockers such as missing Go or private modules.",
+    tools: ["inspect_project", "search_files", "read_file", "apply_patch", "shell", "sandbox"],
+  },
+  rust: {
+    id: "rust",
+    label: "Rust",
+    prompt:
+      "Bias toward Rust crates, Cargo workspaces, CLIs, services, tests, and safety-oriented fixes. Inspect Cargo.toml, workspace members, features, source modules, and tests before editing. Use cargo fmt/check/test when available, avoid broad dependency churn, and explain borrow/lifetime or unsafe tradeoffs clearly.",
+    tools: ["inspect_project", "search_files", "read_file", "apply_patch", "shell", "sandbox"],
+  },
+  dotnet: {
+    id: "dotnet",
+    label: ".NET/C#",
+    prompt:
+      "Bias toward .NET, C#, F#, ASP.NET, console apps, tests, and NuGet projects. Inspect .sln, .csproj, Program.cs, appsettings, and test projects before editing. Use dotnet restore/build/test when available, keep generated bin/obj out of commits, and stop on SDK or credential blockers.",
+    tools: ["inspect_project", "search_files", "read_file", "apply_patch", "shell", "sandbox"],
+  },
+  php: {
+    id: "php",
+    label: "PHP",
+    prompt:
+      "Bias toward PHP, Composer, Laravel/Symfony, WordPress-style projects, CLIs, and tests. Inspect composer.json, framework config, routes, migrations, and tests before editing. Use composer scripts, php -l, and PHPUnit/Pest when available; avoid changing global PHP extensions unless explicitly approved.",
+    tools: ["inspect_project", "search_files", "read_file", "apply_patch", "shell", "sandbox"],
+  },
+  ruby: {
+    id: "ruby",
+    label: "Ruby",
+    prompt:
+      "Bias toward Ruby, Rails, Bundler, gems, Rake tasks, and tests. Inspect Gemfile, gemspec, config/routes.rb, migrations, and tests before editing. Use bundle exec rake/test/rspec when available, keep bundle/vendor artifacts out of commits, and stop on native gem or credential blockers.",
+    tools: ["inspect_project", "search_files", "read_file", "apply_patch", "shell", "sandbox"],
+  },
+  "c-cpp": {
+    id: "c-cpp",
+    label: "C/C++",
+    prompt:
+      "Bias toward C and C++ development while still handling docs, scripts, and system setup. Inspect CMake/Make/build files, patch source carefully, prefer out-of-tree builds, run focused compile/test checks, and use sanitizers/debuggers only when available and safe.",
+    tools: ["inspect_project", "search_files", "read_file", "apply_patch", "shell", "sandbox"],
+  },
+  "r-stan": {
+    id: "r-stan",
+    label: "R/Stan",
+    prompt:
+      "Bias toward R, Stan, statistics, reproducible analysis, and research code. Inspect renv/DESCRIPTION/scripts/data layout, keep outputs reproducible, prefer project-local libraries or Docker, run Rscript/CmdStan checks when available, and save plots/reports as durable artifacts.",
+    tools: ["inspect_project", "files", "shell", "web_search", "canvas", "sandbox"],
+  },
   android: {
     id: "android",
     label: "Android",
     prompt:
-      "Bias toward end-to-end Android app delivery while still handling normal project work. Inspect git status, existing Gradle files, AndroidManifest, SDK paths, Java/Kotlin versions, adb devices, and emulator/AVD availability before editing. Do not use host sudo, apt, dnf, yum, brew, winget, or global host installs during Android tasks; prefer the existing Android SDK, project-local Gradle wrapper, user-writable caches, or a clear setup report. Create missing wrapper directories before downloads, avoid repeated failing install attempts, build with focused Gradle tasks, install and launch with adb when a device/emulator exists, verify with am/logcat/screencap when possible, and commit the finished app only after checks.",
+      "Bias toward end-to-end Android app delivery while still handling normal project work. Inspect git status, existing Gradle files, AndroidManifest, SDK paths, Java/Kotlin versions, adb devices, and emulator/AVD availability before editing. Do not use host sudo, apt, dnf, yum, brew, winget, or global host installs during Android tasks; prefer the existing Android SDK, project-local Gradle wrapper, user-writable caches, or a clear setup report. Create missing wrapper directories before downloads, avoid repeated failing install attempts, build with focused Gradle tasks, install and launch with adb when a device/emulator exists, verify with am/logcat/screencap when possible, save screenshots under durable workspace paths, and commit the finished app only after checks.",
     tools: ["inspect_project", "search_files", "read_file", "apply_patch", "shell", "sandbox", "canvas"],
   },
   website: {
@@ -83,6 +244,20 @@ export const TASK_PROFILES = {
       "Bias toward AAPS workflows while still handling normal project work. Recognize .aaps folders and @lazyingart/aaps conventions, keep work project-local, document assumptions, and avoid secrets or publishing unless explicitly requested.",
     tools: ["files", "shell", "sandbox"],
   },
+  github: {
+    id: "github",
+    label: "GitHub maintenance",
+    prompt:
+      "Bias toward safe git and GitHub maintenance while still fixing code/docs when asked. Always inspect git status and remotes first, separate unrelated changes, run relevant checks before commits, use gh when available for PR/issues/releases, prefer fast-forward pulls, and stop on conflicts or ambiguous history.",
+    tools: ["shell", "files", "web_search", "inspect_project"],
+  },
+  word: {
+    id: "word",
+    label: "Word documents",
+    prompt:
+      "Bias toward Word/docx/document workflows while still using writing, conversion, LaTeX, or scripts when useful. Preserve originals, create clear output filenames, use available local tools such as pandoc/libreoffice/python packages when present, and verify generated documents exist before reporting success.",
+    tools: ["files", "shell", "canvas", "sandbox"],
+  },
   latex: {
     id: "latex",
     label: "LaTeX",
@@ -100,17 +275,124 @@ export const TASK_PROFILES = {
 };
 
 const PROFILE_ALIASES = {
+  default: "auto",
+  general: "auto",
   large: "large-codebase",
   codebase: "large-codebase",
   repo: "large-codebase",
   repository: "large-codebase",
   engineering: "large-codebase",
   engineer: "large-codebase",
+  application: "app",
+  apps: "app",
   mobile: "android",
   apk: "android",
   gradle: "android",
-  kotlin: "android",
-  java: "android",
+  kotlin: "java",
+  jvm: "java",
+  java: "java",
+  maven: "java",
+  spring: "java",
+  ios: "ios",
+  iphone: "ios",
+  ipad: "ios",
+  swift: "ios",
+  swiftui: "ios",
+  xcode: "ios",
+  go: "go",
+  golang: "go",
+  rust: "rust",
+  cargo: "rust",
+  dotnet: "dotnet",
+  ".net": "dotnet",
+  csharp: "dotnet",
+  "c#": "dotnet",
+  aspnet: "dotnet",
+  php: "php",
+  composer: "php",
+  laravel: "php",
+  symfony: "php",
+  ruby: "ruby",
+  rails: "ruby",
+  bundler: "ruby",
+  frontend: "website",
+  web: "website",
+  site: "website",
+  documentation: "docs",
+  docs: "docs",
+  readme: "docs",
+  tutorial: "docs",
+  changelog: "docs",
+  manual: "docs",
+  data: "data",
+  analysis: "data",
+  analytics: "data",
+  csv: "data",
+  etl: "data",
+  dataframe: "data",
+  qa: "qa",
+  test: "qa",
+  testing: "qa",
+  ci: "qa",
+  regression: "qa",
+  database: "database",
+  db: "database",
+  sql: "database",
+  sqlite: "database",
+  postgres: "database",
+  devops: "devops",
+  deploy: "devops",
+  deployment: "devops",
+  docker: "devops",
+  k8s: "devops",
+  kubernetes: "devops",
+  security: "security",
+  sec: "security",
+  audit: "security",
+  secrets: "security",
+  auth: "security",
+  slides: "slides",
+  slide: "slides",
+  presentation: "slides",
+  deck: "slides",
+  powerpoint: "slides",
+  pptx: "slides",
+  education: "education",
+  teach: "education",
+  course: "education",
+  lesson: "education",
+  manuscript: "paper",
+  academic: "paper",
+  article: "paper",
+  report: "paper",
+  literature: "research",
+  sources: "research",
+  chapter: "book",
+  fiction: "novel",
+  story: "novel",
+  supervise: "supervision",
+  supervisor: "supervision",
+  student: "supervision",
+  training: "supervision",
+  homework: "supervision",
+  curriculum: "supervision",
+  selfsupervision: "supervision",
+  "self-supervision": "supervision",
+  cpp: "c-cpp",
+  "c++": "c-cpp",
+  clang: "c-cpp",
+  cmake: "c-cpp",
+  r: "r-stan",
+  stan: "r-stan",
+  statistics: "r-stan",
+  git: "github",
+  gh: "github",
+  release: "github",
+  docx: "word",
+  office: "word",
+  system: "maintenance",
+  sysadmin: "maintenance",
+  computer: "maintenance",
 };
 
 export function listTaskProfiles() {
@@ -129,8 +411,39 @@ export function getTaskProfile(value = "auto") {
 
 export function defaultMaxStepsForProfile(value = "auto") {
   const profile = normalizeTaskProfile(value);
+  if (profile === "code") return 36;
   if (profile === "large-codebase") return 36;
+  if (profile === "qa") return 40;
+  if (profile === "app") return 40;
   if (profile === "android") return 60;
   if (profile === "latex") return 30;
+  if (profile === "supervision") return 40;
+  if (["devops", "security"].includes(profile)) return 36;
+  if (
+    [
+      "paper",
+      "research",
+      "book",
+      "novel",
+      "docs",
+      "data",
+      "database",
+      "slides",
+      "education",
+      "java",
+      "ios",
+      "go",
+      "rust",
+      "dotnet",
+      "php",
+      "ruby",
+      "c-cpp",
+      "r-stan",
+      "github",
+      "word",
+      "maintenance",
+    ].includes(profile)
+  )
+    return 30;
   return 24;
 }

package/src/web-db.js

@@ -1,8 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
-import { DatabaseSync } from "node:sqlite";
 import { getModelPresets, getModelRoleDefaults } from "./model-routing.js";
 import { resolveLanguage } from "./i18n.js";
+import { projectPaths } from "./project.js";
+import { deleteSessionIndex, renameSessionIndex, upsertSessionIndex } from "./session-index.js";
+import { loadDatabaseSync } from "./sqlite.js";
 
 const PREFERENCES_SCHEMA_VERSION = 7;
 
@@ -52,10 +54,12 @@ function defaultPreferences(baseDir) {
 
 export class WebDatabase {
   constructor(baseDir) {
-    this.baseDir = baseDir;
-    this.dbDir = path.join(baseDir, ".sessions");
-    this.dbPath = path.join(this.dbDir, "web-state.sqlite");
+    this.baseDir = path.resolve(baseDir);
+    this.paths = projectPaths(this.baseDir);
+    this.dbDir = this.paths.sessionsDir;
+    this.dbPath = this.paths.sessionDbPath;
     fs.mkdirSync(this.dbDir, { recursive: true });
+    const DatabaseSync = loadDatabaseSync();
     this.db = new DatabaseSync(this.dbPath);
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS preferences (
@@ -85,6 +89,18 @@ export class WebDatabase {
     if (!sessionColumns.some((column) => column.name === "title")) {
       this.db.exec("ALTER TABLE sessions ADD COLUMN title TEXT NOT NULL DEFAULT ''");
     }
+    if (!sessionColumns.some((column) => column.name === "project_root")) {
+      this.db.exec("ALTER TABLE sessions ADD COLUMN project_root TEXT NOT NULL DEFAULT ''");
+    }
+    if (!sessionColumns.some((column) => column.name === "command_cwd")) {
+      this.db.exec("ALTER TABLE sessions ADD COLUMN command_cwd TEXT NOT NULL DEFAULT ''");
+    }
+    if (!sessionColumns.some((column) => column.name === "project_sessions_dir")) {
+      this.db.exec("ALTER TABLE sessions ADD COLUMN project_sessions_dir TEXT NOT NULL DEFAULT ''");
+    }
+    if (!sessionColumns.some((column) => column.name === "session_dir")) {
+      this.db.exec("ALTER TABLE sessions ADD COLUMN session_dir TEXT NOT NULL DEFAULT ''");
+    }
   }
 
   getPreferences() {
@@ -156,12 +172,21 @@ export class WebDatabase {
 
   upsertSession(session) {
     const updatedAt = session.updatedAt || new Date().toISOString();
+    const projectRoot = session.projectRoot || this.baseDir;
+    const commandCwd = session.commandCwd || projectRoot;
+    const projectSessionsDir = session.projectSessionsDir || this.paths.sessionsDir;
+    const sessionDir = session.sessionDir || path.join(this.paths.globalSessionsDir, session.sessionId);
     this.db
       .prepare(
         `INSERT INTO sessions (
-          session_id, provider, model, goal, title, status, started_at, updated_at, ended_at, result, error
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          session_id, project_root, command_cwd, project_sessions_dir, session_dir,
+          provider, model, goal, title, status, started_at, updated_at, ended_at, result, error
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         ON CONFLICT(session_id) DO UPDATE SET
+          project_root = excluded.project_root,
+          command_cwd = excluded.command_cwd,
+          project_sessions_dir = excluded.project_sessions_dir,
+          session_dir = excluded.session_dir,
           provider = excluded.provider,
           model = excluded.model,
           goal = excluded.goal,
@@ -174,6 +199,10 @@ export class WebDatabase {
       )
       .run(
         session.sessionId,
+        projectRoot,
+        commandCwd,
+        projectSessionsDir,
+        sessionDir,
         session.provider,
         session.model,
         session.goal,
@@ -185,6 +214,19 @@ export class WebDatabase {
         session.result || "",
         session.error || ""
       );
+    try {
+      upsertSessionIndex({
+        ...session,
+        projectRoot,
+        commandCwd,
+        projectSessionsDir,
+        sessionDir,
+        createdAt: session.startedAt,
+        updatedAt,
+      });
+    } catch {
+      // The project-local database remains the fallback if the global index cannot be updated.
+    }
   }
 
   getSession(sessionId) {
@@ -193,6 +235,10 @@ export class WebDatabase {
         .prepare(
           `SELECT
              session_id AS sessionId,
+             project_root AS projectRoot,
+             command_cwd AS commandCwd,
+             project_sessions_dir AS projectSessionsDir,
+             session_dir AS sessionDir,
              provider,
              model,
              goal,
@@ -215,6 +261,10 @@ export class WebDatabase {
       .prepare(
         `SELECT
            session_id AS sessionId,
+           project_root AS projectRoot,
+           command_cwd AS commandCwd,
+           project_sessions_dir AS projectSessionsDir,
+           session_dir AS sessionDir,
            provider,
            model,
            goal,
@@ -237,11 +287,13 @@ export class WebDatabase {
     const result = this.db
       .prepare("UPDATE sessions SET title = ?, updated_at = ? WHERE session_id = ?")
       .run(title, updatedAt, sessionId);
+    if (result.changes > 0) renameSessionIndex(sessionId, title);
     return result.changes > 0;
   }
 
   deleteSession(sessionId) {
     const result = this.db.prepare("DELETE FROM sessions WHERE session_id = ?").run(sessionId);
+    if (result.changes > 0) deleteSessionIndex(sessionId);
     return result.changes > 0;
   }
 }

package/src/workspace-tools.js

@@ -16,6 +16,7 @@ const DEFAULT_MAX_DEPTH = 4;
 const SKIP_DIRS = new Set([
   ".git",
   ".sessions",
+  ".aginti-sessions",
   ".aginti",
   "node_modules",
   "dist",

package/web.js

@@ -20,7 +20,15 @@ import { getDockerSandboxStatus, getSandboxLogs, runDockerPreflight } from "./sr
 import { normalizePackageInstallPolicy, normalizeSandboxMode } from "./src/command-policy.js";
 import { summarizeWorkspaceTools, WORKSPACE_TOOL_NAMES } from "./src/workspace-tools.js";
 import { listTaskProfiles, normalizeTaskProfile } from "./src/task-profiles.js";
-import { loadProjectEnv, projectPaths, providerKeyStatus, setProviderKey } from "./src/project.js";
+import {
+  ensureProjectSessionStorage,
+  listProjectSessions,
+  loadProjectEnv,
+  projectPaths,
+  providerKeyStatus,
+  renameProjectSession,
+  setProviderKey,
+} from "./src/project.js";
 import { buildCapabilityReport } from "./src/capabilities.js";
 import { listSkills } from "./src/skill-library.js";
 import { platformInfo, platformLabel, platformSetupHints } from "./src/platform.js";
@@ -38,8 +46,11 @@ const __dirname = path.dirname(__filename);
 const packageDir = __dirname;
 const packageJson = JSON.parse(await fs.readFile(path.join(packageDir, "package.json"), "utf8"));
 const baseDir = path.resolve(process.env.AGINTIFLOW_RUNTIME_DIR || process.cwd());
-const sessionsDir = path.join(baseDir, ".sessions");
+const storagePaths = projectPaths(baseDir);
+const sessionsDir = storagePaths.globalSessionsDir;
+const projectSessionsDir = storagePaths.sessionsDir;
 loadProjectEnv(baseDir);
+await ensureProjectSessionStorage(baseDir);
 
 const app = express();
 const port = Number(process.env.PORT || 3210);
@@ -48,7 +59,11 @@ const runs = new Map();
 const db = new WebDatabase(baseDir);
 
 function sessionStore(sessionId) {
-  return new SessionStore(sessionsDir, sessionId);
+  return new SessionStore(sessionsDir, sessionId, {
+    projectRoot: baseDir,
+    projectSessionsDir,
+    legacySessionDir: path.join(storagePaths.legacySessionsDir, sessionId),
+  });
 }
 
 function isSafeSessionId(sessionId) {
@@ -322,7 +337,8 @@ function deriveSessionRecordFromState(state, existing = null) {
     provider: state.provider || existing?.provider || "deepseek",
     model: state.model || existing?.model || getProviderDefaults(state.provider || existing?.provider || "deepseek").model,
     goal: state.goal || existing?.goal || "",
-    title: existing?.title || "",
+    title: state.title || existing?.title || "",
+    commandCwd: state.commandCwd || existing?.commandCwd || baseDir,
     status,
     startedAt: state.createdAt || existing?.startedAt || new Date().toISOString(),
     updatedAt,
@@ -333,17 +349,19 @@ function deriveSessionRecordFromState(state, existing = null) {
 }
 
 async function syncStoredSessions() {
-  const entries = await fs.readdir(sessionsDir, { withFileTypes: true }).catch(() => []);
-
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-
-    const store = sessionStore(entry.name);
+  const sessions = await listProjectSessions(baseDir, 500);
+  for (const session of sessions) {
+    const store = sessionStore(session.sessionId);
     const state = await store.loadState();
     if (!state?.sessionId) continue;
 
     const existing = db.getSession(state.sessionId);
-    db.upsertSession(deriveSessionRecordFromState(state, existing));
+    db.upsertSession({
+      ...deriveSessionRecordFromState(state, existing),
+      projectRoot: baseDir,
+      projectSessionsDir,
+      sessionDir: store.sessionDir,
+    });
   }
 }
 
@@ -546,6 +564,10 @@ function createRunRecord(config, goal, existingLogs = []) {
     provider: config.provider,
     model: config.model,
     goal,
+    projectRoot: baseDir,
+    commandCwd: config.commandCwd,
+    projectSessionsDir,
+    sessionDir: path.join(sessionsDir, config.sessionId),
     startedAt: new Date().toISOString(),
     updatedAt: new Date().toISOString(),
     endedAt: "",
@@ -615,8 +637,10 @@ app.get("/api/config", async (_req, res) => {
       root: paths.root,
       commandCwd: config.commandCwd,
       sessionsDir,
+      projectSessionsDir,
       sessionDbPath: paths.sessionDbPath,
       sharedSessionFolder: path.resolve(config.sessionsDir) === path.resolve(sessionsDir),
+      globalSessionIndexPath: paths.globalSessionIndexPath,
       localEnvPresent: keyStatus.localEnv,
       platform: {
         ...platform,
@@ -926,6 +950,7 @@ app.patch("/api/sessions/:sessionId", async (req, res) => {
     return;
   }
 
+  await renameProjectSession(baseDir, sessionId, title);
   db.renameSession(sessionId, title);
   await sessionStore(sessionId).appendEvent("session.renamed", { title }).catch(() => {});
   res.json({ ok: true, session: db.getSession(sessionId) });
@@ -945,6 +970,7 @@ app.post("/api/sessions/:sessionId/auto-title", async (req, res) => {
   }
 
   const title = autoSessionTitleFromChat(data);
+  await renameProjectSession(baseDir, sessionId, title);
   db.renameSession(sessionId, title);
   await sessionStore(sessionId).appendEvent("session.auto_renamed", { title }).catch(() => {});
   res.json({ ok: true, session: db.getSession(sessionId) });