@ulpi/cli 0.1.1 → 0.1.2

package/dist/{dist-LZKZFPVX.js → dist-MFFX7TZW.js}

@@ -46,6 +46,7 @@ import {
   parseSourceWithLanguage,
   processIncremental,
   queryBM25,
+  rebuildDepgraph,
   recallAtK,
   releaseCodemapLock,
   removeDocuments,
@@ -60,18 +61,19 @@ import {
   searchCode,
   searchSymbols,
   tokenize
-} from "./chunk-DBMUNBNB.js";
+} from "./chunk-VGZLMUNO.js";
 import "./chunk-NNUWU6CV.js";
 import "./chunk-YM2HV4IA.js";
 import "./chunk-74WVVWJ4.js";
 import "./chunk-KIKPIH6N.js";
+import "./chunk-ZLYRPD7I.js";
 import {
   OpenAIEmbedder
 } from "./chunk-2HEE5OKX.js";
+import "./chunk-7LXY5UVC.js";
 import {
   OllamaEmbedder
 } from "./chunk-KLEASXUR.js";
-import "./chunk-7LXY5UVC.js";
 import "./chunk-4VNS5WPM.js";
 export {
   CodemapStore,
@@ -123,6 +125,7 @@ export {
   parseSourceWithLanguage,
   processIncremental,
   queryBM25,
+  rebuildDepgraph,
   recallAtK,
   releaseCodemapLock,
   removeDocuments,

package/dist/{dist-W7K4WPAF.js → dist-QYFQYSXP.js}

@@ -4,32 +4,33 @@ import {
   Server,
   StdioServerTransport
 } from "./chunk-JWUUVXIV.js";
-import {
-  getIncomingEdges,
-  getOutgoingEdges,
-  getTransitiveDeps,
-  getTransitiveRdeps,
-  loadGraph,
-  loadMetrics,
-  loadPageRank
-} from "./chunk-247GVVKK.js";
 import {
   getCodemapStatus,
   loadManifest,
   loadSymbolIndex,
+  rebuildDepgraph,
   runInitPipeline,
   searchCode,
   searchSymbols
-} from "./chunk-DBMUNBNB.js";
+} from "./chunk-VGZLMUNO.js";
 import "./chunk-NNUWU6CV.js";
 import "./chunk-YM2HV4IA.js";
 import "./chunk-74WVVWJ4.js";
 import "./chunk-KIKPIH6N.js";
+import {
+  getIncomingEdges,
+  getOutgoingEdges,
+  getTransitiveDeps,
+  getTransitiveRdeps,
+  loadGraph,
+  loadMetrics,
+  loadPageRank
+} from "./chunk-ZLYRPD7I.js";
 import "./chunk-2HEE5OKX.js";
-import "./chunk-KLEASXUR.js";
 import {
   getCurrentBranch
 } from "./chunk-7LXY5UVC.js";
+import "./chunk-KLEASXUR.js";
 import "./chunk-4VNS5WPM.js";
 
 // ../../packages/codemap-mcp/dist/index.js
@@ -531,6 +532,31 @@ async function handleGetDepgraphStats(projectDir, _args, branch) {
     content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
   };
 }
+var rebuildDepgraphTool = {
+  name: "rebuild_depgraph",
+  description: "Rebuild the dependency graph (tags, PageRank, cycles, coupling) without re-embedding. Faster than full reindex when only the depgraph is missing or stale.",
+  inputSchema: {
+    type: "object",
+    properties: {}
+  }
+};
+async function handleRebuildDepgraph(projectDir, _args, branch) {
+  const result = await rebuildDepgraph(projectDir, void 0, branch);
+  const payload = {
+    nodeCount: result.nodeCount,
+    edgeCount: result.edgeCount,
+    definitionCount: result.definitionCount,
+    referenceCount: result.referenceCount,
+    cycleCount: result.cycleCount,
+    taggedFiles: result.taggedFiles,
+    totalFiles: result.totalFiles,
+    durationMs: result.durationMs,
+    summary: `Rebuilt depgraph: ${result.nodeCount} nodes, ${result.edgeCount} edges, ${result.definitionCount} defs, ${result.referenceCount} refs, ${result.cycleCount} cycles (${result.taggedFiles}/${result.totalFiles} files tagged) in ${(result.durationMs / 1e3).toFixed(1)}s`
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+  };
+}
 var ALL_TOOLS = [
   searchCodeTool,
   searchSymbolsTool,
@@ -542,7 +568,8 @@ var ALL_TOOLS = [
   getFileRankTool,
   findCyclesTool,
   getCouplingMetricsTool,
-  getDepgraphStatsTool
+  getDepgraphStatsTool,
+  rebuildDepgraphTool
 ];
 var HANDLERS = {
   search_code: handleSearchCode,
@@ -555,7 +582,8 @@ var HANDLERS = {
   get_file_rank: handleGetFileRank,
   find_cycles: handleFindCycles,
   get_coupling_metrics: handleGetCouplingMetrics,
-  get_depgraph_stats: handleGetDepgraphStats
+  get_depgraph_stats: handleGetDepgraphStats,
+  rebuild_depgraph: handleRebuildDepgraph
 };
 function createMcpServer(options) {
   const server = new Server(

package/dist/{dist-R5ZJ4LX5.js → dist-YA2BWZB2.js}

@@ -24,7 +24,7 @@ import {
   savePageRank,
   saveTagsCache,
   updateCacheEntry
-} from "./chunk-247GVVKK.js";
+} from "./chunk-ZLYRPD7I.js";
 import "./chunk-7LXY5UVC.js";
 import "./chunk-4VNS5WPM.js";
 export {

package/dist/{history-Q2LDADFW.js → history-UG65BCO6.js}

@@ -318,6 +318,8 @@ function enrichEntry(entry, rawEvents, model = DEFAULT_AI_MODEL) {
       reject(new Error("Claude CLI not found"));
       return;
     }
+    const env = { ...process.env };
+    delete env.CLAUDECODE;
     const proc = spawn(claudePath, [
       "--print",
       "--model",
@@ -329,7 +331,8 @@ function enrichEntry(entry, rawEvents, model = DEFAULT_AI_MODEL) {
       "--permission-mode",
       "bypassPermissions"
     ], {
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      env
     });
     let stdout = "";
     let stderr = "";
@@ -412,7 +415,7 @@ async function initSubcommand(projectDir) {
   }
   const projectName = path2.basename(projectDir);
   try {
-    initHistoryBranch(projectDir, projectName, "0.1.1");
+    initHistoryBranch(projectDir, projectName, "0.1.2");
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     console.log(chalk.red(`Error: ${message}`));

package/dist/index.js

@@ -138,10 +138,10 @@ async function handleSessionStart(ctx) {
   if (shouldPromptForGeneration(projectDir2)) {
     outputGenerationPrompt();
   }
-  import("./version-checker-M37KI7DY.js").then((m) => m.checkForUpdates()).catch(() => {
+  import("./version-checker-DTAS4ZYK.js").then((m) => m.checkForUpdates()).catch(() => {
   });
   try {
-    const { isMemoryEnabled, loadMemoryConfig, getTopMemories, formatMemoriesForAgent } = await import("./dist-R5F4MX3I.js");
+    const { isMemoryEnabled, loadMemoryConfig, getTopMemories, formatMemoriesForAgent } = await import("./dist-57UMTPGR.js");
     if (isMemoryEnabled(projectDir2)) {
       const config = loadMemoryConfig(projectDir2);
       if (config.surfaceOnStart) {
@@ -155,7 +155,7 @@ async function handleSessionStart(ctx) {
   } catch {
   }
   try {
-    const { loadCodemapConfig } = await import("./dist-LZKZFPVX.js");
+    const { loadCodemapConfig } = await import("./dist-MFFX7TZW.js");
     const { getCodemapBranch, getCurrentBranch } = await import("./dist-RKOGLK7R.js");
     const { historyBranchExists: historyBranchExists2 } = await import("./dist-RJGCUS3L.js");
     const codemapConfig = loadCodemapConfig(projectDir2);
@@ -163,7 +163,7 @@ async function handleSessionStart(ctx) {
       const branch = state.branch ?? getCurrentBranch(projectDir2);
       const shadowBranch = getCodemapBranch(branch);
       if (historyBranchExists2(projectDir2, shadowBranch)) {
-        const { importIndex } = await import("./dist-LZKZFPVX.js");
+        const { importIndex } = await import("./dist-MFFX7TZW.js");
         await importIndex(projectDir2, branch);
       }
     }
@@ -1473,7 +1473,7 @@ ${failureFeedback.join("\n\n")}`
     }
   }
   try {
-    const { isMemoryEnabled, loadMemoryConfig, appendMemoryEvent, toClassificationEvent } = await import("./dist-R5F4MX3I.js");
+    const { isMemoryEnabled, loadMemoryConfig, appendMemoryEvent, toClassificationEvent } = await import("./dist-57UMTPGR.js");
     if (isMemoryEnabled(projectDir2)) {
       const memConfig = loadMemoryConfig(projectDir2);
       if (memConfig.captureMode === "continuous") {
@@ -1493,7 +1493,7 @@ ${failureFeedback.join("\n\n")}`
   }
   if (input.tool_name === "Bash" && /\bgit\s+push\b/.test(String(input.tool_input?.command ?? ""))) {
     try {
-      const { loadCodemapConfig, getCodemapStatus, exportIndex } = await import("./dist-LZKZFPVX.js");
+      const { loadCodemapConfig, getCodemapStatus, exportIndex } = await import("./dist-MFFX7TZW.js");
       const { getCurrentBranch } = await import("./dist-RKOGLK7R.js");
       const codemapConfig = loadCodemapConfig(projectDir2);
       if (codemapConfig.autoExport) {
@@ -1747,6 +1747,7 @@ ${warnings.map((w) => `  - ${w}`).join("\n")}`
 }
 
 // src/hooks/session-end.ts
+import { spawn } from "child_process";
 async function captureSessionCommits(ctx) {
   const { input, state, projectDir: projectDir2 } = ctx;
   if (!state.headAtStart) return;
@@ -1834,24 +1835,35 @@ async function handleSessionEnd(ctx) {
   } catch {
   }
   try {
-    const memEngine = await import("./dist-R5F4MX3I.js");
+    const memEngine = await import("./dist-57UMTPGR.js");
     if (memEngine.isMemoryEnabled(projectDir2)) {
       const config = memEngine.loadMemoryConfig(projectDir2);
       memEngine.finalizeCapture(input.session_id, state, projectDir2);
       if (config.classifier.enabled) {
-        await memEngine.classifySession(projectDir2, input.session_id);
-      }
-      if (config.autoExport) {
         try {
-          memEngine.exportMemories(projectDir2);
+          const args2 = ["memory", "classify", "-p", projectDir2, "--session", input.session_id];
+          if (config.autoExport) args2.push("--export");
+          const child = spawn(process.execPath, [process.argv[1], ...args2], {
+            detached: true,
+            stdio: "ignore",
+            env: { ...process.env, ULPI_BG_CLASSIFY: "1" }
+          });
+          child.unref();
+        } catch {
+        }
+      } else if (config.autoExport) {
+        try {
+          await memEngine.exportMemories(projectDir2);
         } catch {
         }
       }
     }
-  } catch {
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[ulpi] Memory capture failed: ${msg}`);
   }
   try {
-    const { loadCodemapConfig, getCodemapStatus, exportIndex } = await import("./dist-LZKZFPVX.js");
+    const { loadCodemapConfig, getCodemapStatus, exportIndex } = await import("./dist-MFFX7TZW.js");
     const { getCurrentBranch } = await import("./dist-RKOGLK7R.js");
     const codemapConfig = loadCodemapConfig(projectDir2);
     if (codemapConfig.autoExport) {
@@ -2022,7 +2034,7 @@ async function main() {
   switch (command) {
     case "init": {
       const initDir = rawArgs.some((a) => a === "--project" || a === "-p") ? projectDir : process.cwd();
-      return (await import("./init-AY5C2ZAS.js")).runInit([initDir, ...args.slice(1)]);
+      return (await import("./init-22PO3EQB.js")).runInit([initDir, ...args.slice(1)]);
     }
     case "rules":
       return (await import("./rules-E427DKYJ.js")).runRules(args.slice(1), projectDir);
@@ -2041,24 +2053,24 @@ async function main() {
     case "uninstall":
       return (await import("./uninstall-6SW35IK4.js")).runUninstall(args.slice(1), projectDir);
     case "ui":
-      return (await import("./ui-L7UAWXDY.js")).runUI(args.slice(1), projectDir);
+      return (await import("./ui-3EFREFSY.js")).runUI(args.slice(1), projectDir);
     case "update":
-      return (await import("./update-DJ227LL3.js")).runUpdate(args.slice(1));
+      return (await import("./update-364RHTAO.js")).runUpdate(args.slice(1));
     case "history":
-      return (await import("./history-Q2LDADFW.js")).runHistory(args.slice(1), projectDir);
+      return (await import("./history-UG65BCO6.js")).runHistory(args.slice(1), projectDir);
     case "review":
       return (await import("./review-ADUPV3PN.js")).runReview(args.slice(1), projectDir);
     case "config":
       return (await import("./config-EGAXXCGL.js")).runConfig(args.slice(1));
     case "codemap":
-      return (await import("./codemap-RRJIDBQ5.js")).runCodemap(args.slice(1), projectDir);
+      return (await import("./codemap-3BVYMMVM.js")).runCodemap(args.slice(1), projectDir);
     case "memory":
-      return (await import("./memory-J3G24QHS.js")).runMemory(args.slice(1), projectDir);
+      return (await import("./memory-IT4H3WRD.js")).runMemory(args.slice(1), projectDir);
     case "projects":
       return (await import("./projects-ATHDD3D6.js")).runProjects(args.slice(1));
     case "--version":
     case "-v":
-      console.log("0.1.1");
+      console.log("0.1.2");
       return;
     case "--help":
     case "-h":

package/dist/{init-AY5C2ZAS.js → init-22PO3EQB.js}

@@ -121,8 +121,8 @@ async function runInit(args) {
   } catch {
   }
   try {
-    const { runInitPipeline } = await import("./dist-LZKZFPVX.js");
-    const { initMemoryBranch } = await import("./dist-R5F4MX3I.js");
+    const { runInitPipeline } = await import("./dist-MFFX7TZW.js");
+    const { initMemoryBranch } = await import("./dist-57UMTPGR.js");
     console.log(chalk.cyan("\nInitializing code index..."));
     try {
       await runInitPipeline(projectDir, (progress) => {

package/dist/{memory-J3G24QHS.js → memory-IT4H3WRD.js}

@@ -37,7 +37,7 @@ Subcommands:
   export                  Push memories to git branch
   import                  Pull memories from git branch
   serve                   Start MCP server (stdio)
-  classify [session-id]   Run classifier on a captured session
+  classify [session-id]   Classify session(s) \u2014 all unclassified if no ID given
   enable                  Enable memory capture
   disable                 Disable memory capture
 `.trim());
@@ -45,7 +45,7 @@ Subcommands:
 }
 async function initSubcommand(projectDir) {
   console.log(chalk.bold("\nAgent Memory -- Initialize\n"));
-  const { isMemoryInitialized, saveMemoryConfig, DEFAULT_MEMORY_CONFIG } = await import("./dist-R5F4MX3I.js");
+  const { isMemoryInitialized, saveMemoryConfig, DEFAULT_MEMORY_CONFIG } = await import("./dist-57UMTPGR.js");
   const { projectMemoryDir } = await import("./dist-RKOGLK7R.js");
   const fs = await import("fs");
   if (isMemoryInitialized(projectDir)) {
@@ -99,7 +99,7 @@ async function searchSubcommand(args, projectDir) {
   const ora = (await import("ora")).default;
   const spinner = ora("Searching memories...").start();
   try {
-    const { searchMemory, isMemoryInitialized } = await import("./dist-R5F4MX3I.js");
+    const { searchMemory, isMemoryInitialized } = await import("./dist-57UMTPGR.js");
     if (!isMemoryInitialized(projectDir)) {
       spinner.fail("Memory not initialized");
       console.log(chalk.dim("Run 'ulpi memory init' first."));
@@ -165,7 +165,7 @@ async function rememberSubcommand(args, projectDir) {
     console.log(chalk.dim('\nExample: ulpi memory remember "Always run tests before committing" --type PREFERENCE --importance high'));
     return;
   }
-  const { isMemoryInitialized } = await import("./dist-R5F4MX3I.js");
+  const { isMemoryInitialized } = await import("./dist-57UMTPGR.js");
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     return;
@@ -185,7 +185,7 @@ async function rememberSubcommand(args, projectDir) {
   const ora = (await import("ora")).default;
   const spinner = ora("Storing memory...").start();
   try {
-    const { generateMemoryId, rememberMemory } = await import("./dist-R5F4MX3I.js");
+    const { generateMemoryId, rememberMemory } = await import("./dist-57UMTPGR.js");
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const entry = {
       id: generateMemoryId(memType, text),
@@ -211,7 +211,7 @@ async function rememberSubcommand(args, projectDir) {
   }
 }
 async function statusSubcommand(projectDir) {
-  const { isMemoryInitialized, getMemoryStats, isMemoryEnabled, loadMemoryConfig } = await import("./dist-R5F4MX3I.js");
+  const { isMemoryInitialized, getMemoryStats, isMemoryEnabled, loadMemoryConfig } = await import("./dist-57UMTPGR.js");
   console.log(chalk.bold("\nAgent Memory Status\n"));
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.yellow("  Not initialized"));
@@ -252,17 +252,18 @@ async function statusSubcommand(projectDir) {
 }
 async function exportSubcommand(projectDir) {
   console.log(chalk.bold("\nAgent Memory -- Export\n"));
-  const { isMemoryInitialized, exportMemories } = await import("./dist-R5F4MX3I.js");
+  const { isMemoryInitialized, exportMemories } = await import("./dist-57UMTPGR.js");
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     return;
   }
   try {
-    const result = exportMemories(projectDir);
+    const result = await exportMemories(projectDir);
     console.log(chalk.green("\u2713 Export complete"));
     console.log(chalk.dim(`  Branch:   ${result.branchName}`));
     console.log(chalk.dim(`  Commit:   ${result.commitSha.slice(0, 8)}`));
     console.log(chalk.dim(`  Memories: ${result.memoriesExported}`));
+    console.log(chalk.dim(`  Files:    ${result.filesExported}`));
     console.log("");
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -271,15 +272,16 @@ async function exportSubcommand(projectDir) {
 }
 async function importSubcommand(projectDir) {
   console.log(chalk.bold("\nAgent Memory -- Import\n"));
-  const { importMemories } = await import("./dist-R5F4MX3I.js");
+  const { importMemories } = await import("./dist-57UMTPGR.js");
   try {
-    const result = importMemories(projectDir);
+    const result = await importMemories(projectDir);
     if (!result.success) {
       console.log(chalk.yellow(`Import skipped: ${result.message}`));
       return;
     }
     console.log(chalk.green("\u2713 Import complete"));
     console.log(chalk.dim(`  Imported: ${result.memoriesImported}`));
+    console.log(chalk.dim(`  Files:    ${result.filesImported}`));
     console.log(chalk.dim(`  ${result.message}`));
     console.log("");
   } catch (err) {
@@ -288,34 +290,122 @@ async function importSubcommand(projectDir) {
   }
 }
 async function serveSubcommand(projectDir) {
-  const { isMemoryInitialized } = await import("./dist-R5F4MX3I.js");
+  const { isMemoryInitialized } = await import("./dist-57UMTPGR.js");
   if (!isMemoryInitialized(projectDir)) {
     console.error(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     process.exit(1);
   }
   console.error(chalk.dim("[memory-mcp] Starting MCP server..."));
   console.error(chalk.dim(`[memory-mcp] Project: ${projectDir}`));
-  const { startMemoryMcpServer } = await import("./dist-7LHZ65GC.js");
+  const { startMemoryMcpServer } = await import("./dist-3SNTTNM3.js");
   await startMemoryMcpServer({ projectDir });
 }
 async function classifySubcommand(args, projectDir) {
-  const { isMemoryInitialized, listCapturedSessions, classifySession } = await import("./dist-R5F4MX3I.js");
+  const { isMemoryInitialized, listCapturedSessions, classifySession, loadWatermark } = await import("./dist-57UMTPGR.js");
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     return;
   }
-  let sessionId = args.filter((a) => !a.startsWith("--"))[0];
-  if (!sessionId) {
-    const sessions = listCapturedSessions(projectDir);
-    if (sessions.length === 0) {
-      console.log(chalk.yellow("No captured sessions found."));
-      console.log(chalk.dim("Sessions are captured automatically at session end when memory is enabled."));
+  const ora = (await import("ora")).default;
+  const doExport = args.includes("--export");
+  const isBg = !!process.env.ULPI_BG_CLASSIFY;
+  let sessionId;
+  const sessionFlagIdx = args.indexOf("--session");
+  if (sessionFlagIdx !== -1 && args[sessionFlagIdx + 1]) {
+    sessionId = args[sessionFlagIdx + 1];
+  } else {
+    const skipNext = /* @__PURE__ */ new Set();
+    if (sessionFlagIdx !== -1) skipNext.add(sessionFlagIdx + 1);
+    for (let i = 0; i < args.length; i++) {
+      if (skipNext.has(i) || args[i].startsWith("--")) continue;
+      sessionId = args[i];
+      break;
+    }
+  }
+  if (sessionId) {
+    if (isBg) {
+      try {
+        await classifySession(projectDir, sessionId);
+      } catch {
+      }
+      if (doExport) {
+        try {
+          const { exportMemories } = await import("./dist-57UMTPGR.js");
+          await exportMemories(projectDir);
+        } catch {
+        }
+      }
       return;
     }
-    const latest = sessions[sessions.length - 1];
-    sessionId = latest.sessionId;
-    console.log(chalk.dim(`Using latest session: ${sessionId}`));
+    await classifySingleSession(projectDir, sessionId, classifySession);
+    if (doExport) {
+      try {
+        const { exportMemories } = await import("./dist-57UMTPGR.js");
+        const result = await exportMemories(projectDir);
+        console.log(chalk.green(`\u2713 Exported ${result.memoriesExported} memories to ${result.branchName}`));
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(chalk.yellow(`  Export skipped: ${msg}`));
+      }
+    }
+    return;
+  }
+  const sessions = listCapturedSessions(projectDir);
+  if (sessions.length === 0) {
+    console.log(chalk.yellow("No captured sessions found."));
+    console.log(chalk.dim("Sessions are captured automatically at session end when memory is enabled."));
+    return;
+  }
+  const unclassified = sessions.filter((s) => {
+    const wm = loadWatermark(projectDir, s.sessionId);
+    return !wm;
+  });
+  if (unclassified.length === 0) {
+    console.log(chalk.yellow("All captured sessions have been classified."));
+    console.log(chalk.dim(`  Total sessions: ${sessions.length}`));
+    return;
+  }
+  console.log(chalk.bold(`
+Agent Memory -- Classify Sessions
+`));
+  console.log(chalk.dim(`  Found ${unclassified.length} unclassified session(s)
+`));
+  let totalExtracted = 0;
+  let totalStored = 0;
+  let succeeded = 0;
+  let failed = 0;
+  for (let i = 0; i < unclassified.length; i++) {
+    const session = unclassified[i];
+    const label = `[${i + 1}/${unclassified.length}] ${session.sessionId.slice(0, 8)}... (${session.filesWritten} writes, ${session.commandsRun} cmds)`;
+    const spinner = ora(label).start();
+    try {
+      const result = await classifySession(projectDir, session.sessionId, (progress) => {
+        const pct = progress.total > 0 ? ` (${Math.round(progress.current / progress.total * 100)}%)` : "";
+        spinner.text = `${label} \u2014 ${progress.message}${pct}`;
+      });
+      totalExtracted += result.memoriesExtracted;
+      totalStored += result.memoriesStored;
+      succeeded++;
+      if (result.memoriesStored > 0) {
+        spinner.succeed(`${label} \u2014 ${result.memoriesStored} memories stored`);
+      } else {
+        spinner.info(`${label} \u2014 no new memories`);
+      }
+    } catch (err) {
+      failed++;
+      const message = err instanceof Error ? err.message : String(err);
+      spinner.fail(`${label} \u2014 ${message}`);
+    }
   }
+  console.log("");
+  console.log(chalk.bold("  Summary"));
+  console.log(chalk.dim(`    Sessions processed: ${succeeded}/${unclassified.length}`));
+  if (failed > 0) console.log(chalk.red(`    Failed:             ${failed}`));
+  console.log(chalk.dim(`    Memories extracted: ${totalExtracted}`));
+  console.log(chalk.dim(`    Memories stored:    ${totalStored}`));
+  console.log("");
+}
+async function classifySingleSession(projectDir, sessionId, classifySession) {
   console.log(chalk.bold(`
 Agent Memory -- Classify Session
 `));
@@ -340,7 +430,7 @@ Agent Memory -- Classify Session
   }
 }
 async function enableSubcommand(projectDir) {
-  const { loadMemoryConfig, saveMemoryConfig, isMemoryInitialized } = await import("./dist-R5F4MX3I.js");
+  const { loadMemoryConfig, saveMemoryConfig, isMemoryInitialized } = await import("./dist-57UMTPGR.js");
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     return;
@@ -351,7 +441,7 @@ async function enableSubcommand(projectDir) {
   console.log(chalk.green("\u2713 Memory capture enabled"));
 }
 async function disableSubcommand(projectDir) {
-  const { loadMemoryConfig, saveMemoryConfig, isMemoryInitialized } = await import("./dist-R5F4MX3I.js");
+  const { loadMemoryConfig, saveMemoryConfig, isMemoryInitialized } = await import("./dist-57UMTPGR.js");
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     return;

package/dist/{server-MOYPE4SM-N7SE2AN7.js → server-KYER5KX3-43RQQ4MY.js}

@@ -1,6 +1,6 @@
 import {
   createApiServer
-} from "./chunk-Q4HIY43N.js";
+} from "./chunk-UA6EFK64.js";
 import "./chunk-MIAQVCFW.js";
 import "./chunk-2MZER6ND.js";
 import "./chunk-3SBPZRB5.js";