chapterhouse 0.8.0 → 0.8.1

package/dist/copilot/agents.js

@@ -340,7 +340,7 @@ export function buildAgentRoster() {
 }
 // The wiki tools that every agent gets regardless of tool config
 const WIKI_TOOL_NAMES = new Set([
-    "wiki_search", "wiki_read", "wiki_update", "wiki_append_timeline", "wiki_ingest_source",
+    "wiki_search", "wiki_read", "wiki_update", "wiki_reindex", "wiki_append_timeline", "wiki_ingest_source",
     "memory_recall", "memory_propose", "memory_list_action_items",
 ]);
 // Management tools that only @chapterhouse should have

package/dist/copilot/system-message.js

@@ -119,6 +119,7 @@ You can delegate **multiple tasks simultaneously**. Different agents can work in
 - \`memory_recall\`: Search scoped agent memory for stored facts, decisions, and observations.
 - \`memory_reflect\`: Synthesize durable patterns from repeated observations in the scoped memory store.
 - \`wiki_update\`: Create or update wiki pages when knowledge belongs in the shared wiki.
+- \`wiki_reindex\`: Force a filesystem-to-SQLite wiki reindex if existing pages are missing from search.
 
 Subagent proposals from \`memory_propose\` are processed automatically at end-of-task, so you do not need to manually review them mid-conversation.
 

package/dist/copilot/tools.js

@@ -11,7 +11,7 @@ import { agentEventBus } from "./agent-event-bus.js";
 import { getCurrentSourceChannel, getCurrentActivityCallback, getCurrentActiveProjectRules, getCurrentAuthenticatedUser, getLastAuthenticatedUser, getCurrentAuthorizationHeader, getCurrentSessionKey, sendToAgentSession, invalidateOrchestratorSession, maybeScheduleScopeChangeCheckpoint, resetCheckpointSessionState, switchSessionModel, } from "./orchestrator.js";
 import { getRouterConfig, updateRouterConfig } from "./router.js";
 import { ensureWikiStructure, writePage, assertPagePath } from "../wiki/fs.js";
-import { searchIndex, addToIndex, buildIndexEntryForPage, } from "../wiki/index-manager.js";
+import { searchIndex, addToIndex, buildIndexEntryForPage, reindexWikiPages, } from "../wiki/index-manager.js";
 import { traverse as wikiTraverse } from "../wiki/links.js";
 import { validateWikiFrontmatter, validateAndBackfillFrontmatter } from "../wiki/frontmatter.js";
 import { appendTimeline } from "../wiki/timeline.js";
@@ -1558,6 +1558,16 @@ export function createTools(deps) {
             parameters: z.object({}).passthrough(),
             handler: async () => "This tool has been removed. The wiki index is now maintained automatically via SQLite FTS5.",
         }),
+        defineTool("wiki_reindex", {
+            description: "Force a full wiki filesystem-to-SQLite reindex pass.",
+            parameters: z.object({}),
+            handler: async () => {
+                ensureWikiStructure();
+                const result = reindexWikiPages();
+                appendLog("update", `wiki_reindex: rebuilt ${result.indexedPageCount} page(s)`);
+                return `Reindexed ${result.indexedPageCount} wiki page(s) from disk.`;
+            },
+        }),
         defineTool("wiki_traverse", {
             description: "Walk the wiki entity graph from a starting page. Returns pages connected by typed links. " +
                 "Use to discover related knowledge, trace dependencies, find who works on a project, etc. " +

package/dist/copilot/tools.wiki.test.js

@@ -146,6 +146,33 @@ Runtime notes with enough content to avoid incidental lint noise in the audit-lo
     const log = wikiFs.readLogFile();
     assert.match(log, /update \| wiki_update: Chapterhouse \(pages\/shared\/chapterhouse\.md\) \| tools-test-agent/);
 });
+test("wiki_reindex rebuilds wiki_pages from disk on demand", async () => {
+    const toolsModule = await loadToolsModule();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const wikiReindex = tools.find((entry) => entry.name === "wiki_reindex");
+    assert.ok(wikiReindex);
+    const { wikiFs, indexManager } = await readWikiArtifacts();
+    wikiFs.ensureWikiStructure();
+    wikiFs.writePage("pages/topics/rust/index.md", `---
+title: Rust
+summary: Systems programming
+updated: 2026-05-12
+---
+
+# Rust
+`);
+    for (const entry of indexManager.parseIndex()) {
+        indexManager.removeFromIndex(entry.path);
+    }
+    assert.equal(indexManager.parseIndex().length, 0, "Precondition: wiki_pages should start empty");
+    const result = await wikiReindex.handler({});
+    assert.match(result, /^Reindexed \d+ wiki page\(s\) from disk\.$/);
+    assert.ok(indexManager.parseIndex().some((entry) => entry.path === "pages/topics/rust/index.md"));
+    assert.match(wikiFs.readLogFile(), /update \| wiki_reindex: rebuilt \d+ page\(s\) \| tools-test-agent/);
+});
 test("removed legacy wiki tools return helpful stub messages without mutating wiki pages", async () => {
     const toolsModule = await loadToolsModule();
     const tools = toolsModule.createTools({

package/dist/copilot/turn-event-log-env.test.js

@@ -1,19 +1,15 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-test("SESSION_BUFFER_CAPACITY respects CHAPTERHOUSE_SSE_BUFFER_CAPACITY", async () => {
-    const previous = process.env.CHAPTERHOUSE_SSE_BUFFER_CAPACITY;
-    process.env.CHAPTERHOUSE_SSE_BUFFER_CAPACITY = "3";
-    try {
-        const module = await import(`./turn-event-log.js?capacity=${Date.now()}`);
-        assert.equal(module.SESSION_BUFFER_CAPACITY, 3);
-    }
-    finally {
-        if (previous === undefined) {
-            delete process.env.CHAPTERHOUSE_SSE_BUFFER_CAPACITY;
-        }
-        else {
-            process.env.CHAPTERHOUSE_SSE_BUFFER_CAPACITY = previous;
-        }
-    }
+test("SESSION_BUFFER_CAPACITY respects config.sseBufferCapacity", async (t) => {
+    t.mock.module("../config.js", {
+        namedExports: {
+            config: {
+                sseBufferCapacity: 3,
+                sseReplayLimit: 50,
+            },
+        },
+    });
+    const module = await import(`./turn-event-log.js?capacity=${Date.now()}`);
+    assert.equal(module.SESSION_BUFFER_CAPACITY, 3);
 });
 //# sourceMappingURL=turn-event-log-env.test.js.map

package/dist/daemon.js

@@ -23,6 +23,7 @@ import { isWorkiqAutoInstallEnabled, ensureWorkiqMcpEntry } from "./copilot/work
 import { MemoryHousekeepingScheduler } from "./memory/housekeeping-scheduler.js";
 import { runP6Migration } from "./memory/migration.js";
 import { WikiConsolidationScheduler } from "./wiki/scheduler.js";
+import { ensureWikiIndexPopulated } from "./wiki/index-manager.js";
 const log = logger.child({ module: "daemon" });
 const modeContext = new ModeContext(config);
 let memoryHousekeepingScheduler;
@@ -131,6 +132,15 @@ async function main() {
     }
     const p6Migration = await runP6Migration(getDb());
     log.info({ p6Migration }, "P6 wiki seed migration complete");
+    try {
+        const wikiReindex = ensureWikiIndexPopulated();
+        if (wikiReindex.reindexed) {
+            log.info(wikiReindex, "Rebuilt wiki index from disk on startup");
+        }
+    }
+    catch (err) {
+        log.error({ err: err instanceof Error ? err.message : err }, "Startup wiki reindex check failed");
+    }
     // Prune orphaned session folders older than 7 days
     pruneOldSessions();
     // One-time deprecation note for legacy Telegram users (v1 → v2)

package/dist/memory/eot.js

@@ -127,6 +127,16 @@ function isNonEmptyString(value) {
 function isIsoTimestamp(value) {
     return !Number.isNaN(Date.parse(value));
 }
+function validateObservationPayload(payload) {
+    const observation = payload;
+    if (!isNonEmptyString(observation.content)) {
+        return undefined;
+    }
+    return {
+        ...observation,
+        content: observation.content.trim(),
+    };
+}
 function validateActionItemPayload(payload) {
     const actionItem = payload;
     if (!isNonEmptyString(actionItem.title)) {
@@ -195,15 +205,20 @@ function rememberAcceptedMemory(kind, scopeSlug, payload, source, confidence, so
         throw new Error(`Unknown memory scope '${scopeSlug}'.`);
     }
     if (kind === "observation") {
-        const observation = payload;
+        const observation = validateObservationPayload(payload);
+        if (!observation) {
+            log.warn({ scopeSlug, source, sourceAgent }, "Skipping accepted observation proposal with empty content");
+            return false;
+        }
+        const content = observation.content;
         recordObservation({
             scope_id: scope.id,
             entity_id: observation.entity_id,
-            content: observation.content,
+            content,
             source: observation.source ?? source,
             confidence,
         });
-        return;
+        return true;
     }
     if (kind === "decision") {
         const decision = payload;
@@ -213,7 +228,7 @@ function rememberAcceptedMemory(kind, scopeSlug, payload, source, confidence, so
             rationale: decision.rationale ?? decision.title,
             decided_at: decision.decided_at,
         });
-        return;
+        return true;
     }
     if (kind === "action_item") {
         const actionItem = validateActionItemPayload(payload);
@@ -233,7 +248,7 @@ function rememberAcceptedMemory(kind, scopeSlug, payload, source, confidence, so
             due_at: actionItem.due_at,
             source: sourceAgent ? `subagent_proposal:${sourceAgent}` : actionItem.source ?? source,
         });
-        return;
+        return true;
     }
     const entity = payload;
     const entityKind = entity.entity_kind ?? entity.kind;
@@ -247,6 +262,7 @@ function rememberAcceptedMemory(kind, scopeSlug, payload, source, confidence, so
         summary: entity.summary,
         confidence,
     });
+    return true;
 }
 export async function runEndOfTaskMemoryHook(input) {
     const autoAcceptEnabled = isMemoryAutoAcceptEnabled();
@@ -293,7 +309,12 @@ export async function runEndOfTaskMemoryHook(input) {
             else {
                 const envelope = parseEnvelope(proposal.payload);
                 try {
-                    rememberAcceptedMemory(envelope.kind, resolveAcceptedProposalScopeSlug(envelope, proposal), envelope.payload, `agent:${proposal.sourceAgent}`, envelope.confidence, proposal.sourceAgent);
+                    const accepted = rememberAcceptedMemory(envelope.kind, resolveAcceptedProposalScopeSlug(envelope, proposal), envelope.payload, `agent:${proposal.sourceAgent}`, envelope.confidence, proposal.sourceAgent);
+                    if (!accepted) {
+                        resolveInboxItem(proposal.id, "accepted", decision.reason);
+                        summary.accepted++;
+                        continue;
+                    }
                     resolveInboxItem(proposal.id, "accepted", decision.reason);
                     summary.accepted++;
                 }
@@ -321,8 +342,9 @@ export async function runEndOfTaskMemoryHook(input) {
     }
     if (autoAcceptEnabled) {
         for (const implicitMemory of review.implicit_memories) {
-            rememberAcceptedMemory(implicitMemory.kind, implicitMemory.scope_slug, implicitMemory.payload, "agent:eot", implicitMemory.confidence);
-            summary.implicit_extracted++;
+            if (rememberAcceptedMemory(implicitMemory.kind, implicitMemory.scope_slug, implicitMemory.payload, "agent:eot", implicitMemory.confidence)) {
+                summary.implicit_extracted++;
+            }
         }
     }
     log.info(summary, "memory.eot.processed");

package/dist/memory/eot.test.js

@@ -2,6 +2,7 @@ import assert from "node:assert/strict";
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import test from "node:test";
+import { resetSingletons } from "../test/helpers/reset-singletons.js";
 const repoRoot = process.cwd();
 const sandboxRoot = join(repoRoot, ".test-work", `memory-eot-${process.pid}`);
 const chapterhouseHome = join(sandboxRoot, ".chapterhouse");
@@ -18,24 +19,40 @@ async function loadModules(cacheBust = `${Date.now()}-${Math.random()}`) {
     const agentsModule = await import(new URL(`../copilot/agents.js?case=${cacheBust}`, import.meta.url).href);
     return { dbModule, memoryModule, eotModule, agentsModule };
 }
+async function loadModulesWithWarnSpy(t, cacheBust) {
+    const warnings = [];
+    t.mock.module("../util/logger.js", {
+        namedExports: {
+            childLogger: () => ({
+                info: () => { },
+                warn: (...args) => {
+                    warnings.push(args);
+                },
+                error: () => { },
+            }),
+        },
+    });
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    const memoryModule = await import(new URL(`./index.js?case=${cacheBust}`, import.meta.url).href);
+    const eotModule = await import(new URL(`./eot.js?case=${cacheBust}`, import.meta.url).href);
+    return { dbModule, memoryModule, eotModule, warnings };
+}
 function getFunction(module, name) {
     const value = module[name];
     assert.equal(typeof value, "function", `expected ${name} to be exported`);
     return value;
 }
-test.beforeEach(async () => {
+test.beforeEach(() => {
     process.env.CHAPTERHOUSE_HOME = sandboxRoot;
     delete process.env.CHAPTERHOUSE_MEMORY_EOT_HOOK_ENABLED;
     delete process.env.CHAPTERHOUSE_MEMORY_AUTO_ACCEPT;
-    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
-    dbModule.closeDb();
     resetSandbox();
+    resetSingletons();
 });
-test.after(async () => {
+test.after(() => {
     delete process.env.CHAPTERHOUSE_MEMORY_EOT_HOOK_ENABLED;
     delete process.env.CHAPTERHOUSE_MEMORY_AUTO_ACCEPT;
-    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
-    dbModule.closeDb();
+    resetSingletons();
     rmSync(sandboxRoot, { recursive: true, force: true });
 });
 test("runEndOfTaskMemoryHook does nothing when CHAPTERHOUSE_MEMORY_EOT_HOOK_ENABLED=0", async () => {
@@ -239,6 +256,98 @@ test("runEndOfTaskMemoryHook rejects invalid action_item proposals with a clear
     assert.match(inbox.resolution_reason ?? "", /title/i);
     assert.ok(inbox.resolved_at);
 });
+async function runAcceptedObservationHookScenario(t, cacheBust, taskId, payload) {
+    const warnings = [];
+    t.mock.module("../util/logger.js", {
+        namedExports: {
+            childLogger: () => ({
+                info: () => { },
+                warn: (obj, msg) => warnings.push({ obj, msg }),
+                error: () => { },
+            }),
+        },
+    });
+    const { dbModule, memoryModule, eotModule } = await loadModules(cacheBust);
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const listObservations = getFunction(memoryModule, "listObservations");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse);
+    const before = listObservations({ scope_id: chapterhouse.id });
+    const inserted = db.prepare(`
+    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
+    VALUES (?, 'memory_proposal', ?, 'coder', ?, 'pending')
+  `).run(chapterhouse.id, JSON.stringify({
+        kind: "observation",
+        payload,
+        confidence: 0.9,
+    }), taskId);
+    await runEndOfTaskMemoryHook({
+        taskId,
+        finalResult: "Completed and reviewed an observation proposal.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [{
+                    proposal_id: Number(inserted.lastInsertRowid),
+                    decision: "accept",
+                    reason: "Durable finding.",
+                }],
+            implicit_memories: [],
+        }),
+    });
+    const inbox = db.prepare(`
+    SELECT status, resolution_reason
+    FROM mem_inbox
+    WHERE id = ?
+  `).get(Number(inserted.lastInsertRowid));
+    return {
+        beforeCount: before.length,
+        after: listObservations({ scope_id: chapterhouse.id }),
+        warnings,
+        inbox,
+    };
+}
+test("runEndOfTaskMemoryHook skips accepted observation proposals with null content and warns", async (t) => {
+    const result = await runAcceptedObservationHookScenario(t, "observation-null-content", "task-eot-observation-null-content", { content: null });
+    assert.equal(result.after.length, result.beforeCount);
+    assert.equal(result.after.some((row) => row.content.trim().length === 0), false);
+    assert.equal(result.inbox.status, "accepted");
+    assert.equal(result.inbox.resolution_reason, "Durable finding.");
+    assert.ok(result.warnings.some((entry) => /empty content/i.test(entry.msg)));
+});
+test("runEndOfTaskMemoryHook skips accepted observation proposals with undefined content and warns", async (t) => {
+    const result = await runAcceptedObservationHookScenario(t, "observation-undefined-content", "task-eot-observation-undefined-content", {});
+    assert.equal(result.after.length, result.beforeCount);
+    assert.equal(result.after.some((row) => row.content.trim().length === 0), false);
+    assert.equal(result.inbox.status, "accepted");
+    assert.equal(result.inbox.resolution_reason, "Durable finding.");
+    assert.ok(result.warnings.some((entry) => /empty content/i.test(entry.msg)));
+});
+test("runEndOfTaskMemoryHook skips accepted observation proposals with empty string content and warns", async (t) => {
+    const result = await runAcceptedObservationHookScenario(t, "observation-empty-string-content", "task-eot-observation-empty-string-content", { content: "" });
+    assert.equal(result.after.length, result.beforeCount);
+    assert.equal(result.after.some((row) => row.content.trim().length === 0), false);
+    assert.equal(result.inbox.status, "accepted");
+    assert.equal(result.inbox.resolution_reason, "Durable finding.");
+    assert.ok(result.warnings.some((entry) => /empty content/i.test(entry.msg)));
+});
+test("runEndOfTaskMemoryHook skips accepted observation proposals with whitespace-only content and warns", async (t) => {
+    const result = await runAcceptedObservationHookScenario(t, "observation-whitespace-content", "task-eot-observation-whitespace-content", { content: "   " });
+    assert.equal(result.after.length, result.beforeCount);
+    assert.equal(result.after.some((row) => row.content.trim().length === 0), false);
+    assert.equal(result.inbox.status, "accepted");
+    assert.equal(result.inbox.resolution_reason, "Durable finding.");
+    assert.ok(result.warnings.some((entry) => /empty content/i.test(entry.msg)));
+});
+test("runEndOfTaskMemoryHook inserts accepted observation proposals with valid content", async (t) => {
+    const result = await runAcceptedObservationHookScenario(t, "observation-valid-content", "task-eot-observation-valid-content", { content: " Durable finding from the task. " });
+    assert.equal(result.after.length, result.beforeCount + 1);
+    assert.ok(result.after.some((row) => row.content === "Durable finding from the task."));
+    assert.equal(result.inbox.status, "accepted");
+    assert.equal(result.inbox.resolution_reason, "Durable finding.");
+    assert.equal(result.warnings.length, 0);
+});
 test("runEndOfTaskMemoryHook rejects action_item proposals with ambiguous entity references", async () => {
     const { dbModule, memoryModule, eotModule } = await loadModules("action-item-ambiguous-entity");
     const db = dbModule.getDb();
@@ -549,4 +658,109 @@ test("runEndOfTaskMemoryHook accepts implicit entity memories with entity_kind",
         && entity.kind === "host"
         && entity.summary === "NAS host used by Bellonda."), true);
 });
+test("runEndOfTaskMemoryHook skips implicit observation memories with null content and warns", async (t) => {
+    const { memoryModule, eotModule, warnings } = await loadModulesWithWarnSpy(t, "implicit-null-content");
+    const getScope = getFunction(memoryModule, "getScope");
+    const listObservations = getFunction(memoryModule, "listObservations");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    const initialCount = listObservations({ scope_id: chapterhouse.id }).length;
+    const summary = await runEndOfTaskMemoryHook({
+        taskId: "task-eot-implicit-null",
+        finalResult: "The reviewer attempted to persist an invalid implicit memory.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [],
+            implicit_memories: [{
+                    kind: "observation",
+                    scope_slug: "chapterhouse",
+                    payload: {
+                        content: null,
+                    },
+                }],
+        }),
+    });
+    assert.equal(listObservations({ scope_id: chapterhouse.id }).length, initialCount);
+    assert.equal(summary.implicit_extracted, 0);
+    assert.equal(warnings.length, 1);
+});
+test("runEndOfTaskMemoryHook skips implicit observation memories with undefined content and warns", async (t) => {
+    const { memoryModule, eotModule, warnings } = await loadModulesWithWarnSpy(t, "implicit-undefined-content");
+    const getScope = getFunction(memoryModule, "getScope");
+    const listObservations = getFunction(memoryModule, "listObservations");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    const initialCount = listObservations({ scope_id: chapterhouse.id }).length;
+    const summary = await runEndOfTaskMemoryHook({
+        taskId: "task-eot-implicit-undefined",
+        finalResult: "The reviewer attempted to persist an invalid implicit memory.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [],
+            implicit_memories: [{
+                    kind: "observation",
+                    scope_slug: "chapterhouse",
+                    payload: {},
+                }],
+        }),
+    });
+    assert.equal(listObservations({ scope_id: chapterhouse.id }).length, initialCount);
+    assert.equal(summary.implicit_extracted, 0);
+    assert.equal(warnings.length, 1);
+});
+test("runEndOfTaskMemoryHook skips implicit observation memories with empty content and warns", async (t) => {
+    const { memoryModule, eotModule, warnings } = await loadModulesWithWarnSpy(t, "implicit-empty-content");
+    const getScope = getFunction(memoryModule, "getScope");
+    const listObservations = getFunction(memoryModule, "listObservations");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    const initialCount = listObservations({ scope_id: chapterhouse.id }).length;
+    const summary = await runEndOfTaskMemoryHook({
+        taskId: "task-eot-implicit-empty",
+        finalResult: "The reviewer attempted to persist an invalid implicit memory.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [],
+            implicit_memories: [{
+                    kind: "observation",
+                    scope_slug: "chapterhouse",
+                    payload: {
+                        content: "   ",
+                    },
+                }],
+        }),
+    });
+    assert.equal(listObservations({ scope_id: chapterhouse.id }).length, initialCount);
+    assert.equal(summary.implicit_extracted, 0);
+    assert.equal(warnings.length, 1);
+});
+test("runEndOfTaskMemoryHook persists implicit observation memories with valid content", async (t) => {
+    const { memoryModule, eotModule, warnings } = await loadModulesWithWarnSpy(t, "implicit-valid-content");
+    const getScope = getFunction(memoryModule, "getScope");
+    const listObservations = getFunction(memoryModule, "listObservations");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    const summary = await runEndOfTaskMemoryHook({
+        taskId: "task-eot-implicit-valid",
+        finalResult: "The reviewer discovered a valid durable memory.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [],
+            implicit_memories: [{
+                    kind: "observation",
+                    scope_slug: "chapterhouse",
+                    payload: {
+                        content: "A valid implicit memory should still be stored.",
+                    },
+                }],
+        }),
+    });
+    assert.equal(listObservations({ scope_id: chapterhouse.id }).some((row) => row.content === "A valid implicit memory should still be stored."), true);
+    assert.equal(summary.implicit_extracted, 1);
+    assert.equal(warnings.length, 0);
+});
 //# sourceMappingURL=eot.test.js.map

package/dist/memory/migration.test.js

@@ -2,6 +2,7 @@ import assert from "node:assert/strict";
 import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import test from "node:test";
+import { resetSingletons } from "../test/helpers/reset-singletons.js";
 let sandboxRoot;
 let chapterhouseHome;
 let dbModule;
@@ -20,12 +21,15 @@ test.before(async () => {
     sandboxRoot = mkdtempSync(join(process.cwd(), ".test-work", "memory-migration-"));
     process.env.CHAPTERHOUSE_HOME = sandboxRoot;
     chapterhouseHome = join(sandboxRoot, ".chapterhouse");
+    resetSingletons();
     const nonce = `${Date.now()}-${Math.random()}`;
     dbModule = await import(new URL(`../store/db.js?case=${nonce}`, import.meta.url).href);
     migrationModule = await import(new URL(`./migration.js?case=${nonce}`, import.meta.url).href);
 });
 test.beforeEach(() => {
+    process.env.CHAPTERHOUSE_HOME = sandboxRoot;
     dbModule.closeDb();
+    resetSingletons();
     resetSandbox();
 });
 test.after(() => {
@@ -33,6 +37,10 @@ test.after(() => {
         dbModule.closeDb();
     }
     catch { }
+    try {
+        resetSingletons();
+    }
+    catch { }
     try {
         rmSync(sandboxRoot, { recursive: true, force: true });
     }
@@ -84,9 +92,9 @@ test("runP6Migration is idempotent across repeated runs", async () => {
     assert.equal(db.prepare(`SELECT COUNT(*) AS count FROM mem_observations WHERE source = 'migration:p6'`).get().count, 1);
     assert.equal(db.prepare(`SELECT COUNT(*) AS count FROM mem_migrations WHERE name = 'p6-wiki-seed'`).get().count, 1);
 });
-test("runP6Migration skips gracefully when the wiki pages directory is empty or absent", async () => {
+test("runP6Migration skips gracefully when the wiki skeleton exists but contains no migratable pages", async () => {
     const db = dbModule.getDb();
-    assert.equal(existsSync(join(chapterhouseHome, "wiki", "pages")), false);
+    assert.equal(existsSync(join(chapterhouseHome, "wiki", "pages")), true);
     const result = await migrationModule.runP6Migration(db);
     assert.deepEqual(result, {
         entitiesCreated: 0,

package/dist/paths.js

@@ -12,36 +12,56 @@ function resolveChapterhouseHome() {
         ? configuredHome
         : join(configuredHome, ".chapterhouse");
 }
-export const CHAPTERHOUSE_HOME = resolveChapterhouseHome();
+// Reset in tests via src/test/helpers/reset-singletons.ts
+export let CHAPTERHOUSE_HOME = resolveChapterhouseHome();
 export function getChapterhouseHome() {
     return resolveChapterhouseHome();
 }
 /** Path to the SQLite database */
-export const DB_PATH = join(CHAPTERHOUSE_HOME, "chapterhouse.db");
+export let DB_PATH = join(CHAPTERHOUSE_HOME, "chapterhouse.db");
 export function getDbPath() {
     return join(resolveChapterhouseHome(), "chapterhouse.db");
 }
 /** Path to the user .env file */
-export const ENV_PATH = join(CHAPTERHOUSE_HOME, ".env");
+export let ENV_PATH = join(CHAPTERHOUSE_HOME, ".env");
 /** Path to user-local skills */
-export const SKILLS_DIR = join(CHAPTERHOUSE_HOME, "skills");
+export let SKILLS_DIR = join(CHAPTERHOUSE_HOME, "skills");
 /** Path to Chapterhouse's isolated session state (keeps CLI history clean) */
-export const SESSIONS_DIR = join(CHAPTERHOUSE_HOME, "sessions");
+export let SESSIONS_DIR = join(CHAPTERHOUSE_HOME, "sessions");
 /** Path to the API bearer token file */
-export const API_TOKEN_PATH = join(CHAPTERHOUSE_HOME, "api-token");
+export let API_TOKEN_PATH = join(CHAPTERHOUSE_HOME, "api-token");
+/** Path to Chapterhouse runtime logs */
+export const LOGS_DIR = join(CHAPTERHOUSE_HOME, "logs");
 /** Agent definition files (~/.chapterhouse/agents/) */
-export const AGENTS_DIR = join(CHAPTERHOUSE_HOME, "agents");
+export let AGENTS_DIR = join(CHAPTERHOUSE_HOME, "agents");
 /** Root of the LLM-maintained wiki knowledge base */
-export const WIKI_DIR = join(CHAPTERHOUSE_HOME, "wiki");
+export let WIKI_DIR = join(CHAPTERHOUSE_HOME, "wiki");
 /** Wiki pages (entity, concept, summary files) */
-export const WIKI_PAGES_DIR = join(WIKI_DIR, "pages");
+export let WIKI_PAGES_DIR = join(WIKI_DIR, "pages");
 /** Raw ingested source documents (immutable) */
-export const WIKI_SOURCES_DIR = join(WIKI_DIR, "sources");
+export let WIKI_SOURCES_DIR = join(WIKI_DIR, "sources");
+function refreshCachedPaths() {
+    CHAPTERHOUSE_HOME = resolveChapterhouseHome();
+    DB_PATH = join(CHAPTERHOUSE_HOME, "chapterhouse.db");
+    ENV_PATH = join(CHAPTERHOUSE_HOME, ".env");
+    SKILLS_DIR = join(CHAPTERHOUSE_HOME, "skills");
+    SESSIONS_DIR = join(CHAPTERHOUSE_HOME, "sessions");
+    API_TOKEN_PATH = join(CHAPTERHOUSE_HOME, "api-token");
+    AGENTS_DIR = join(CHAPTERHOUSE_HOME, "agents");
+    WIKI_DIR = join(CHAPTERHOUSE_HOME, "wiki");
+    WIKI_PAGES_DIR = join(WIKI_DIR, "pages");
+    WIKI_SOURCES_DIR = join(WIKI_DIR, "sources");
+}
+export function resetPathsForTests() {
+    refreshCachedPaths();
+}
 export function resolveWikiRelativePath(relativePath) {
     return join(WIKI_DIR, ...normalizeWikiPath(relativePath).split("/"));
 }
 /** Ensure ~/.chapterhouse/ exists */
 export function ensureChapterhouseHome() {
-    mkdirSync(resolveChapterhouseHome(), { recursive: true });
+    const home = resolveChapterhouseHome();
+    mkdirSync(home, { recursive: true });
+    mkdirSync(join(home, "logs"), { recursive: true });
 }
 //# sourceMappingURL=paths.js.map