chapterhouse 0.3.14 → 0.3.16

package/dist/config.js

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { existsSync, readFileSync, writeFileSync } from "fs";
 import { API_TOKEN_PATH, ENV_PATH, ensureChapterhouseHome } from "./paths.js";
 export const DISABLE_DOTENV_ENV_VAR = "CHAPTERHOUSE_DISABLE_DOTENV";
-const DEFAULT_WORKER_TIMEOUT_MS = 600_000;
+const DEFAULT_WORKER_TIMEOUT_MS = 900_000;
 const BOOLEAN_ENV_PATTERN = /^(true|false)$/;
 function loadRuntimeEnv() {
     if (process.env[DISABLE_DOTENV_ENV_VAR] === "1") {
@@ -37,6 +37,7 @@ const configSchema = z.object({
     TEAM_CHAPTERHOUSE_TOKEN: z.string().optional(),
     TEAM_WIKI_CACHE_TTL_MINUTES: z.string().optional(),
     TEAM_WIKI_PATHS: z.string().optional(),
+    WIKI_ENTITY_CATEGORIES: z.string().optional(),
     TEAMS_WEBHOOK_URL: z.string().optional(),
     TEAMS_NOTIFICATIONS_ENABLED: z.string().optional(),
     COPILOT_TOKEN: z.string().optional(),
@@ -51,6 +52,7 @@ const configSchema = z.object({
 export const DEFAULT_MODEL = "claude-sonnet-4.6";
 export const DEFAULT_TEAM_WIKI_CACHE_TTL_MINUTES = 60;
 export const DEFAULT_TEAM_WIKI_PATHS = ["pages/team", "pages/okrs", "pages/kpis", "pages/shared"];
+export const DEFAULT_ENTITY_CATEGORIES = ["projects", "people", "orgs", "tools", "topics", "areas"];
 export const DEFAULT_STANDUP_TIME = "09:00";
 export const DEFAULT_ADO_ORG = "";
 export const DEFAULT_ADO_PROJECT = "";
@@ -128,6 +130,13 @@ function parseTeamWikiPaths(rawValue) {
         .filter(Boolean);
     return paths.length > 0 ? paths : [...DEFAULT_TEAM_WIKI_PATHS];
 }
+function parseEntityCategories(rawValue) {
+    const cats = (rawValue || DEFAULT_ENTITY_CATEGORIES.join(","))
+        .split(",")
+        .map((value) => value.trim().toLowerCase().replace(/[^a-z0-9-]/g, ""))
+        .filter(Boolean);
+    return cats.length > 0 ? [...new Set(cats)] : [...DEFAULT_ENTITY_CATEGORIES];
+}
 function resolveConfiguredApiToken(envToken, { apiTokenPath = API_TOKEN_PATH, exists = existsSync, readFile = readFileSync, } = {}) {
     const trimmedEnvToken = envToken?.trim();
     if (trimmedEnvToken) {
@@ -213,6 +222,7 @@ export function parseRuntimeConfig(env, options = {}) {
         teamChapterhouseToken: raw.TEAM_CHAPTERHOUSE_TOKEN?.trim() || "",
         teamWikiCacheTtlMinutes: parsedTeamWikiCacheTtlMinutes,
         teamWikiPaths: parseTeamWikiPaths(raw.TEAM_WIKI_PATHS),
+        wikiEntityCategories: parseEntityCategories(raw.WIKI_ENTITY_CATEGORIES),
         teamsWebhookUrl,
         teamsNotificationsEnabled,
         apiRateLimitWindowMs,
@@ -253,6 +263,7 @@ export const config = {
     teamChapterhouseToken: runtimeConfig.teamChapterhouseToken,
     teamWikiCacheTtlMinutes: runtimeConfig.teamWikiCacheTtlMinutes,
     teamWikiPaths: runtimeConfig.teamWikiPaths,
+    wikiEntityCategories: runtimeConfig.wikiEntityCategories,
     teamsWebhookUrl: runtimeConfig.teamsWebhookUrl,
     teamsNotificationsEnabled: runtimeConfig.teamsNotificationsEnabled,
     apiRateLimitWindowMs: runtimeConfig.apiRateLimitWindowMs,

package/dist/copilot/system-message.js

@@ -115,6 +115,13 @@ You can delegate **multiple tasks simultaneously**. Different agents can work in
 
 **Past conversations**: Daily conversation summaries are auto-written to \`pages/conversations/YYYY-MM-DD.md\`. When the user references something from earlier ("what did we decide about X", "remember when we…", "the thing we discussed yesterday"), call \`wiki_search\` (or \`recall\`) — don't guess from your own context, since older turns may have been compacted out.
 
+**Wiki structure** — the wiki enforces a topic layout, so put things in the right place:
+- **Entity categories** (\`projects\`, \`people\`, \`orgs\`, \`tools\`, \`topics\`, \`areas\`): every named thing gets its own directory \`pages/<category>/<topic-slug>/\`. The topic's overview lives at \`pages/<category>/<topic-slug>/index.md\`; related sub-pages ("facets") go alongside it, e.g. \`pages/projects/chapterhouse/decisions.md\`, \`pages/projects/chapterhouse/feature-ideas.md\`. Exactly one topic level deep; lowercase-slug names only.
+- **Flat categories** (\`preferences\`, \`facts\`, \`routines\`): a single file each, e.g. \`pages/preferences.md\`.
+- **Decisions** are always recorded against an entity, never as a standalone page: a decision about a project goes to \`pages/projects/<topic>/decisions.md\`. With \`remember\`, pass \`category: "decision"\` plus \`about\` (which entity category) and \`entity\`.
+- With \`remember\`, pass \`entity\` for entity categories (and \`facet\` to target a sub-page). With \`wiki_update\`, give the full canonical path — bad paths are rejected with a suggested correction; just retry with the suggestion.
+- If the structure ever looks wrong, call \`wiki_rebuild_index\` to regenerate the index from disk.
+
 **Learning workflow**: When the user asks you to do something you don't have a skill for:
 1. **Search skills.sh first**: Use the find-skills skill to search for existing community skills.
 2. **Present what you found**: Tell the user the skill name, what it does, and its security status.

package/dist/copilot/tools.js

@@ -8,9 +8,13 @@ import { listSkills, createSkill, removeSkill } from "./skills.js";
 import { config, persistModel } from "../config.js";
 import { getCurrentSourceChannel, getCurrentActivityCallback, getCurrentAuthenticatedUser, getLastAuthenticatedUser, getCurrentAuthorizationHeader, getCurrentSessionKey, switchSessionModel, } from "./orchestrator.js";
 import { getRouterConfig, updateRouterConfig } from "./router.js";
-import { ensureWikiStructure, readPage, writePage, deletePage, listPages, writeRawSource, listSources, assertPagePath } from "../wiki/fs.js";
-import { searchIndex, addToIndex, removeFromIndex, parseIndex, buildIndexEntryForPage } from "../wiki/index-manager.js";
+import { ensureWikiStructure, readPage, writePage, deletePage, writeRawSource, assertPagePath } from "../wiki/fs.js";
+import { searchIndex, addToIndex, removeFromIndex, buildIndexEntryForPage } from "../wiki/index-manager.js";
+import { validateWikiFrontmatter } from "../wiki/frontmatter.js";
+import { lintWiki, renderWikiLintReport } from "../wiki/lint.js";
 import { appendLog } from "../wiki/log-manager.js";
+import { loadTaxonomy } from "../wiki/taxonomy.js";
+import { getCategoryDir, topicPagePath, slugify, entityCategories, FLAT_CATEGORIES } from "../wiki/topic-structure.js";
 import { withWikiWrite } from "../wiki/lock.js";
 import { readWikiPage, teamWikiSync } from "../wiki/team-sync.js";
 import { getAgentRegistry, getAgent, createEphemeralAgentSession, getAgentSessionStatus, getTask, registerTask, completeTask, failTask, createAgentFile, removeAgentFile, loadAgents, } from "./agents.js";
@@ -20,17 +24,6 @@ import { TeamPushClient } from "../integrations/team-push.js";
 import { OKRMapper, parseOKRPageContent } from "./okr-mapper.js";
 import { childLogger } from "../util/logger.js";
 const log = childLogger("tools");
-function getCategoryDir(category) {
-    const map = {
-        person: "people",
-        project: "projects",
-        preference: "preferences",
-        fact: "facts",
-        routine: "routines",
-        decision: "decisions",
-    };
-    return map[category] || category;
-}
 /** Escape a string for safe inclusion as a single-line YAML scalar value. */
 function yamlEscape(value) {
     // Always quote and escape backslashes, double quotes, and newlines.
@@ -650,55 +643,73 @@ export function createTools(deps) {
         }),
         // ----- Wiki-backed memory facades (preserve existing remember/recall/forget UX) -----
         defineTool("remember", {
-            description: "Save a fact, preference, or detail to the wiki. Routes to entity-specific pages automatically. " +
+            description: "Save a fact, preference, or detail to the wiki. Routes to topic pages automatically. " +
                 "Use for discrete facts ('The team prefers dark mode', 'Project uses Vercel'). " +
+                "Entity categories (project/person/org/tool/topic/area) are filed under pages/<category>/<topic>/index.md; " +
+                "pass `entity` for those, and `facet` to file under a sub-page like pages/projects/chapterhouse/feature-ideas.md. " +
+                "A `decision` is always recorded against an entity: pass both `about` (which entity category) and `entity`; " +
+                "it lands at pages/<about>/<entity>/decisions.md. " +
                 "For richer knowledge pages, use wiki_update instead.",
             parameters: z.object({
-                category: z.enum(["preference", "fact", "project", "person", "routine", "decision"])
-                    .describe("Category: preference (likes/dislikes/settings), fact (general knowledge), project (codebase/repo info), person (people info), routine (schedules/habits), decision (choices made)"),
+                category: z.enum(["preference", "fact", "project", "person", "routine", "decision", "org", "tool", "topic", "area"])
+                    .describe("Category. Entity categories (need `entity`): project (codebase/repo), person (people), org (companies/teams), tool (software/technologies), topic (knowledge areas), area (areas of responsibility). decision (a choice made — needs `about` + `entity`). Flat categories: preference (likes/dislikes/settings), fact (general knowledge), routine (schedules/habits)."),
                 content: z.string().describe("The thing to remember — a concise, self-contained statement"),
-                entity: z.string().optional().describe("The specific entity this is about (e.g. 'team', 'chapterhouse', 'vercel'). Routes to a dedicated entity page."),
+                entity: z.string().optional().describe("Required for entity categories and for decisions: the specific topic this is about (e.g. 'chapterhouse', 'vercel', 'Brian'). Routes to pages/<category>/<topic-slug>/…"),
+                about: z.enum(["project", "person", "org", "tool", "topic", "area"]).optional()
+                    .describe("Required only when category='decision': which entity category the decision concerns. The decision is filed at pages/<about>/<entity>/decisions.md."),
+                facet: z.string().optional().describe("Optional sub-page within the topic directory (e.g. 'feature-ideas', 'architecture'). Only meaningful with an entity category + `entity`. Defaults to the topic's index page. (For decisions use `about` instead.)"),
                 related: z.array(z.string()).optional().describe("Wiki page paths this connects to, for cross-referencing"),
             }),
             handler: async (args) => {
                 return withWikiWrite(async () => {
                     ensureWikiStructure();
                     const now = new Date().toISOString().slice(0, 10);
-                    // Entity routing: code-authoritative slugification and page lookup
+                    const titleCase = (s) => s.split(/[-_\s]+/).filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+                    // Routing: code-authoritative slugification and page lookup.
                     let pagePath;
                     let title;
-                    if (args.entity) {
-                        const slug = args.entity.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-                        const categoryDir = getCategoryDir(args.category);
-                        pagePath = `pages/${categoryDir}/${slug}.md`;
-                        // Check for existing page with fuzzy match before creating new
-                        const existingPages = searchIndex(args.entity, 5);
-                        const existingMatch = existingPages.find((p) => {
-                            const pSlug = p.path.split("/").pop()?.replace(".md", "") || "";
-                            return pSlug === slug || p.title.toLowerCase() === args.entity.toLowerCase();
-                        });
-                        if (existingMatch) {
-                            pagePath = existingMatch.path;
-                            title = existingMatch.title;
+                    let routedCategoryDir; // the directory under pages/ this ends up in
+                    if (args.category === "decision") {
+                        if (!args.about || !args.entity) {
+                            return `A decision needs both 'about' (the entity category it concerns — one of: ${entityCategories().join(", ")}) and 'entity' (the specific one, e.g. "chapterhouse"). It will be filed at pages/<about>/<entity>/decisions.md.`;
                         }
-                        else {
-                            title = args.entity.split(/[-_\s]+/).map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+                        routedCategoryDir = getCategoryDir(args.about);
+                        if (!entityCategories().includes(routedCategoryDir)) {
+                            return `'${args.about}' isn't a known entity category. Use one of: ${entityCategories().join(", ")}.`;
                         }
+                        pagePath = topicPagePath(args.about, args.entity, "decisions");
+                        const existingMatch = searchIndex(args.entity, 5).find((p) => p.path === pagePath);
+                        title = existingMatch ? existingMatch.title : `${titleCase(args.entity)} — Decisions`;
                     }
                     else {
-                        const categoryMap = {
-                            preference: "pages/preferences.md",
-                            fact: "pages/facts.md",
-                            project: "pages/projects.md",
-                            person: "pages/people.md",
-                            routine: "pages/routines.md",
-                            decision: "pages/decisions.md",
-                        };
-                        pagePath = categoryMap[args.category] || `pages/${args.category}.md`;
-                        title = args.category.charAt(0).toUpperCase() + args.category.slice(1);
+                        routedCategoryDir = getCategoryDir(args.category);
+                        const isFlat = FLAT_CATEGORIES.includes(routedCategoryDir);
+                        if (!isFlat) {
+                            if (!args.entity) {
+                                return `The '${args.category}' category needs an 'entity' (the specific ${args.category} this is about) so it can be filed under pages/${routedCategoryDir}/<topic>/. Re-call remember with an entity, e.g. entity: "chapterhouse".`;
+                            }
+                            const facet = args.facet ? slugify(args.facet) : "index";
+                            pagePath = topicPagePath(args.category, args.entity, facet);
+                            // Reuse an existing page if the index already has one at (or matching) this path.
+                            const existingPages = searchIndex(args.entity, 5);
+                            const existingMatch = existingPages.find((p) => p.path === pagePath ||
+                                (facet === "index" && p.title.toLowerCase() === args.entity.toLowerCase() && p.path.startsWith(`pages/${routedCategoryDir}/`)));
+                            if (existingMatch) {
+                                pagePath = existingMatch.path;
+                                title = existingMatch.title;
+                            }
+                            else {
+                                const topicTitle = titleCase(args.entity);
+                                title = facet === "index" ? topicTitle : `${topicTitle} — ${titleCase(facet)}`;
+                            }
+                        }
+                        else {
+                            pagePath = `pages/${routedCategoryDir}.md`;
+                            title = titleCase(routedCategoryDir);
+                        }
                     }
                     // Defense-in-depth: pagePath is constructed from controlled parts but
-                    // assertPagePath will catch any drift (e.g. an entity slug producing "..").
+                    // assertPagePath also enforces the topic-structure rules.
                     assertPagePath(pagePath);
                     const existing = readPage(pagePath);
                     if (existing) {
@@ -753,7 +764,7 @@ export function createTools(deps) {
                 "Use when you need to look up something the user told you, or when asked 'do you remember...?'",
             parameters: z.object({
                 keyword: z.string().optional().describe("Search term to match against wiki pages"),
-                category: z.enum(["preference", "fact", "project", "person", "routine", "decision"]).optional()
+                category: z.enum(["preference", "fact", "project", "person", "routine", "decision", "org", "tool", "topic", "area"]).optional()
                     .describe("Optional: filter by category"),
             }),
             handler: async (args) => {
@@ -916,9 +927,12 @@ export function createTools(deps) {
         }),
         defineTool("wiki_read", {
             description: "Read a specific wiki page by path. Use after wiki_search to read full page content. " +
-                "Paths are relative to the wiki root (e.g. 'pages/preferences.md', 'index.md').",
+                "Paths are relative to the wiki root. Layout: entity categories (projects, people, orgs, tools, " +
+                "topics, areas) live at 'pages/<category>/<topic>/index.md' (the topic overview) plus optional " +
+                "'pages/<category>/<topic>/<facet>.md' sub-pages; flat categories at 'pages/<category>.md' " +
+                "(preferences, facts, routines, decisions); daily summaries at 'pages/conversations/YYYY-MM-DD.md'.",
             parameters: z.object({
-                path: z.string().describe("Path to the wiki page (e.g. 'pages/people/brian.md', 'index.md')"),
+                path: z.string().describe("Path to the wiki page (e.g. 'pages/people/brian/index.md', 'pages/projects/chapterhouse/decisions.md', 'index.md')"),
             }),
             handler: async (args) => {
                 ensureWikiStructure();
@@ -932,9 +946,14 @@ export function createTools(deps) {
             description: "Create or update a wiki page. You provide the full page content (markdown with optional " +
                 "YAML frontmatter). The page will be written to disk and the index updated. Use this for " +
                 "rich knowledge pages, entity pages, synthesis documents — anything more structured than " +
-                "a quick 'remember' call. After creating/updating a page, the index is automatically updated.",
+                "a quick 'remember' call. After creating/updating a page, the index is automatically updated. " +
+                "PATH RULES: entity-category pages MUST be 'pages/<category>/<topic-slug>/<page>.md' where " +
+                "category is one of projects, people, orgs, tools, topics, areas, '<page>' is 'index' for the " +
+                "topic overview or a facet name (e.g. 'decisions', 'feature-ideas') — exactly one topic level, " +
+                "lowercase slugs only. Flat-category pages MUST be 'pages/<category>.md' (preferences, facts, " +
+                "routines, decisions). Bad paths are rejected with a suggested correction.",
             parameters: z.object({
-                path: z.string().describe("Page path relative to wiki root (e.g. 'pages/projects/max.md')"),
+                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"),
                 section: z.string().optional().describe("Index section (default: 'Knowledge')"),
@@ -944,20 +963,20 @@ export function createTools(deps) {
                 return withWikiWrite(async () => {
                     ensureWikiStructure();
                     assertPagePath(args.path);
+                    const validation = validateWikiFrontmatter(args.content, {
+                        allowedTags: loadTaxonomy(),
+                    });
+                    if (!validation.valid) {
+                        throw new Error(validation.errors.map((error) => error.message).join("\n\n"));
+                    }
                     writePage(args.path, args.content);
-                    // Rebuild from disk so the index summary/tags/updated reflect the actual page,
-                    // but prefer caller-supplied title/summary/section as overrides.
+                    // Rebuild from disk so the index summary/tags/updated reflect the actual page.
                     const today = new Date().toISOString().slice(0, 10);
                     const rebuilt = buildIndexEntryForPage(args.path, {
-                        title: args.title,
-                        summary: indexSafe(args.summary).slice(0, 160),
                         section: args.section || "Knowledge",
                         updated: today,
                     });
                     if (rebuilt) {
-                        // Overrides win even if the page frontmatter says otherwise.
-                        rebuilt.title = args.title;
-                        rebuilt.summary = indexSafe(args.summary).slice(0, 160);
                         rebuilt.section = args.section || "Knowledge";
                         addToIndex(rebuilt);
                     }
@@ -1048,25 +1067,11 @@ export function createTools(deps) {
             parameters: z.object({}),
             handler: async () => {
                 ensureWikiStructure();
-                const indexEntries = parseIndex();
-                const pages = listPages();
-                const sources = listSources();
-                const indexPaths = new Set(indexEntries.map((e) => e.path));
-                const orphans = pages.filter((p) => !indexPaths.has(p));
-                const missing = indexEntries.filter((e) => !readPage(e.path));
-                const report = [`Wiki health report (${pages.length} pages, ${sources.length} sources):`];
-                if (orphans.length > 0) {
-                    report.push(`\n**Orphan pages** (not in index):\n${orphans.map((p) => `- ${p}`).join("\n")}`);
-                }
-                if (missing.length > 0) {
-                    report.push(`\n**Missing pages** (in index but not on disk):\n${missing.map((e) => `- ${e.path}: ${e.title}`).join("\n")}`);
-                }
-                if (orphans.length === 0 && missing.length === 0) {
-                    report.push("\n✅ No issues found. Index and pages are in sync.");
-                }
-                report.push(`\n**Suggestions**: Look for pages that should link to each other, topics mentioned but lacking their own page, and stale content that needs updating.`);
-                appendLog("lint", `${orphans.length} orphans, ${missing.length} missing`);
-                return report.join("\n");
+                const report = lintWiki();
+                const orphanCount = report.issues.filter((issue) => issue.rule === "orphan-page").length;
+                const missingCount = report.issues.filter((issue) => issue.rule === "missing-page").length;
+                appendLog("lint", `${orphanCount} orphans, ${missingCount} missing`);
+                return renderWikiLintReport(report);
             },
         }),
         defineTool("wiki_rebuild_index", {
@@ -1078,7 +1083,7 @@ export function createTools(deps) {
                 return withWikiWrite(async () => {
                     const { rebuildIndexFromPages } = await import("../wiki/index-manager.js");
                     const entries = rebuildIndexFromPages();
-                    appendLog("lint", `wiki_rebuild_index: rebuilt ${entries.length} entries from pages on disk`);
+                    appendLog("rebuild-index", `wiki_rebuild_index: rebuilt ${entries.length} entries from pages on disk`);
                     return `Rebuilt index with ${entries.length} entries.`;
                 });
             },

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

@@ -0,0 +1,143 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import test from "node:test";
+async function loadToolsModule() {
+    return await import(new URL(`./tools.js?cachebust=${Date.now()}-${Math.random()}`, import.meta.url).href);
+}
+async function readWikiArtifacts() {
+    const nonce = `${Date.now()}-${Math.random()}`;
+    const wikiFs = await import(new URL(`../wiki/fs.js?case=${nonce}`, import.meta.url).href);
+    return wikiFs;
+}
+test.beforeEach(() => {
+    process.env.CHAPTERHOUSE_HOME = mkdtempSync(join(tmpdir(), "chapterhouse-tools-wiki-"));
+    process.env.CHAPTERHOUSE_AGENT_NAME = "tools-test-agent";
+});
+test.afterEach(async () => {
+    const home = process.env.CHAPTERHOUSE_HOME;
+    if (home) {
+        const dbModule = await import("../store/db.js");
+        dbModule.closeDb();
+        rmSync(home, { recursive: true, force: true });
+    }
+});
+test("wiki_update rejects content without required frontmatter", async () => {
+    const toolsModule = await loadToolsModule();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const tool = tools.find((entry) => entry.name === "wiki_update");
+    assert.ok(tool);
+    await assert.rejects(tool.handler({
+        path: "pages/shared/chapterhouse.md",
+        title: "Chapterhouse",
+        summary: "Runtime notes",
+        content: "# Chapterhouse\n\nRuntime notes.\n",
+    }), /Wiki page frontmatter violates the required shape/i);
+});
+test("wiki_update rejects malformed summaries and unknown tags", async () => {
+    const toolsModule = await loadToolsModule();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const tool = tools.find((entry) => entry.name === "wiki_update");
+    assert.ok(tool);
+    await assert.rejects(tool.handler({
+        path: "pages/shared/chapterhouse.md",
+        title: "Chapterhouse",
+        summary: "Runtime notes",
+        content: `---
+title: Chapterhouse
+summary: **Runtime notes**
+tags: [engineering, made-up-tag]
+---
+
+# Chapterhouse
+
+Runtime notes.
+`,
+    }), /Add it to `pages\/_meta\/taxonomy\.md` first\./);
+});
+test("wiki_update accepts valid frontmatter and refreshes the index entry", async () => {
+    const toolsModule = await loadToolsModule();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const tool = tools.find((entry) => entry.name === "wiki_update");
+    assert.ok(tool);
+    const result = await tool.handler({
+        path: "pages/shared/chapterhouse.md",
+        title: "Chapterhouse",
+        summary: "Runtime notes",
+        content: `---
+title: Chapterhouse
+summary: Runtime notes
+tags: [engineering]
+autostub: true
+confidence: low
+contested: true
+contradictions: [pages/shared/other.md]
+---
+
+# Chapterhouse
+
+Runtime notes.
+`,
+    });
+    assert.equal(result, "Wiki page updated: Chapterhouse (pages/shared/chapterhouse.md)");
+    const wikiFs = await readWikiArtifacts();
+    assert.match(wikiFs.readPage("pages/shared/chapterhouse.md") ?? "", /summary: Runtime notes/);
+    assert.match(wikiFs.readIndexFile(), /\[Chapterhouse\]\(pages\/shared\/chapterhouse\.md\) — Runtime notes/);
+});
+test("wiki tools append audit entries to pages/_meta/log.md", async () => {
+    const toolsModule = await loadToolsModule();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const wikiUpdate = tools.find((entry) => entry.name === "wiki_update");
+    const wikiIngest = tools.find((entry) => entry.name === "wiki_ingest");
+    const wikiLint = tools.find((entry) => entry.name === "wiki_lint");
+    const wikiRebuildIndex = tools.find((entry) => entry.name === "wiki_rebuild_index");
+    const forget = tools.find((entry) => entry.name === "forget");
+    assert.ok(wikiUpdate && wikiIngest && wikiLint && wikiRebuildIndex && forget);
+    await wikiUpdate.handler({
+        path: "pages/shared/chapterhouse.md",
+        title: "Chapterhouse",
+        summary: "Runtime notes",
+        content: `---
+title: Chapterhouse
+summary: Runtime notes
+updated: 2026-05-12
+tags: [engineering]
+---
+
+# Chapterhouse
+
+## Overview
+
+Runtime notes with enough content to avoid incidental lint noise in the audit-log test.
+`,
+    });
+    await wikiIngest.handler({
+        type: "text",
+        source: "Source content for the wiki ingest audit log test.",
+        name: "audit-log-source",
+    });
+    await wikiLint.handler({});
+    await wikiRebuildIndex.handler({});
+    await forget.handler({ page_path: "pages/shared/chapterhouse.md" });
+    const wikiFs = await readWikiArtifacts();
+    const log = wikiFs.readLogFile();
+    assert.match(log, /update \| wiki_update: Chapterhouse \(pages\/shared\/chapterhouse\.md\) \| tools-test-agent/);
+    assert.match(log, /ingest \| Ingested text: audit-log-source \(\d+ chars\) \| tools-test-agent/);
+    assert.match(log, /lint \| .* \| tools-test-agent/);
+    assert.match(log, /rebuild-index \| wiki_rebuild_index: rebuilt \d+ entries from pages on disk \| tools-test-agent/);
+    assert.match(log, /delete \| forget: deleted page pages\/shared\/chapterhouse\.md \| tools-test-agent/);
+});
+//# sourceMappingURL=tools.wiki.test.js.map

package/dist/daemon.js

@@ -11,6 +11,7 @@ import { checkForUpdate } from "./update.js";
 import { ensureWikiStructure } from "./wiki/fs.js";
 import { seedTeamWiki } from "./wiki/seed-team-wiki.js";
 import { shouldMigrate, migrateMemoriesToWiki, shouldReorganize, reorganizeWiki } from "./wiki/migrate.js";
+import { shouldEnforceTopics, enforceTopicStructure } from "./wiki/migrate-topics.js";
 import { SESSIONS_DIR } from "./paths.js";
 import { getDisplayHost } from "./api/server-runtime.js";
 import { StandupScheduler } from "./copilot/standup.js";
@@ -113,6 +114,11 @@ async function main() {
         const count = reorganizeWiki();
         log.info({ count }, "Created entity pages during reorganization");
     }
+    if (shouldEnforceTopics()) {
+        log.info("Enforcing wiki topic-directory structure");
+        const moved = enforceTopicStructure();
+        log.info({ moved }, "Topic-structure migration complete");
+    }
     // Prune orphaned session folders older than 7 days
     pruneOldSessions();
     // One-time deprecation note for legacy Telegram users (v1 → v2)

package/dist/wiki/frontmatter.js

@@ -0,0 +1,148 @@
+const FRONTMATTER_RE = /^---\s*\n([\s\S]*?)\n---\s*\n?/;
+const SUMMARY_MARKDOWN_RE = /(\*\*|__|[_*`~]|^\s*#+\s|\[[^\]]+\]\([^)]+\)|!\[[^\]]*\]\([^)]+\)|^\s*>)/m;
+const FRONTMATTER_TEMPLATE = `---\ntitle: <title>\nsummary: <plain-text one-line summary, max 200 chars>\nupdated: YYYY-MM-DD\ntags: []\nrelated: []\n---`;
+export function parseWikiFrontmatter(content) {
+    const match = content.match(FRONTMATTER_RE);
+    if (!match) {
+        return {
+            parsed: { metadata: {} },
+            body: content,
+        };
+    }
+    const parsed = { metadata: {} };
+    for (const line of match[1].split("\n")) {
+        const idx = line.indexOf(":");
+        if (idx <= 0)
+            continue;
+        const key = line.slice(0, idx).trim();
+        const rawValue = line.slice(idx + 1).trim();
+        const value = parseValue(rawValue);
+        switch (key) {
+            case "title":
+            case "summary":
+            case "updated":
+                if (typeof value === "string")
+                    parsed[key] = value;
+                else
+                    parsed.metadata[key] = value;
+                break;
+            case "tags":
+            case "contradictions":
+            case "related":
+                if (Array.isArray(value))
+                    parsed[key] = value;
+                else
+                    parsed.metadata[key] = value;
+                break;
+            case "autostub":
+            case "contested":
+                if (typeof value === "boolean")
+                    parsed[key] = value;
+                else
+                    parsed.metadata[key] = value;
+                break;
+            case "confidence":
+                if (value === "high" || value === "medium" || value === "low") {
+                    parsed.confidence = value;
+                }
+                else {
+                    parsed.metadata[key] = value;
+                }
+                break;
+            default:
+                parsed.metadata[key] = value;
+                break;
+        }
+    }
+    return {
+        parsed,
+        body: content.slice(match[0].length),
+    };
+}
+export function hasWikiFrontmatter(content) {
+    return FRONTMATTER_RE.test(content);
+}
+export function validateWikiFrontmatter(content, options = {}) {
+    const errors = [];
+    const { parsed } = parseWikiFrontmatter(content);
+    if (!hasWikiFrontmatter(content)) {
+        errors.push({
+            rule: "missing-frontmatter",
+            message: "Wiki page frontmatter violates the required shape: missing YAML frontmatter. Use:\n" + FRONTMATTER_TEMPLATE,
+        });
+        return { valid: false, errors };
+    }
+    if (!parsed.title?.trim()) {
+        errors.push({
+            rule: "missing-title",
+            field: "title",
+            message: formatFrontmatterMessage("missing 'title'"),
+        });
+    }
+    if (!parsed.summary?.trim()) {
+        errors.push({
+            rule: "missing-summary",
+            field: "summary",
+            message: formatFrontmatterMessage("missing 'summary'"),
+        });
+    }
+    else {
+        const summary = parsed.summary.trim();
+        if (summary.length > 200 ||
+            summary.includes("\n") ||
+            summary.includes("\r") ||
+            SUMMARY_MARKDOWN_RE.test(summary)) {
+            errors.push({
+                rule: "invalid-summary",
+                field: "summary",
+                message: formatFrontmatterMessage("invalid 'summary' (use plain text, one line, max 200 chars)"),
+            });
+        }
+    }
+    for (const field of ["updated", "tags", "autostub", "confidence", "contested", "contradictions", "related"]) {
+        if (field in parsed.metadata) {
+            errors.push({
+                rule: "invalid-field-type",
+                field,
+                message: formatFrontmatterMessage(`invalid '${field}' type`),
+            });
+        }
+    }
+    if (options.allowedTags && parsed.tags) {
+        const allowed = new Set(options.allowedTags.map((tag) => tag.toLowerCase()));
+        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.`),
+                });
+            }
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+function formatFrontmatterMessage(reason) {
+    return `Wiki page frontmatter violates the required shape: ${reason}. Use:\n${FRONTMATTER_TEMPLATE}`;
+}
+function parseValue(rawValue) {
+    if (rawValue.startsWith("[") && rawValue.endsWith("]")) {
+        return rawValue
+            .slice(1, -1)
+            .split(",")
+            .map((item) => stripQuotes(item.trim()))
+            .filter(Boolean);
+    }
+    if (rawValue === "true")
+        return true;
+    if (rawValue === "false")
+        return false;
+    return stripQuotes(rawValue);
+}
+function stripQuotes(value) {
+    return value.replace(/^['"]|['"]$/g, "");
+}
+//# sourceMappingURL=frontmatter.js.map