autohand-cli 0.6.12 → 0.7.2

package/dist/{CommunitySkillsCache-XPDVYU3K.js → CommunitySkillsCache-AY3ZYDTN.js}

@@ -2,6 +2,7 @@ import {
   CommunitySkillsCache
 } from "./chunk-5PD2L6WI.js";
 import "./chunk-FUEL6BK7.js";
+import "./chunk-3RG5ZIWI.js";
 export {
   CommunitySkillsCache
 };

package/dist/{CommunitySkillsCache-X3X237QQ.cjs → CommunitySkillsCache-KO4DSKMA.cjs}

@@ -2,6 +2,7 @@
 
 var _chunkKN5C4TR4cjs = require('./chunk-KN5C4TR4.cjs');
 require('./chunk-XTHHDIBG.cjs');
+require('./chunk-OBGZSXTJ.cjs');
 
 
 exports.CommunitySkillsCache = _chunkKN5C4TR4cjs.CommunitySkillsCache;

package/dist/{GitHubRegistryFetcher-K744NNAJ.cjs → GitHubRegistryFetcher-S4JREWUQ.cjs}

@@ -1,6 +1,7 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
 var _chunkYHD6TUIRcjs = require('./chunk-YHD6TUIR.cjs');
+require('./chunk-OBGZSXTJ.cjs');
 
 
 exports.GitHubRegistryFetcher = _chunkYHD6TUIRcjs.GitHubRegistryFetcher;

package/dist/{GitHubRegistryFetcher-US2JJID4.js → GitHubRegistryFetcher-V23KTTLM.js}

@@ -1,6 +1,7 @@
 import {
   GitHubRegistryFetcher
 } from "./chunk-UJ2JSM6H.js";
+import "./chunk-3RG5ZIWI.js";
 export {
   GitHubRegistryFetcher
 };

package/dist/HookManager-OGINWAJN.cjs

@@ -0,0 +1,7 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkSXYYH3VDcjs = require('./chunk-SXYYH3VD.cjs');
+require('./chunk-OBGZSXTJ.cjs');
+
+
+exports.HookManager = _chunkSXYYH3VDcjs.HookManager;

package/dist/HookManager-VG46FXSZ.js

@@ -0,0 +1,7 @@
+import {
+  HookManager
+} from "./chunk-UOLJZFPJ.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  HookManager
+};

package/dist/MemoryManager-AFS5EZJ2.js

@@ -0,0 +1,8 @@
+import {
+  MemoryManager
+} from "./chunk-4L5WYXHN.js";
+import "./chunk-FUEL6BK7.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  MemoryManager
+};

package/dist/MemoryManager-KE6EKW7Y.cjs

@@ -0,0 +1,8 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkURY4AS4Lcjs = require('./chunk-URY4AS4L.cjs');
+require('./chunk-XTHHDIBG.cjs');
+require('./chunk-OBGZSXTJ.cjs');
+
+
+exports.MemoryManager = _chunkURY4AS4Lcjs.MemoryManager;

package/dist/{PermissionManager-PMTQN263.cjs → PermissionManager-MAPKIJMD.cjs}

@@ -4,6 +4,7 @@
 var _chunkOKMYLMCRcjs = require('./chunk-OKMYLMCR.cjs');
 require('./chunk-3CO5R6M2.cjs');
 require('./chunk-XTHHDIBG.cjs');
+require('./chunk-OBGZSXTJ.cjs');
 
 
 

package/dist/{PermissionManager-YFZI4ZZ6.js → PermissionManager-V2Q2OAS2.js}

@@ -4,6 +4,7 @@ import {
 } from "./chunk-YMP7AGNT.js";
 import "./chunk-27ISZOFA.js";
 import "./chunk-FUEL6BK7.js";
+import "./chunk-3RG5ZIWI.js";
 export {
   DEFAULT_SECURITY_BLACKLIST,
   PermissionManager

package/dist/SessionManager-MKLGLZWC.cjs

@@ -0,0 +1,10 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkUPR5PKX4cjs = require('./chunk-UPR5PKX4.cjs');
+require('./chunk-XTHHDIBG.cjs');
+require('./chunk-OBGZSXTJ.cjs');
+
+
+
+exports.Session = _chunkUPR5PKX4cjs.Session; exports.SessionManager = _chunkUPR5PKX4cjs.SessionManager;

package/dist/SessionManager-V25OJDDY.js

@@ -0,0 +1,10 @@
+import {
+  Session,
+  SessionManager
+} from "./chunk-2FLBGPE3.js";
+import "./chunk-FUEL6BK7.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  Session,
+  SessionManager
+};

package/dist/{SkillsRegistry-OINIPILA.cjs → SkillsRegistry-4RU2OAEQ.cjs}

@@ -3,6 +3,7 @@
 var _chunkCVYEUA3Dcjs = require('./chunk-CVYEUA3D.cjs');
 require('./chunk-JHGIWNHL.cjs');
 require('./chunk-XTHHDIBG.cjs');
+require('./chunk-OBGZSXTJ.cjs');
 
 
 exports.SkillsRegistry = _chunkCVYEUA3Dcjs.SkillsRegistry;

package/dist/{SkillsRegistry-7NICF6FY.js → SkillsRegistry-FTLVJZMA.js}

@@ -3,6 +3,7 @@ import {
 } from "./chunk-SKU4M27Z.js";
 import "./chunk-QHPFA6OE.js";
 import "./chunk-FUEL6BK7.js";
+import "./chunk-3RG5ZIWI.js";
 export {
   SkillsRegistry
 };

package/dist/{agents-GRAFXZY3.cjs → agents-CHNQ7LQ4.cjs}

@@ -3,6 +3,7 @@
 
 var _chunk3ZUWWML7cjs = require('./chunk-3ZUWWML7.cjs');
 require('./chunk-XTHHDIBG.cjs');
+require('./chunk-OBGZSXTJ.cjs');
 
 
 

package/dist/{agents-B33IAATH.js → agents-E4NEH2PN.js}

@@ -3,6 +3,7 @@ import {
   metadata
 } from "./chunk-7HB7GSQF.js";
 import "./chunk-FUEL6BK7.js";
+import "./chunk-3RG5ZIWI.js";
 export {
   handler,
   metadata

package/dist/{agents-new-67NJJSDA.cjs → agents-new-GHVWXW7T.cjs}

@@ -4,6 +4,7 @@
 var _chunk53YDUYNScjs = require('./chunk-53YDUYNS.cjs');
 require('./chunk-3HPUOQJN.cjs');
 require('./chunk-XTHHDIBG.cjs');
+require('./chunk-OBGZSXTJ.cjs');
 
 
 

package/dist/{agents-new-KTXJFC5E.js → agents-new-W6HMQ7V5.js}

@@ -4,6 +4,7 @@ import {
 } from "./chunk-MWLAHCU7.js";
 import "./chunk-7BYSXAKS.js";
 import "./chunk-FUEL6BK7.js";
+import "./chunk-3RG5ZIWI.js";
 export {
   createAgent,
   metadata

package/dist/automode-BJYGRMEQ.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkOTS4YFSZcjs = require('./chunk-OTS4YFSZ.cjs');
+require('./chunk-OBGZSXTJ.cjs');
+
+
+
+exports.automode = _chunkOTS4YFSZcjs.automode; exports.metadata = _chunkOTS4YFSZcjs.metadata;

package/dist/automode-XCNP6HP4.js

@@ -0,0 +1,9 @@
+import {
+  automode,
+  metadata
+} from "./chunk-CXZEPTRI.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  automode,
+  metadata
+};

package/dist/chunk-2FLBGPE3.js

@@ -0,0 +1,199 @@
+import {
+  AUTOHAND_PATHS
+} from "./chunk-FUEL6BK7.js";
+
+// src/session/SessionManager.ts
+import fs from "fs-extra";
+import path from "path";
+import crypto from "crypto";
+var SessionManager = class {
+  constructor(baseDir) {
+    this.currentSession = null;
+    this.index = null;
+    this.sessionsDir = baseDir ?? AUTOHAND_PATHS.sessions;
+  }
+  async initialize() {
+    await fs.ensureDir(this.sessionsDir);
+    await this.loadIndex();
+  }
+  async createSession(projectPath, model) {
+    const sessionId = this.generateSessionId();
+    const sessionDir = path.join(this.sessionsDir, sessionId);
+    await fs.ensureDir(sessionDir);
+    const metadata = {
+      sessionId,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
+      projectPath: path.resolve(projectPath),
+      projectName: path.basename(projectPath),
+      model,
+      messageCount: 0,
+      status: "active"
+    };
+    const session = new Session(sessionDir, metadata);
+    await session.save();
+    this.currentSession = session;
+    await this.addToIndex(session.metadata);
+    return session;
+  }
+  async loadSession(sessionId) {
+    const sessionDir = path.join(this.sessionsDir, sessionId);
+    if (!await fs.pathExists(sessionDir)) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const metadataPath = path.join(sessionDir, "metadata.json");
+    const metadata = await fs.readJson(metadataPath);
+    const session = new Session(sessionDir, metadata);
+    await session.load();
+    this.currentSession = session;
+    return session;
+  }
+  async listSessions(filter) {
+    await this.loadIndex();
+    if (!this.index) return [];
+    let sessions = this.index.sessions;
+    if (filter?.project) {
+      const projectPath = path.resolve(filter.project);
+      const sessionIds = this.index.byProject[projectPath] || [];
+      sessions = sessions.filter((s) => sessionIds.includes(s.id));
+    }
+    if (filter?.since) {
+      sessions = sessions.filter((s) => new Date(s.createdAt) >= filter.since);
+    }
+    const fullMetadata = [];
+    for (const s of sessions) {
+      const sessionDir = path.join(this.sessionsDir, s.id);
+      const metadataPath = path.join(sessionDir, "metadata.json");
+      if (await fs.pathExists(metadataPath)) {
+        const metadata = await fs.readJson(metadataPath);
+        fullMetadata.push(metadata);
+      }
+    }
+    return fullMetadata.sort(
+      (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+    );
+  }
+  async getLastSession(projectPath) {
+    const sessions = await this.listSessions(projectPath ? { project: projectPath } : void 0);
+    return sessions[0] || null;
+  }
+  async closeSession(summary) {
+    if (!this.currentSession) return;
+    this.currentSession.metadata.closedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.currentSession.metadata.lastActiveAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.currentSession.metadata.status = "completed";
+    if (summary) {
+      this.currentSession.metadata.summary = summary;
+    }
+    await this.currentSession.save();
+    await this.updateIndex(this.currentSession.metadata);
+    this.currentSession = null;
+  }
+  getCurrentSession() {
+    return this.currentSession;
+  }
+  generateSessionId() {
+    const timestamp = Date.now();
+    const uuid = crypto.randomUUID();
+    return `${uuid}-${timestamp}`;
+  }
+  async loadIndex() {
+    const indexPath = path.join(this.sessionsDir, "index.json");
+    if (await fs.pathExists(indexPath)) {
+      this.index = await fs.readJson(indexPath);
+    } else {
+      this.index = { sessions: [], byProject: {} };
+    }
+  }
+  async saveIndex() {
+    const indexPath = path.join(this.sessionsDir, "index.json");
+    await fs.writeJson(indexPath, this.index, { spaces: 2 });
+  }
+  async addToIndex(metadata) {
+    if (!this.index) await this.loadIndex();
+    if (!this.index) return;
+    this.index.sessions.push({
+      id: metadata.sessionId,
+      projectPath: metadata.projectPath,
+      createdAt: metadata.createdAt,
+      summary: metadata.summary
+    });
+    if (!this.index.byProject[metadata.projectPath]) {
+      this.index.byProject[metadata.projectPath] = [];
+    }
+    this.index.byProject[metadata.projectPath].push(metadata.sessionId);
+    await this.saveIndex();
+  }
+  async updateIndex(metadata) {
+    if (!this.index) return;
+    const session = this.index.sessions.find((s) => s.id === metadata.sessionId);
+    if (session) {
+      session.summary = metadata.summary;
+    }
+    await this.saveIndex();
+  }
+};
+var Session = class {
+  constructor(sessionDir, metadata) {
+    this.messages = [];
+    this.state = null;
+    this.sessionDir = sessionDir;
+    this.metadata = metadata;
+  }
+  async append(message) {
+    this.messages.push(message);
+    this.metadata.messageCount = this.messages.length;
+    this.metadata.lastActiveAt = (/* @__PURE__ */ new Date()).toISOString();
+    const conversationPath = path.join(this.sessionDir, "conversation.jsonl");
+    await fs.appendFile(conversationPath, JSON.stringify(message) + "\n");
+    await this.save();
+  }
+  async appendTransient(message) {
+    const conversationPath = path.join(this.sessionDir, "conversation.jsonl");
+    await fs.appendFile(conversationPath, JSON.stringify(message) + "\n");
+  }
+  async updateState(state) {
+    this.state = state;
+    const statePath = path.join(this.sessionDir, "state.json");
+    await fs.writeJson(statePath, state, { spaces: 2 });
+  }
+  async save() {
+    const metadataPath = path.join(this.sessionDir, "metadata.json");
+    await fs.writeJson(metadataPath, this.metadata, { spaces: 2 });
+  }
+  async load() {
+    const conversationPath = path.join(this.sessionDir, "conversation.jsonl");
+    if (await fs.pathExists(conversationPath)) {
+      const content = await fs.readFile(conversationPath, "utf-8");
+      this.messages = content.trim().split("\n").filter((line) => line).map((line) => JSON.parse(line));
+    }
+    const statePath = path.join(this.sessionDir, "state.json");
+    if (await fs.pathExists(statePath)) {
+      this.state = await fs.readJson(statePath);
+    }
+  }
+  getMessages() {
+    return this.messages;
+  }
+  getState() {
+    return this.state;
+  }
+  async close(summary) {
+    this.metadata.closedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.metadata.status = "completed";
+    if (summary) {
+      this.metadata.summary = summary;
+    }
+    await this.save();
+  }
+};
+
+export {
+  SessionManager,
+  Session
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{chunk-5RX6NVQO.cjs → chunk-3L76MLO5.cjs}

@@ -15,7 +15,16 @@ var HOOK_EVENTS = [
   "subagent-stop",
   "permission-request",
   "notification",
-  "session-error"
+  "session-error",
+  // Auto-mode events
+  "automode:start",
+  "automode:iteration",
+  "automode:checkpoint",
+  "automode:pause",
+  "automode:resume",
+  "automode:cancel",
+  "automode:complete",
+  "automode:error"
 ];
 var EVENT_DESCRIPTIONS = {
   "session-start": "When a session begins",
@@ -29,7 +38,16 @@ var EVENT_DESCRIPTIONS = {
   "subagent-stop": "When a subagent finishes",
   "permission-request": "When permission is requested",
   "notification": "When notifications are shown",
-  "session-error": "When an error occurs"
+  "session-error": "When an error occurs",
+  // Auto-mode events
+  "automode:start": "When auto-mode loop starts",
+  "automode:iteration": "Each auto-mode iteration",
+  "automode:checkpoint": "When auto-mode creates a checkpoint",
+  "automode:pause": "When auto-mode is paused",
+  "automode:resume": "When auto-mode is resumed",
+  "automode:cancel": "When auto-mode is cancelled",
+  "automode:complete": "When auto-mode completes",
+  "automode:error": "When auto-mode encounters an error"
 };
 var HOOK_ICONS = {
   // Script-based hooks

package/dist/chunk-3RG5ZIWI.js

@@ -0,0 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};

package/dist/chunk-4L5WYXHN.js

@@ -0,0 +1,246 @@
+import {
+  AUTOHAND_PATHS,
+  PROJECT_DIR_NAME
+} from "./chunk-FUEL6BK7.js";
+
+// src/memory/MemoryManager.ts
+import fs from "fs-extra";
+import path from "path";
+import crypto from "crypto";
+var SIMILARITY_THRESHOLD = 0.6;
+var MemoryManager = class {
+  constructor(workspaceRoot) {
+    this.projectMemoryDir = null;
+    this.userMemoryDir = AUTOHAND_PATHS.memory;
+    if (workspaceRoot) {
+      this.projectMemoryDir = path.join(workspaceRoot, PROJECT_DIR_NAME, "memory");
+    }
+  }
+  setWorkspace(workspaceRoot) {
+    this.projectMemoryDir = path.join(workspaceRoot, PROJECT_DIR_NAME, "memory");
+  }
+  async initialize() {
+    await fs.ensureDir(this.userMemoryDir);
+    if (this.projectMemoryDir) {
+      await fs.ensureDir(this.projectMemoryDir);
+    }
+  }
+  getMemoryDir(level) {
+    if (level === "project") {
+      if (!this.projectMemoryDir) {
+        throw new Error("Project memory directory not set. Use setWorkspace() first.");
+      }
+      return this.projectMemoryDir;
+    }
+    return this.userMemoryDir;
+  }
+  async store(content, level, tags, source) {
+    const dir = this.getMemoryDir(level);
+    await fs.ensureDir(dir);
+    const similar = await this.findSimilar(content, level);
+    if (similar && similar.score >= SIMILARITY_THRESHOLD) {
+      return this.updateMemory(similar.entry.id, content, level, tags);
+    }
+    const id = this.generateId();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = {
+      id,
+      content,
+      createdAt: now,
+      updatedAt: now,
+      tags,
+      source
+    };
+    const entryPath = path.join(dir, `${id}.json`);
+    await fs.writeJson(entryPath, entry, { spaces: 2 });
+    await this.updateIndex(level, entry);
+    return entry;
+  }
+  async updateMemory(id, content, level, tags) {
+    const dir = this.getMemoryDir(level);
+    const entryPath = path.join(dir, `${id}.json`);
+    if (!await fs.pathExists(entryPath)) {
+      throw new Error(`Memory entry not found: ${id}`);
+    }
+    const existing = await fs.readJson(entryPath);
+    const updated = {
+      ...existing,
+      content,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      tags: tags ?? existing.tags
+    };
+    await fs.writeJson(entryPath, updated, { spaces: 2 });
+    await this.updateIndex(level, updated);
+    return updated;
+  }
+  async get(id, level) {
+    const dir = this.getMemoryDir(level);
+    const entryPath = path.join(dir, `${id}.json`);
+    if (!await fs.pathExists(entryPath)) {
+      return null;
+    }
+    return fs.readJson(entryPath);
+  }
+  async list(level) {
+    const dir = this.getMemoryDir(level);
+    if (!await fs.pathExists(dir)) {
+      return [];
+    }
+    const files = await fs.readdir(dir);
+    const entries = [];
+    for (const file of files) {
+      if (file.endsWith(".json") && file !== "index.json") {
+        const entryPath = path.join(dir, file);
+        const entry = await fs.readJson(entryPath);
+        entries.push(entry);
+      }
+    }
+    return entries.sort(
+      (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+    );
+  }
+  async listAll() {
+    const user = await this.list("user");
+    let project = [];
+    if (this.projectMemoryDir) {
+      try {
+        project = await this.list("project");
+      } catch {
+      }
+    }
+    return { project, user };
+  }
+  async delete(id, level) {
+    const dir = this.getMemoryDir(level);
+    const entryPath = path.join(dir, `${id}.json`);
+    if (await fs.pathExists(entryPath)) {
+      await fs.remove(entryPath);
+      await this.removeFromIndex(level, id);
+    }
+  }
+  async findSimilar(content, level) {
+    const entries = await this.list(level);
+    let bestMatch = null;
+    for (const entry of entries) {
+      const score = this.calculateSimilarity(content, entry.content);
+      if (!bestMatch || score > bestMatch.score) {
+        bestMatch = { entry, score };
+      }
+    }
+    return bestMatch;
+  }
+  async search(query, level) {
+    const levels = level ? [level] : ["project", "user"];
+    const results = [];
+    const queryLower = query.toLowerCase();
+    for (const lvl of levels) {
+      try {
+        const entries = await this.list(lvl);
+        for (const entry of entries) {
+          if (entry.content.toLowerCase().includes(queryLower) || entry.tags?.some((t) => t.toLowerCase().includes(queryLower))) {
+            results.push(entry);
+          }
+        }
+      } catch {
+      }
+    }
+    return results;
+  }
+  async recall(query, level) {
+    const levels = level ? [level] : ["user", "project"];
+    const results = [];
+    for (const lvl of levels) {
+      try {
+        const entries = await this.list(lvl);
+        for (const entry of entries) {
+          if (!query || entry.content.toLowerCase().includes(query.toLowerCase())) {
+            results.push({ content: entry.content, level: lvl });
+          }
+        }
+      } catch {
+      }
+    }
+    return results;
+  }
+  /**
+   * Get memories formatted for LLM context injection
+   */
+  async getContextMemories() {
+    const { project, user } = await this.listAll();
+    const parts = [];
+    if (project.length > 0) {
+      parts.push("## Project Memories");
+      for (const entry of project.slice(0, 10)) {
+        parts.push(`- ${entry.content}`);
+      }
+    }
+    if (user.length > 0) {
+      parts.push("## User Preferences");
+      for (const entry of user.slice(0, 10)) {
+        parts.push(`- ${entry.content}`);
+      }
+    }
+    return parts.join("\n");
+  }
+  calculateSimilarity(a, b) {
+    const wordsA = this.tokenize(a);
+    const wordsB = this.tokenize(b);
+    if (wordsA.size === 0 || wordsB.size === 0) {
+      return 0;
+    }
+    const intersection = new Set([...wordsA].filter((x) => wordsB.has(x)));
+    const union = /* @__PURE__ */ new Set([...wordsA, ...wordsB]);
+    return intersection.size / union.size;
+  }
+  tokenize(text) {
+    return new Set(
+      text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 2)
+    );
+  }
+  generateId() {
+    return crypto.randomUUID().split("-")[0];
+  }
+  async updateIndex(level, entry) {
+    const dir = this.getMemoryDir(level);
+    const indexPath = path.join(dir, "index.json");
+    let index;
+    if (await fs.pathExists(indexPath)) {
+      index = await fs.readJson(indexPath);
+    } else {
+      index = { version: 1, entries: [] };
+    }
+    const existingIdx = index.entries.findIndex((e) => e.id === entry.id);
+    const indexEntry = {
+      id: entry.id,
+      preview: entry.content.slice(0, 100),
+      createdAt: entry.createdAt,
+      updatedAt: entry.updatedAt,
+      tags: entry.tags
+    };
+    if (existingIdx >= 0) {
+      index.entries[existingIdx] = indexEntry;
+    } else {
+      index.entries.push(indexEntry);
+    }
+    await fs.writeJson(indexPath, index, { spaces: 2 });
+  }
+  async removeFromIndex(level, id) {
+    const dir = this.getMemoryDir(level);
+    const indexPath = path.join(dir, "index.json");
+    if (!await fs.pathExists(indexPath)) {
+      return;
+    }
+    const index = await fs.readJson(indexPath);
+    index.entries = index.entries.filter((e) => e.id !== id);
+    await fs.writeJson(indexPath, index, { spaces: 2 });
+  }
+};
+
+export {
+  MemoryManager
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */