@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-hermes-memory/tests/handlers/sync-markdown-memories.test.ts

@@ -11,9 +11,27 @@ import {
   registerSyncMarkdownMemoriesCommand,
   syncMarkdownMemoriesToSqlite,
 } from '../../src/handlers/sync-markdown-memories.js';
-import { ENTRY_DELIMITER } from '../../src/constants.js';
-import { addMemory, getMemories, searchMemories } from '../../src/store/sqlite-memory-store.js';
+import { ENTRY_DELIMITER, MDSYNC_METADATA_KEY_PREFIX } from '../../src/constants.js';
+import { addMemory, getMemories, reconcileMarkdownMemoryScope, searchMemories } from '../../src/store/sqlite-memory-store.js';
 import { AtomicLockCoordinator } from '../../src/store/atomic-lock-coordinator.js';
+import { MemoryStore } from '../../src/store/memory-store.js';
+
+async function withBlockedMemoryWrites<T>(dbManager: DatabaseManager, fn: () => T | Promise<T>): Promise<T> {
+  const db = dbManager.getDb() as { prepare: (sql: string) => unknown };
+  const originalPrepare = db.prepare.bind(db);
+  db.prepare = (sql: string) => {
+    const normalized = sql.replace(/\s+/g, ' ').trim();
+    if (/^INSERT(?: OR REPLACE)? INTO memories\b/i.test(normalized) || /^UPDATE memories\b/i.test(normalized)) {
+      throw new Error(`unexpected memories write: ${normalized}`);
+    }
+    return originalPrepare(sql);
+  };
+  try {
+    return await fn();
+  } finally {
+    db.prepare = originalPrepare;
+  }
+}
 
 describe('memory sqlite sync + markdown backfill', () => {
   let tmpDir: string;
@@ -488,4 +506,167 @@ describe('memory sqlite sync + markdown backfill', () => {
       targetManager.close();
     }
   });
+
+  it('skips unchanged markdown on a second startup sync without inserting', async () => {
+    fs.writeFileSync(path.join(globalDir, 'MEMORY.md'), 'startup skip entry', 'utf-8');
+    const first = await syncMarkdownMemoriesToSqlite(dbManager, globalDir, undefined, agentRoot);
+    assert.strictEqual(first.imported, 1);
+
+    const second = await withBlockedMemoryWrites(dbManager, () =>
+      syncMarkdownMemoriesToSqlite(dbManager, globalDir, undefined, agentRoot),
+    );
+    assert.strictEqual(second.imported, 0);
+    assert.strictEqual(second.warnings.length, 0, 'a working skip never touches memories, so no blocked-write errors');
+    assert.strictEqual(second.skipped, 1);
+    assert.strictEqual(getMemories(dbManager, { target: 'memory', project: null }).length, 1);
+  });
+
+  it('repairs COUNT-preserving sqlite-only drift through the command, not startup', async () => {
+    fs.writeFileSync(path.join(globalDir, 'MEMORY.md'), 'canonical markdown content', 'utf-8');
+    await syncMarkdownMemoriesToSqlite(dbManager, globalDir, undefined, agentRoot);
+    dbManager.getDb().prepare(`
+      UPDATE memories SET content = 'drifted sqlite content' WHERE target = 'memory' AND project IS NULL
+    `).run();
+
+    await syncMarkdownMemoriesToSqlite(dbManager, globalDir, undefined, agentRoot);
+    assert.strictEqual(
+      getMemories(dbManager, { target: 'memory', project: null })[0].content,
+      'drifted sqlite content',
+    );
+
+    let handler: any;
+    const mockPi = {
+      registerCommand: (_name: string, opts: any) => {
+        handler = opts.handler;
+      },
+    } as unknown as ExtensionAPI;
+    const notifications: Array<{ message: string; severity: string }> = [];
+    const ctx = {
+      ui: {
+        notify: (message: string, severity: string) => {
+          notifications.push({ message, severity });
+        },
+      },
+    } as any;
+
+    registerSyncMarkdownMemoriesCommand(mockPi, dbManager, globalDir, undefined, agentRoot);
+    await handler({}, ctx);
+
+    assert.strictEqual(
+      getMemories(dbManager, { target: 'memory', project: null })[0].content,
+      'canonical markdown content',
+    );
+    assert.ok(notifications.some((n) => n.message.includes('SQLite sync complete')));
+  });
+
+  it('still reconciles a same-size rewrite that preserves mtime', async () => {
+    const memoryFile = path.join(globalDir, 'MEMORY.md');
+    const first = 'same-len-entry-aaa';
+    const second = 'same-len-entry-bbb';
+    assert.strictEqual(first.length, second.length);
+    fs.writeFileSync(memoryFile, first, 'utf-8');
+    await syncMarkdownMemoriesToSqlite(dbManager, globalDir, undefined, agentRoot);
+    assert.deepStrictEqual(
+      getMemories(dbManager, { target: 'memory', project: null }).map((entry) => entry.content),
+      [first],
+    );
+
+    const st = fs.statSync(memoryFile);
+    fs.writeFileSync(memoryFile, second, 'utf-8');
+    fs.utimesSync(memoryFile, st.atime, st.mtime);
+
+    await syncMarkdownMemoriesToSqlite(dbManager, globalDir, undefined, agentRoot);
+    assert.deepStrictEqual(
+      getMemories(dbManager, { target: 'memory', project: null }).map((entry) => entry.content),
+      [second],
+    );
+  });
+
+  it('skips startup sync after a live mutation observer already reconciled', async () => {
+    const store = new MemoryStore({
+      memoryDir: globalDir,
+      memoryCharLimit: 5000,
+      userCharLimit: 5000,
+      failureCharLimit: 5000,
+    } as any);
+    await store.loadFromDisk();
+    store.setMutationObserver((target, entries) => {
+      reconcileMarkdownMemoryScope(dbManager, entries, target, null);
+      return null;
+    });
+
+    const added = await store.add('memory', 'observer composed entry');
+    assert.ok(added.success);
+    assert.strictEqual(getMemories(dbManager, { target: 'memory', project: null }).length, 1);
+
+    const counters = await withBlockedMemoryWrites(dbManager, () =>
+      syncMarkdownMemoriesToSqlite(dbManager, globalDir, undefined, agentRoot),
+    );
+    assert.strictEqual(counters.imported, 0);
+    assert.strictEqual(counters.warnings.length, 0, 'the observer-written fingerprint must let startup skip without touching memories');
+    assert.strictEqual(counters.skipped, 1);
+  });
+
+  it('scoped startup sync reconciles only globals and the current project', async () => {
+    fs.writeFileSync(path.join(globalDir, 'MEMORY.md'), 'global memory', 'utf-8');
+    fs.writeFileSync(path.join(globalDir, 'USER.md'), 'global user', 'utf-8');
+    const total = 30;
+    for (let i = 0; i < total; i++) {
+      const dir = path.join(agentRoot, 'projects-memory', `proj-${i}`);
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(path.join(dir, 'MEMORY.md'), `memory for project ${i}`, 'utf-8');
+    }
+    // A stale mirror row outside the startup scope must survive: scoped runs
+    // never prune scopes they did not reconcile (the full command does that).
+    addMemory(dbManager, 'stale out-of-scope row', 'memory', 'proj-29');
+
+    const counters = await syncMarkdownMemoriesToSqlite(dbManager, globalDir, undefined, agentRoot, {
+      onlyProjects: ['proj-0'],
+    });
+
+    assert.strictEqual(counters.projectCount, 1);
+    assert.strictEqual(counters.filesScanned, 3, 'global MEMORY.md + USER.md + proj-0 only');
+    const current = searchMemories(dbManager, 'memory for project 0', { project: 'proj-0', target: 'memory' });
+    assert.strictEqual(current.length, 1);
+    assert.deepStrictEqual(getMemories(dbManager, { project: 'proj-1', target: 'memory' }), []);
+    assert.strictEqual(
+      getMemories(dbManager, { project: 'proj-29', target: 'memory' }).length,
+      1,
+      'out-of-scope mirror rows are left alone',
+    );
+    const fingerprints = dbManager.getDb().prepare(
+      `SELECT key FROM extension_metadata WHERE key LIKE '${MDSYNC_METADATA_KEY_PREFIX}%'`,
+    ).all() as Array<{ key: string }>;
+    assert.ok(
+      fingerprints.every((row) => row.key.includes('proj-0') || row.key.includes('null')),
+      `no fingerprint may be recorded for unscanned projects: ${fingerprints.map((row) => row.key)}`,
+    );
+  });
+
+  it('scoped startup sync with no project reconciles globals only', async () => {
+    fs.writeFileSync(path.join(globalDir, 'MEMORY.md'), 'global memory', 'utf-8');
+    const dir = path.join(agentRoot, 'projects-memory', 'proj-0');
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, 'MEMORY.md'), 'memory for project 0', 'utf-8');
+
+    const counters = await syncMarkdownMemoriesToSqlite(dbManager, globalDir, undefined, agentRoot, {
+      onlyProjects: [],
+    });
+
+    assert.strictEqual(counters.projectCount, 0);
+    assert.strictEqual(counters.filesScanned, 1);
+    assert.deepStrictEqual(getMemories(dbManager, { project: 'proj-0', target: 'memory' }), []);
+  });
+
+  it('scoped startup sync still prunes the current project when its file is gone', async () => {
+    addMemory(dbManager, 'stale current-project row', 'memory', 'proj-gone');
+
+    const counters = await syncMarkdownMemoriesToSqlite(dbManager, globalDir, undefined, agentRoot, {
+      onlyProjects: ['proj-gone'],
+    });
+
+    assert.strictEqual(counters.projectCount, 1);
+    assert.strictEqual(counters.removed, 1);
+    assert.deepStrictEqual(getMemories(dbManager, { project: 'proj-gone', target: 'memory' }), []);
+  });
 });

package/dist/extensions/pi-hermes-memory/tests/handlers/system-prompt.test.ts

@@ -108,9 +108,7 @@ describe("system prompt injection", () => {
     assert.ok(prompt1.includes("Original entry"), "snapshot should contain original entry");
 
     // Add a new entry in-memory (simulating a tool call that adds memory mid-session)
-    store.add("memory", "New entry after load");
-    // Wait for async write
-    await new Promise((r) => setTimeout(r, 250));
+    await store.add("memory", "New entry after load");
 
     // formatForSystemPrompt should still return the snapshot from load time
     const prompt2 = store.formatForSystemPrompt();

package/dist/extensions/pi-hermes-memory/tests/index.test.ts

@@ -27,4 +27,21 @@ describe("shouldWarnAutoConsolidationFailure", () => {
       false,
     );
   });
+
+  it("warns for a partial consolidation even when progress was made", () => {
+    assert.strictEqual(
+      shouldWarnAutoConsolidationFailure(true, true, true),
+      true,
+    );
+    assert.strictEqual(
+      shouldWarnAutoConsolidationFailure(false, true, true),
+      false,
+      "the warning flag still governs",
+    );
+    assert.strictEqual(
+      shouldWarnAutoConsolidationFailure(true, true, false),
+      false,
+      "a clean successful run stays quiet",
+    );
+  });
 });

package/dist/extensions/pi-hermes-memory/tests/integration/corruption-recovery-integration.test.ts

@@ -69,6 +69,8 @@ describe('Corruption recovery during markdown sync', () => {
 
       // 5. The entry must actually be persisted in the rebuilt database —
       // a swallowed zero-count success would leave the memory in markdown only.
+      // The rebuild strips copied markdown-scope fingerprints (copyRecoverableRows),
+      // so the retry on the new handle re-mirrors instead of trusting them.
       assert.ok(second.inserted >= 1, `expected the entry to persist after recovery, got ${JSON.stringify(second)}`);
       const rows = dbManager.getDb()
         .prepare('SELECT content FROM memories WHERE target = ? ORDER BY id ASC')
@@ -81,6 +83,25 @@ describe('Corruption recovery during markdown sync', () => {
       // 6. The original path must now hold a fresh, healthy database.
       const header = fs.readFileSync(dbFile).subarray(0, 16).toString('utf-8');
       assert.equal(header, 'SQLite format 3\x00', 'a fresh SQLite database must exist at the original path');
+
+      // 7. Fingerprint on the rebuilt handle must skip a third identical reconcile.
+      const recoveredDb = dbManager.getDb() as { prepare: (sql: string) => unknown };
+      const originalPrepare = recoveredDb.prepare.bind(recoveredDb);
+      recoveredDb.prepare = (sql: string) => {
+        const normalized = sql.replace(/\s+/g, ' ').trim();
+        if (/^INSERT(?: OR REPLACE)? INTO memories\b/i.test(normalized) || /^UPDATE memories\b/i.test(normalized)) {
+          throw new Error(`unexpected memories write after recovery skip: ${normalized}`);
+        }
+        return originalPrepare(sql);
+      };
+      try {
+        const third = reconcileMarkdownMemoryScope(dbManager, ['second entry after corruption'], 'memory', null);
+        assert.equal(third.inserted, 0);
+        assert.equal(third.existing, 1);
+        assert.equal(third.removed, 0);
+      } finally {
+        recoveredDb.prepare = originalPrepare;
+      }
     } finally {
       try { dbManager.close(); } catch { /* best effort */ }
       // Best-effort: on Windows the shared AtomicLockCoordinator keeps

package/dist/extensions/pi-hermes-memory/tests/lazy-startup.test.ts

@@ -0,0 +1,313 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs/promises";
+import { existsSync } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { after, beforeEach, afterEach, describe, it } from "node:test";
+
+// Bind the entry point to a disposable agent root, never the user's memory.
+const root = await fs.mkdtemp(path.join(os.tmpdir(), "pi-lazy-startup-"));
+const previousRoot = process.env.PI_CODING_AGENT_DIR;
+process.env.PI_CODING_AGENT_DIR = root;
+const { default: registerExtension } = await import("../src/index.js");
+const { MemoryStore } = await import("../src/store/memory-store.js");
+const { DatabaseManager } = await import("../src/store/db.js");
+const globalDir = path.join(root, "pi-hermes-memory");
+const cwd = path.join(root, "workspace");
+const projectDir = path.join(root, "projects-memory", "workspace");
+let handlers: Record<string, Array<(event: any, ctx: any) => any>>;
+let tools: Record<string, any>;
+let commands: Record<string, any>;
+let notifications: string[];
+let ctx: any;
+
+async function configure(overrides: Record<string, unknown> = {}) {
+  await fs.writeFile(path.join(root, "hermes-memory-config.json"), JSON.stringify({
+    lazyInitialization: true,
+    reviewEnabled: false, correctionDetection: false,
+    flushOnCompact: false, flushOnShutdown: false,
+    ...overrides,
+  }));
+}
+
+function register() {
+  registerExtension({
+    on(event: string, handler: any) { (handlers[event] ??= []).push(handler); },
+    registerTool(tool: any) { tools[tool.name] = tool; },
+    registerCommand(name: string, options: any) { commands[name] = options; },
+  } as any);
+}
+
+async function emit(event: string, data: any = {}) {
+  let result: any;
+  for (const handler of handlers[event] ?? []) result = (await handler(data, ctx)) ?? result;
+  return result;
+}
+
+async function search(query = "durable") {
+  return tools.memory_search.execute("search", { query }, undefined, undefined, ctx);
+}
+
+async function writeSession() {
+  const dir = path.join(root, "sessions", "workspace");
+  await fs.mkdir(dir, { recursive: true });
+  const file = path.join(dir, "history.jsonl");
+  const timestamp = new Date().toISOString();
+  await fs.writeFile(file, [
+    { type: "session", id: "history", timestamp, cwd },
+    { type: "message", id: "m1", parentId: null, timestamp,
+      message: { role: "user", content: [{ type: "text", text: "historical deployment decision" }], timestamp: Date.now() } },
+  ].map((entry) => JSON.stringify(entry)).join("\n"));
+  return file;
+}
+
+beforeEach(async () => {
+  await fs.mkdir(globalDir, { recursive: true });
+  await fs.mkdir(projectDir, { recursive: true });
+  await fs.mkdir(cwd, { recursive: true });
+  await fs.writeFile(path.join(globalDir, "MEMORY.md"), "durable global fact");
+  await fs.writeFile(path.join(projectDir, "MEMORY.md"), "durable project fact");
+  await fs.writeFile(path.join(globalDir, "STANDING.md"), "- Always ask before deployment.\n");
+  await configure();
+  handlers = {}; tools = {}; commands = {}; notifications = [];
+  ctx = {
+    cwd, hasUI: true,
+    sessionManager: { getBranch: () => [], getSessionFile: () => undefined },
+    ui: { notify: (text: string) => notifications.push(text) },
+  };
+});
+
+afterEach(async () => {
+  await emit("session_shutdown", { reason: "quit" });
+  for (const name of await fs.readdir(root)) await fs.rm(path.join(root, name), { recursive: true, force: true });
+});
+
+after(async () => {
+  if (previousRoot === undefined) delete process.env.PI_CODING_AGENT_DIR;
+  else process.env.PI_CODING_AGENT_DIR = previousRoot;
+  await fs.rm(root, { recursive: true, force: true });
+});
+
+describe("lazy startup lifecycle", () => {
+  it("keeps generic conversation, skills, preview and cold shutdown free of memory/DB loading", async (t) => {
+    const loads = t.mock.method(MemoryStore.prototype, "loadFromDisk");
+    const opens = t.mock.method(DatabaseManager.prototype, "getDb");
+    register();
+    await emit("session_start");
+    const resources = await emit("resources_discover", { cwd, reason: "startup" });
+    assert.deepEqual(resources.skillPaths, [path.join(globalDir, "skills"), path.join(projectDir, "skills")]);
+    const prompt = await emit("before_agent_start", { systemPrompt: "base" });
+    assert.match(prompt.systemPrompt, /Always ask before deployment/);
+    assert.match(prompt.systemPrompt, /memory-policy/);
+    assert.doesNotMatch(prompt.systemPrompt, /durable global fact/);
+    await emit("message_end", { message: { role: "user", content: "hello" } });
+    await emit("turn_end", { message: { role: "assistant", content: [] } });
+    await commands["memory-preview-context"].handler("", ctx);
+    await commands["memory-switch-project"].handler("", ctx);
+    assert.ok(notifications.some((text) => text.includes("workspace (1 entry)")));
+    await emit("session_shutdown", { reason: "quit" });
+    assert.equal(loads.mock.callCount(), 0);
+    assert.equal(opens.mock.callCount(), 0);
+    assert.equal(existsSync(path.join(globalDir, "sessions.db")), false);
+  });
+
+  it("loads and synchronizes once for concurrent first search and write", async (t) => {
+    const loads = t.mock.method(MemoryStore.prototype, "loadFromDisk");
+    register();
+    await emit("session_start");
+    const results = await Promise.all([
+      search(), search(),
+      tools.memory_add.execute("write", { target: "project", content: "new durable project fact" }, undefined, undefined, ctx),
+    ]);
+    assert.equal(results[0].details.count, 2);
+    assert.equal(results[2].details.success, true);
+    assert.equal(loads.mock.callCount(), 2, "one global and one project load");
+    assert.equal((await search()).details.count, 3);
+    assert.equal(loads.mock.callCount(), 2);
+    assert.match(await fs.readFile(path.join(projectDir, "MEMORY.md"), "utf8"), /durable project fact/);
+  });
+
+  it("initializes from a command without a prior model turn", async () => {
+    register();
+    await emit("session_start");
+    await commands["memory-insights"].handler("", ctx);
+    assert.ok(notifications.some((text) => text.includes("durable global fact")));
+    assert.equal(existsSync(path.join(globalDir, "sessions.db")), true);
+  });
+
+  it("backfills JSONL history before the first SQLite session search returns", async () => {
+    const file = await writeSession();
+    ctx.sessionManager.getSessionFile = () => file;
+    register();
+    await emit("session_start");
+    assert.equal(existsSync(path.join(globalDir, "sessions.db")), false);
+    const result = await tools.session_search.execute("id", { query: "historical" }, undefined, undefined, ctx);
+    assert.equal(result.details.count, 1);
+    assert.match(result.content[0].text, /historical deployment decision/);
+  });
+
+  it("leaves an unused resumed session in JSONL without opening SQLite on exit", async () => {
+    const file = await writeSession();
+    ctx.sessionManager.getSessionFile = () => file;
+    register();
+    await emit("session_start");
+    await emit("session_shutdown", { reason: "quit" });
+    assert.equal(existsSync(path.join(globalDir, "sessions.db")), false);
+    assert.match(await fs.readFile(file, "utf8"), /historical deployment decision/);
+  });
+
+  it("keeps anchor-only session search independent of the memory database", async () => {
+    await configure({ sessionSearch: { variant: "anchors" } });
+    await writeSession();
+    register();
+    await emit("session_start");
+    const result = await tools.session_search.execute("id", { markdown: "all:\n- historical" }, undefined, undefined, ctx);
+    assert.equal(result.details.count, 1);
+    assert.equal(existsSync(path.join(globalDir, "sessions.db")), false);
+  });
+
+  it("supports a custom memory directory without waiting for a nonexistent migration", async () => {
+    const custom = path.join(root, "custom", "store");
+    await fs.mkdir(custom, { recursive: true });
+    await fs.writeFile(path.join(custom, "MEMORY.md"), "custom durable fact");
+    await configure({ memoryDir: custom });
+    register();
+    await emit("session_start");
+    assert.equal(existsSync(path.join(custom, "sessions.db")), false);
+    assert.equal((await search("custom")).details.count, 1);
+    assert.equal(existsSync(path.join(custom, "sessions.db")), true);
+  });
+
+  it("retries a failed first load before allowing search", async (t) => {
+    const original = MemoryStore.prototype.loadFromDisk;
+    let fail = true;
+    t.mock.method(MemoryStore.prototype, "loadFromDisk", async function (this: InstanceType<typeof MemoryStore>) {
+      if (fail) { fail = false; throw new Error("transient read failure"); }
+      return original.call(this);
+    });
+    register();
+    await emit("session_start");
+    await assert.rejects(search(), /transient read failure/);
+    assert.equal((await search()).details.count, 2);
+  });
+
+  it("clears a rejected project load before switching to a non-project cwd or retrying", async (t) => {
+    const original = MemoryStore.prototype.loadFromDisk;
+    let loads = 0;
+    t.mock.method(MemoryStore.prototype, "loadFromDisk", async function (this: InstanceType<typeof MemoryStore>) {
+      if (++loads === 2) throw new Error("project load failed");
+      return original.call(this);
+    });
+    register();
+    await emit("session_start");
+    await assert.rejects(search(), /project load failed/);
+    ctx.cwd = os.homedir();
+    assert.equal((await search()).details.count, 2);
+    const unavailable = await tools.memory_add.execute("write", { target: "project", content: "not a project" }, undefined, undefined, ctx);
+    assert.equal(unavailable.details.success, false);
+    ctx.cwd = cwd;
+    assert.equal((await search()).details.count, 2);
+    assert.equal(loads, 3);
+  });
+
+  it("does not close or reopen SQLite beneath a first-use project bind", async (t) => {
+    const originalLoad = MemoryStore.prototype.loadFromDisk;
+    const binding = Promise.withResolvers<void>();
+    const release = Promise.withResolvers<void>();
+    let loads = 0;
+    t.mock.method(MemoryStore.prototype, "loadFromDisk", async function (this: InstanceType<typeof MemoryStore>) {
+      if (++loads === 2) { binding.resolve(); await release.promise; }
+      return originalLoad.call(this);
+    });
+    const getDb = t.mock.method(DatabaseManager.prototype, "getDb");
+    const close = t.mock.method(DatabaseManager.prototype, "close");
+    register();
+    await emit("session_start");
+    const first = search();
+    await binding.promise;
+    const rejected = assert.rejects(first, /shut down/);
+    let shutDown = false;
+    const shutdown = emit("session_shutdown", { reason: "quit" }).then(() => { shutDown = true; });
+    try {
+      await new Promise(setImmediate);
+      assert.equal(shutDown, false);
+      assert.equal(close.mock.callCount(), 0);
+    } finally {
+      release.resolve();
+      await Promise.all([rejected, shutdown]);
+    }
+    const manager = getDb.mock.calls[0].this;
+    assert.throws(() => manager.getDb(), /shut down/);
+    assert.equal(close.mock.callCount(), 1);
+  });
+
+  it("waits for the full scheduled batch across forty multi-message history files", async (t) => {
+    const dir = path.join(root, "sessions", "workspace");
+    await fs.mkdir(dir, { recursive: true });
+    const timestamp = new Date().toISOString();
+    for (let fileIndex = 0; fileIndex < 40; fileIndex++) {
+      const id = `history-${fileIndex}`;
+      const entries = [
+        { type: "session", id, timestamp, cwd },
+        ...Array.from({ length: 25 }, (_, i) => ({
+          type: "message", id: `${id}-m${i}`, parentId: i ? `${id}-m${i - 1}` : null, timestamp,
+          message: { role: "user", content: [{ type: "text", text: `historical decision ${fileIndex} ${i}` }], timestamp: Date.now() },
+        })),
+      ];
+      await fs.writeFile(path.join(dir, `${id}.jsonl`), entries.map((entry) => JSON.stringify(entry)).join("\n"));
+    }
+    const getDb = t.mock.method(DatabaseManager.prototype, "getDb");
+    register();
+    await emit("session_start");
+    await tools.session_search.execute("id", { query: "historical" }, undefined, undefined, ctx);
+    const stats = getDb.mock.calls[0].this.getStats();
+    assert.equal(stats.sessions, 40);
+    assert.equal(stats.messages, 1000);
+  });
+
+  for (const overrides of [{ lazyInitialization: false }, { memoryMode: "legacy-inject" }]) {
+    it(`preserves eager loading with ${JSON.stringify(overrides)}`, async (t) => {
+      await configure(overrides);
+      const loads = t.mock.method(MemoryStore.prototype, "loadFromDisk");
+      register();
+      await emit("session_start");
+      assert.equal(loads.mock.callCount(), 2);
+      assert.equal(existsSync(path.join(globalDir, "sessions.db")), true);
+      if (overrides.memoryMode === "legacy-inject") {
+        const before = await emit("before_agent_start", { systemPrompt: "base" });
+        assert.match(before.systemPrompt, /durable global fact/);
+        await tools.memory_add.execute("id", { target: "memory", content: "late addition" }, undefined, undefined, ctx);
+        const after = await emit("before_agent_start", { systemPrompt: "base" });
+        assert.equal(after.systemPrompt, before.systemPrompt);
+      }
+    });
+  }
+
+  it("migrates legacy memory on first use, not startup", async () => {
+    const legacy = path.join(root, "memory");
+    await fs.mkdir(legacy);
+    await fs.writeFile(path.join(legacy, "USER.md"), "legacy durable preference");
+    register();
+    await emit("session_start");
+    assert.equal(existsSync(path.join(globalDir, "USER.md")), false);
+    assert.equal((await search("legacy")).details.count, 1);
+    assert.match(await fs.readFile(path.join(globalDir, "USER.md"), "utf8"), /legacy durable preference/);
+  });
+
+  it("keeps legacy pins and skill discovery available even when memory initialization fails", async (t) => {
+    const legacy = path.join(root, "memory");
+    await fs.mkdir(legacy);
+    await fs.rename(path.join(globalDir, "STANDING.md"), path.join(legacy, "STANDING.md"));
+    const getDb = t.mock.method(DatabaseManager.prototype, "getDb", () => { throw new Error("database unavailable"); });
+    register();
+    await emit("session_start");
+    const resources = await emit("resources_discover", { cwd, reason: "startup" });
+    assert.equal(resources.skillPaths.length, 2);
+    assert.equal(getDb.mock.callCount(), 0);
+    const prompt = await emit("before_agent_start", { systemPrompt: "base" });
+    assert.match(prompt.systemPrompt, /Always ask before deployment/);
+    await assert.rejects(search(), /database unavailable/);
+    const afterFailure = await emit("before_agent_start", { systemPrompt: "base" });
+    assert.match(afterFailure.systemPrompt, /Always ask before deployment/);
+  });
+});