chapterhouse 0.8.0 → 0.8.2

package/dist/api/server.js

@@ -16,8 +16,9 @@ import { createAuthMiddleware, getBootstrapAuthResponse } from "./auth.js";
 import { assertAgentEditAccess } from "./agent-edit-access.js";
 import { createConcurrentConnectionLimiter, createFixedWindowRateLimiter } from "./rate-limit.js";
 import { createTeamRouter } from "./team.js";
-import { writePage, deletePage, pageExists, listPages, ensureWikiStructure, assertPagePath, } from "../wiki/fs.js";
+import { writePage, deletePage, pageExists, listPages, ensureWikiStructure, assertPagePath, getWikiDir, } from "../wiki/fs.js";
 import { parseWikiFrontmatter } from "../wiki/frontmatter.js";
+import { normalizeWikiPath } from "../wiki/path-utils.js";
 import { loadRegistry, saveRegistry } from "../wiki/project-registry.js";
 import { getProjectRulesPath, listTopLevelSoftRules, loadProjectRules, loadProjectRuleSummary, renderInitialProjectRulesPage, saveProjectRulesHardFields, saveProjectRulesSoftRules, } from "../wiki/project-rules.js";
 import { readWikiPage, teamWikiSync } from "../wiki/team-sync.js";
@@ -192,6 +193,78 @@ function createProjectDetailPayload(slug, cwd) {
         softRules: listTopLevelSoftRules(rules.soft),
     };
 }
+function coerceWikiPageUpdated(path, updated) {
+    const normalized = updated?.trim();
+    if (normalized) {
+        return normalized;
+    }
+    try {
+        return statSync(join(getWikiDir(), path)).mtime.toISOString();
+    }
+    catch {
+        return "unknown";
+    }
+}
+function parseWikiSourcePages(value) {
+    if (!value) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed)
+            ? parsed.filter((entry) => typeof entry === "string").map((entry) => normalizeWikiPath(entry))
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+function listWikiSources(page) {
+    const rows = getDb().prepare(`
+    SELECT source_type, origin, raw_path, pages_updated, status, session_id, ingested_at
+    FROM wiki_sources
+    ORDER BY ingested_at DESC, id ASC
+  `).all();
+    return rows
+        .filter((row) => !page || parseWikiSourcePages(row.pages_updated).includes(page))
+        .map((row) => ({
+        source_url: row.origin,
+        path: row.raw_path ?? undefined,
+        kind: row.source_type,
+        status: row.status,
+        session_id: row.session_id,
+        ingested_at: row.ingested_at,
+    }));
+}
+function wikiPathToSlug(path) {
+    const segments = normalizeWikiPath(path).split("/").filter(Boolean);
+    const file = segments[segments.length - 1] ?? path;
+    const base = file.endsWith(".md") ? file.slice(0, -3) : file;
+    if (base === "index" && segments.length >= 2) {
+        return segments[segments.length - 2] ?? base;
+    }
+    return base;
+}
+function listWikiLinks(page) {
+    const rows = page
+        ? getDb().prepare(`
+      SELECT from_page, to_page, link_type
+      FROM wiki_links
+      WHERE from_page = ? OR to_page = ?
+      ORDER BY from_page ASC, to_page ASC, link_type ASC
+    `).all(page, page)
+        : getDb().prepare(`
+      SELECT from_page, to_page, link_type
+      FROM wiki_links
+      ORDER BY from_page ASC, to_page ASC, link_type ASC
+    `).all();
+    return rows.map((row) => ({
+        source_slug: wikiPathToSlug(row.from_page),
+        target_slug: wikiPathToSlug(row.to_page),
+        link_type: row.link_type,
+        ...(page ? { direction: row.from_page === page ? "outgoing" : "incoming" } : {}),
+    }));
+}
 // Load a configured API token when present; startup validation below enforces auth.
 let apiToken = null;
 try {
@@ -312,6 +385,13 @@ function readPathParam(req) {
     }
     return raw;
 }
+function readOptionalPageFilter(req) {
+    const raw = req.query.page;
+    if (typeof raw !== "string" || !raw.trim()) {
+        return undefined;
+    }
+    return normalizeWikiPath(raw.trim());
+}
 function assertValidPagePath(path) {
     try {
         assertPagePath(path);
@@ -1448,7 +1528,7 @@ app.get("/api/wiki/pages", async (req, res) => {
         summary: e.summary,
         section: e.section,
         tags: e.tags || [],
-        updated: e.updated || "",
+        updated: coerceWikiPageUpdated(e.path, e.updated),
         scope: getWikiPageScope(e.path),
     }));
     const orphanResults = listPages()
@@ -1459,11 +1539,19 @@ app.get("/api/wiki/pages", async (req, res) => {
         summary: "",
         section: "Unindexed",
         tags: [],
-        updated: "",
+        updated: coerceWikiPageUpdated(p, undefined),
         scope: getWikiPageScope(p),
     }));
     res.json([...indexedResults, ...orphanResults]);
 });
+app.get("/api/wiki/sources", async (req, res) => {
+    ensureWikiStructure();
+    res.json({ sources: listWikiSources(readOptionalPageFilter(req)) });
+});
+app.get("/api/wiki/links", async (req, res) => {
+    ensureWikiStructure();
+    res.json({ links: listWikiLinks(readOptionalPageFilter(req)) });
+});
 app.get("/api/wiki/page", async (req, res) => {
     const path = assertValidPagePath(readPathParam(req));
     const authorizationHeader = typeof req.headers.authorization === "string"

package/dist/api/server.test.js

@@ -1,9 +1,10 @@
 import assert from "node:assert/strict";
 import { spawn } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, utimesSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import test from "node:test";
 import Database from "better-sqlite3";
+import { z } from "zod";
 import { DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS, STANDALONE_API_SERVER_STARTUP_TIMEOUT_MS, getFreePort, stopChild, waitForApiServerReady, } from "../test/api-server.js";
 test("supports API_TOKEN env var and personal health route helpers", async () => {
     const runtime = await import("./server-runtime.js");
@@ -83,6 +84,23 @@ test("formats named SSE status events", async () => {
     assert.equal(sse.formatSseEvent("status", { status: "dreaming", message: "Consolidating memories..." }), 'event: status\ndata: {"status":"dreaming","message":"Consolidating memories..."}\n\n');
 });
 const repoRoot = process.cwd();
+const wikiLinkResponseSchema = z.object({
+    links: z.array(z.object({
+        source_slug: z.string(),
+        target_slug: z.string(),
+        link_type: z.string(),
+    }).passthrough()),
+});
+const wikiSourcesResponseSchema = z.object({
+    sources: z.array(z.object({
+        source_url: z.string().optional(),
+        path: z.string().optional(),
+        kind: z.string(),
+        status: z.string(),
+        session_id: z.string().nullable().optional(),
+        ingested_at: z.string().nullable().optional(),
+    }).passthrough()),
+});
 function getProjectDbPath(testRoot) {
     return join(testRoot, ".chapterhouse", "chapterhouse.db");
 }
@@ -873,6 +891,60 @@ test("server wiki route still returns 404 for other missing wiki pages", async (
         assert.deepEqual(await response.json(), { error: "Page not found" });
     });
 });
+test("GET /api/wiki/pages coerces empty updated fields to page mtimes", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
+        const indexedPath = join(testRoot, ".chapterhouse", "wiki", "pages", "topics", "coerced-updated", "index.md");
+        const indexedMtime = new Date("2026-05-15T12:00:00.000Z");
+        mkdirSync(join(testRoot, ".chapterhouse", "wiki", "pages", "topics", "coerced-updated"), { recursive: true });
+        writeFileSync(indexedPath, "# Coerced Updated\n", "utf-8");
+        utimesSync(indexedPath, indexedMtime, indexedMtime);
+        const orphanPath = join(testRoot, ".chapterhouse", "wiki", "pages", "topics", "orphan-updated", "index.md");
+        const orphanMtime = new Date("2026-05-15T13:30:00.000Z");
+        mkdirSync(join(testRoot, ".chapterhouse", "wiki", "pages", "topics", "orphan-updated"), { recursive: true });
+        writeFileSync(orphanPath, "# Orphan Updated\n", "utf-8");
+        utimesSync(orphanPath, orphanMtime, orphanMtime);
+        const db = new Database(getProjectDbPath(testRoot));
+        try {
+            db.prepare(`
+        INSERT INTO wiki_pages (path, title, tags, summary, last_updated)
+        VALUES (?, ?, ?, ?, ?)
+      `).run("pages/topics/coerced-updated/index.md", "Coerced Updated", "[]", "Missing updated value", "");
+        }
+        finally {
+            db.close();
+        }
+        const response = await fetch(`${baseUrl}/api/wiki/pages`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(response.status, 200);
+        const pages = await response.json();
+        assert.equal(pages.find((page) => page.path === "pages/topics/coerced-updated/index.md")?.updated, indexedMtime.toISOString());
+        assert.equal(pages.find((page) => page.path === "pages/topics/orphan-updated/index.md")?.updated, orphanMtime.toISOString());
+    });
+});
+test("GET /api/wiki/pages returns a non-empty updated value for pages with frontmatter", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
+        const pageDir = join(testRoot, ".chapterhouse", "wiki", "pages", "projects", "frontmatter-updated");
+        mkdirSync(pageDir, { recursive: true });
+        writeFileSync(join(pageDir, "index.md"), `---
+title: Frontmatter Updated
+summary: Has explicit metadata.
+updated: 2026-05-14
+---
+
+# Frontmatter Updated
+`, "utf-8");
+        const response = await fetch(`${baseUrl}/api/wiki/pages`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(response.status, 200);
+        const pages = await response.json();
+        const page = pages.find((entry) => entry.path === "pages/projects/frontmatter-updated/index.md");
+        assert.ok(page, "expected frontmatter page to be listed");
+        assert.equal(typeof page.updated, "string");
+        assert.notEqual(page.updated, "");
+    });
+});
 test("server projects route returns an empty list when the registry is missing", async () => {
     await withStartedServer(async ({ baseUrl, authHeader }) => {
         const response = await fetch(`${baseUrl}/api/projects`, {
@@ -1476,4 +1548,153 @@ test("GET /api/wiki/korg/sessions returns grouped active research sessions", asy
         });
     });
 });
+test("GET /api/wiki/sources returns an empty sources payload when no sources exist", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const response = await fetch(`${baseUrl}/api/wiki/sources`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(response.status, 200);
+        const body = await response.json();
+        assert.deepEqual(body, { sources: [] });
+        assert.ok(wikiSourcesResponseSchema.safeParse(body).success, "response should match WikiSourcesResponseSchema");
+    });
+});
+test("GET /api/wiki/sources filters sources by page", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
+        const db = new Database(getProjectDbPath(testRoot));
+        try {
+            db.prepare(`
+        INSERT INTO wiki_sources (id, source_type, origin, title, ingested_at, raw_path, parsed_content, pages_updated, status, session_id, session_name)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run("src-filter-match", "pdf", "https://example.com/roadmap.pdf", "Roadmap", "2026-05-15T10:00:00.000Z", "sources/roadmap.pdf", "roadmap body", JSON.stringify(["pages/projects/wiki-api/index.md"]), "complete", "sess-1", "Wiki API");
+            db.prepare(`
+        INSERT INTO wiki_sources (id, source_type, origin, title, ingested_at, raw_path, parsed_content, pages_updated, status, session_id, session_name)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run("src-filter-miss", "text", "notes about another page", "Other", "2026-05-15T11:00:00.000Z", "sources/other.md", "other body", JSON.stringify(["pages/projects/other/index.md"]), "active", null, null);
+        }
+        finally {
+            db.close();
+        }
+        const response = await fetch(`${baseUrl}/api/wiki/sources?page=${encodeURIComponent("pages/projects/wiki-api/index.md")}`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(response.status, 200);
+        const body = await response.json();
+        const parsed = wikiSourcesResponseSchema.safeParse(body);
+        if (!parsed.success) {
+            assert.fail(parsed.error.message);
+        }
+        assert.deepEqual(parsed.data, {
+            sources: [
+                {
+                    source_url: "https://example.com/roadmap.pdf",
+                    path: "sources/roadmap.pdf",
+                    kind: "pdf",
+                    status: "complete",
+                    session_id: "sess-1",
+                    ingested_at: "2026-05-15T10:00:00.000Z",
+                },
+            ],
+        });
+    });
+});
+test("GET /api/wiki/links returns all links when no page filter is provided", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
+        const db = new Database(getProjectDbPath(testRoot));
+        try {
+            db.prepare(`
+        INSERT INTO wiki_links (from_page, to_page, link_type, extracted_at)
+        VALUES (?, ?, ?, ?)
+      `).run("pages/projects/wiki-api/index.md", "pages/topics/contracts/index.md", "references", "2026-05-15T12:00:00.000Z");
+            db.prepare(`
+        INSERT INTO wiki_links (from_page, to_page, link_type, extracted_at)
+        VALUES (?, ?, ?, ?)
+      `).run("pages/people/trinity/index.md", "pages/projects/wiki-api/index.md", "implements", "2026-05-15T12:01:00.000Z");
+        }
+        finally {
+            db.close();
+        }
+        const response = await fetch(`${baseUrl}/api/wiki/links`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(response.status, 200);
+        const body = await response.json();
+        const parsed = wikiLinkResponseSchema.safeParse(body);
+        if (!parsed.success) {
+            assert.fail(parsed.error.message);
+        }
+        assert.deepEqual(parsed.data, {
+            links: [
+                {
+                    source_slug: "trinity",
+                    target_slug: "wiki-api",
+                    link_type: "implements",
+                },
+                {
+                    source_slug: "wiki-api",
+                    target_slug: "contracts",
+                    link_type: "references",
+                },
+            ],
+        });
+    });
+});
+test("GET /api/wiki/links returns an empty typed links payload when a page has no graph edges", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const response = await fetch(`${baseUrl}/api/wiki/links?page=${encodeURIComponent("pages/projects/wiki-api/index.md")}`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(response.status, 200);
+        const body = await response.json();
+        assert.deepEqual(body, { links: [] });
+        assert.ok(wikiLinkResponseSchema.safeParse(body).success, "response should match WikiLinksResponseSchema");
+    });
+});
+test("GET /api/wiki/links filters incoming and outgoing links for a page", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
+        const db = new Database(getProjectDbPath(testRoot));
+        try {
+            db.prepare(`
+        INSERT INTO wiki_links (from_page, to_page, link_type, extracted_at)
+        VALUES (?, ?, ?, ?)
+      `).run("pages/projects/wiki-api/index.md", "pages/topics/contracts/index.md", "references", "2026-05-15T12:00:00.000Z");
+            db.prepare(`
+        INSERT INTO wiki_links (from_page, to_page, link_type, extracted_at)
+        VALUES (?, ?, ?, ?)
+      `).run("pages/people/trinity/index.md", "pages/projects/wiki-api/index.md", "implements", "2026-05-15T12:01:00.000Z");
+            db.prepare(`
+        INSERT INTO wiki_links (from_page, to_page, link_type, extracted_at)
+        VALUES (?, ?, ?, ?)
+      `).run("pages/projects/other/index.md", "pages/topics/unrelated/index.md", "references", "2026-05-15T12:02:00.000Z");
+        }
+        finally {
+            db.close();
+        }
+        const response = await fetch(`${baseUrl}/api/wiki/links?page=${encodeURIComponent("pages/projects/wiki-api/index.md")}`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(response.status, 200);
+        const body = await response.json();
+        const parsed = wikiLinkResponseSchema.safeParse(body);
+        if (!parsed.success) {
+            assert.fail(parsed.error.message);
+        }
+        assert.deepEqual(parsed.data, {
+            links: [
+                {
+                    source_slug: "trinity",
+                    target_slug: "wiki-api",
+                    link_type: "implements",
+                    direction: "incoming",
+                },
+                {
+                    source_slug: "wiki-api",
+                    target_slug: "contracts",
+                    link_type: "references",
+                    direction: "outgoing",
+                },
+            ],
+        });
+    });
+});
 //# sourceMappingURL=server.test.js.map

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");