@hir4ta/mneme 0.20.2 → 0.22.0

package/README.md

@@ -1,5 +1,7 @@
 # mneme
 
+![Version](https://img.shields.io/badge/version-0.22.0-blue)
+![Node.js](https://img.shields.io/badge/node-%3E%3D22.5.0-brightgreen)
 [![NPM Version](https://img.shields.io/npm/v/%40hir4ta%2Fmneme)](https://www.npmjs.com/package/@hir4ta/mneme)
 [![MIT License](https://img.shields.io/npm/l/%40hir4ta%2Fmneme)](https://github.com/hir4ta/mneme/blob/main/LICENSE)
 
@@ -9,41 +11,26 @@ Provides automatic session saving, intelligent memory search, and web dashboard
 
 ## Features
 
-### Core Features
 - **Incremental save**: Save only new interactions on each turn completion (Node.js, fast)
 - **Auto memory search**: Related past sessions/decisions automatically injected on each prompt
 - **PreCompact support**: Catch up unsaved interactions before Auto-Compact (context 95% full)
 - **Full data extraction**: Save summary, decisions, patterns, and rules with `/mneme:save`
-- **Memory-informed planning**: Design and plan with past knowledge via `/mneme:plan`
 - **Session Resume**: Resume past sessions with `/mneme:resume` (with chain tracking)
 - **Session Suggestion**: Recent 3 sessions shown at session start
-- **Rule-based Review**: Code review based on `dev-rules.json` / `review-guidelines.json`
-- **GitHub PR Review**: Review GitHub PRs with `/mneme:review <PR URL>`
-- **Knowledge Harvesting**: Extract rules and patterns from PR comments with `/mneme:harvest`
-- **Weekly Reports**: Auto-generate Markdown reports aggregating review results
-- **Web Dashboard**: View sessions, decisions, patterns, and rules
+- **Knowledge Harvesting**: Extract decision/pattern/rule sources from PR comments with `/mneme:harvest`
+- **Web Dashboard**: View sessions, source artifacts, and development rules
+- **Development Rules + Approval**: Generate rules from decisions/patterns/rules and approve/reject inline
+- **Knowledge Graph Layer**: Visualize sessions and approved development rules as one graph
 
 ## Problems Solved
 
-### Common Issues in Claude Code Development
+Claude Code sessions lose context on exit or Auto-Compact, making past decisions untraceable and knowledge hard to reuse.
 
-- **Context Loss**: Conversation context is lost on session end or Auto-Compact
-- **Opaque Decisions**: "Why did we choose this design?" becomes untraceable
-- **Repeated Mistakes**: Same errors solved multiple times without learning
-- **Hard to Reuse Knowledge**: Past interactions and decisions are hard to search
+**Common Issues**: Context loss across sessions, repeated mistakes, opaque design decisions
 
-### What mneme Enables
+**What mneme Enables**: Auto-save with resume, automatic memory search on every prompt, searchable decision/pattern history
 
-- **Auto-save + Resume** enables context continuity across sessions
-- **Auto memory search** brings relevant past knowledge to every conversation
-- **Decision & Pattern Recording** tracks reasoning and error solutions
-- **Search and Dashboard** for quick access to past records
-- **Review Feature** for repository-specific code review
-
-### Team Benefits
-
-- `.mneme/` JSON files are **Git-manageable**, enabling team sharing of decisions and session history
-- Quickly understand background and context during onboarding or reviews
+**Team Benefits**: `.mneme/` JSON files are Git-managed, enabling team sharing of decisions and session history.
 
 ## Installation
 
@@ -119,62 +106,29 @@ This will auto-update on Claude Code startup.
 
 ## Usage
 
-### Incremental Save
-
-**Conversation logs are auto-saved on each turn completion** (Node.js streaming). No configuration needed.
-
-- **Stop hook**: Saves only new interactions on each assistant response completion
-- **PreCompact hook**: Catches up unsaved interactions before Auto-Compact
-- **SessionEnd hook**: Lightweight cleanup only (no heavy processing)
-
-**If you don't run `/mneme:save`, conversation history is deleted at session end** (prevents garbage data).
-
-### Auto Memory Search
-
-**On every prompt**, mneme automatically:
-1. Extracts keywords from your message
-2. Searches sessions/decisions/patterns
-3. Injects relevant context to Claude
-
-This means past knowledge is always available without manual lookup.
-
-### Session Suggestion
-
-At session start, recent 3 sessions are shown:
-
-```
-**Recent sessions:**
-  1. [abc123] JWT authentication implementation (2026-01-27, main)
-  2. [def456] Dashboard UI improvements (2026-01-26, main)
-  3. [ghi789] Bug fixes (2026-01-25, main)
-
-Continue from a previous session? Use `/mneme:resume <id>`
-```
-
 ### Commands
 
-| Command | Description |
-|---------|-------------|
-| `/init-mneme` | Initialize mneme in current project |
-| `/mneme:save` | Extract all data: summary, decisions, patterns, rules |
-| `/mneme:plan [topic]` | Memory-informed design + Socratic questions + task breakdown |
-| `/mneme:resume [id]` | Resume session (show list if ID omitted) |
-| `/mneme:search "query"` | Search sessions, decisions, and patterns |
-| `/mneme:review [--staged\|--all\|--diff=branch\|--full]` | Rule-based code review |
-| `/mneme:review <PR URL>` | Review GitHub PR |
-| `/mneme:harvest <PR URL>` | Extract knowledge from PR review comments |
-| `/mneme:report [--from YYYY-MM-DD --to YYYY-MM-DD]` | Weekly review report |
+| Command                  | Description                                           |
+| ------------------------ | ----------------------------------------------------- |
+| `/init-mneme`            | Initialize mneme in current project                   |
+| `/mneme:save`            | Extract all data: summary, decisions, patterns, rules |
+| `/mneme:resume [id]`     | Resume session (show list if ID omitted)              |
+| `/mneme:search "query"`  | Search sessions and approved development rules        |
+| `/mneme:harvest <PR URL>`| Extract knowledge from PR review comments             |
 
 ### Recommended Workflow
 
 ```
-plan → implement → save → review
+implement → save → approve rules
 ```
 
-1. **plan**: Design with memory lookup + Socratic questions + task breakdown
-2. **implement**: Follow the plan
-3. **save**: Extract decisions, patterns, rules
-4. **review**: Verify against plan and code quality
+1. **implement**: Write code
+2. **save**: Extract source knowledge and generate development rule candidates
+3. **validate**: Run `npm run validate:sources` to enforce required fields/priority/tags
+4. **approve rules**: Review and approve/reject generated development rules inline
+
+Detailed runtime flow (hooks, uncommitted policy, auto-compact path):
+- `docs/mneme-runtime-flow.md`
 
 ### Dashboard
 
@@ -195,9 +149,7 @@ npx @hir4ta/mneme --dashboard --port 8080
 #### Screens
 
 - **Sessions**: List and view sessions
-- **Decisions**: List and view technical decisions
-- **Rules**: View dev rules and review guidelines
-- **Patterns**: View learned patterns (good patterns, anti-patterns, error solutions)
+- **Development Rules**: Review and approve rules generated from decisions/patterns/rules
 - **Statistics**: View activity charts and session statistics
 - **Graph**: Visualize session connections by shared tags
 
@@ -205,227 +157,43 @@ npx @hir4ta/mneme --dashboard --port 8080
 
 The dashboard supports English and Japanese. Click the language toggle (EN/JA) in the header to switch. The preference is saved to localStorage.
 
-### MCP Tools
-
-mneme provides MCP servers with search and database tools callable directly from Claude Code:
-
-| Server | Tool | Description |
-|--------|------|-------------|
-| mneme-search | `mneme_search` | Unified search (FTS5, tag alias resolution) |
-| mneme-search | `mneme_get_session` | Get session details |
-| mneme-search | `mneme_get_decision` | Get decision details |
-| mneme-db | `mneme_list_projects` | List all projects |
-| mneme-db | `mneme_cross_project_search` | Cross-project search |
-
-### Subagents
-
-| Agent | Description |
-|-------|-------------|
-| `mneme-reviewer` | Rule-based code review (isolated context) |
-
-## How It Works
-
-```mermaid
-flowchart TB
-    subgraph incremental [Incremental Save]
-        A[Each Turn] --> B[Stop Hook]
-        B --> C[Node.js streaming]
-        C --> D[Save only new interactions]
-    end
-
-    subgraph autosearch [Auto Memory Search]
-        E[User Prompt] --> F[UserPromptSubmit Hook]
-        F --> G[Search sessions/decisions/patterns]
-        G --> H[Inject relevant context]
-    end
-
-    subgraph precompact [PreCompact Catch-up]
-        I[Context 95% Full] --> J[PreCompact Hook]
-        J --> K[Catch up missed interactions]
-    end
-
-    subgraph sessionend [Session End]
-        L[Exit] --> M[SessionEnd Hook]
-        M --> N{Committed?}
-        N -->|Yes| O[Keep interactions]
-        N -->|No| P[Delete interactions]
-    end
-
-    subgraph manual [Manual Actions]
-        Q["mneme:save"] --> R[Extract decisions + patterns + rules]
-        R --> S[Mark session committed]
-        T["mneme:plan"] --> U[Memory-informed design + tasks]
-    end
-
-    subgraph resume [Session Resume]
-        V["mneme:resume"] --> W[Select from list]
-        W --> X[Restore past context + set resumedFrom]
-    end
-
-    subgraph review [Review]
-        Y["mneme:review"] --> Z[Rule-based findings]
-        Z --> AA[Save review results]
-    end
-
-    subgraph dashboard [Dashboard]
-        AB["npx @hir4ta/mneme -d"] --> AC[Open in browser]
-        AC --> AD[View all data]
-    end
-
-    D --> Q
-    H --> Q
-    S --> AB
-    AA --> AB
-```
+### Weekly Knowledge HTML Export
 
-## Data Storage
+Generate a shareable HTML snapshot for the last 7 days of knowledge activity:
 
-mneme uses a **hybrid storage** approach for privacy and collaboration:
-
-| Storage | Location | Purpose | Sharing |
-|---------|----------|---------|---------|
-| **JSON** | `.mneme/` | Summaries, decisions, patterns, rules | Git-managed (team shared) |
-| **SQLite** | `.mneme/local.db` | Interactions, backups | Local only (gitignored) |
-
-**Why hybrid?**
-- **Privacy**: Conversation history (interactions) stays local (gitignored)
-- **Lightweight**: JSON files reduced from 100KB+ to ~5KB (interactions excluded)
-- **Future-ready**: Embeddings table prepared for semantic search
-
-### Directory Structure
-
-**Project-local (`.mneme/`)**:
-```text
-.mneme/
-├── local.db          # SQLite with interactions (gitignored)
-├── tags.json         # Tag master file (93 tags, prevents notation variations)
-├── sessions/         # Session metadata (YYYY/MM) - Git-managed
-│   └── YYYY/MM/
-│       └── {id}.json # Metadata only (interactions in local.db)
-├── decisions/        # Technical decisions (from /save) - Git-managed
-│   └── YYYY/MM/
-│       └── {id}.json
-├── patterns/         # Error patterns (from /save) - Git-managed
-│   └── {user}.json
-├── rules/            # Dev rules / review guidelines - Git-managed
-├── reviews/          # Review results (YYYY/MM) - Git-managed
-└── reports/          # Weekly reports (YYYY-MM) - Git-managed
+```bash
+npm run export:weekly-html
 ```
 
-The `local.db` file is automatically added to `.mneme/.gitignore` to keep conversations private.
-
-### Session JSON Schema
-
-Session metadata is stored in JSON (interactions are stored in SQLite for privacy):
-
-```json
-{
-  "id": "abc12345",
-  "sessionId": "full-uuid-from-claude-code",
-  "createdAt": "2026-01-27T10:00:00Z",
-  "endedAt": "2026-01-27T12:00:00Z",
-  "title": "JWT authentication implementation",
-  "tags": ["auth", "jwt"],
-  "context": {
-    "branch": "feature/auth",
-    "projectDir": "/path/to/project",
-    "user": { "name": "tanaka", "email": "tanaka@example.com" }
-  },
-  "metrics": {
-    "userMessages": 5,
-    "assistantResponses": 5,
-    "thinkingBlocks": 5,
-    "toolUsage": [{"name": "Edit", "count": 3}, {"name": "Write", "count": 2}]
-  },
-  "files": [
-    { "path": "src/auth/jwt.ts", "action": "create" }
-  ],
-  "resumedFrom": "def45678",
-  "status": "complete",
-
-  "summary": {
-    "title": "JWT authentication implementation",
-    "goal": "Implement JWT-based auth with refresh token support",
-    "outcome": "success",
-    "description": "Implemented JWT auth with RS256 signing",
-    "sessionType": "implementation"
-  },
-
-  "plan": {
-    "tasks": ["[x] JWT signing method selection", "[x] Middleware implementation", "[ ] Add tests"],
-    "remaining": ["Add tests"]
-  },
-
-  "discussions": [
-    {
-      "topic": "Signing algorithm",
-      "decision": "Adopt RS256",
-      "reasoning": "Security considerations for production",
-      "alternatives": ["HS256 (simpler but requires shared secret)"]
-    }
-  ],
-
-  "errors": [
-    {
-      "error": "secretOrPrivateKey must be asymmetric",
-      "cause": "Using HS256 secret with RS256",
-      "solution": "Generate RS256 key pair"
-    }
-  ],
-
-  "handoff": {
-    "stoppedReason": "Test creation postponed to next session",
-    "notes": ["vitest configured", "Mock key pair in test/fixtures/"],
-    "nextSteps": ["Create jwt.test.ts", "Add E2E tests"]
-  },
-
-  "references": [
-    { "url": "https://jwt.io/introduction", "title": "JWT Introduction" }
-  ]
-}
-```
+Output:
+- `.mneme/exports/weekly-knowledge-YYYY-MM-DD.html`
 
-### Session Types
+## Data Storage
 
-The `sessionType` field classifies the session type.
+mneme uses a **hybrid storage** approach: JSON files are Git-managed for team sharing, while SQLite keeps conversations private (gitignored).
 
-| Type | Description |
-|------|-------------|
-| `decision` | Decision cycle present (design choices, tech selection) |
-| `implementation` | Code changes made |
-| `research` | Research, learning, catchup |
-| `exploration` | Codebase exploration |
-| `discussion` | Discussion, consultation only |
-| `debug` | Debugging, investigation |
-| `review` | Code review |
+| Storage    | Location          | Purpose                               | Sharing                   |
+| ---------- | ----------------- | ------------------------------------- | ------------------------- |
+| **JSON**   | `.mneme/`         | Summaries, decisions, patterns, rules | Git-managed (team shared) |
+| **SQLite** | `.mneme/local.db` | Interactions, backups                 | Local only (gitignored)   |
 
-### Tags
+Conversations are auto-saved on each turn. No configuration needed.
 
-Tags are selected from `.mneme/tags.json` to prevent notation variations (e.g., "フロント" → "frontend"). The master file contains 93 tags across 11 categories:
+Auto memory search runs on every prompt: keywords are extracted, past sessions/development rules are searched, and relevant context is injected automatically.
 
-- **domain**: frontend, backend, api, db, infra, mobile, cli
-- **phase**: feature, bugfix, refactor, test, docs
-- **ai**: llm, ai-agent, mcp, rag, vector-db, embedding
-- **cloud**: serverless, microservices, edge, wasm
-- And more...
+At session start, the 3 most recent sessions are shown so you can quickly resume with `/mneme:resume <id>`.
 
 ## Security and Privacy
 
 mneme operates **entirely locally** with no data sent to external servers.
 
-| Item | Description |
-|------|-------------|
-| **External Communication** | None - no curl/fetch/HTTP requests are made |
-| **Data Storage** | All data stored in project's `.mneme/` directory |
-| **Conversation History** | Stored in `local.db`, automatically gitignored (not shared via Git) |
-| **Tools Used** | bash, Node.js, jq, sqlite3 (no external dependencies) |
-| **Code** | Open source - all code is auditable |
-
-### Privacy by Design
-
-- **Conversations (interactions) are local-only**: Stored in SQLite (`local.db`), auto-added to `.gitignore`
-- **Only metadata is Git-shareable**: Session summaries, decisions, patterns can be shared with team via JSON
-- **No telemetry**: No usage tracking or external data transmission
+| Item                       | Description                                                         |
+| -------------------------- | ------------------------------------------------------------------- |
+| **External Communication** | None - no curl/fetch/HTTP requests are made                         |
+| **Data Storage**           | All data stored in project's `.mneme/` directory                    |
+| **Conversation History**   | Stored in `local.db`, automatically gitignored (not shared via Git) |
+| **Tools Used**             | bash, Node.js, jq, sqlite3 (no external dependencies)               |
+| **Code**                   | Open source - all code is auditable                                 |
 
 ## License
 

package/dist/lib/db.js

@@ -1,8 +1,4 @@
-// lib/db.ts
-import { execSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+// lib/suppress-sqlite-warning.ts
 var originalEmit = process.emit;
 process.emit = (event, ...args) => {
   if (event === "warning" && typeof args[0] === "object" && args[0] !== null && "name" in args[0] && args[0].name === "ExperimentalWarning" && "message" in args[0] && typeof args[0].message === "string" && args[0].message.includes("SQLite")) {
@@ -10,6 +6,12 @@ process.emit = (event, ...args) => {
   }
   return originalEmit.apply(process, [event, ...args]);
 };
+
+// lib/db.ts
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 var { DatabaseSync } = await import("node:sqlite");
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);

package/dist/lib/incremental-save.js

@@ -1,10 +1,6 @@
 #!/usr/bin/env node
 
-// lib/incremental-save.ts
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import * as readline from "node:readline";
+// lib/suppress-sqlite-warning.ts
 var originalEmit = process.emit;
 process.emit = (event, ...args) => {
   if (event === "warning" && typeof args[0] === "object" && args[0] !== null && "name" in args[0] && args[0].name === "ExperimentalWarning" && "message" in args[0] && typeof args[0].message === "string" && args[0].message.includes("SQLite")) {
@@ -12,6 +8,12 @@ process.emit = (event, ...args) => {
   }
   return originalEmit.apply(process, [event, ...args]);
 };
+
+// lib/incremental-save.ts
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import * as readline from "node:readline";
 var { DatabaseSync } = await import("node:sqlite");
 function getSchemaPath() {
   const scriptDir = path.dirname(new URL(import.meta.url).pathname);
@@ -414,6 +416,32 @@ function resolveMnemeSessionId(projectPath, claudeSessionId) {
   }
   return shortId;
 }
+function findSessionFileById(projectPath, mnemeSessionId) {
+  const sessionsDir = path.join(projectPath, ".mneme", "sessions");
+  const searchDir = (dir) => {
+    if (!fs.existsSync(dir)) return null;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const result = searchDir(fullPath);
+        if (result) return result;
+      } else if (entry.name === `${mnemeSessionId}.json`) {
+        return fullPath;
+      }
+    }
+    return null;
+  };
+  return searchDir(sessionsDir);
+}
+function hasSessionSummary(sessionFile) {
+  if (!sessionFile) return false;
+  try {
+    const session = JSON.parse(fs.readFileSync(sessionFile, "utf8"));
+    return !!session.summary;
+  } catch {
+    return false;
+  }
+}
 async function incrementalSave(claudeSessionId, transcriptPath, projectPath) {
   if (!claudeSessionId || !transcriptPath || !projectPath) {
     return {
@@ -572,29 +600,8 @@ function cleanupUncommittedSession(claudeSessionId, projectPath) {
       return { deleted: false, count: 0 };
     }
     const mnemeSessionId = resolveMnemeSessionId(projectPath, claudeSessionId);
-    const sessionsDir = path.join(projectPath, ".mneme", "sessions");
-    let hasSummary = false;
-    const searchDir = (dir) => {
-      if (!fs.existsSync(dir)) return null;
-      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-        if (entry.isDirectory()) {
-          const result = searchDir(path.join(dir, entry.name));
-          if (result) return result;
-        } else if (entry.name === `${mnemeSessionId}.json`) {
-          return path.join(dir, entry.name);
-        }
-      }
-      return null;
-    };
-    const sessionFile = searchDir(sessionsDir);
-    if (sessionFile) {
-      try {
-        const session = JSON.parse(fs.readFileSync(sessionFile, "utf8"));
-        hasSummary = !!session.summary;
-      } catch {
-      }
-    }
-    if (hasSummary) {
+    const sessionFile = findSessionFileById(projectPath, mnemeSessionId);
+    if (hasSessionSummary(sessionFile)) {
       return { deleted: false, count: 0 };
     }
     const countStmt = db.prepare(
@@ -620,6 +627,80 @@ function cleanupUncommittedSession(claudeSessionId, projectPath) {
     db.close();
   }
 }
+function cleanupStaleUncommittedSessions(projectPath, graceDays) {
+  const dbPath = path.join(projectPath, ".mneme", "local.db");
+  if (!fs.existsSync(dbPath)) {
+    return { deletedSessions: 0, deletedInteractions: 0 };
+  }
+  const db = new DatabaseSync(dbPath);
+  let deletedSessions = 0;
+  let deletedInteractions = 0;
+  const normalizedGraceDays = Math.max(1, Math.floor(graceDays));
+  try {
+    const staleStmt = db.prepare(
+      `
+      SELECT claude_session_id, mneme_session_id
+      FROM session_save_state
+      WHERE is_committed = 0
+        AND updated_at <= datetime('now', ?)
+      `
+    );
+    const staleRows = staleStmt.all(`-${normalizedGraceDays} days`);
+    if (staleRows.length === 0) {
+      return { deletedSessions: 0, deletedInteractions: 0 };
+    }
+    const deleteInteractionStmt = db.prepare(
+      "DELETE FROM interactions WHERE claude_session_id = ?"
+    );
+    const countInteractionStmt = db.prepare(
+      "SELECT COUNT(*) as count FROM interactions WHERE claude_session_id = ?"
+    );
+    const deleteStateStmt = db.prepare(
+      "DELETE FROM session_save_state WHERE claude_session_id = ?"
+    );
+    for (const row of staleRows) {
+      const sessionFile = findSessionFileById(
+        projectPath,
+        row.mneme_session_id
+      );
+      if (hasSessionSummary(sessionFile)) {
+        continue;
+      }
+      const countResult = countInteractionStmt.get(row.claude_session_id);
+      const count = countResult?.count || 0;
+      if (count > 0) {
+        deleteInteractionStmt.run(row.claude_session_id);
+        deletedInteractions += count;
+      }
+      deleteStateStmt.run(row.claude_session_id);
+      if (sessionFile && fs.existsSync(sessionFile)) {
+        try {
+          fs.unlinkSync(sessionFile);
+          deletedSessions += 1;
+        } catch {
+        }
+      }
+      const linkPath = path.join(
+        projectPath,
+        ".mneme",
+        "session-links",
+        `${row.claude_session_id.slice(0, 8)}.json`
+      );
+      if (fs.existsSync(linkPath)) {
+        try {
+          fs.unlinkSync(linkPath);
+        } catch {
+        }
+      }
+    }
+    return { deletedSessions, deletedInteractions };
+  } catch (error) {
+    console.error(`[mneme] Error cleaning stale sessions: ${error}`);
+    return { deletedSessions: 0, deletedInteractions: 0 };
+  } finally {
+    db.close();
+  }
+}
 async function main() {
   const args = process.argv.slice(2);
   const getArg = (name) => {
@@ -668,6 +749,18 @@ async function main() {
     const result = cleanupUncommittedSession(sessionId, projectPath);
     console.log(JSON.stringify(result));
     process.exit(0);
+  } else if (command === "cleanup-stale") {
+    const projectPath = getArg("project");
+    const graceDays = Number.parseInt(getArg("grace-days") || "7", 10);
+    if (!projectPath) {
+      console.error(
+        "Usage: incremental-save.js cleanup-stale --project <path> [--grace-days <n>]"
+      );
+      process.exit(1);
+    }
+    const result = cleanupStaleUncommittedSessions(projectPath, graceDays);
+    console.log(JSON.stringify(result));
+    process.exit(0);
   } else {
     console.error("Commands: save, commit, cleanup");
     process.exit(1);
@@ -677,6 +770,7 @@ if (import.meta.url === `file://${process.argv[1]}`) {
   main();
 }
 export {
+  cleanupStaleUncommittedSessions,
   cleanupUncommittedSession,
   incrementalSave,
   markSessionCommitted