chapterhouse 0.9.0 → 0.9.2

package/agents/korg.agent.md

@@ -14,6 +14,26 @@ 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.
 
+## Character
+
+You are a careful analyst and archivist. You take the long view: a knowledge base is only as good as its structure, its provenance, and the accuracy of what's been distilled. You treat every source as evidence, every page as a living document, and every synthesis as a claim that must be earned.
+
+**Personality:**
+
+- You think before you write. When ingesting a new source, you form a view on what it actually says before deciding how it changes existing compiled truth.
+- You surface uncertainty explicitly. If evidence is thin or conflicting, say so — don't smooth it over with confident prose.
+- You explain your reasoning when it matters. A user asking why you organized something a certain way deserves a real answer, not a deflection.
+- You push back on low-quality sources. If something looks like noise or marketing, name it.
+- You take provenance seriously. Where something came from is part of what it means.
+
+**Communication:**
+
+- Write like a thoughtful analyst, not a bullet-point generator. Prose when the idea warrants it.
+- Be precise but not pedantic. Define terms when the distinction matters; skip it when it doesn't.
+- When you surface a synthesis or conclusion, make it clear what the evidence is and where it came from.
+- Don't perform enthusiasm. "This is a rich source" means nothing. Tell the user what's actually in it.
+- End cleanly. No trailing "Let me know if you'd like me to dig deeper!" when the work speaks for itself.
+
 ## Your Toolkit
 
 - `wiki_ingest_source(source, type?, topic?, session_id?, session_name?)` — ingest a URL, PDF, repo, or text into the PKB

package/dist/api/korg.js

@@ -1,20 +1,3 @@
-import { sendToAgentSession } from "../copilot/orchestrator.js";
-export async function routeKorgMessage(input) {
-    const message = input.message.trim();
-    const sessionId = input.sessionKey?.trim() || `korg-${Date.now()}`;
-    const sessionName = input.sessionKey?.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, sessionKey: sessionId, reply };
-}
 export function listKorgResearchSessions(db) {
     return db.prepare(`
     SELECT

package/dist/api/route-coverage.test.js

@@ -13,8 +13,7 @@
 // POST   /api/wiki/update           — static auth guard tested below
 // POST   /api/wiki/page/pin         — auth + traversal guard tested
 // POST   /api/wiki/ingest           — NOT tested (add in Phase 3c)
-// GET    /api/wiki/korg/sessions    — NOT tested (add in Phase 3c)
-// POST   /api/wiki/korg             — NOT tested (add in Phase 3c)
+// GET    /api/wiki/korg/sessions    — tested (server.test.ts: grouped active sessions)
 // ──────────────────────────────────────────────────────────────────────────────
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";

package/dist/api/server.js

@@ -42,7 +42,7 @@ import { recordDecision } from "../memory/decisions.js";
 import { upsertEntity } from "../memory/entities.js";
 import { getInboxItem, listPendingInboxItems, resolveInboxItem } from "../memory/inbox.js";
 import { ingestSource } from "../wiki/ingest.js";
-import { listKorgResearchSessions, routeKorgMessage } from "./korg.js";
+import { listKorgResearchSessions } from "./korg.js";
 const log = childLogger("server");
 const modeContext = new ModeContext(config);
 void searchIndex; // re-exported by index-manager; reference here documents the dep
@@ -146,10 +146,6 @@ const prMergeHookSchema = z.object({
     body: z.string().optional(),
     files_changed: z.array(z.string()).optional(),
 });
-const korgRequestSchema = z.object({
-    message: requiredString("Missing 'message' in request body"),
-    sessionKey: 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" }),
@@ -209,6 +205,13 @@ function coerceWikiPageUpdated(path, updated) {
 function wikiPathToBrowserSlug(path) {
     return path.replace(/^pages\//, "").replace(/\.md$/, "");
 }
+function entityTypeFromPath(path) {
+    const rest = path.startsWith("pages/") ? path.slice("pages/".length) : path;
+    const segs = rest.split("/").filter(Boolean);
+    if (segs.length <= 1)
+        return (segs[0] || "pages").replace(/\.md$/i, "");
+    return segs[0];
+}
 function normalizeOptionalQueryParam(value) {
     if (typeof value !== "string") {
         return undefined;
@@ -255,8 +258,8 @@ function listDbWikiBrowserPages(filters) {
     const clauses = [];
     const params = [];
     if (filters.type) {
-        clauses.push("entity_type = ?");
-        params.push(filters.type);
+        clauses.push("(entity_type = ? OR (entity_type IS NULL AND path LIKE ?))");
+        params.push(filters.type, `pages/${filters.type}/%`);
     }
     if (filters.q) {
         clauses.push("(title LIKE ? COLLATE NOCASE OR COALESCE(summary, '') LIKE ? COLLATE NOCASE)");
@@ -272,7 +275,7 @@ function listDbWikiBrowserPages(filters) {
         slug: wikiPathToBrowserSlug(row.path),
         title: row.title,
         summary: row.summary ?? "",
-        type: row.entity_type ?? "topics",
+        type: row.entity_type ?? entityTypeFromPath(row.path),
         last_updated: coerceWikiPageUpdated(row.path, row.last_updated ?? undefined),
         ...(row.pinned ? { pinned: true } : {}),
     }));
@@ -1742,11 +1745,6 @@ 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()) });
 });

package/dist/copilot/tools.js

@@ -15,7 +15,7 @@ import { searchIndex, addToIndex, buildIndexEntryForPage, reindexWikiPages, } fr
 import { traverse as wikiTraverse } from "../wiki/links.js";
 import { validateWikiFrontmatter, validateAndBackfillFrontmatter } from "../wiki/frontmatter.js";
 import { appendTimeline } from "../wiki/timeline.js";
-import { ingestSource, detectSourceType } from "../wiki/ingest.js";
+import { ingestSource, detectSourceType, looksLikeLocalFilePath } from "../wiki/ingest.js";
 import { appendLog } from "../wiki/log-manager.js";
 import { loadTaxonomy } from "../wiki/taxonomy.js";
 import { topicPagePath } from "../wiki/topic-structure.js";
@@ -72,6 +72,38 @@ function isTimeoutError(err) {
     const msg = err instanceof Error ? err.message : String(err);
     return /timeout|timed?\s*out/i.test(msg);
 }
+function validateWikiPageInput(path, content, allowedTags = loadTaxonomy()) {
+    assertPagePath(path);
+    const backfilled = validateAndBackfillFrontmatter(path, content);
+    const nextContent = backfilled.changed ? backfilled.content : content;
+    const validation = validateWikiFrontmatter(nextContent, { allowedTags });
+    if (!validation.valid) {
+        throw new Error(validation.errors.map((error) => error.message).join("\n\n"));
+    }
+    return nextContent;
+}
+function writeWikiPageAndRefreshIndex(page, logSource) {
+    writePage(page.path, page.content);
+    const today = new Date().toISOString().slice(0, 10);
+    const rebuilt = buildIndexEntryForPage(page.path, {
+        section: page.section || "Knowledge",
+        updated: today,
+    });
+    if (rebuilt) {
+        rebuilt.section = page.section || "Knowledge";
+        addToIndex(rebuilt);
+    }
+    else {
+        addToIndex({
+            path: page.path,
+            title: page.title,
+            summary: indexSafe(page.summary),
+            section: page.section || "Knowledge",
+            updated: today,
+        });
+    }
+    appendLog("update", `${logSource}: ${indexSafe(page.title)} (${page.path})`);
+}
 function hasAdoPat() {
     return (process.env.ADO_PAT?.trim() || config.adoPat).length > 0;
 }
@@ -204,13 +236,20 @@ const memoryProposeArgsSchema = z.object({
     }
 });
 const memoryTierTableSchema = z.enum(["observation", "decision", "entity", "action_item"]);
-const wikiUpdateArgsSchema = z.object({
+const wikiPageArgsSchema = z.object({
     path: z.string().describe("Page path relative to wiki root (e.g. 'pages/projects/chapterhouse/index.md', 'pages/projects/chapterhouse/decisions.md', 'pages/people/brian/index.md')"),
     title: z.string().describe("Page title for the index"),
-    summary: z.string().describe("One-line summary for the index"),
+    summary: z.string().max(160, "Summary must be 160 characters or fewer").describe("One-line summary for the index"),
     section: z.string().optional().describe("Index section (default: 'Knowledge')"),
     content: z.string().describe("Full page content (markdown)"),
 });
+const wikiUpdateArgsSchema = wikiPageArgsSchema;
+const wikiBatchUpdateArgsSchema = z.object({
+    pages: z.array(wikiPageArgsSchema)
+        .min(1)
+        .max(50)
+        .describe("Array of pages to create or update (1–50 items)"),
+});
 function getCurrentQuarter(now = new Date()) {
     return `${now.getUTCFullYear()}-Q${Math.floor(now.getUTCMonth() / 3) + 1}`;
 }
@@ -1497,48 +1536,59 @@ export function createTools(deps) {
             parameters: wikiUpdateArgsSchema,
             handler: async (args) => {
                 try {
-                    let parsedArgs = wikiUpdateArgsSchema.parse(args);
+                    const parsedArgs = wikiUpdateArgsSchema.parse(args);
+                    ensureWikiStructure();
                     return await withWikiWrite(async () => {
-                        ensureWikiStructure();
-                        assertPagePath(parsedArgs.path);
-                        // Backfill missing frontmatter fields before validation
-                        const backfilled = validateAndBackfillFrontmatter(parsedArgs.path, parsedArgs.content);
-                        if (backfilled.changed) {
-                            parsedArgs = { ...parsedArgs, content: backfilled.content };
-                        }
-                        const validation = validateWikiFrontmatter(parsedArgs.content, {
-                            allowedTags: loadTaxonomy(),
-                        });
-                        if (!validation.valid) {
-                            throw new Error(validation.errors.map((error) => error.message).join("\n\n"));
-                        }
-                        writePage(parsedArgs.path, parsedArgs.content);
-                        // Rebuild from disk so the index summary/tags/updated reflect the actual page.
-                        const today = new Date().toISOString().slice(0, 10);
-                        const rebuilt = buildIndexEntryForPage(parsedArgs.path, {
-                            section: parsedArgs.section || "Knowledge",
-                            updated: today,
-                        });
-                        if (rebuilt) {
-                            rebuilt.section = parsedArgs.section || "Knowledge";
-                            addToIndex(rebuilt);
+                        const content = validateWikiPageInput(parsedArgs.path, parsedArgs.content);
+                        const page = { ...parsedArgs, content };
+                        writeWikiPageAndRefreshIndex(page, "wiki_update");
+                        return `Wiki page updated: ${page.title} (${page.path})`;
+                    });
+                }
+                catch (err) {
+                    const error = sanitizeWikiUpdateError(err);
+                    log.error({ err: err instanceof Error ? err.message : err, path: typeof args?.path === "string" ? args.path : undefined }, "wiki_update failed");
+                    return { error };
+                }
+            },
+        }),
+        defineTool("wiki_batch_update", {
+            description: "Create or update multiple wiki pages in a single operation. " +
+                "Each page follows the same path rules as wiki_update. " +
+                "Up to 50 pages per call. Returns a per-page success/error summary.",
+            parameters: wikiBatchUpdateArgsSchema,
+            handler: async (args) => {
+                try {
+                    const parsedArgs = wikiBatchUpdateArgsSchema.parse(args);
+                    ensureWikiStructure();
+                    return await withWikiWrite(async () => {
+                        const allowedTags = loadTaxonomy();
+                        const results = [];
+                        for (const pageArgs of parsedArgs.pages) {
+                            try {
+                                const content = validateWikiPageInput(pageArgs.path, pageArgs.content, allowedTags);
+                                writeWikiPageAndRefreshIndex({ ...pageArgs, content }, "wiki_batch_update");
+                                results.push({ path: pageArgs.path, status: "ok" });
+                            }
+                            catch (err) {
+                                results.push({
+                                    path: pageArgs.path,
+                                    status: "error",
+                                    error: sanitizeWikiUpdateError(err),
+                                });
+                            }
                         }
-                        else {
-                            addToIndex({
-                                path: parsedArgs.path,
-                                title: parsedArgs.title,
-                                summary: indexSafe(parsedArgs.summary).slice(0, 160),
-                                section: parsedArgs.section || "Knowledge",
-                                updated: today,
-                            });
+                        const createdCount = results.filter((result) => result.status === "ok").length;
+                        const errors = results.filter((result) => result.status === "error");
+                        if (errors.length === 0) {
+                            return `Created ${createdCount} pages successfully.`;
                         }
-                        appendLog("update", `wiki_update: ${indexSafe(parsedArgs.title)} (${parsedArgs.path})`);
-                        return `Wiki page updated: ${parsedArgs.title} (${parsedArgs.path})`;
+                        return `Created ${createdCount} pages successfully.\nErrors (${errors.length}):\n${errors.map((result) => `  • ${result.path} — ${result.error}`).join("\n")}`;
                     });
                 }
                 catch (err) {
                     const error = sanitizeWikiUpdateError(err);
-                    log.error({ err: err instanceof Error ? err.message : err, path: typeof args?.path === "string" ? args.path : undefined }, "wiki_update failed");
+                    log.error({ err: err instanceof Error ? err.message : err }, "wiki_batch_update failed");
                     return { error };
                 }
             },
@@ -1634,6 +1684,11 @@ export function createTools(deps) {
             handler: async (args) => {
                 ensureWikiStructure();
                 try {
+                    if (looksLikeLocalFilePath(args.source)) {
+                        return {
+                            error: "wiki_ingest_source does not support local file paths. Provide a URL, git repo URL, or raw text content.",
+                        };
+                    }
                     const sourceType = args.type ?? detectSourceType(args.source);
                     const result = await ingestSource(args.source, sourceType, args.topic, {
                         sessionId: args.session_id,