chapterhouse 0.7.0 → 0.8.1

package/agents/korg.agent.md

@@ -0,0 +1,65 @@
+---
+name: Korg
+description: PKB synthesizer — handles ingestion, synthesis, and knowledge consolidation
+model: claude-sonnet-4.6
+scope: pkb
+skills:
+  - pkb-source
+  - pkb-research
+  - pkb-people
+persistent: true
+---
+
+You are **Korg**, the Personal Knowledge Base (PKB) synthesizer for Chapterhouse.
+
+Your mission: ingest external sources, extract structured knowledge, maintain compiled truth pages, and manage research sessions — so the user's wiki becomes a reliable, growing knowledge asset.
+
+## Your Toolkit
+
+- `wiki_ingest_source(source, type?, topic?, session_id?, session_name?)` — ingest a URL, PDF, repo, or text into the PKB
+- `wiki_append_timeline(page, entry, source_id?)` — append an event to a page's timeline section
+- `wiki_search(query)` — search the wiki knowledge base
+- `wiki_read(path)` — read a specific wiki page
+- `wiki_update(path, title, summary, content)` — create or update a wiki page
+- `memory_propose(kind, payload)` — propose a memory to the orchestrator
+
+## PKB Schema
+
+Entity pages live at `pages/{type}/{slug}/index.md` where type is one of: `people`, `projects`, `orgs`, `tools`, `topics`, `areas`.
+
+Each entity page has two zones:
+1. **Summary** — the `## Summary` section: a distilled, up-to-date synthesis of what is known. Rewritten on every new source ingestion.
+2. **Timeline** — the `## Timeline` section: append-only record of events, observations, and source ingestions. Never edited, only appended.
+
+Frontmatter must include: `title`, `summary` (one-line, plain text ≤200 chars), `updated`, `tags`.
+
+## Synthesis Principles
+
+1. **Summary over raw notes.** After ingesting a new source, rewrite the `## Summary` section to reflect current understanding — don't just append.
+2. **Timeline is append-only.** Never edit existing timeline entries. Each new event gets a `### {ISO timestamp}` heading.
+3. **Source attribution.** Every ingestion event in the timeline should reference the `source_id` returned by `wiki_ingest_source`.
+4. **Idempotency.** Before ingesting, check if the source is already known. `wiki_ingest_source` handles this automatically.
+
+## Research Session Lifecycle
+
+1. User provides a research topic.
+2. Create `pages/research/{slug}/index.md` — the research hub with frontmatter, summary, and empty timeline.
+3. Create `pages/research/{slug}/synthesis.md` — the compiled synthesis document (rewritten after each source).
+4. For each source: call `wiki_ingest_source`, update `synthesis.md` with new understanding, append to timeline.
+5. When research is complete, write a final synthesis and close the session with a timeline entry.
+
+## People Capture
+
+When ingesting information about a person:
+- Page: `pages/people/{slug}/index.md`
+- Summary: role, affiliation, key facts, relationship to user
+- Timeline: every interaction, meeting, or observation
+- After significant interactions, extract follow-up items and propose them with `memory_propose`
+
+## Behavioral Rules
+
+- Always call `wiki_ingest_source` before manually creating pages — let the pipeline do entity extraction.
+- Keep summaries factual and concise. Avoid speculation in compiled truth.
+- If entity extraction returns nothing useful, create a minimal page with the source content.
+- Log every ingestion event with `wiki_append_timeline` on the relevant entity pages.
+- When unsure about entity type, use `topics` as the fallback category.

package/dist/api/korg.js

@@ -0,0 +1,34 @@
+import { sendToAgentSession } from "../copilot/orchestrator.js";
+export async function routeKorgMessage(input) {
+    const message = input.message.trim();
+    const sessionId = input.session_id?.trim() || `korg-${Date.now()}`;
+    const sessionName = input.session_id?.trim() || message.slice(0, 80).trim() || sessionId;
+    const prompt = [
+        "Handle this request as Korg via the API.",
+        `Research session id: ${sessionId}`,
+        `Research session name: ${sessionName}`,
+        `When you ingest sources for this session, pass session_id: \"${sessionId}\" and session_name: \"${sessionName}\" to wiki_ingest_source.`,
+        "Reply directly to the user with the next best research action or synthesis.",
+        "",
+        message,
+    ].join("\n");
+    const reply = await sendToAgentSession("korg", prompt);
+    return { ok: true, session_id: sessionId, reply };
+}
+export function listKorgResearchSessions(db) {
+    return db.prepare(`
+    SELECT
+      session_id AS id,
+      COALESCE(NULLIF(TRIM(session_name), ''), session_id) AS name,
+      COUNT(*) AS source_count,
+      0 AS open_questions,
+      MAX(ingested_at) AS last_activity
+    FROM wiki_sources
+    WHERE status = 'active'
+      AND session_id IS NOT NULL
+      AND TRIM(session_id) != ''
+    GROUP BY session_id, COALESCE(NULLIF(TRIM(session_name), ''), session_id)
+    ORDER BY MAX(ingested_at) DESC, session_id ASC
+  `).all();
+}
+//# sourceMappingURL=korg.js.map

package/dist/api/korg.test.js

@@ -0,0 +1,42 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+test("routeKorgMessage creates a research session id and delegates to the persistent Korg agent", async (t) => {
+    const calls = [];
+    t.mock.module("../copilot/orchestrator.js", {
+        namedExports: {
+            sendToAgentSession: async (slug, prompt) => {
+                calls.push({ slug, prompt });
+                return "Korg reply";
+            },
+        },
+    });
+    const mod = await import(new URL(`./korg.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
+    const result = await mod.routeKorgMessage({ message: "Research local-first PKB patterns." });
+    assert.equal(result.ok, true);
+    assert.match(result.session_id, /^korg-/);
+    assert.equal(result.reply, "Korg reply");
+    assert.deepEqual(calls, [{
+            slug: "korg",
+            prompt: calls[0].prompt,
+        }]);
+    assert.match(calls[0].prompt, /Research session id:/);
+    assert.match(calls[0].prompt, /Research local-first PKB patterns\./);
+});
+test("routeKorgMessage preserves an existing research session id in the delegated prompt", async (t) => {
+    let prompt = "";
+    t.mock.module("../copilot/orchestrator.js", {
+        namedExports: {
+            sendToAgentSession: async (_slug, incomingPrompt) => {
+                prompt = incomingPrompt;
+                return "Continuing session";
+            },
+        },
+    });
+    const mod = await import(new URL(`./korg.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
+    const result = await mod.routeKorgMessage({ message: "Add two more sources.", session_id: "compiler-research" });
+    assert.equal(result.session_id, "compiler-research");
+    assert.equal(result.reply, "Continuing session");
+    assert.match(prompt, /compiler-research/);
+    assert.match(prompt, /Add two more sources\./);
+});
+//# sourceMappingURL=korg.test.js.map

package/dist/api/server.js

@@ -33,8 +33,14 @@ import { formatSseData, formatSseEvent } from "./sse.js";
 import { assertAuthenticationConfigured, createHealthPayload, createPublicConfigPayload, getDisplayHost, resolveApiToken, shouldServeSpaPath, } from "./server-runtime.js";
 import { BadRequestError, ForbiddenError, InternalServerError, NotFoundError, apiNotFoundHandler, asBadRequest, createApiErrorHandler, parseRequest, } from "./errors.js";
 import { childLogger } from "../util/logger.js";
-import { getActiveScope } from "../memory/active-scope.js";
-import { createScope, getScope } from "../memory/scopes.js";
+import { getActiveScope, setActiveScope } from "../memory/active-scope.js";
+import { createScope, getScope, listScopes } from "../memory/scopes.js";
+import { handleGitCommitHook, handlePrMergeHook } from "../memory/hooks.js";
+import { recordObservation } from "../memory/observations.js";
+import { recordDecision } from "../memory/decisions.js";
+import { upsertEntity } from "../memory/entities.js";
+import { getInboxItem, listPendingInboxItems, resolveInboxItem } from "../memory/inbox.js";
+import { listKorgResearchSessions, routeKorgMessage } from "./korg.js";
 const log = childLogger("server");
 const modeContext = new ModeContext(config);
 void searchIndex; // re-exported by index-manager; reference here documents the dep
@@ -107,6 +113,41 @@ const scopeCreateSchema = z.object({
     title: requiredString("Missing 'title' in request body"),
     description: z.string().optional(),
 }).strict();
+const setActiveScopeSchema = z.object({
+    scope: z.string().nullable(),
+});
+const memoryEntriesQuerySchema = z.object({
+    store: z.enum(["observations", "decisions", "entities", "action_items"]).optional(),
+    tier: z.enum(["hot", "warm", "cold"]).optional(),
+});
+const memoryRememberSchema = z.object({
+    content: requiredString("Missing 'content' in request body"),
+    kind: z.enum(["observation", "decision"]).optional(),
+    entity_name: z.string().optional(),
+    entity_kind: z.string().optional(),
+    title: z.string().optional(),
+    decided_at: z.string().optional(),
+    tier: z.enum(["hot", "warm", "cold"]).optional(),
+});
+const inboxRouteSchema = z.object({
+    action: z.enum(["accept", "reject", "route"]),
+    reason: z.string().optional(),
+    target_scope: z.string().optional(),
+});
+const gitCommitHookSchema = z.object({
+    message: requiredString("Missing 'message' in request body"),
+    stat: z.string().optional(),
+});
+const prMergeHookSchema = z.object({
+    number: z.number({ error: "Missing or invalid 'number' in request body" }).int().positive(),
+    title: requiredString("Missing 'title' in request body"),
+    body: z.string().optional(),
+    files_changed: z.array(z.string()).optional(),
+});
+const korgRequestSchema = z.object({
+    message: requiredString("Missing 'message' in request body"),
+    session_id: z.string().trim().min(1).optional(),
+}).strict();
 const projectHardRulesSchema = z.object({
     hardRules: z.object({
         auto_pr: z.boolean({ error: "hardRules.auto_pr must be a boolean" }),
@@ -1072,6 +1113,193 @@ app.get("/api/memory/active-scope", (_req, res) => {
         title: activeScope.title,
     });
 });
+app.post("/api/memory/active-scope", (req, res) => {
+    const body = parseRequest(setActiveScopeSchema, req.body ?? {});
+    try {
+        const scope = setActiveScope(body.scope);
+        res.json({ ok: true, scope: scope?.slug ?? null });
+    }
+    catch (err) {
+        res.status(404).json({ error: err instanceof Error ? err.message : String(err) });
+    }
+});
+app.get("/api/memory/scopes", (_req, res) => {
+    const db = getDb();
+    const activeScope = getActiveScope();
+    const scopes = listScopes();
+    const result = scopes.map((scope) => {
+        const counts = {
+            observations: db.prepare(`SELECT COUNT(*) AS count FROM mem_observations WHERE scope_id = ?`).get(scope.id).count,
+            decisions: db.prepare(`SELECT COUNT(*) AS count FROM mem_decisions WHERE scope_id = ?`).get(scope.id).count,
+            entities: db.prepare(`SELECT COUNT(*) AS count FROM mem_entities WHERE scope_id = ?`).get(scope.id).count,
+            action_items: db.prepare(`SELECT COUNT(*) AS count FROM mem_action_items WHERE scope_id = ?`).get(scope.id).count,
+        };
+        return {
+            slug: scope.slug,
+            title: scope.title,
+            description: scope.description,
+            active: activeScope?.slug === scope.slug,
+            counts,
+        };
+    });
+    res.json({ scopes: result });
+});
+app.get("/api/memory/inbox", (_req, res) => {
+    const items = listPendingInboxItems();
+    const result = items.map((item) => ({
+        id: item.id,
+        scope_slug: item.scopeId
+            ? getDb().prepare(`SELECT slug FROM mem_scopes WHERE id = ?`).get(item.scopeId)?.slug ?? null
+            : null,
+        kind: item.kind,
+        payload: item.payload,
+        source_agent: item.sourceAgent,
+        created_at: item.createdAt,
+    }));
+    res.json({ items: result, total: result.length });
+});
+app.post("/api/memory/inbox/:id/route", (req, res) => {
+    const id = Number(req.params.id);
+    if (!Number.isInteger(id) || id <= 0) {
+        res.status(400).json({ error: "Invalid inbox item id" });
+        return;
+    }
+    const body = parseRequest(inboxRouteSchema, req.body ?? {});
+    const item = getInboxItem(id);
+    if (!item) {
+        res.status(404).json({ error: `Inbox item '${id}' not found` });
+        return;
+    }
+    if (item.status !== "pending") {
+        res.status(409).json({ error: `Inbox item '${id}' is already resolved` });
+        return;
+    }
+    const status = body.action === "accept" ? "accepted" : "rejected";
+    const reason = body.reason ?? (body.action === "accept" ? "Accepted via web UI" : "Rejected via web UI");
+    resolveInboxItem(id, status, reason);
+    log.info({ id, action: body.action }, "inbox item routed via web UI");
+    res.json({ ok: true });
+});
+app.get("/api/memory/:scope", (req, res) => {
+    const scopeSlug = String(req.params.scope);
+    const scope = getScope(scopeSlug);
+    if (!scope) {
+        res.status(404).json({ error: `Memory scope '${scopeSlug}' not found` });
+        return;
+    }
+    const query = parseRequest(memoryEntriesQuerySchema, req.query);
+    const store = query.store ?? "observations";
+    const tier = query.tier;
+    const db = getDb();
+    let entries;
+    let total;
+    if (store === "observations") {
+        if (tier) {
+            entries = db.prepare(`SELECT id, content, source, tier, entity_id, created_at FROM mem_observations WHERE scope_id = ? AND tier = ? AND archived_at IS NULL ORDER BY id DESC LIMIT 100`).all(scope.id, tier);
+            total = db.prepare(`SELECT COUNT(*) AS n FROM mem_observations WHERE scope_id = ? AND tier = ? AND archived_at IS NULL`).get(scope.id, tier).n;
+        }
+        else {
+            entries = db.prepare(`SELECT id, content, source, tier, entity_id, created_at FROM mem_observations WHERE scope_id = ? AND archived_at IS NULL ORDER BY id DESC LIMIT 100`).all(scope.id);
+            total = db.prepare(`SELECT COUNT(*) AS n FROM mem_observations WHERE scope_id = ? AND archived_at IS NULL`).get(scope.id).n;
+        }
+    }
+    else if (store === "decisions") {
+        if (tier) {
+            entries = db.prepare(`SELECT id, title, rationale, tier, entity_id, decided_at, created_at FROM mem_decisions WHERE scope_id = ? AND tier = ? AND archived_at IS NULL ORDER BY decided_at DESC, id DESC LIMIT 100`).all(scope.id, tier);
+            total = db.prepare(`SELECT COUNT(*) AS n FROM mem_decisions WHERE scope_id = ? AND tier = ? AND archived_at IS NULL`).get(scope.id, tier).n;
+        }
+        else {
+            entries = db.prepare(`SELECT id, title, rationale, tier, entity_id, decided_at, created_at FROM mem_decisions WHERE scope_id = ? AND archived_at IS NULL ORDER BY decided_at DESC, id DESC LIMIT 100`).all(scope.id);
+            total = db.prepare(`SELECT COUNT(*) AS n FROM mem_decisions WHERE scope_id = ? AND archived_at IS NULL`).get(scope.id).n;
+        }
+    }
+    else if (store === "entities") {
+        if (tier) {
+            entries = db.prepare(`SELECT id, kind, name, summary, tier, created_at, updated_at FROM mem_entities WHERE scope_id = ? AND tier = ? ORDER BY updated_at DESC, id DESC LIMIT 100`).all(scope.id, tier);
+            total = db.prepare(`SELECT COUNT(*) AS n FROM mem_entities WHERE scope_id = ? AND tier = ?`).get(scope.id, tier).n;
+        }
+        else {
+            entries = db.prepare(`SELECT id, kind, name, summary, tier, created_at, updated_at FROM mem_entities WHERE scope_id = ? ORDER BY updated_at DESC, id DESC LIMIT 100`).all(scope.id);
+            total = db.prepare(`SELECT COUNT(*) AS n FROM mem_entities WHERE scope_id = ?`).get(scope.id).n;
+        }
+    }
+    else {
+        if (tier) {
+            entries = db.prepare(`SELECT id, title, detail, status, tier, due_at, entity_id, created_at FROM mem_action_items WHERE scope_id = ? AND tier = ? ORDER BY created_at DESC, id DESC LIMIT 100`).all(scope.id, tier);
+            total = db.prepare(`SELECT COUNT(*) AS n FROM mem_action_items WHERE scope_id = ? AND tier = ?`).get(scope.id, tier).n;
+        }
+        else {
+            entries = db.prepare(`SELECT id, title, detail, status, tier, due_at, entity_id, created_at FROM mem_action_items WHERE scope_id = ? ORDER BY created_at DESC, id DESC LIMIT 100`).all(scope.id);
+            total = db.prepare(`SELECT COUNT(*) AS n FROM mem_action_items WHERE scope_id = ?`).get(scope.id).n;
+        }
+    }
+    res.json({ entries, total });
+});
+app.post("/api/memory/:scope/remember", (req, res) => {
+    const scopeSlug = String(req.params.scope);
+    const scope = getScope(scopeSlug);
+    if (!scope) {
+        res.status(404).json({ error: `Memory scope '${scopeSlug}' not found` });
+        return;
+    }
+    const body = parseRequest(memoryRememberSchema, req.body ?? {});
+    if (body.entity_name && !body.entity_kind) {
+        res.status(400).json({ error: "entity_kind is required when entity_name is provided" });
+        return;
+    }
+    const kind = body.kind ?? "observation";
+    const entity = body.entity_name
+        ? upsertEntity({
+            scope_id: scope.id,
+            kind: body.entity_kind,
+            name: body.entity_name,
+            tier: body.tier ?? "warm",
+        })
+        : undefined;
+    if (kind === "decision") {
+        if (!body.title) {
+            res.status(400).json({ error: "title is required when kind='decision'" });
+            return;
+        }
+        const decision = recordDecision({
+            scope_id: scope.id,
+            entity_id: entity?.id,
+            title: body.title,
+            rationale: body.content,
+            decided_at: body.decided_at ?? new Date().toISOString().slice(0, 10),
+            tier: body.tier ?? "warm",
+        });
+        log.info({ id: decision.id, scope: scopeSlug, kind }, "memory written via web UI");
+        res.json({ ok: true, id: String(decision.id) });
+        return;
+    }
+    const observation = recordObservation({
+        scope_id: scope.id,
+        entity_id: entity?.id,
+        content: body.content,
+        source: "agent:web-ui",
+        tier: body.tier ?? "warm",
+    });
+    log.info({ id: observation.id, scope: scopeSlug, kind }, "memory written via web UI");
+    res.json({ ok: true, id: String(observation.id) });
+});
+app.post("/api/memory/hooks/git-commit", authMiddleware, (req, res, next) => {
+    const body = parseRequest(gitCommitHookSchema, req.body ?? {});
+    handleGitCommitHook({ message: body.message, stat: body.stat })
+        .then((result) => res.json({ ok: true, observation_id: result.observation_id }))
+        .catch(next);
+});
+app.post("/api/memory/hooks/pr-merge", authMiddleware, (req, res, next) => {
+    const body = parseRequest(prMergeHookSchema, req.body ?? {});
+    handlePrMergeHook({
+        number: body.number,
+        title: body.title,
+        body: body.body,
+        files_changed: body.files_changed,
+    })
+        .then((result) => res.json({ ok: true, observation_id: result.observation_id }))
+        .catch(next);
+});
 app.post("/api/scopes", (req, res) => {
     const body = parseRequest(scopeCreateSchema, req.body ?? {});
     if (getScope(body.slug)) {
@@ -1266,6 +1494,14 @@ app.delete("/api/wiki/page", async (req, res) => {
     const removed = await withWikiWrite(() => deletePage(path));
     res.json({ ok: removed, path });
 });
+app.post("/api/wiki/korg", authMiddleware, async (req, res) => {
+    const body = parseRequest(korgRequestSchema, req.body ?? {});
+    const result = await routeKorgMessage(body);
+    res.json(result);
+});
+app.get("/api/wiki/korg/sessions", authMiddleware, (_req, res) => {
+    res.json({ sessions: listKorgResearchSessions(getDb()) });
+});
 // ---------------------------------------------------------------------------
 // Skills
 // ---------------------------------------------------------------------------

package/dist/api/server.test.js

@@ -241,10 +241,13 @@ test("server channels route returns chapterhouse plus persistent agents in chann
         const channels = await response.json();
         assert.deepEqual(channels.map((channel) => channel.key), [
             "default",
+            "agent:korg",
         ]);
         assert.deepEqual(channels.map((channel) => channel.label), [
             "# chapterhouse",
+            "# korg",
         ]);
+        assert.equal(channels[1]?.scope, "pkb");
     });
 });
 test("server agents routes return source-aware charter summaries and details", async () => {
@@ -1277,4 +1280,200 @@ test("server caps concurrent SSE connections per IP", async () => {
         API_RATE_LIMIT_SSE_MAX_CONNECTIONS: "2",
     });
 });
+test("POST /api/memory/active-scope sets and clears the active scope", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const unauthorized = await fetch(`${baseUrl}/api/memory/active-scope`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ scope: "chapterhouse" }),
+        });
+        assert.equal(unauthorized.status, 401);
+        const set = await fetch(`${baseUrl}/api/memory/active-scope`, {
+            method: "POST",
+            headers: { authorization: authHeader, "content-type": "application/json" },
+            body: JSON.stringify({ scope: "chapterhouse" }),
+        });
+        assert.equal(set.status, 200);
+        assert.deepEqual(await set.json(), { ok: true, scope: "chapterhouse" });
+        const verify = await fetch(`${baseUrl}/api/memory/active-scope`, {
+            headers: { authorization: authHeader },
+        });
+        assert.deepEqual(await verify.json(), { slug: "chapterhouse", title: "Chapterhouse" });
+        const clear = await fetch(`${baseUrl}/api/memory/active-scope`, {
+            method: "POST",
+            headers: { authorization: authHeader, "content-type": "application/json" },
+            body: JSON.stringify({ scope: null }),
+        });
+        assert.equal(clear.status, 200);
+        assert.deepEqual(await clear.json(), { ok: true, scope: null });
+        const unknownScope = await fetch(`${baseUrl}/api/memory/active-scope`, {
+            method: "POST",
+            headers: { authorization: authHeader, "content-type": "application/json" },
+            body: JSON.stringify({ scope: "nonexistent-scope" }),
+        });
+        assert.equal(unknownScope.status, 404);
+    });
+});
+test("GET /api/memory/scopes lists all scopes with entry counts", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const unauthorized = await fetch(`${baseUrl}/api/memory/scopes`);
+        assert.equal(unauthorized.status, 401);
+        const res = await fetch(`${baseUrl}/api/memory/scopes`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(res.status, 200);
+        const body = await res.json();
+        assert.ok(Array.isArray(body.scopes));
+        assert.ok(body.scopes.length >= 2, "expected at least 2 seeded scopes");
+        const chapterhouse = body.scopes.find((s) => s.slug === "chapterhouse");
+        assert.ok(chapterhouse, "expected chapterhouse scope");
+        assert.ok(typeof chapterhouse.counts.observations === "number");
+        assert.ok(typeof chapterhouse.counts.decisions === "number");
+    });
+});
+test("GET /api/memory/:scope returns entries for a scope and 404 for unknown", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const unauthorized = await fetch(`${baseUrl}/api/memory/chapterhouse`);
+        assert.equal(unauthorized.status, 401);
+        const res = await fetch(`${baseUrl}/api/memory/chapterhouse`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(res.status, 200);
+        const body = await res.json();
+        assert.ok(Array.isArray(body.entries));
+        assert.ok(typeof body.total === "number");
+        const withStore = await fetch(`${baseUrl}/api/memory/chapterhouse?store=decisions`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(withStore.status, 200);
+        const withTier = await fetch(`${baseUrl}/api/memory/chapterhouse?store=observations&tier=hot`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(withTier.status, 200);
+        const notFound = await fetch(`${baseUrl}/api/memory/no-such-scope`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(notFound.status, 404);
+        assert.deepEqual(await notFound.json(), { error: "Memory scope 'no-such-scope' not found" });
+    });
+});
+test("POST /api/memory/:scope/remember writes an observation or decision", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const unauthorized = await fetch(`${baseUrl}/api/memory/chapterhouse/remember`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ content: "Test observation" }),
+        });
+        assert.equal(unauthorized.status, 401);
+        const obs = await fetch(`${baseUrl}/api/memory/chapterhouse/remember`, {
+            method: "POST",
+            headers: { authorization: authHeader, "content-type": "application/json" },
+            body: JSON.stringify({ content: "Chapterhouse uses SQLite for memory." }),
+        });
+        assert.equal(obs.status, 200);
+        const obsBody = await obs.json();
+        assert.equal(obsBody.ok, true);
+        assert.ok(typeof obsBody.id === "string");
+        const dec = await fetch(`${baseUrl}/api/memory/chapterhouse/remember`, {
+            method: "POST",
+            headers: { authorization: authHeader, "content-type": "application/json" },
+            body: JSON.stringify({ kind: "decision", title: "Use SQLite", content: "SQLite chosen for persistence." }),
+        });
+        assert.equal(dec.status, 200);
+        const decBody = await dec.json();
+        assert.equal(decBody.ok, true);
+        const noTitle = await fetch(`${baseUrl}/api/memory/chapterhouse/remember`, {
+            method: "POST",
+            headers: { authorization: authHeader, "content-type": "application/json" },
+            body: JSON.stringify({ kind: "decision", content: "Missing title." }),
+        });
+        assert.equal(noTitle.status, 400);
+        const notFound = await fetch(`${baseUrl}/api/memory/missing-scope/remember`, {
+            method: "POST",
+            headers: { authorization: authHeader, "content-type": "application/json" },
+            body: JSON.stringify({ content: "Will not land." }),
+        });
+        assert.equal(notFound.status, 404);
+    });
+});
+test("GET /api/memory/inbox lists pending proposals", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const unauthorized = await fetch(`${baseUrl}/api/memory/inbox`);
+        assert.equal(unauthorized.status, 401);
+        const empty = await fetch(`${baseUrl}/api/memory/inbox`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(empty.status, 200);
+        const body = await empty.json();
+        assert.ok(Array.isArray(body.items));
+        assert.ok(typeof body.total === "number");
+        assert.equal(body.items.length, body.total);
+    });
+});
+test("POST /api/memory/inbox/:id/route accepts and rejects proposals", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        // First queue a proposal via the remember endpoint so we have something to route
+        const rememberRes = await fetch(`${baseUrl}/api/memory/chapterhouse/remember`, {
+            method: "POST",
+            headers: { authorization: authHeader, "content-type": "application/json" },
+            body: JSON.stringify({ content: "Proposal for inbox routing test." }),
+        });
+        assert.equal(rememberRes.status, 200);
+        const notFound = await fetch(`${baseUrl}/api/memory/inbox/99999/route`, {
+            method: "POST",
+            headers: { authorization: authHeader, "content-type": "application/json" },
+            body: JSON.stringify({ action: "accept" }),
+        });
+        assert.equal(notFound.status, 404);
+        const badId = await fetch(`${baseUrl}/api/memory/inbox/not-a-number/route`, {
+            method: "POST",
+            headers: { authorization: authHeader, "content-type": "application/json" },
+            body: JSON.stringify({ action: "accept" }),
+        });
+        assert.equal(badId.status, 400);
+        const unauthorized = await fetch(`${baseUrl}/api/memory/inbox/1/route`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ action: "accept" }),
+        });
+        assert.equal(unauthorized.status, 401);
+    });
+});
+test("GET /api/wiki/korg/sessions returns grouped active research sessions", 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-1", "text", "session-one", "First source", "2026-05-14T21:00:00.000Z", "sources/src-1.md", "open questions remain", "[]", "active", "compiler-research", "Compiler research");
+            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-2", "text", "session-one-b", "Second source", "2026-05-14T22:00:00.000Z", "sources/src-2.md", "follow-up questions", "[]", "active", "compiler-research", "Compiler research");
+            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-3", "text", "archived-session", "Archived source", "2026-05-13T20:00:00.000Z", "sources/src-3.md", "done", "[]", "archived", "old-session", "Old session");
+        }
+        finally {
+            db.close();
+        }
+        const response = await fetch(`${baseUrl}/api/wiki/korg/sessions`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(response.status, 200);
+        assert.deepEqual(await response.json(), {
+            sessions: [
+                {
+                    id: "compiler-research",
+                    name: "Compiler research",
+                    source_count: 2,
+                    open_questions: 0,
+                    last_activity: "2026-05-14T22:00:00.000Z",
+                },
+            ],
+        });
+    });
+});
 //# sourceMappingURL=server.test.js.map