@lazyingart/agintiflow 0.20.25 → 0.20.39

package/src/project.js

@@ -6,6 +6,15 @@ import { promisify } from "node:util";
 import { listAgentWrappers } from "./tool-wrappers.js";
 import { getDockerSandboxStatus } from "./docker-sandbox.js";
 import { platformInfo, platformLabel, platformSetupHints } from "./platform.js";
+import {
+  LEGACY_PROJECT_SESSIONS_DIR_NAME,
+  PROJECT_SESSIONS_DIR_NAME,
+  globalSessionPaths,
+  isSafeSessionId,
+  listSessionIndex,
+  renameSessionIndex,
+  upsertSessionIndex,
+} from "./session-index.js";
 
 const execFileAsync = promisify(execFile);
 const LOCAL_ENV_KEYS = new Set([
@@ -45,6 +54,7 @@ export function resolveProjectRoot(input = process.cwd()) {
 
 export function projectPaths(projectRoot = process.cwd()) {
   const root = resolveProjectRoot(projectRoot);
+  const globalPaths = globalSessionPaths();
   return {
     root,
     agintiInstructionsPath: path.join(root, "AGINTI.md"),
@@ -56,12 +66,91 @@ export function projectPaths(projectRoot = process.cwd()) {
     codebaseMapPath: path.join(root, ".aginti", "codebase-map.json"),
     notesDir: path.join(root, "notes"),
     notesReadmePath: path.join(root, "notes", "README.md"),
-    sessionsDir: path.join(root, ".sessions"),
-    sessionDbPath: path.join(root, ".sessions", "web-state.sqlite"),
+    sessionsDir: path.join(root, PROJECT_SESSIONS_DIR_NAME),
+    legacySessionsDir: path.join(root, LEGACY_PROJECT_SESSIONS_DIR_NAME),
+    sessionDbPath: path.join(root, PROJECT_SESSIONS_DIR_NAME, "web-state.sqlite"),
+    legacySessionDbPath: path.join(root, LEGACY_PROJECT_SESSIONS_DIR_NAME, "web-state.sqlite"),
+    agintiflowHome: globalPaths.home,
+    globalSessionsDir: globalPaths.sessionsDir,
+    globalSessionIndexPath: globalPaths.indexDbPath,
     gitignorePath: path.join(root, ".gitignore"),
   };
 }
 
+export function sessionStoreOptions(projectRoot = process.cwd(), sessionId = "") {
+  const paths = projectPaths(projectRoot);
+  return {
+    projectRoot: paths.root,
+    projectSessionsDir: paths.sessionsDir,
+    legacySessionDir: sessionId ? path.join(paths.legacySessionsDir, sessionId) : "",
+  };
+}
+
+export async function ensureProjectSessionStorage(projectRoot = process.cwd()) {
+  const paths = projectPaths(projectRoot);
+  await fsp.mkdir(paths.sessionsDir, { recursive: true });
+  await fsp.mkdir(paths.globalSessionsDir, { recursive: true });
+
+  const legacyEntries = await fsp.readdir(paths.legacySessionsDir, { withFileTypes: true }).catch(() => []);
+  if (legacyEntries.length > 0) {
+    for (const entry of legacyEntries) {
+      if (!entry.isDirectory() || !isSafeSessionId(entry.name)) continue;
+      const legacyDir = path.join(paths.legacySessionsDir, entry.name);
+      const legacyStatePath = path.join(legacyDir, "state.json");
+      const state = await fsp.readFile(legacyStatePath, "utf8").then(JSON.parse).catch(() => null);
+      if (!state?.sessionId && !state?.createdAt) continue;
+
+      const sessionId = isSafeSessionId(state.sessionId) ? state.sessionId : entry.name;
+      const globalDir = path.join(paths.globalSessionsDir, sessionId);
+      const globalStatePath = path.join(globalDir, "state.json");
+      const hasGlobalState = await fsp.stat(globalStatePath).then((stat) => stat.isFile()).catch(() => false);
+      if (!hasGlobalState) {
+        await fsp.mkdir(path.dirname(globalDir), { recursive: true });
+        await fsp.cp(legacyDir, globalDir, { recursive: true, force: false, errorOnExist: false });
+      }
+
+      const pointerDir = path.join(paths.sessionsDir, sessionId);
+      await fsp.mkdir(pointerDir, { recursive: true });
+      const pointer = {
+        sessionId,
+        projectRoot: paths.root,
+        commandCwd: state.commandCwd || paths.root,
+        sessionDir: globalDir,
+        artifactsDir: path.join(globalDir, "artifacts"),
+        createdAt: state.createdAt || state.startedAt || "",
+        updatedAt: state.updatedAt || state.createdAt || "",
+        title: state.title || "",
+        goal: state.goal || "",
+        provider: state.provider || "",
+        model: state.model || "",
+        migratedFrom: legacyDir,
+      };
+      await fsp.writeFile(path.join(pointerDir, "session.json"), `${JSON.stringify(pointer, null, 2)}\n`, "utf8");
+      try {
+        upsertSessionIndex({
+          ...state,
+          sessionId,
+          projectRoot: paths.root,
+          commandCwd: state.commandCwd || paths.root,
+          projectSessionsDir: paths.sessionsDir,
+          sessionDir: globalDir,
+          status: state.status || "saved",
+        });
+      } catch {
+        // Migration should still leave readable pointers even if the global index is unavailable.
+      }
+    }
+  }
+
+  const hasNewDb = await fsp.stat(paths.sessionDbPath).then((stat) => stat.isFile()).catch(() => false);
+  const hasLegacyDb = await fsp.stat(paths.legacySessionDbPath).then((stat) => stat.isFile()).catch(() => false);
+  if (!hasNewDb && hasLegacyDb) {
+    await fsp.copyFile(paths.legacySessionDbPath, paths.sessionDbPath).catch(() => {});
+  }
+
+  return paths;
+}
+
 export function defaultAgintiInstructions() {
   return [
     "# AGINTI.md",
@@ -202,6 +291,7 @@ export async function initProject(projectRoot = process.cwd()) {
   await ensureDir(paths.controlDir);
   await ensureDir(paths.notesDir);
   await ensureDir(paths.sessionsDir);
+  await fsp.mkdir(paths.globalSessionsDir, { recursive: true });
   await ensureFile(
     paths.agintiInstructionsPath,
     defaultAgintiInstructions()
@@ -217,7 +307,8 @@ export async function initProject(projectRoot = process.cwd()) {
       "- `.env` is ignored and can hold local provider keys.",
       "- `.env.example` documents accepted variable names.",
       "- `codebase-map.json` is a generated, ignored project-intelligence cache.",
-      "- `.sessions/` at the project root stores CLI and web run history.",
+      "- `../.aginti-sessions/` stores project-local session pointers and the web UI database.",
+      "- `~/.agintiflow/sessions/<session-id>/` stores canonical session history and artifacts.",
       "",
     ].join("\n")
   );
@@ -256,11 +347,14 @@ export async function initProject(projectRoot = process.cwd()) {
     ".aginti/.env.*",
     "!.aginti/.env.example",
     ".aginti/codebase-map.json",
+    ".aginti-sessions/",
     ".sessions/",
   ]);
   if (gitignore.changed) updated.push(paths.gitignorePath);
   else skipped.push(paths.gitignorePath);
 
+  await ensureProjectSessionStorage(projectRoot);
+
   return {
     ok: true,
     projectRoot: paths.root,
@@ -391,37 +485,66 @@ export async function setProviderKey(projectRoot, provider, value) {
 }
 
 export async function listProjectSessions(projectRoot = process.cwd(), limit = 50) {
-  const paths = projectPaths(projectRoot);
+  const paths = await ensureProjectSessionStorage(projectRoot);
+  const indexed = (() => {
+    try {
+      return listSessionIndex({ projectRoot: paths.root, limit: Math.max(limit, 100) });
+    } catch {
+      return [];
+    }
+  })();
+  const byId = new Map();
+  for (const session of indexed) {
+    if (session.sessionId) byId.set(session.sessionId, session);
+  }
+
   const entries = await fsp.readdir(paths.sessionsDir, { withFileTypes: true }).catch(() => []);
-  const sessions = [];
   for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const statePath = path.join(paths.sessionsDir, entry.name, "state.json");
+    if (!entry.isDirectory() || !isSafeSessionId(entry.name)) continue;
+    const pointerPath = path.join(paths.sessionsDir, entry.name, "session.json");
+    const pointer = await fsp.readFile(pointerPath, "utf8").then(JSON.parse).catch(() => ({}));
+    const statePath = path.join(pointer.sessionDir || path.join(paths.globalSessionsDir, entry.name), "state.json");
+    const state = await fsp.readFile(statePath, "utf8").then(JSON.parse).catch(() => null);
+    const sessionId = state?.sessionId || pointer.sessionId || entry.name;
+    if (!sessionId) continue;
+    const record = {
+      ...byId.get(sessionId),
+      sessionId,
+      projectRoot: paths.root,
+      commandCwd: state?.commandCwd || pointer.commandCwd || paths.root,
+      sessionDir: pointer.sessionDir || path.join(paths.globalSessionsDir, sessionId),
+      provider: state?.provider || pointer.provider || byId.get(sessionId)?.provider || "",
+      model: state?.model || pointer.model || byId.get(sessionId)?.model || "",
+      goal: state?.goal || pointer.goal || byId.get(sessionId)?.goal || "",
+      title: state?.title || pointer.title || byId.get(sessionId)?.title || "",
+      createdAt: state?.createdAt || pointer.createdAt || byId.get(sessionId)?.createdAt || "",
+      updatedAt: state?.updatedAt || pointer.updatedAt || byId.get(sessionId)?.updatedAt || state?.createdAt || "",
+      stepsCompleted: state?.stepsCompleted || 0,
+    };
+    byId.set(sessionId, record);
     try {
-      const state = JSON.parse(await fsp.readFile(statePath, "utf8"));
-      sessions.push({
-        sessionId: state.sessionId || entry.name,
-        provider: state.provider || "",
-        model: state.model || "",
-        goal: state.goal || "",
-        createdAt: state.createdAt || "",
-        updatedAt: state.updatedAt || state.createdAt || "",
-        stepsCompleted: state.stepsCompleted || 0,
+      upsertSessionIndex({
+        ...record,
+        projectSessionsDir: paths.sessionsDir,
+        status: record.status || "saved",
       });
     } catch {
-      // Ignore malformed or unrelated session folders.
+      // Project pointer scanning should not fail when the optional global index is unavailable.
     }
   }
+
+  const sessions = [...byId.values()];
   return sessions.sort((a, b) => String(b.updatedAt).localeCompare(String(a.updatedAt))).slice(0, limit);
 }
 
 export async function showProjectSession(projectRoot, sessionId) {
-  const paths = projectPaths(projectRoot);
+  const paths = await ensureProjectSessionStorage(projectRoot);
   const safeId = String(sessionId || "");
-  if (!/^[A-Za-z0-9._:-]+$/.test(safeId) || safeId.includes("..")) {
+  if (!isSafeSessionId(safeId)) {
     throw new Error("Invalid session id.");
   }
-  const sessionDir = path.join(paths.sessionsDir, safeId);
+  const pointer = await fsp.readFile(path.join(paths.sessionsDir, safeId, "session.json"), "utf8").then(JSON.parse).catch(() => ({}));
+  const sessionDir = pointer.sessionDir || path.join(paths.globalSessionsDir, safeId);
   const state = JSON.parse(await fsp.readFile(path.join(sessionDir, "state.json"), "utf8"));
   let events = [];
   try {
@@ -438,6 +561,8 @@ export async function showProjectSession(projectRoot, sessionId) {
     provider: state.provider || "",
     model: state.model || "",
     goal: state.goal || "",
+    title: state.title || pointer.title || "",
+    commandCwd: state.commandCwd || pointer.commandCwd || paths.root,
     createdAt: state.createdAt || "",
     updatedAt: state.updatedAt || "",
     chat: state.chat || [],
@@ -445,6 +570,59 @@ export async function showProjectSession(projectRoot, sessionId) {
   };
 }
 
+export async function renameProjectSession(projectRoot, sessionId, title) {
+  const paths = await ensureProjectSessionStorage(projectRoot);
+  const safeId = String(sessionId || "");
+  if (!isSafeSessionId(safeId)) throw new Error("Invalid session id.");
+  const cleanTitle = String(title || "").replace(/\s+/g, " ").trim().slice(0, 90);
+  if (!cleanTitle) throw new Error("Title is required.");
+  const pointerPath = path.join(paths.sessionsDir, safeId, "session.json");
+  const pointer = await fsp.readFile(pointerPath, "utf8").then(JSON.parse).catch(() => ({}));
+  const sessionDir = pointer.sessionDir || path.join(paths.globalSessionsDir, safeId);
+  const statePath = path.join(sessionDir, "state.json");
+  const state = await fsp.readFile(statePath, "utf8").then(JSON.parse).catch(() => ({}));
+  const updatedAt = new Date().toISOString();
+  const nextState = {
+    ...state,
+    sessionId: state.sessionId || safeId,
+    title: cleanTitle,
+    updatedAt,
+  };
+  await fsp.mkdir(sessionDir, { recursive: true });
+  await fsp.writeFile(statePath, `${JSON.stringify(nextState, null, 2)}\n`, "utf8");
+  const nextPointer = {
+    ...pointer,
+    sessionId: safeId,
+    projectRoot: paths.root,
+    commandCwd: nextState.commandCwd || pointer.commandCwd || paths.root,
+    sessionDir,
+    artifactsDir: path.join(sessionDir, "artifacts"),
+    title: cleanTitle,
+    updatedAt,
+    goal: nextState.goal || pointer.goal || "",
+    provider: nextState.provider || pointer.provider || "",
+    model: nextState.model || pointer.model || "",
+  };
+  await fsp.mkdir(path.dirname(pointerPath), { recursive: true });
+  await fsp.writeFile(pointerPath, `${JSON.stringify(nextPointer, null, 2)}\n`, "utf8");
+  try {
+    renameSessionIndex(safeId, cleanTitle);
+    upsertSessionIndex({
+      ...nextState,
+      sessionId: safeId,
+      title: cleanTitle,
+      projectRoot: paths.root,
+      commandCwd: nextState.commandCwd || pointer.commandCwd || paths.root,
+      projectSessionsDir: paths.sessionsDir,
+      sessionDir,
+      status: nextState.status || "saved",
+    });
+  } catch {
+    // The title is still persisted in state.json and the project pointer.
+  }
+  return { ok: true, sessionId: safeId, title: cleanTitle, sessionDir };
+}
+
 export async function npmLatestVersion(packageName = "@lazyingart/agintiflow") {
   try {
     const { stdout } = await execFileAsync("npm", ["view", packageName, "version", "--json"], {
@@ -492,6 +670,8 @@ export async function doctorReport(projectRoot, packageVersion, config) {
       controlDir: paths.controlDir,
       sessionsDir: paths.sessionsDir,
       sessionDbPath: paths.sessionDbPath,
+      globalSessionsDir: paths.globalSessionsDir,
+      globalSessionIndexPath: paths.globalSessionIndexPath,
       localEnvPresent: keyStatus.localEnv,
     },
     keys: {

package/src/session-index.js

@@ -0,0 +1,135 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { loadDatabaseSync } from "./sqlite.js";
+
+export const PROJECT_SESSIONS_DIR_NAME = ".aginti-sessions";
+export const LEGACY_PROJECT_SESSIONS_DIR_NAME = ".sessions";
+
+export function agintiflowHome() {
+  return path.resolve(process.env.AGINTIFLOW_HOME || path.join(os.homedir(), ".agintiflow"));
+}
+
+export function globalSessionPaths(sessionId = "") {
+  const home = agintiflowHome();
+  const sessionsDir = path.join(home, "sessions");
+  return {
+    home,
+    sessionsDir,
+    indexDbPath: path.join(sessionsDir, "index.sqlite"),
+    sessionDir: sessionId ? path.join(sessionsDir, sessionId) : "",
+  };
+}
+
+export function isSafeSessionId(sessionId) {
+  const text = String(sessionId || "");
+  return /^[A-Za-z0-9._:-]+$/.test(text) && !text.includes("..");
+}
+
+function ensureIndexDb() {
+  const paths = globalSessionPaths();
+  fs.mkdirSync(paths.sessionsDir, { recursive: true });
+  const DatabaseSync = loadDatabaseSync();
+  const db = new DatabaseSync(paths.indexDbPath);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      session_id TEXT PRIMARY KEY,
+      project_root TEXT NOT NULL DEFAULT '',
+      command_cwd TEXT NOT NULL DEFAULT '',
+      project_sessions_dir TEXT NOT NULL DEFAULT '',
+      session_dir TEXT NOT NULL DEFAULT '',
+      provider TEXT NOT NULL DEFAULT '',
+      model TEXT NOT NULL DEFAULT '',
+      goal TEXT NOT NULL DEFAULT '',
+      title TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT '',
+      created_at TEXT NOT NULL DEFAULT '',
+      updated_at TEXT NOT NULL DEFAULT '',
+      ended_at TEXT,
+      result TEXT NOT NULL DEFAULT '',
+      error TEXT NOT NULL DEFAULT ''
+    );
+  `);
+  const existingColumns = db.prepare("PRAGMA table_info(sessions)").all();
+  if (!existingColumns.some((column) => column.name === "command_cwd")) {
+    db.exec("ALTER TABLE sessions ADD COLUMN command_cwd TEXT NOT NULL DEFAULT ''");
+  }
+  return db;
+}
+
+export function upsertSessionIndex(record = {}) {
+  const sessionId = String(record.sessionId || record.session_id || "").trim();
+  if (!isSafeSessionId(sessionId)) return false;
+  const now = new Date().toISOString();
+  const db = ensureIndexDb();
+  const paths = globalSessionPaths(sessionId);
+  const createdAt = record.createdAt || record.startedAt || record.created_at || now;
+  const updatedAt = record.updatedAt || record.updated_at || createdAt || now;
+  db.prepare(
+    `INSERT INTO sessions (
+       session_id, project_root, command_cwd, project_sessions_dir, session_dir,
+       provider, model, goal, title, status, created_at, updated_at, ended_at, result, error
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(session_id) DO UPDATE SET
+       project_root = CASE WHEN excluded.project_root != '' THEN excluded.project_root ELSE sessions.project_root END,
+       command_cwd = CASE WHEN excluded.command_cwd != '' THEN excluded.command_cwd ELSE sessions.command_cwd END,
+       project_sessions_dir = CASE WHEN excluded.project_sessions_dir != '' THEN excluded.project_sessions_dir ELSE sessions.project_sessions_dir END,
+       session_dir = CASE WHEN excluded.session_dir != '' THEN excluded.session_dir ELSE sessions.session_dir END,
+       provider = CASE WHEN excluded.provider != '' THEN excluded.provider ELSE sessions.provider END,
+       model = CASE WHEN excluded.model != '' THEN excluded.model ELSE sessions.model END,
+       goal = CASE WHEN excluded.goal != '' THEN excluded.goal ELSE sessions.goal END,
+       title = CASE WHEN excluded.title != '' THEN excluded.title ELSE sessions.title END,
+       status = CASE WHEN excluded.status != '' THEN excluded.status ELSE sessions.status END,
+       updated_at = excluded.updated_at,
+       ended_at = excluded.ended_at,
+       result = CASE WHEN excluded.result != '' THEN excluded.result ELSE sessions.result END,
+       error = CASE WHEN excluded.error != '' THEN excluded.error ELSE sessions.error END`
+  ).run(
+    sessionId,
+    String(record.projectRoot || record.project_root || ""),
+    String(record.commandCwd || record.command_cwd || record.projectRoot || record.project_root || ""),
+    String(record.projectSessionsDir || record.project_sessions_dir || ""),
+    String(record.sessionDir || record.session_dir || paths.sessionDir),
+    String(record.provider || ""),
+    String(record.model || ""),
+    String(record.goal || ""),
+    String(record.title || ""),
+    String(record.status || ""),
+    createdAt,
+    updatedAt,
+    record.endedAt || record.ended_at || null,
+    String(record.result || ""),
+    String(record.error || "")
+  );
+  return true;
+}
+
+export function renameSessionIndex(sessionId, title) {
+  if (!isSafeSessionId(sessionId)) return false;
+  const db = ensureIndexDb();
+  const result = db
+    .prepare("UPDATE sessions SET title = ?, updated_at = ? WHERE session_id = ?")
+    .run(String(title || "").trim(), new Date().toISOString(), sessionId);
+  return result.changes > 0;
+}
+
+export function deleteSessionIndex(sessionId) {
+  if (!isSafeSessionId(sessionId)) return false;
+  const db = ensureIndexDb();
+  const result = db.prepare("DELETE FROM sessions WHERE session_id = ?").run(sessionId);
+  return result.changes > 0;
+}
+
+export function listSessionIndex({ projectRoot = "", 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`;
+  if (projectRoot) {
+    return db
+      .prepare(`SELECT ${columns} FROM sessions WHERE project_root = ? ORDER BY updated_at DESC LIMIT ?`)
+      .all(path.resolve(projectRoot), maxRows);
+  }
+  return db.prepare(`SELECT ${columns} FROM sessions ORDER BY updated_at DESC LIMIT ?`).all(maxRows);
+}

package/src/session-store.js

@@ -1,22 +1,51 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import crypto from "node:crypto";
+import { deleteSessionIndex, globalSessionPaths, isSafeSessionId, upsertSessionIndex } from "./session-index.js";
 
 export class SessionStore {
-  constructor(baseDir, sessionId) {
-    this.baseDir = baseDir;
+  constructor(baseDir, sessionId, options = {}) {
+    this.baseDir = path.resolve(baseDir);
     this.sessionId = sessionId;
-    this.sessionDir = path.join(baseDir, sessionId);
+    const globalPaths = globalSessionPaths(sessionId);
+    this.projectRoot = options.projectRoot ? path.resolve(options.projectRoot) : "";
+    this.projectSessionsDir = options.projectSessionsDir ? path.resolve(options.projectSessionsDir) : "";
+    this.legacySessionDir = options.legacySessionDir ? path.resolve(options.legacySessionDir) : "";
+    this.sessionDir = path.resolve(options.sessionDir || (baseDir ? path.join(this.baseDir, sessionId) : globalPaths.sessionDir));
     this.artifactsDir = path.join(this.sessionDir, "artifacts");
     this.statePath = path.join(this.sessionDir, "state.json");
     this.planPath = path.join(this.sessionDir, "plan.md");
     this.eventsPath = path.join(this.sessionDir, "events.jsonl");
     this.inboxPath = path.join(this.sessionDir, "inbox.jsonl");
     this.storageStatePath = path.join(this.sessionDir, "storage-state.json");
+    this.pointerDir = this.projectSessionsDir && isSafeSessionId(sessionId) ? path.join(this.projectSessionsDir, sessionId) : "";
+    this.pointerPath = this.pointerDir ? path.join(this.pointerDir, "session.json") : "";
   }
 
   async ensure() {
     await fs.mkdir(this.artifactsDir, { recursive: true });
+    await this.writePointer().catch(() => {});
+  }
+
+  async writePointer(state = {}) {
+    if (!this.pointerPath) return;
+    await fs.mkdir(this.pointerDir, { recursive: true });
+    const existing = await fs.readFile(this.pointerPath, "utf8").then(JSON.parse).catch(() => ({}));
+    const now = new Date().toISOString();
+    const payload = {
+      sessionId: this.sessionId,
+      projectRoot: this.projectRoot,
+      commandCwd: state.commandCwd || existing.commandCwd || this.projectRoot,
+      sessionDir: this.sessionDir,
+      artifactsDir: this.artifactsDir,
+      createdAt: state.createdAt || state.startedAt || existing.createdAt || now,
+      updatedAt: state.updatedAt || existing.updatedAt || now,
+      title: state.title || existing.title || "",
+      goal: state.goal || existing.goal || "",
+      provider: state.provider || existing.provider || "",
+      model: state.model || existing.model || "",
+    };
+    await fs.writeFile(this.pointerPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
   }
 
   async loadState() {
@@ -24,6 +53,14 @@ export class SessionStore {
       const raw = await fs.readFile(this.statePath, "utf8");
       return JSON.parse(raw);
     } catch {
+      if (this.legacySessionDir) {
+        try {
+          const raw = await fs.readFile(path.join(this.legacySessionDir, "state.json"), "utf8");
+          return JSON.parse(raw);
+        } catch {
+          return null;
+        }
+      }
       return null;
     }
   }
@@ -31,6 +68,19 @@ export class SessionStore {
   async saveState(state) {
     await this.ensure();
     await fs.writeFile(this.statePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+    await this.writePointer(state).catch(() => {});
+    try {
+      upsertSessionIndex({
+        ...state,
+        sessionId: this.sessionId,
+        projectRoot: this.projectRoot,
+        projectSessionsDir: this.projectSessionsDir,
+        sessionDir: this.sessionDir,
+        status: state.status || "saved",
+      });
+    } catch {
+      // Session state remains durable even if the optional global index is unavailable.
+    }
   }
 
   async savePlan(planText) {
@@ -66,6 +116,18 @@ export class SessionStore {
         .filter(Boolean)
         .map((line) => JSON.parse(line));
     } catch {
+      if (this.legacySessionDir) {
+        try {
+          const raw = await fs.readFile(path.join(this.legacySessionDir, "events.jsonl"), "utf8");
+          return raw
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => JSON.parse(line));
+        } catch {
+          return [];
+        }
+      }
       return [];
     }
   }
@@ -131,5 +193,7 @@ export class SessionStore {
 
   async remove() {
     await fs.rm(this.sessionDir, { recursive: true, force: true });
+    if (this.pointerDir) await fs.rm(this.pointerDir, { recursive: true, force: true }).catch(() => {});
+    deleteSessionIndex(this.sessionId);
   }
 }

package/src/skill-library.js

@@ -102,14 +102,28 @@ function scoreSkill(skill, text, taskProfile) {
   if (skill.triggers.includes(taskProfile)) score += 6;
   for (const trigger of skill.triggers) {
     const needle = trigger.toLowerCase();
-    if (needle && text.includes(needle)) score += Math.max(2, Math.min(6, Math.ceil(needle.length / 6)));
+    if (needle && textHasTrigger(text, needle)) score += Math.max(2, Math.min(6, Math.ceil(needle.length / 6)));
   }
   for (const token of skill.description.toLowerCase().split(/[^a-z0-9+#.-]+/).filter((item) => item.length > 3)) {
-    if (text.includes(token)) score += 0.25;
+    if (textHasTrigger(text, token)) score += 0.25;
   }
   return score;
 }
 
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function textHasTrigger(text, needle) {
+  if (!needle) return false;
+  if (/^[a-z0-9]+(?:[\s_-]+[a-z0-9]+)*$/.test(needle)) {
+    const parts = needle.split(/[\s_-]+/).filter(Boolean).map(escapeRegExp);
+    if (parts.length === 0) return false;
+    return new RegExp(`(^|[^a-z0-9])${parts.join("[^a-z0-9]+")}([^a-z0-9]|$)`).test(text);
+  }
+  return text.includes(needle);
+}
+
 export function selectSkillsForGoal(goal = "", { taskProfile = "auto", limit = 6, includeBody = true } = {}) {
   const text = `${goal} ${taskProfile}`.toLowerCase();
   const skills = listSkills({ includeBody });

package/src/sqlite.js

@@ -0,0 +1,19 @@
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+let cachedDatabaseSync = null;
+
+export function loadDatabaseSync() {
+  if (cachedDatabaseSync) return cachedDatabaseSync;
+  const originalEmitWarning = process.emitWarning;
+  process.emitWarning = function filteredSqliteWarning(warning, ...args) {
+    if (String(warning || "").includes("SQLite is an experimental feature")) return;
+    return originalEmitWarning.call(process, warning, ...args);
+  };
+  try {
+    cachedDatabaseSync = require("node:sqlite").DatabaseSync;
+    return cachedDatabaseSync;
+  } finally {
+    process.emitWarning = originalEmitWarning;
+  }
+}

package/src/static-preview-server.js

@@ -48,7 +48,14 @@ function isBlockedPath(relativePath) {
   const segments = relativePath.split(path.sep).filter(Boolean);
   const lowerBase = (segments.at(-1) || "").toLowerCase();
   const lowerPath = segments.join("/").toLowerCase();
-  if (segments.includes(".git") || segments.includes("node_modules") || segments.includes(".sessions")) return true;
+  if (
+    segments.includes(".git") ||
+    segments.includes("node_modules") ||
+    segments.includes(".sessions") ||
+    segments.includes(".aginti-sessions")
+  ) {
+    return true;
+  }
   if (lowerBase === ".env" || lowerBase.startsWith(".env.")) return true;
   if (lowerBase === ".npmrc" || lowerBase === ".pypirc") return true;
   return /(^|\/)(secrets?|tokens?|passwords?|private[-_]?keys?|credentials?)(\/|\.|$)/i.test(lowerPath);