chapterhouse 0.9.0 → 0.9.2

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/shared/api-schemas.js

@@ -314,9 +314,6 @@ export const WikiPageUpdateResponseSchema = z.object({
     page: WikiPageDetailSchema.shape.page.optional(),
     pinned: z.boolean().optional(),
 }).passthrough();
-export const WikiKorgResponseSchema = z.object({
-    reply: z.string(),
-}).passthrough();
 export const WikiReingestResponseSchema = z.object({
     ok: z.boolean(),
 }).passthrough();

package/dist/store/db.js

@@ -551,6 +551,7 @@ export function getDb() {
         ensureChapterhouseHome();
         db = new Database(getDbPath());
         db.pragma("journal_mode = WAL");
+        db.pragma("busy_timeout = 5000");
         db.pragma("foreign_keys = ON");
         db.exec(`
       CREATE TABLE IF NOT EXISTS worker_sessions (

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.`),
                 });
             }
         }