chapterhouse 0.3.14 → 0.3.15

package/dist/config.js

@@ -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

@@ -11,6 +11,7 @@ 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 { appendLog } from "../wiki/log-manager.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 +21,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 +640,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 +761,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 +924,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 +943,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')"),

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/fs.js

@@ -5,6 +5,7 @@ import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, unlink
 import { join, dirname, relative, resolve, sep } from "path";
 import { WIKI_DIR, WIKI_PAGES_DIR, WIKI_SOURCES_DIR } from "../paths.js";
 import { normalizeWikiPath } from "./path-utils.js";
+import { topicPathError } from "./topic-structure.js";
 const INDEX_PATH = join(WIKI_DIR, "index.md");
 const LOG_PATH = join(WIKI_DIR, "log.md");
 /**
@@ -43,6 +44,10 @@ export function assertPagePath(relativePath) {
     if (!normalizedPath.endsWith(".md")) {
         throw new Error(`Wiki page paths must end in .md: ${relativePath}`);
     }
+    const structureError = topicPathError(normalizedPath);
+    if (structureError) {
+        throw new Error(`Wiki path violates the topic structure: ${structureError}`);
+    }
     // resolvePath also enforces the wiki-root containment check.
     resolvePath(normalizedPath);
 }

package/dist/wiki/index-manager.js

@@ -6,6 +6,7 @@ import { join } from "path";
 import { WIKI_DIR } from "../paths.js";
 import { readIndexFile, writeIndexFile, listPages, readPage } from "./fs.js";
 import { normalizeWikiPath } from "./path-utils.js";
+import { entityCategories, FLAT_CATEGORIES } from "./topic-structure.js";
 const INDEX_PATH = join(WIKI_DIR, "index.md");
 // mtime-based cache so per-message context injection doesn't re-parse on every turn.
 let cache;
@@ -39,8 +40,9 @@ export function parseIndex() {
             currentSection = sectionMatch[1].trim();
             continue;
         }
-        // Entry lines: - [Title](path) — Summary | tags: t1, t2 | updated: YYYY-MM-DD
-        const entryMatch = line.match(/^-\s+\[(.+?)\]\((.+?)\)\s*[—–-]\s*(.+)/);
+        // Entry lines (possibly indented sub-bullets):
+        //   - [Title](path) — Summary | tags: t1, t2 | updated: YYYY-MM-DD
+        const entryMatch = line.match(/^\s*-\s+\[(.+?)\]\((.+?)\)\s*[—–-]\s*(.+)/);
         if (entryMatch) {
             const rawSummary = entryMatch[3].trim();
             // Parse optional | tags: ... | updated: ... suffixes
@@ -120,9 +122,11 @@ export function buildIndexEntryForPage(path, fallback) {
         const body = content.replace(/^---[\s\S]*?---\s*/, "");
         for (const raw of body.split("\n")) {
             const line = raw.trim();
-            if (!line || line.startsWith("#"))
+            if (!line || line.startsWith("#") || line.startsWith("<!--"))
                 continue;
             summary = line.replace(/^[-*]\s+/, "").replace(/_\(\d{4}-\d{2}-\d{2}\)_$/, "").trim();
+            if (!summary)
+                continue;
             break;
         }
     }
@@ -157,7 +161,7 @@ export function rebuildIndexFromPages() {
                 section = sm[1].trim();
                 continue;
             }
-            const em = line.match(/^-\s+\[.+?\]\((.+?)\)/);
+            const em = line.match(/^\s*-\s+\[.+?\]\((.+?)\)/);
             if (em) {
                 const normalizedPath = normalizeWikiPath(em[1].trim());
                 previous.set(normalizedPath, { path: normalizedPath, title: "", summary: "", section });
@@ -181,13 +185,51 @@ export function writeIndex(entries) {
     writeIndexInternal(entries);
     invalidateCache();
 }
+/** Derive the top-level category of a page from its path under pages/. */
+function categoryOfPath(path) {
+    const rest = path.startsWith("pages/") ? path.slice("pages/".length) : path;
+    const segs = rest.split("/").filter(Boolean);
+    if (segs.length <= 1)
+        return (segs[0] || "pages").replace(/\.md$/i, "");
+    return segs[0];
+}
+/** Derive the topic slug of an entity-category page (pages/<cat>/<topic>/<file>), if any. */
+function topicOfPath(path) {
+    const rest = path.startsWith("pages/") ? path.slice("pages/".length) : path;
+    const segs = rest.split("/").filter(Boolean);
+    return segs.length >= 3 ? segs[1] : undefined;
+}
+function isTopicIndexFile(path) {
+    return /\/index\.md$/i.test(path);
+}
+function humanize(slug) {
+    return slug.split(/[-_]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function renderEntryLine(item, indent = "") {
+    let line = `${indent}- [${item.title}](${item.path}) — ${item.summary}`;
+    if (item.tags?.length)
+        line += ` | tags: ${item.tags.join(", ")}`;
+    if (item.updated)
+        line += ` | updated: ${item.updated}`;
+    return line;
+}
 function writeIndexInternal(entries) {
-    const sections = new Map();
+    // Group by top-level category derived from the page path (not the stored
+    // `section`, which is no longer authoritative).
+    const byCategory = new Map();
     for (const entry of entries) {
-        const list = sections.get(entry.section) || [];
+        const cat = categoryOfPath(entry.path);
+        const list = byCategory.get(cat) || [];
         list.push(entry);
-        sections.set(entry.section, list);
+        byCategory.set(cat, list);
     }
+    const entityCats = entityCategories();
+    const entityCatSet = new Set(entityCats);
+    const known = [...entityCats, ...FLAT_CATEGORIES];
+    const orderedCategories = [
+        ...known.filter((c) => byCategory.has(c)),
+        ...[...byCategory.keys()].filter((c) => !known.includes(c)).sort(),
+    ];
     const lines = [
         "# Wiki Index",
         "",
@@ -196,19 +238,52 @@ function writeIndexInternal(entries) {
         `Last updated: ${new Date().toISOString().slice(0, 10)}`,
         "",
     ];
-    for (const [section, items] of sections) {
-        lines.push(`## ${section}`, "");
-        for (const item of items) {
-            let line = `- [${item.title}](${item.path}) — ${item.summary}`;
-            if (item.tags?.length)
-                line += ` | tags: ${item.tags.join(", ")}`;
-            if (item.updated)
-                line += ` | updated: ${item.updated}`;
-            lines.push(line);
+    for (const cat of orderedCategories) {
+        const items = byCategory.get(cat);
+        lines.push(`## ${humanize(cat)}`, "");
+        if (entityCatSet.has(cat)) {
+            // Two-level layout: topic directory -> overview (index.md) + facet pages.
+            // Pages not yet in canonical <category>/<topic>/<file> shape are listed as
+            // plain bullets (they'll be relocated by the topic-structure migration).
+            const byTopic = new Map();
+            const ungrouped = [];
+            for (const entry of items) {
+                const topic = topicOfPath(entry.path);
+                if (!topic) {
+                    ungrouped.push(entry);
+                    continue;
+                }
+                const list = byTopic.get(topic) || [];
+                list.push(entry);
+                byTopic.set(topic, list);
+            }
+            for (const topic of [...byTopic.keys()].sort()) {
+                const topicItems = byTopic.get(topic);
+                const overview = topicItems.find((e) => isTopicIndexFile(e.path));
+                const facets = topicItems
+                    .filter((e) => !isTopicIndexFile(e.path))
+                    .sort((a, b) => a.path.localeCompare(b.path));
+                if (overview) {
+                    lines.push(renderEntryLine(overview));
+                }
+                else {
+                    lines.push(`- **${humanize(topic)}** _(no overview page)_`);
+                }
+                for (const facet of facets)
+                    lines.push(renderEntryLine(facet, "  "));
+            }
+            for (const entry of ungrouped.sort((a, b) => a.path.localeCompare(b.path))) {
+                lines.push(renderEntryLine(entry));
+            }
+        }
+        else {
+            for (const entry of [...items].sort((a, b) => a.path.localeCompare(b.path))) {
+                lines.push(renderEntryLine(entry));
+            }
         }
         lines.push("");
     }
-    if (sections.size === 0) {
+    if (orderedCategories.length === 0) {
         lines.push("## Pages", "", "_(No pages yet.)_", "");
     }
     writeIndexFile(lines.join("\n"));

package/dist/wiki/index-manager.test.js

@@ -73,6 +73,25 @@ test("parseIndex self-heals an empty index from on-disk pages", async () => {
     ]);
     assert.match(wikiFs.readIndexFile(), /\[Vision\]\(pages\/team\/vision\.md\)/);
 });
+test("the index renders entity categories as topic groups with nested facet pages", async () => {
+    const { indexManager, wikiFs } = await loadModules();
+    wikiFs.writePage("pages/projects/chapterhouse/index.md", "---\ntitle: Chapterhouse\nupdated: 2026-05-09\n---\n\n# Chapterhouse\n\nThe per-session orchestrator.\n");
+    wikiFs.writePage("pages/projects/chapterhouse/decisions.md", "---\ntitle: Chapterhouse Decisions\nupdated: 2026-05-09\n---\n\n# Decisions\n\nUse SSE for streaming.\n");
+    wikiFs.writePage("pages/preferences.md", "---\ntitle: Preferences\n---\n\n# Preferences\n\nDark mode.\n");
+    indexManager.rebuildIndexFromPages();
+    const index = wikiFs.readIndexFile();
+    assert.match(index, /## Projects/);
+    assert.match(index, /^- \[Chapterhouse\]\(pages\/projects\/chapterhouse\/index\.md\) — /m);
+    assert.match(index, /^ {2}- \[Chapterhouse Decisions\]\(pages\/projects\/chapterhouse\/decisions\.md\) — /m);
+    assert.match(index, /## Preferences/);
+    // Indented facet bullets must still round-trip through parseIndex.
+    const paths = indexManager.parseIndex().map((entry) => entry.path).sort();
+    assert.deepEqual(paths, [
+        "pages/preferences.md",
+        "pages/projects/chapterhouse/decisions.md",
+        "pages/projects/chapterhouse/index.md",
+    ]);
+});
 test("searchIndex ranks strong metadata matches and falls back to page bodies", async () => {
     const { indexManager, wikiFs } = await loadModules();
     wikiFs.writePage("pages/team/api.md", "# API\n\nObservability budget and telemetry plans.\n");

package/dist/wiki/migrate-topics.js

@@ -0,0 +1,132 @@
+// ---------------------------------------------------------------------------
+// One-time migration: enforce the topic-directory structure for entity
+// categories (pages/<category>/<topic-slug>/index.md + facet pages).
+//
+// Fixes wikis created before the structure was enforced, e.g.:
+//   pages/projects/chapterhouse.md               -> pages/projects/chapterhouse/index.md
+//   pages/projects/chapterhouse-feature-ideas.md -> pages/projects/chapterhouse/feature-ideas.md
+//   pages/projects/chapterhouse/decisions.md     -> (already correct, left alone)
+// ---------------------------------------------------------------------------
+import { existsSync, readdirSync, statSync } from "fs";
+import { join } from "path";
+import { getState, setState } from "../store/db.js";
+import { WIKI_PAGES_DIR } from "../paths.js";
+import { ensureWikiStructure, readPage, writePage, deletePage, listPages } from "./fs.js";
+import { rebuildIndexFromPages } from "./index-manager.js";
+import { appendLog } from "./log-manager.js";
+import { entityCategories, slugify } from "./topic-structure.js";
+import { childLogger } from "../util/logger.js";
+const log = childLogger("wiki:migrate-topics");
+const TOPIC_STRUCTURE_KEY = "wiki_topic_structure_v1";
+export function shouldEnforceTopics() {
+    return getState(TOPIC_STRUCTURE_KEY) !== "true";
+}
+function dirNamesUnder(absDir) {
+    if (!existsSync(absDir))
+        return [];
+    return readdirSync(absDir, { withFileTypes: true })
+        .filter((e) => e.isDirectory())
+        .map((e) => e.name);
+}
+function fileBaseNamesUnder(absDir) {
+    if (!existsSync(absDir))
+        return [];
+    return readdirSync(absDir, { withFileTypes: true })
+        .filter((e) => e.isFile() && e.name.endsWith(".md"))
+        .map((e) => e.name.replace(/\.md$/i, ""));
+}
+function stripFrontmatter(content) {
+    return content.replace(/^---\s*\n[\s\S]*?\n---\s*\n?/, "");
+}
+/** Move src -> dest. If dest exists, merge src's body into it. Returns true if anything happened. */
+function moveOrMerge(srcRel, destRel, today) {
+    if (srcRel === destRel)
+        return false;
+    const srcContent = readPage(srcRel);
+    if (srcContent == null)
+        return false;
+    const destContent = readPage(destRel);
+    if (destContent != null) {
+        const merged = `${destContent.trimEnd()}\n\n<!-- merged from ${srcRel} on ${today} -->\n\n${stripFrontmatter(srcContent).trim()}\n`;
+        writePage(destRel, merged);
+    }
+    else {
+        writePage(destRel, srcContent);
+    }
+    deletePage(srcRel);
+    appendLog("migrate", `topic-structure: ${srcRel} -> ${destRel}${destContent != null ? " (merged)" : ""}`);
+    log.info({ from: srcRel, to: destRel, merged: destContent != null }, "moved wiki page into topic structure");
+    return true;
+}
+/**
+ * Bring the wiki page tree into compliance with the topic structure.
+ * Idempotent; safe to call repeatedly. Returns the number of pages moved/merged.
+ */
+export function enforceTopicStructure() {
+    ensureWikiStructure();
+    const today = new Date().toISOString().slice(0, 10);
+    let moves = 0;
+    for (const cat of entityCategories()) {
+        const catAbs = join(WIKI_PAGES_DIR, cat);
+        if (!existsSync(catAbs) || !statSync(catAbs).isDirectory()) {
+            // Also handle a bare `pages/<cat>.md` flat file for an entity category.
+            const bareFlat = `pages/${cat}.md`;
+            if (readPage(bareFlat) != null) {
+                if (moveOrMerge(bareFlat, `pages/${cat}/general/index.md`, today)) {
+                    moves++;
+                    log.warn({ page: bareFlat }, "moved entity-category flat file to a 'general' topic; consider splitting it");
+                }
+            }
+            continue;
+        }
+        // Topics already represented by a directory under pages/<cat>/.
+        const existingDirs = new Set(dirNamesUnder(catAbs));
+        // All bare files directly under pages/<cat>/ (the things that need relocating).
+        const bareFiles = fileBaseNamesUnder(catAbs);
+        // The full set of candidate topic stems: existing dirs + every bare file stem.
+        const topicSet = new Set([...existingDirs, ...bareFiles]);
+        for (const base of bareFiles) {
+            const srcRel = `pages/${cat}/${base}.md`;
+            // Is `base` a facet of some other topic T (i.e. base === "T-<facet>")? Pick the longest such T.
+            let facetOf;
+            let facetName = "";
+            for (const t of topicSet) {
+                if (t === base)
+                    continue;
+                if (base.startsWith(`${t}-`) && t.length > (facetOf?.length ?? 0)) {
+                    facetOf = t;
+                    facetName = base.slice(t.length + 1);
+                }
+            }
+            if (facetOf) {
+                const dest = `pages/${cat}/${slugify(facetOf)}/${slugify(facetName) || "notes"}.md`;
+                if (moveOrMerge(srcRel, dest, today))
+                    moves++;
+            }
+            else {
+                const dest = `pages/${cat}/${slugify(base)}/index.md`;
+                if (moveOrMerge(srcRel, dest, today))
+                    moves++;
+            }
+        }
+    }
+    if (moves > 0) {
+        rebuildIndexFromPages();
+        appendLog("migrate", `topic-structure: ${moves} page(s) relocated; index rebuilt`);
+    }
+    else {
+        // Still rebuild once so the index picks up the hierarchical layout.
+        rebuildIndexFromPages();
+    }
+    // Sanity log of anything still off (non-blocking).
+    for (const p of listPages()) {
+        const segs = p.replace(/^pages\//, "").split("/").filter(Boolean);
+        if (entityCategories().includes(segs[0]) && segs.length !== 3) {
+            log.warn({ page: p }, "wiki page still not in canonical topic shape after migration");
+        }
+    }
+    setState(TOPIC_STRUCTURE_KEY, "true");
+    log.info({ moves }, "topic-structure migration complete");
+    return moves;
+}
+//# sourceMappingURL=migrate-topics.js.map

package/dist/wiki/migrate-topics.test.js

@@ -0,0 +1,57 @@
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+const repoRoot = process.cwd();
+const sandboxRoot = join(repoRoot, ".test-work", `wiki-migrate-topics-${process.pid}`);
+process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+async function loadModules() {
+    const nonce = `${Date.now()}-${Math.random()}`;
+    const migrate = await import(new URL(`./migrate-topics.js?case=${nonce}`, import.meta.url).href);
+    const wikiFs = await import(new URL(`./fs.js?case=${nonce}`, import.meta.url).href);
+    return { migrate, wikiFs };
+}
+test.beforeEach(() => {
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    rmSync(sandboxRoot, { recursive: true, force: true });
+});
+test.after(() => {
+    rmSync(sandboxRoot, { recursive: true, force: true });
+});
+test("enforceTopicStructure relocates bare entity pages and folds facet pages", async () => {
+    const { migrate, wikiFs } = await loadModules();
+    wikiFs.ensureWikiStructure();
+    wikiFs.writePage("pages/projects/chapterhouse.md", "---\ntitle: Chapterhouse\n---\n\n# Chapterhouse\n\n- Source at ~/projects/chapterhouse\n");
+    wikiFs.writePage("pages/projects/chapterhouse-feature-ideas.md", "---\ntitle: Chapterhouse Feature Ideas\n---\n\n# Feature Ideas\n\n- Add wiki topics\n");
+    wikiFs.writePage("pages/projects/chapterhouse/decisions.md", "---\ntitle: Decisions\n---\n\n# Decisions\n\n- Use SSE\n");
+    wikiFs.writePage("pages/conversations/2026-05-09.md", "# 2026-05-09\n\nDaily summary.\n");
+    const moves = migrate.enforceTopicStructure();
+    assert.equal(moves, 2);
+    assert.equal(wikiFs.pageExists("pages/projects/chapterhouse.md"), false);
+    assert.equal(wikiFs.pageExists("pages/projects/chapterhouse-feature-ideas.md"), false);
+    assert.equal(wikiFs.pageExists("pages/projects/chapterhouse/index.md"), true);
+    assert.equal(wikiFs.pageExists("pages/projects/chapterhouse/feature-ideas.md"), true);
+    assert.equal(wikiFs.pageExists("pages/projects/chapterhouse/decisions.md"), true);
+    // Conversations are exempt and untouched.
+    assert.equal(wikiFs.pageExists("pages/conversations/2026-05-09.md"), true);
+    assert.match(wikiFs.readPage("pages/projects/chapterhouse/index.md") ?? "", /Source at ~\/projects\/chapterhouse/);
+    assert.match(wikiFs.readPage("pages/projects/chapterhouse/feature-ideas.md") ?? "", /Add wiki topics/);
+    // Index reflects the new shape.
+    assert.match(wikiFs.readIndexFile(), /^- \[Chapterhouse\]\(pages\/projects\/chapterhouse\/index\.md\) — /m);
+    assert.match(wikiFs.readIndexFile(), /^ {2}- \[.+\]\(pages\/projects\/chapterhouse\/feature-ideas\.md\) — /m);
+    // Idempotent.
+    assert.equal(migrate.enforceTopicStructure(), 0);
+});
+test("enforceTopicStructure merges into an existing topic index instead of clobbering it", async () => {
+    const { migrate, wikiFs } = await loadModules();
+    wikiFs.ensureWikiStructure();
+    wikiFs.writePage("pages/people/brian/index.md", "---\ntitle: Brian\n---\n\n# Brian\n\n- Likes Go\n");
+    wikiFs.writePage("pages/people/brian.md", "---\ntitle: Brian\n---\n\n# Brian\n\n- Based in the US\n");
+    const moves = migrate.enforceTopicStructure();
+    assert.equal(moves, 1);
+    assert.equal(wikiFs.pageExists("pages/people/brian.md"), false);
+    const merged = wikiFs.readPage("pages/people/brian/index.md") ?? "";
+    assert.match(merged, /Likes Go/);
+    assert.match(merged, /Based in the US/);
+});
+//# sourceMappingURL=migrate-topics.test.js.map

package/dist/wiki/topic-structure.js

@@ -0,0 +1,167 @@
+// ---------------------------------------------------------------------------
+// Wiki topic structure: the canonical layout rules for pages/.
+//
+// Entity categories (projects, people, orgs, tools, topics, areas by default)
+// require a topic-level directory: pages/<category>/<topic-slug>/<page>.md,
+// where index.md is the topic's overview page and other files are facets.
+//
+// Flat categories (preferences, facts, routines, decisions) stay as single
+// files: pages/<category>.md.
+//
+// Some prefixes (conversations/, team/, okrs/, kpis/, shared/) follow their
+// own conventions and are exempt from these rules.
+// ---------------------------------------------------------------------------
+import { config } from "../config.js";
+import { normalizeWikiPath } from "./path-utils.js";
+/**
+ * Flat categories: each is a single file at pages/<category>.md.
+ * Note: `decisions` is intentionally NOT flat — a decision is always recorded as a
+ * `decisions.md` facet under the entity it concerns (e.g. pages/projects/chapterhouse/decisions.md).
+ */
+export const FLAT_CATEGORIES = ["preferences", "facts", "routines"];
+/** Path prefixes (relative to the wiki root) that follow their own conventions. */
+export const EXEMPT_PREFIXES = [
+    "pages/conversations/",
+    "pages/team/",
+    "pages/okrs/",
+    "pages/kpis/",
+    "pages/shared/",
+];
+/** Map a `remember`-style category name to its directory under pages/. */
+const CATEGORY_DIR_MAP = {
+    person: "people",
+    people: "people",
+    project: "projects",
+    projects: "projects",
+    org: "orgs",
+    orgs: "orgs",
+    organization: "orgs",
+    tool: "tools",
+    tools: "tools",
+    topic: "topics",
+    topics: "topics",
+    area: "areas",
+    areas: "areas",
+    preference: "preferences",
+    preferences: "preferences",
+    fact: "facts",
+    facts: "facts",
+    routine: "routines",
+    routines: "routines",
+    decision: "decisions",
+    decisions: "decisions",
+};
+export function getCategoryDir(category) {
+    return CATEGORY_DIR_MAP[category.toLowerCase()] || category.toLowerCase();
+}
+/** The active list of entity-category directories (configurable via WIKI_ENTITY_CATEGORIES). */
+export function entityCategories() {
+    return config.wikiEntityCategories;
+}
+function isEntityCategory(dir) {
+    return entityCategories().includes(dir);
+}
+function isFlatCategory(dir) {
+    return FLAT_CATEGORIES.includes(dir);
+}
+function isExemptPath(relativePath) {
+    return EXEMPT_PREFIXES.some((p) => relativePath.startsWith(p));
+}
+/** Slugify a free-text name into a wiki-safe path segment. */
+export function slugify(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        || "untitled";
+}
+/**
+ * Canonical path for an entity topic page.
+ * topicPagePath("project", "Chapterhouse")              -> "pages/projects/chapterhouse/index.md"
+ * topicPagePath("project", "Chapterhouse", "decisions") -> "pages/projects/chapterhouse/decisions.md"
+ */
+export function topicPagePath(category, entity, facet = "index") {
+    const dir = getCategoryDir(category);
+    const topic = slugify(entity);
+    const page = slugify(facet) || "index";
+    return `pages/${dir}/${topic}/${page}.md`;
+}
+const SLUG_RE = /^[a-z0-9][a-z0-9-]*$/;
+/**
+ * Validate that a tool-writable wiki page path conforms to the canonical layout.
+ * Assumes the path has already passed the basic safety checks in assertPagePath
+ * (under pages/, ends in .md, no traversal).
+ */
+export function validateTopicPath(relativePath) {
+    const path = normalizeWikiPath(relativePath);
+    if (!path.startsWith("pages/")) {
+        // assertPagePath handles this; nothing topic-structural to add.
+        return { ok: true };
+    }
+    if (isExemptPath(path)) {
+        return { ok: true };
+    }
+    const rest = path.slice("pages/".length); // e.g. "projects/chapterhouse/index.md"
+    const segments = rest.split("/").filter(Boolean);
+    // For a single-segment path the "category" is the bare filename (pages/preferences.md).
+    const topDir = segments.length === 1 ? segments[0].replace(/\.md$/i, "") : (segments[0] ?? "");
+    if (isFlatCategory(topDir)) {
+        if (segments.length === 1 && rest === `${topDir}.md`) {
+            return { ok: true };
+        }
+        return {
+            ok: false,
+            reason: `'${topDir}' is a flat category and must be a single file.`,
+            suggestion: `pages/${topDir}.md`,
+        };
+    }
+    if (isEntityCategory(topDir)) {
+        if (segments.length === 2) {
+            // pages/projects/foo.md  ->  pages/projects/foo/index.md
+            const base = slugify(segments[1].replace(/\.md$/i, ""));
+            return {
+                ok: false,
+                reason: `Entity category '${topDir}' requires a topic directory: pages/${topDir}/<topic>/<page>.md. ` +
+                    `'index.md' is the topic's overview page.`,
+                suggestion: `pages/${topDir}/${base}/index.md`,
+            };
+        }
+        if (segments.length !== 3) {
+            const flat = segments.slice(1, -1).map((s) => slugify(s.replace(/\.md$/i, ""))).filter(Boolean);
+            const topic = flat[0] || "topic";
+            const page = slugify(segments[segments.length - 1].replace(/\.md$/i, "")) || "index";
+            return {
+                ok: false,
+                reason: `Entity category '${topDir}' allows exactly one topic level: pages/${topDir}/<topic>/<page>.md. ` +
+                    `Got ${segments.length} path segments.`,
+                suggestion: `pages/${topDir}/${topic}/${page}.md`,
+            };
+        }
+        const [, topic, file] = segments;
+        const pageSlug = file.replace(/\.md$/i, "");
+        if (!SLUG_RE.test(topic) || !SLUG_RE.test(pageSlug)) {
+            return {
+                ok: false,
+                reason: `Topic and page names must be lowercase slugs ([a-z0-9-]).`,
+                suggestion: `pages/${topDir}/${slugify(topic)}/${slugify(pageSlug) || "index"}.md`,
+            };
+        }
+        return { ok: true };
+    }
+    // Unknown top-level directory.
+    const valid = [...entityCategories(), ...FLAT_CATEGORIES].sort().join(", ");
+    return {
+        ok: false,
+        reason: `'${topDir}' is not a recognized wiki category. ` +
+            `Use one of: ${valid} (entity categories take a topic directory: pages/<category>/<topic>/<page>.md). ` +
+            `Conversations and team pages are written by the system.`,
+    };
+}
+/** Convenience: returns the error message string for an invalid path, or undefined if valid. */
+export function topicPathError(relativePath) {
+    const result = validateTopicPath(relativePath);
+    if (result.ok)
+        return undefined;
+    return result.suggestion ? `${result.reason} Use: ${result.suggestion}` : result.reason;
+}
+//# sourceMappingURL=topic-structure.js.map

package/dist/wiki/topic-structure.test.js

@@ -0,0 +1,74 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { getCategoryDir, slugify, topicPagePath, validateTopicPath, topicPathError, } from "./topic-structure.js";
+test("getCategoryDir maps category names to directories", () => {
+    assert.equal(getCategoryDir("project"), "projects");
+    assert.equal(getCategoryDir("projects"), "projects");
+    assert.equal(getCategoryDir("person"), "people");
+    assert.equal(getCategoryDir("org"), "orgs");
+    assert.equal(getCategoryDir("tool"), "tools");
+    assert.equal(getCategoryDir("topic"), "topics");
+    assert.equal(getCategoryDir("area"), "areas");
+    assert.equal(getCategoryDir("decision"), "decisions");
+    assert.equal(getCategoryDir("preference"), "preferences");
+});
+test("slugify normalizes free text into a safe path segment", () => {
+    assert.equal(slugify("Chapter House!"), "chapter-house");
+    assert.equal(slugify("  --Foo_Bar--  "), "foo-bar");
+    assert.equal(slugify("v0.3.14"), "v0-3-14");
+    assert.equal(slugify("!!!"), "untitled");
+});
+test("topicPagePath builds canonical paths", () => {
+    assert.equal(topicPagePath("project", "Chapterhouse"), "pages/projects/chapterhouse/index.md");
+    assert.equal(topicPagePath("project", "Chapterhouse", "decisions"), "pages/projects/chapterhouse/decisions.md");
+    assert.equal(topicPagePath("person", "Brian K"), "pages/people/brian-k/index.md");
+    assert.equal(topicPagePath("tool", "Kubernetes"), "pages/tools/kubernetes/index.md");
+});
+test("validateTopicPath accepts canonical and exempt paths", () => {
+    assert.deepEqual(validateTopicPath("pages/projects/chapterhouse/index.md"), { ok: true });
+    assert.deepEqual(validateTopicPath("pages/projects/chapterhouse/decisions.md"), { ok: true });
+    assert.deepEqual(validateTopicPath("pages/people/brian/index.md"), { ok: true });
+    assert.deepEqual(validateTopicPath("pages/preferences.md"), { ok: true });
+    assert.deepEqual(validateTopicPath("pages/facts.md"), { ok: true });
+    assert.deepEqual(validateTopicPath("pages/conversations/2026-05-12.md"), { ok: true });
+    assert.deepEqual(validateTopicPath("pages/team/onboarding.md"), { ok: true });
+    assert.deepEqual(validateTopicPath("pages/okrs/2026-Q2.md"), { ok: true });
+});
+test("validateTopicPath rejects a bare entity-category file and suggests the topic index", () => {
+    const r = validateTopicPath("pages/projects/chapterhouse.md");
+    assert.equal(r.ok, false);
+    assert.equal(r.ok === false && r.suggestion, "pages/projects/chapterhouse/index.md");
+});
+test("validateTopicPath rejects entity paths that nest too deep", () => {
+    const r = validateTopicPath("pages/projects/chapterhouse/sub/deep.md");
+    assert.equal(r.ok, false);
+    assert.equal(r.ok === false && r.suggestion, "pages/projects/chapterhouse/deep.md");
+});
+test("validateTopicPath rejects a flat category used as a directory", () => {
+    const r = validateTopicPath("pages/preferences/foo.md");
+    assert.equal(r.ok, false);
+    assert.equal(r.ok === false && r.suggestion, "pages/preferences.md");
+});
+test("validateTopicPath treats `decisions` as an entity facet, not a flat page", () => {
+    // A standalone pages/decisions.md is no longer valid…
+    assert.equal(validateTopicPath("pages/decisions.md").ok, false);
+    // …decisions live as a facet under the entity they concern.
+    assert.deepEqual(validateTopicPath("pages/projects/chapterhouse/decisions.md"), { ok: true });
+    assert.deepEqual(validateTopicPath("pages/tools/kubernetes/decisions.md"), { ok: true });
+});
+test("validateTopicPath rejects unknown top-level categories", () => {
+    const r = validateTopicPath("pages/randomstuff/foo.md");
+    assert.equal(r.ok, false);
+    assert.match(r.ok === false ? r.reason : "", /not a recognized wiki category/);
+});
+test("validateTopicPath rejects non-slug topic or page names", () => {
+    const r = validateTopicPath("pages/projects/Chapter House/index.md");
+    assert.equal(r.ok, false);
+    assert.equal(r.ok === false && r.suggestion, "pages/projects/chapter-house/index.md");
+});
+test("topicPathError returns a message for invalid paths and undefined for valid ones", () => {
+    assert.equal(topicPathError("pages/projects/chapterhouse/index.md"), undefined);
+    assert.equal(topicPathError("pages/preferences.md"), undefined);
+    assert.match(String(topicPathError("pages/projects/chapterhouse.md")), /Use: pages\/projects\/chapterhouse\/index\.md/);
+});
+//# sourceMappingURL=topic-structure.test.js.map

package/package.json

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