chapterhouse 0.9.1 → 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/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,

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

@@ -11,6 +11,16 @@ async function readWikiArtifacts() {
     const indexManager = await import(new URL(`../wiki/index-manager.js?case=${nonce}`, import.meta.url).href);
     return { wikiFs, indexManager };
 }
+async function loadWikiTool(name) {
+    const toolsModule = await loadToolsModule();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const tool = tools.find((entry) => entry.name === name);
+    assert.ok(tool, `Expected tool '${name}' to be registered`);
+    return tool;
+}
 test.before(() => {
     mkdirSync(join(process.cwd(), ".test-work"), { recursive: true });
 });
@@ -70,9 +80,143 @@ Runtime notes.
 `,
     });
     assert.equal(typeof result, "object");
-    assert.match(result.error, /invalid 'summary'/i);
-    assert.match(result.error, /unknown tag 'made-up-tag'/i);
-    assert.match(result.error, /pages\/_meta\/taxonomy\.md/);
+    const error = result.error;
+    assert.match(error, /invalid 'summary'/i);
+    assert.match(error, /unknown tag 'made-up-tag'|tag "made-up-tag" is not in the allowed tag list/i);
+    assert.match(error, /Valid tags:/i);
+    assert.match(error, /engineering/i);
+    assert.match(error, /release/i);
+});
+test("wiki_update accepts an empty tags list", async () => {
+    const tool = await loadWikiTool("wiki_update");
+    const result = await tool.handler({
+        path: "pages/shared/chapterhouse.md",
+        title: "Chapterhouse",
+        summary: "Runtime notes",
+        content: `---
+title: Chapterhouse
+summary: Runtime notes
+tags: []
+---
+
+# Chapterhouse
+
+Runtime notes.
+`,
+    });
+    assert.equal(result, "Wiki page updated: Chapterhouse (pages/shared/chapterhouse.md)");
+});
+test("wiki_update accepts mixed-case valid tags with surrounding whitespace", async () => {
+    const tool = await loadWikiTool("wiki_update");
+    const { wikiFs } = await readWikiArtifacts();
+    wikiFs.writePage("pages/_meta/taxonomy.md", "## Custom\n- workflow\n");
+    const result = await tool.handler({
+        path: "pages/shared/chapterhouse.md",
+        title: "Chapterhouse",
+        summary: "Runtime notes",
+        content: `---
+title: Chapterhouse
+summary: Runtime notes
+tags: [ Engineering , workflow ]
+---
+
+# Chapterhouse
+
+Runtime notes.
+`,
+    });
+    assert.equal(result, "Wiki page updated: Chapterhouse (pages/shared/chapterhouse.md)");
+});
+test("wiki_update accepts summaries that are exactly 160 characters long", async () => {
+    const tool = await loadWikiTool("wiki_update");
+    const summary = "x".repeat(160);
+    const result = await tool.handler({
+        path: "pages/shared/chapterhouse.md",
+        title: "Chapterhouse",
+        summary,
+        content: `---
+title: Chapterhouse
+summary: ${summary}
+tags: [engineering]
+---
+
+# Chapterhouse
+
+${summary}
+`,
+    });
+    assert.equal(result, "Wiki page updated: Chapterhouse (pages/shared/chapterhouse.md)");
+});
+test("wiki_update rejects summaries longer than 160 characters", async () => {
+    const tool = await loadWikiTool("wiki_update");
+    const result = await tool.handler({
+        path: "pages/shared/chapterhouse.md",
+        title: "Chapterhouse",
+        summary: "x".repeat(161),
+        content: `---
+title: Chapterhouse
+summary: Runtime notes
+tags: [engineering]
+---
+
+# Chapterhouse
+
+Runtime notes.
+`,
+    });
+    assert.deepEqual(result, {
+        error: "Summary must be 160 characters or fewer",
+    });
+    const { wikiFs } = await readWikiArtifacts();
+    assert.equal(wikiFs.readPage("pages/shared/chapterhouse.md"), undefined);
+});
+test("wiki_update keeps empty-summary behavior unchanged", async () => {
+    const tool = await loadWikiTool("wiki_update");
+    const result = await tool.handler({
+        path: "pages/shared/chapterhouse.md",
+        title: "Chapterhouse",
+        summary: "",
+        content: `---
+title: Chapterhouse
+summary:
+tags: [engineering]
+---
+
+# Chapterhouse
+
+Runtime notes.
+`,
+    });
+    assert.equal(typeof result, "object");
+    assert.match(result.error, /missing 'summary'/i);
+});
+test("wiki_ingest_source rejects local file-style inputs with a clear error", async () => {
+    const tool = await loadWikiTool("wiki_ingest_source");
+    for (const source of [
+        "./notes.md",
+        "../notes.md",
+        "/var/data/notes.md",
+        "notes.md",
+        "C:\\Users\\brian\\notes.md",
+        "file:///home/brian/notes.md",
+    ]) {
+        const result = await tool.handler({ source });
+        assert.equal(typeof result, "object", `Expected '${source}' to be rejected`);
+        const error = result.error;
+        assert.match(error, /local|file/i, `Expected '${source}' error to mention local-file rejection`);
+        assert.match(error, /url|http|https/i, `Expected '${source}' error to mention the remote URL requirement`);
+    }
+    const { wikiFs } = await readWikiArtifacts();
+    assert.deepEqual(wikiFs.listSources(), []);
+});
+test("wiki_ingest_source still passes remote URLs through to ingestSource", async () => {
+    const tool = await loadWikiTool("wiki_ingest_source");
+    const result = await tool.handler({
+        source: "http://127.0.0.1/private",
+    });
+    assert.deepEqual(result, {
+        error: "Cannot fetch internal/private URLs.",
+    });
 });
 test("wiki_update accepts valid frontmatter and refreshes the index entry", async () => {
     const toolsModule = await loadToolsModule();
@@ -116,6 +260,211 @@ Runtime notes.
         },
     ]);
 });
+test("wiki_batch_update creates multiple pages and refreshes the index", async () => {
+    const toolsModule = await loadToolsModule();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const tool = tools.find((entry) => entry.name === "wiki_batch_update");
+    assert.ok(tool);
+    const result = await tool.handler({
+        pages: [
+            {
+                path: "pages/projects/atlas/index.md",
+                title: "Atlas",
+                summary: "Project atlas overview",
+                content: `---
+title: Atlas
+summary: Project atlas overview
+tags: [project]
+---
+
+# Atlas
+
+Project atlas overview.
+`,
+            },
+            {
+                path: "pages/people/alice/index.md",
+                title: "Alice",
+                summary: "Team profile for Alice",
+                section: "People",
+                content: `---
+title: Alice
+summary: Team profile for Alice
+tags: [people]
+---
+
+# Alice
+
+Team profile for Alice.
+`,
+            },
+        ],
+    });
+    assert.equal(result, "Created 2 pages successfully.");
+    const { wikiFs, indexManager } = await readWikiArtifacts();
+    const index = indexManager.parseIndex();
+    assert.match(wikiFs.readPage("pages/projects/atlas/index.md") ?? "", /summary: Project atlas overview/);
+    assert.match(wikiFs.readPage("pages/people/alice/index.md") ?? "", /summary: Team profile for Alice/);
+    assert.ok(index.some((entry) => entry.path === "pages/projects/atlas/index.md" && entry.summary === "Project atlas overview"));
+    assert.ok(index.some((entry) => entry.path === "pages/people/alice/index.md" && entry.summary === "Team profile for Alice"));
+});
+test("wiki_batch_update reports per-page path errors and continues other writes", async () => {
+    const toolsModule = await loadToolsModule();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const tool = tools.find((entry) => entry.name === "wiki_batch_update");
+    assert.ok(tool);
+    const result = await tool.handler({
+        pages: [
+            {
+                path: "pages/projects/atlas/index.md",
+                title: "Atlas",
+                summary: "Project atlas overview",
+                content: `---
+title: Atlas
+summary: Project atlas overview
+tags: [project]
+---
+
+# Atlas
+
+Project atlas overview.
+`,
+            },
+            {
+                path: "../secrets.md",
+                title: "Secrets",
+                summary: "Should be rejected",
+                content: `---
+title: Secrets
+summary: Should be rejected
+tags: [project]
+---
+
+# Secrets
+`,
+            },
+        ],
+    });
+    assert.equal(result, "Created 1 pages successfully.\nErrors (1):\n  • ../secrets.md — Refused unsafe wiki path: ../secrets.md");
+    const { wikiFs } = await readWikiArtifacts();
+    assert.match(wikiFs.readPage("pages/projects/atlas/index.md") ?? "", /summary: Project atlas overview/);
+    assert.equal(wikiFs.readPage("../secrets.md"), undefined);
+});
+test("wiki_batch_update reports per-page tag errors and continues other writes", async () => {
+    const toolsModule = await loadToolsModule();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const tool = tools.find((entry) => entry.name === "wiki_batch_update");
+    assert.ok(tool);
+    const result = await tool.handler({
+        pages: [
+            {
+                path: "pages/projects/atlas/index.md",
+                title: "Atlas",
+                summary: "Project atlas overview",
+                content: `---
+title: Atlas
+summary: Project atlas overview
+tags: [project]
+---
+
+# Atlas
+
+Project atlas overview.
+`,
+            },
+            {
+                path: "pages/people/alice/index.md",
+                title: "Alice",
+                summary: "Team profile for Alice",
+                content: `---
+title: Alice
+summary: Team profile for Alice
+tags: [personal]
+---
+
+# Alice
+
+Team profile for Alice.
+`,
+            },
+        ],
+    });
+    assert.equal(typeof result, "string");
+    assert.match(result, /^Created 1 pages successfully\.\nErrors \(1\):/);
+    assert.match(result, /pages\/people\/alice\/index\.md — Wiki page frontmatter violates the required shape: unknown tag 'personal'/);
+    const { wikiFs } = await readWikiArtifacts();
+    assert.match(wikiFs.readPage("pages/projects/atlas/index.md") ?? "", /summary: Project atlas overview/);
+    assert.equal(wikiFs.readPage("pages/people/alice/index.md"), undefined);
+});
+test("wiki_batch_update fails fast on an empty pages array", async () => {
+    const toolsModule = await loadToolsModule();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const tool = tools.find((entry) => entry.name === "wiki_batch_update");
+    assert.ok(tool);
+    const result = await tool.handler({ pages: [] });
+    assert.deepEqual(result, { error: "Too small: expected array to have >=1 items" });
+    const { indexManager } = await readWikiArtifacts();
+    assert.deepEqual(indexManager.parseIndex(), []);
+});
+test("wiki_batch_update fails fast when more than 50 pages are requested", async () => {
+    const toolsModule = await loadToolsModule();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const tool = tools.find((entry) => entry.name === "wiki_batch_update");
+    assert.ok(tool);
+    const result = await tool.handler({
+        pages: Array.from({ length: 51 }, (_, index) => ({
+            path: `pages/projects/page-${index + 1}/index.md`,
+            title: `Page ${index + 1}`,
+            summary: `Summary ${index + 1}`,
+            content: `---\ntitle: Page ${index + 1}\nsummary: Summary ${index + 1}\ntags: [project]\n---\n\n# Page ${index + 1}\n`,
+        })),
+    });
+    assert.deepEqual(result, { error: "Too big: expected array to have <=50 items" });
+    const { indexManager } = await readWikiArtifacts();
+    assert.deepEqual(indexManager.parseIndex(), []);
+});
+test("wiki_batch_update inherits summary length validation from the per-page schema", async () => {
+    const toolsModule = await loadToolsModule();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const tool = tools.find((entry) => entry.name === "wiki_batch_update");
+    assert.ok(tool);
+    const result = await tool.handler({
+        pages: [{
+                path: "pages/projects/atlas/index.md",
+                title: "Atlas",
+                summary: "x".repeat(161),
+                content: `---
+title: Atlas
+summary: Project atlas overview
+tags: [project]
+---
+
+# Atlas
+`,
+            }],
+    });
+    assert.deepEqual(result, { error: "Summary must be 160 characters or fewer" });
+    const { indexManager } = await readWikiArtifacts();
+    assert.deepEqual(indexManager.parseIndex(), []);
+});
 test("retained wiki tools append audit entries to pages/_meta/log.md", async () => {
     const toolsModule = await loadToolsModule();
     const tools = toolsModule.createTools({

package/dist/memory/eot.js

@@ -26,6 +26,14 @@ function isMemoryAutoAcceptEnabled() {
         return true;
     return true;
 }
+function isFrictionHookEnabled() {
+    const raw = process.env.CHAPTERHOUSE_MEMORY_EOT_FRICTION_ENABLED?.trim();
+    if (raw === "0")
+        return false;
+    if (raw === "1")
+        return true;
+    return false;
+}
 function buildReviewerSystemPrompt() {
     return [
         "You review subagent memory proposals at end-of-task.",
@@ -48,6 +56,20 @@ function buildReviewerUserPrompt(finalResult, proposals) {
         })),
     }, null, 2);
 }
+function buildFrictionSystemPrompt() {
+    return [
+        "You review a completed agent task for tool friction.",
+        "Tool friction is: missing validation feedback, missing batch capability, silent failures,",
+        "overly strict input constraints, or tool gaps that caused the agent to work around limitations.",
+        "If you identify friction, return a JSON array of action items.",
+        "Each item must have: title (string), detail (string), source (always 'eot:friction').",
+        "If no friction was found, return an empty array [].",
+        "Return JSON only. No prose, no wrapping.",
+    ].join("\n");
+}
+function buildFrictionUserPrompt(finalResult) {
+    return JSON.stringify({ final_result: finalResult }, null, 2);
+}
 function parseEnvelope(raw) {
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") {
@@ -121,6 +143,34 @@ function parseReviewerResponse(raw) {
             : [],
     };
 }
+function parseFrictionResponse(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        return parsed.flatMap((entry) => {
+            if (!entry || typeof entry !== "object") {
+                return [];
+            }
+            const candidate = entry;
+            if (!isNonEmptyString(candidate.title) || typeof candidate.detail !== "string") {
+                return [];
+            }
+            if (candidate.source !== "eot:friction") {
+                return [];
+            }
+            return [{
+                    title: candidate.title.trim(),
+                    detail: candidate.detail,
+                    source: "eot:friction",
+                }];
+        }).slice(0, 3);
+    }
+    catch {
+        return [];
+    }
+}
 function isNonEmptyString(value) {
     return typeof value === "string" && value.trim().length > 0;
 }
@@ -199,6 +249,25 @@ function resolveAcceptedProposalScopeSlug(envelope, proposal) {
     }
     throw new Error("No memory scope could be resolved for this proposal.");
 }
+function resolveActiveScopeSlug() {
+    const activeScope = getActiveScope();
+    if (activeScope) {
+        return activeScope.slug;
+    }
+    return getScope("chapterhouse")?.slug;
+}
+function resolveCallLLM(input) {
+    return input.callLLM ?? (async ({ system, user, model }) => {
+        const result = await runOneShotPrompt({
+            client: input.copilotClient,
+            model,
+            system,
+            user,
+            expectJson: true,
+        });
+        return result.content;
+    });
+}
 function rememberAcceptedMemory(kind, scopeSlug, payload, source, confidence, sourceAgent) {
     const scope = getScope(scopeSlug);
     if (!scope) {
@@ -279,16 +348,7 @@ export async function runEndOfTaskMemoryHook(input) {
     }
     const proposals = listPendingMemoryProposalsForTask(input.taskId);
     summary.proposals_total = proposals.length;
-    const callLLM = input.callLLM ?? (async ({ system, user, model }) => {
-        const result = await runOneShotPrompt({
-            client: input.copilotClient,
-            model,
-            system,
-            user,
-            expectJson: true,
-        });
-        return result.content;
-    });
+    const callLLM = resolveCallLLM(input);
     const review = parseReviewerResponse(await callLLM({
         system: buildReviewerSystemPrompt(),
         user: buildReviewerUserPrompt(input.finalResult, proposals),
@@ -347,8 +407,51 @@ export async function runEndOfTaskMemoryHook(input) {
             }
         }
     }
+    await runFrictionHook({
+        taskId: input.taskId,
+        finalResult: input.finalResult,
+        copilotClient: input.copilotClient,
+        callLLM,
+        model: input.model,
+    });
     log.info(summary, "memory.eot.processed");
     input.onProcessed?.(summary);
     return summary;
 }
+export async function runFrictionHook(input) {
+    try {
+        if (!isFrictionHookEnabled()) {
+            return;
+        }
+        if (input.finalResult.trim().length <= 100) {
+            return;
+        }
+        const scopeSlug = resolveActiveScopeSlug();
+        if (!scopeSlug) {
+            return;
+        }
+        const callLLM = resolveCallLLM(input);
+        const raw = await callLLM({
+            system: buildFrictionSystemPrompt(),
+            user: buildFrictionUserPrompt(input.finalResult),
+            model: input.model ?? config.copilotModel,
+        });
+        const frictionItems = parseFrictionResponse(raw);
+        for (const item of frictionItems) {
+            try {
+                rememberAcceptedMemory("action_item", scopeSlug, {
+                    title: item.title,
+                    detail: item.detail,
+                    source: item.source,
+                }, "eot:friction");
+            }
+            catch (err) {
+                log.warn({ err, taskId: input.taskId, title: item.title }, "friction hook: failed to record action item");
+            }
+        }
+    }
+    catch (err) {
+        log.warn({ err, taskId: input.taskId }, "friction hook failed");
+    }
+}
 //# sourceMappingURL=eot.js.map

package/dist/memory/eot.test.js

@@ -763,4 +763,119 @@ test("runEndOfTaskMemoryHook persists implicit observation memories with valid c
     assert.equal(summary.implicit_extracted, 1);
     assert.equal(warnings.length, 0);
 });
+test("runFrictionHook does nothing by default when CHAPTERHOUSE_MEMORY_EOT_FRICTION_ENABLED is unset", async () => {
+    const { eotModule } = await loadModules("friction-disabled-default");
+    const runFrictionHook = getFunction(eotModule, "runFrictionHook");
+    let llmCalls = 0;
+    await runFrictionHook({
+        taskId: "task-friction-disabled-default",
+        finalResult: "A substantive final result that is definitely longer than one hundred characters to prove the friction hook still stays off by default.",
+        copilotClient: {},
+        callLLM: async () => {
+            llmCalls++;
+            return "[]";
+        },
+    });
+    assert.equal(llmCalls, 0);
+});
+test("runFrictionHook skips short final results even when enabled", async () => {
+    process.env.CHAPTERHOUSE_MEMORY_EOT_FRICTION_ENABLED = "1";
+    const { eotModule } = await loadModules("friction-short-result");
+    const runFrictionHook = getFunction(eotModule, "runFrictionHook");
+    let llmCalls = 0;
+    await runFrictionHook({
+        taskId: "task-friction-short-result",
+        finalResult: "too short",
+        copilotClient: {},
+        callLLM: async () => {
+            llmCalls++;
+            return "[]";
+        },
+    });
+    assert.equal(llmCalls, 0);
+});
+test("runFrictionHook records action items when enabled and the task result is substantive", async () => {
+    process.env.CHAPTERHOUSE_MEMORY_EOT_FRICTION_ENABLED = "1";
+    const { memoryModule, eotModule } = await loadModules("friction-records-action-items");
+    const getScope = getFunction(memoryModule, "getScope");
+    const setActiveScope = getFunction(memoryModule, "setActiveScope");
+    const listActionItems = getFunction(memoryModule, "listActionItems");
+    const runFrictionHook = getFunction(eotModule, "runFrictionHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    setActiveScope("chapterhouse");
+    await runFrictionHook({
+        taskId: "task-friction-records-action-items",
+        finalResult: "The agent had to retry the same command several times because the tool returned a generic error with no validation detail, which made the task materially slower and harder to finish cleanly.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify([
+            {
+                title: "Improve validation feedback for memory tools",
+                detail: "Return the rejected field name and allowed values instead of a generic failure.",
+                source: "eot:friction",
+            },
+        ]),
+    });
+    const actionItems = listActionItems({ scope_id: chapterhouse.id });
+    assert.equal(actionItems.length, 1);
+    assert.equal(actionItems[0]?.title, "Improve validation feedback for memory tools");
+    assert.equal(actionItems[0]?.detail, "Return the rejected field name and allowed values instead of a generic failure.");
+    assert.equal(actionItems[0]?.source, "eot:friction");
+    assert.equal(actionItems[0]?.status, "open");
+});
+test("runFrictionHook caps parsed friction items at 3", async () => {
+    process.env.CHAPTERHOUSE_MEMORY_EOT_FRICTION_ENABLED = "1";
+    const { memoryModule, eotModule } = await loadModules("friction-cap");
+    const getScope = getFunction(memoryModule, "getScope");
+    const setActiveScope = getFunction(memoryModule, "setActiveScope");
+    const listActionItems = getFunction(memoryModule, "listActionItems");
+    const runFrictionHook = getFunction(eotModule, "runFrictionHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    setActiveScope("chapterhouse");
+    await runFrictionHook({
+        taskId: "task-friction-cap",
+        finalResult: "The toolchain created several distinct sources of friction across the task, and the result is long enough that the friction hook should inspect it and write only the first three issues back into memory.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify([
+            { title: "Item 1", detail: "detail 1", source: "eot:friction" },
+            { title: "Item 2", detail: "detail 2", source: "eot:friction" },
+            { title: "Item 3", detail: "detail 3", source: "eot:friction" },
+            { title: "Item 4", detail: "detail 4", source: "eot:friction" },
+        ]),
+    });
+    assert.deepEqual(listActionItems({ scope_id: chapterhouse.id }).map((item) => item.title).sort(), ["Item 1", "Item 2", "Item 3"]);
+});
+test("runFrictionHook treats malformed JSON as no friction items", async () => {
+    process.env.CHAPTERHOUSE_MEMORY_EOT_FRICTION_ENABLED = "1";
+    const { memoryModule, eotModule } = await loadModules("friction-malformed-json");
+    const getScope = getFunction(memoryModule, "getScope");
+    const setActiveScope = getFunction(memoryModule, "setActiveScope");
+    const listActionItems = getFunction(memoryModule, "listActionItems");
+    const runFrictionHook = getFunction(eotModule, "runFrictionHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    setActiveScope("chapterhouse");
+    await runFrictionHook({
+        taskId: "task-friction-malformed-json",
+        finalResult: "The agent hit confusing tool friction repeatedly, but the friction reviewer returned malformed JSON and the hook should safely ignore it without writing any action items.",
+        copilotClient: {},
+        callLLM: async () => "{not valid json",
+    });
+    assert.deepEqual(listActionItems({ scope_id: chapterhouse.id }), []);
+});
+test("runFrictionHook never propagates errors from the LLM call", async (t) => {
+    process.env.CHAPTERHOUSE_MEMORY_EOT_FRICTION_ENABLED = "1";
+    const { eotModule, warnings } = await loadModulesWithWarnSpy(t, "friction-no-throw");
+    const runFrictionHook = getFunction(eotModule, "runFrictionHook");
+    await assert.doesNotReject(() => runFrictionHook({
+        taskId: "task-friction-no-throw",
+        finalResult: "The agent encountered enough friction to trigger the hook, but the LLM call itself crashed and the hook must still fail closed without breaking end-of-task processing.",
+        copilotClient: {},
+        callLLM: async () => {
+            throw new Error("boom");
+        },
+    }));
+    assert.equal(warnings.length, 1);
+});
 //# sourceMappingURL=eot.test.js.map

package/dist/wiki/frontmatter.js

@@ -175,12 +175,13 @@ export function validateWikiFrontmatter(content, options = {}) {
     }
     if (options.allowedTags && parsed.tags) {
         const allowed = new Set(options.allowedTags.map((tag) => tag.toLowerCase()));
+        const validTags = options.allowedTags.join(", ");
         for (const tag of parsed.tags) {
             if (!allowed.has(tag.toLowerCase())) {
                 errors.push({
                     rule: "unknown-tag",
                     field: "tags",
-                    message: formatFrontmatterMessage(`unknown tag '${tag}'. Add it to \`pages/_meta/taxonomy.md\` first.`),
+                    message: formatFrontmatterMessage(`unknown tag '${tag}'. Tag "${tag}" is not in the allowed tag list. Valid tags: ${validTags}. Add it to \`pages/_meta/taxonomy.md\` first.`),
                 });
             }
         }

package/dist/wiki/frontmatter.test.js

@@ -104,7 +104,8 @@ tags: [engineering, made-up-tag]
 `, { allowedTags: ["engineering", "release"] });
     assert.equal(result.valid, false);
     assert.deepEqual(result.errors.map((error) => error.rule), ["unknown-tag"]);
-    assert.match(result.errors[0]?.message ?? "", /Add it to `pages\/_meta\/taxonomy\.md` first\./);
+    assert.match(result.errors[0]?.message ?? "", /made-up-tag/);
+    assert.match(result.errors[0]?.message ?? "", /Valid tags: engineering, release/);
 });
 test("parseProjectRulesFrontmatter parses typed hard-rule fields and flags unknown keys", async () => {
     const { parseProjectRulesFrontmatter } = await loadFrontmatterModule();

package/dist/wiki/ingest.js

@@ -331,6 +331,22 @@ export async function ingestSource(source, type, topic, session) {
 // ---------------------------------------------------------------------------
 // Type auto-detection
 // ---------------------------------------------------------------------------
+const URL_SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i;
+export function looksLikeLocalFilePath(source) {
+    const trimmed = source.trim();
+    if (!trimmed)
+        return false;
+    if (/^[a-z]:[\\/]/i.test(trimmed))
+        return true;
+    if (trimmed.startsWith("file://") || trimmed.startsWith("./") || trimmed.startsWith("../") || trimmed.startsWith("/") || trimmed.startsWith("~/")) {
+        return true;
+    }
+    if (URL_SCHEME_RE.test(trimmed))
+        return false;
+    if (/\s/.test(trimmed))
+        return false;
+    return trimmed.includes("/") || trimmed.includes("\\") || /\.[a-z0-9]+$/i.test(trimmed);
+}
 export function detectSourceType(source) {
     const trimmed = source.trim();
     if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chapterhouse",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "Chapterhouse — a team-level AI assistant for engineering teams, built on the GitHub Copilot SDK. Web UI only.",
   "bin": {
     "chapterhouse": "dist/cli.js"