chapterhouse 0.1.1

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

@@ -0,0 +1,129 @@
+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-index-${process.pid}`);
+process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+async function loadModules() {
+    const nonce = `${Date.now()}-${Math.random()}`;
+    const indexManager = await import(new URL(`./index-manager.js?case=${nonce}`, import.meta.url).href);
+    const wikiFs = await import(new URL(`./fs.js?case=${nonce}`, import.meta.url).href);
+    return { indexManager, wikiFs };
+}
+function resetSandbox() {
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    rmSync(sandboxRoot, { recursive: true, force: true });
+}
+test.beforeEach(() => {
+    resetSandbox();
+});
+test.after(() => {
+    rmSync(sandboxRoot, { recursive: true, force: true });
+});
+test("parseIndex reads sections, summaries, tags, and updated dates", async () => {
+    const { indexManager, wikiFs } = await loadModules();
+    wikiFs.writeIndexFile(`# Wiki Index\n\n## People\n\n- [Ada Lovelace](pages/people/ada.md) — Platform owner | tags: engineer, compiler | updated: 2026-05-01\n\n## Projects\n\n- [Roadmap](pages/projects/roadmap.md) - Shared priorities\n`);
+    assert.deepEqual(indexManager.parseIndex(), [
+        {
+            path: "pages/people/ada.md",
+            title: "Ada Lovelace",
+            summary: "Platform owner",
+            section: "People",
+            tags: ["engineer", "compiler"],
+            updated: "2026-05-01",
+        },
+        {
+            path: "pages/projects/roadmap.md",
+            title: "Roadmap",
+            summary: "Shared priorities",
+            section: "Projects",
+            tags: undefined,
+            updated: undefined,
+        },
+    ]);
+});
+test("buildIndexEntryForPage derives title, metadata, and a trimmed summary from page content", async () => {
+    const { indexManager, wikiFs } = await loadModules();
+    wikiFs.writePage("pages/shared/runbooks/deploy.md", `---\ntitle: Deploy Runbook\ntags: [ops, release]\nupdated: 2026-05-04\n---\n\n# Deploy\n\n${"Deploy carefully ".repeat(20)}\n`);
+    const entry = indexManager.buildIndexEntryForPage("pages/shared/runbooks/deploy.md");
+    assert.deepEqual(entry, {
+        path: "pages/shared/runbooks/deploy.md",
+        title: "Deploy Runbook",
+        summary: `${("Deploy carefully ".repeat(20)).trim().slice(0, 157)}…`,
+        section: "Knowledge",
+        tags: ["ops", "release"],
+        updated: "2026-05-04",
+    });
+});
+test("parseIndex self-heals an empty index from on-disk pages", async () => {
+    const { indexManager, wikiFs } = await loadModules();
+    wikiFs.writePage("pages/team/vision.md", "# Vision\n\nShared direction for the team.\n");
+    wikiFs.writeIndexFile("# Wiki Index\n\n");
+    const entries = indexManager.parseIndex();
+    assert.deepEqual(entries, [
+        {
+            path: "pages/team/vision.md",
+            title: "Vision",
+            summary: "Shared direction for the team.",
+            section: "Knowledge",
+            tags: undefined,
+            updated: undefined,
+        },
+    ]);
+    assert.match(wikiFs.readIndexFile(), /\[Vision\]\(pages\/team\/vision\.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");
+    wikiFs.writePage("pages/team/ops.md", "# Ops\n\nDaily operational notes.\n");
+    indexManager.writeIndex([
+        {
+            path: "pages/team/api.md",
+            title: "API",
+            summary: "Status of the platform",
+            section: "Team",
+            tags: ["api"],
+            updated: new Date().toISOString().slice(0, 10),
+        },
+        {
+            path: "pages/team/ops.md",
+            title: "Operations",
+            summary: "Runbooks and incident work",
+            section: "Team",
+        },
+    ]);
+    const metadataHit = indexManager.searchIndex("api", 1);
+    const bodyFallback = indexManager.searchIndex("telemetry", 1);
+    assert.deepEqual(metadataHit.map((entry) => entry.path), ["pages/team/api.md"]);
+    assert.deepEqual(bodyFallback.map((entry) => entry.path), ["pages/team/api.md"]);
+});
+test("addToIndex, removeFromIndex, and getIndexSummary keep the catalog in sync", async () => {
+    const { indexManager } = await loadModules();
+    indexManager.addToIndex({
+        path: "pages/people/ada.md",
+        title: "Ada Lovelace",
+        summary: "Owns release quality",
+        section: "People",
+        tags: ["qa"],
+        updated: "2026-05-05",
+    });
+    indexManager.addToIndex({
+        path: "pages/projects/launch.md",
+        title: "Launch",
+        summary: "Tracks release milestones",
+        section: "Projects",
+    });
+    indexManager.addToIndex({
+        path: "pages/people/ada.md",
+        title: "Ada Lovelace",
+        summary: "Owns regression coverage",
+        section: "People",
+        tags: ["qa", "testing"],
+        updated: "2026-05-06",
+    });
+    assert.equal(indexManager.removeFromIndex("pages/projects/launch.md"), true);
+    assert.equal(indexManager.removeFromIndex("pages/projects/missing.md"), false);
+    assert.equal(indexManager.getIndexSummary(), "**People**: Ada Lovelace: Owns regression coverage [qa, testing] (2026-05-06)");
+});
+//# sourceMappingURL=index-manager.test.js.map

package/dist/wiki/lock.js

@@ -0,0 +1,26 @@
+// ---------------------------------------------------------------------------
+// In-process serializer for wiki mutations.
+//
+// All wiki state (pages + index.md + log.md) is shared mutable state in flat
+// files. To prevent lost updates and torn writes when remember/forget/wiki_update
+// and the async episode-writer overlap, every mutation must run through
+// withWikiWrite(). Reads do NOT need to acquire the lock — they are protected
+// by atomic file replacement at the FS level.
+// ---------------------------------------------------------------------------
+let chain = Promise.resolve();
+/**
+ * Run an async wiki mutation under the global write lock.
+ * Calls are serialized FIFO. Errors propagate to the caller but do not
+ * break the chain for subsequent writers.
+ */
+export function withWikiWrite(fn) {
+    const next = chain.then(() => fn(), () => fn());
+    // Keep the chain alive even if `next` rejects so the next caller can run.
+    chain = next.catch(() => undefined);
+    return next;
+}
+/** For tests/diagnostics: wait for the current write queue to drain. */
+export function drainWikiWrites() {
+    return chain.then(() => undefined, () => undefined);
+}
+//# sourceMappingURL=lock.js.map

package/dist/wiki/lock.test.js

@@ -0,0 +1,30 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { drainWikiWrites, withWikiWrite } from "./lock.js";
+test("withWikiWrite serializes concurrent writers in FIFO order", async () => {
+    const order = [];
+    await Promise.all([
+        withWikiWrite(async () => {
+            order.push("start-1");
+            await new Promise((resolve) => setTimeout(resolve, 20));
+            order.push("end-1");
+        }),
+        withWikiWrite(async () => {
+            order.push("start-2");
+            order.push("end-2");
+        }),
+    ]);
+    assert.deepEqual(order, ["start-1", "end-1", "start-2", "end-2"]);
+});
+test("withWikiWrite keeps the queue alive after a writer fails", async () => {
+    await assert.rejects(withWikiWrite(async () => {
+        throw new Error("boom");
+    }), /boom/);
+    const seen = [];
+    await withWikiWrite(async () => {
+        seen.push("ran");
+    });
+    await drainWikiWrites();
+    assert.deepEqual(seen, ["ran"]);
+});
+//# sourceMappingURL=lock.test.js.map

package/dist/wiki/log-manager.js

@@ -0,0 +1,20 @@
+// ---------------------------------------------------------------------------
+// Wiki log.md manager — append-only chronological operation log
+// ---------------------------------------------------------------------------
+import { appendFileSync } from "fs";
+import { join } from "path";
+import { WIKI_DIR } from "../paths.js";
+import { ensureWikiStructure } from "./fs.js";
+const LOG_PATH = join(WIKI_DIR, "log.md");
+/**
+ * Append a timestamped entry to log.md.
+ * Format: `## [YYYY-MM-DD HH:MM] type | description`
+ */
+export function appendLog(type, description) {
+    ensureWikiStructure();
+    const now = new Date();
+    const ts = now.toISOString().slice(0, 16).replace("T", " ");
+    const entry = `## [${ts}] ${type} | ${description}\n\n`;
+    appendFileSync(LOG_PATH, entry, "utf-8");
+}
+//# sourceMappingURL=log-manager.js.map

package/dist/wiki/migrate.js

@@ -0,0 +1,306 @@
+// ---------------------------------------------------------------------------
+// One-time migration: SQLite memories → wiki pages
+// ---------------------------------------------------------------------------
+import { getDb, getState, setState } from "../store/db.js";
+import { ensureWikiStructure, writePage, readPage, writeRawSource, deletePage } from "./fs.js";
+import { addToIndex, removeFromIndex } from "./index-manager.js";
+import { appendLog } from "./log-manager.js";
+const MIGRATION_KEY = "wiki_migrated";
+const REORG_KEY = "wiki_reorganized";
+/** Check whether a migration is needed (wiki not yet populated from SQLite). */
+export function shouldMigrate() {
+    return getState(MIGRATION_KEY) !== "true";
+}
+/** Check whether reorganization is needed. */
+export function shouldReorganize() {
+    return getState(MIGRATION_KEY) === "true" && getState(REORG_KEY) !== "true";
+}
+/** Category → wiki page path and section name */
+const CATEGORY_MAP = {
+    preference: { path: "pages/preferences.md", title: "Preferences", section: "Knowledge" },
+    fact: { path: "pages/facts.md", title: "Facts", section: "Knowledge" },
+    project: { path: "pages/projects.md", title: "Projects", section: "Knowledge" },
+    person: { path: "pages/people.md", title: "People", section: "Knowledge" },
+    routine: { path: "pages/routines.md", title: "Routines", section: "Knowledge" },
+};
+/**
+ * Migrate all existing SQLite memories into wiki pages.
+ * Groups memories by category, creates one page per category.
+ * Returns the number of memories migrated.
+ */
+export function migrateMemoriesToWiki() {
+    ensureWikiStructure();
+    const db = getDb();
+    const rows = db.prepare(`SELECT id, category, content, source, created_at FROM memories ORDER BY category, id`).all();
+    if (rows.length === 0) {
+        setState(MIGRATION_KEY, "true");
+        appendLog("migrate", "No memories to migrate (empty table).");
+        return 0;
+    }
+    // Group by category
+    const grouped = {};
+    for (const row of rows) {
+        if (!grouped[row.category])
+            grouped[row.category] = [];
+        grouped[row.category].push(row);
+    }
+    const now = new Date().toISOString().slice(0, 10);
+    for (const [category, items] of Object.entries(grouped)) {
+        const mapping = CATEGORY_MAP[category] || {
+            path: `pages/${category}.md`,
+            title: category.charAt(0).toUpperCase() + category.slice(1),
+            section: "Knowledge",
+        };
+        // Build the page content
+        const lines = [
+            "---",
+            `title: ${mapping.title}`,
+            `tags: [${category}, migrated]`,
+            `created: ${now}`,
+            `updated: ${now}`,
+            "---",
+            "",
+            `# ${mapping.title}`,
+            "",
+            `_Migrated from Chapterhouse's memory store on ${now}._`,
+            "",
+        ];
+        for (const item of items) {
+            lines.push(`- ${item.content} _(${item.source}, ${item.created_at.slice(0, 10)})_`);
+        }
+        lines.push("");
+        // Check if a page already exists (avoid clobbering manual content)
+        const existing = readPage(mapping.path);
+        // Idempotency marker: if the migration block was already appended, skip the
+        // append so re-runs don't duplicate bullets.
+        const MIGRATE_MARKER = `<!-- migrate:${category}:v1 -->`;
+        if (existing) {
+            if (existing.includes(MIGRATE_MARKER)) {
+                // Already migrated; just refresh the index entry.
+                const entry = {
+                    path: mapping.path,
+                    title: mapping.title,
+                    summary: `${items.length} ${category} memories (already migrated)`,
+                    section: mapping.section,
+                };
+                addToIndex(entry);
+                continue;
+            }
+            // Extract only the bullet-point items to append
+            const bulletLines = lines.filter((l) => l.startsWith("- "));
+            writePage(mapping.path, existing + `\n${MIGRATE_MARKER}\n## Migrated Memories\n\n` + bulletLines.join("\n") + "\n");
+        }
+        else {
+            // Embed the marker in fresh pages too so future re-runs are no-ops.
+            lines.splice(lines.length - 1, 0, MIGRATE_MARKER);
+            writePage(mapping.path, lines.join("\n"));
+        }
+        // Update index
+        const entry = {
+            path: mapping.path,
+            title: mapping.title,
+            summary: `${items.length} ${category} memories (migrated from SQLite)`,
+            section: mapping.section,
+        };
+        addToIndex(entry);
+    }
+    const total = rows.length;
+    const categories = Object.keys(grouped).join(", ");
+    appendLog("migrate", `Migrated ${total} memories across categories: ${categories}`);
+    setState(MIGRATION_KEY, "true");
+    console.log(`[chapterhouse] Wiki migration complete: ${total} memories → ${Object.keys(grouped).length} pages`);
+    return total;
+}
+// ---------------------------------------------------------------------------
+// One-time reorganization: flat dump pages → entity pages
+// ---------------------------------------------------------------------------
+// Patterns for junk content to filter out during reorg
+const JUNK_PATTERNS = [
+    /smoke\s*test/i,
+    /re-?smoke/i,
+    /final\s*smoke/i,
+    /test.*memory/i,
+    /testing.*remember/i,
+];
+function isJunk(line) {
+    return JUNK_PATTERNS.some((p) => p.test(line));
+}
+/** Parse bullet points from a wiki page body (stripping frontmatter). */
+function extractBullets(content) {
+    const body = content.replace(/^---[\s\S]*?---\s*/, "");
+    return body.split("\n")
+        .filter((l) => l.trim().startsWith("- "))
+        .map((l) => l.trim());
+}
+/** Detect entity mentions in bullet text for routing. */
+function detectEntity(bullet, category) {
+    // People: look for capitalized names
+    if (category === "person" || category === "people") {
+        const nameMatch = bullet.match(/^-\s+(.+?)\s+(?:is|prefers|likes|works|lives|uses|—)/i);
+        if (nameMatch) {
+            const name = nameMatch[1].replace(/^['"]|['"]$/g, "").trim();
+            if (name.length > 1 && name.length < 40 && /^[A-Z]/.test(name))
+                return name;
+        }
+    }
+    // Projects: look for project names
+    if (category === "project" || category === "projects") {
+        const projMatch = bullet.match(/^-\s+(?:Project\s+)?(.+?)\s+(?:is|uses|runs|—)/i);
+        if (projMatch) {
+            const name = projMatch[1].replace(/^['"]|['"]$/g, "").trim();
+            if (name.length > 1 && name.length < 40)
+                return name;
+        }
+    }
+    return undefined;
+}
+/**
+ * Reorganize wiki pages from flat category dumps into entity pages.
+ * Archives originals to sources/migrated-archive/, filters junk,
+ * splits into entity pages where possible.
+ */
+export function reorganizeWiki() {
+    ensureWikiStructure();
+    const dumpPages = [
+        "pages/preferences.md",
+        "pages/facts.md",
+        "pages/projects.md",
+        "pages/people.md",
+        "pages/routines.md",
+        "pages/decision.md",
+        "pages/task.md",
+    ];
+    const now = new Date().toISOString().slice(0, 10);
+    let pagesCreated = 0;
+    for (const pagePath of dumpPages) {
+        const content = readPage(pagePath);
+        if (!content)
+            continue;
+        // Archive the original
+        const archiveName = `migrated-archive/${pagePath.replace("pages/", "").replace(/\//g, "-")}`;
+        writeRawSource(archiveName, content);
+        const category = pagePath.replace("pages/", "").replace(".md", "");
+        const bullets = extractBullets(content);
+        const validBullets = bullets.filter((b) => !isJunk(b));
+        if (validBullets.length === 0) {
+            // All junk — remove the page
+            deletePage(pagePath);
+            removeFromIndex(pagePath);
+            appendLog("reorg", `Removed junk page: ${pagePath}`);
+            continue;
+        }
+        // Try to split into entity pages
+        const entityGroups = new Map();
+        const ungrouped = [];
+        for (const bullet of validBullets) {
+            const entity = detectEntity(bullet, category);
+            if (entity) {
+                const list = entityGroups.get(entity) || [];
+                list.push(bullet);
+                entityGroups.set(entity, list);
+            }
+            else {
+                ungrouped.push(bullet);
+            }
+        }
+        // Write entity pages
+        const categoryDir = getCategoryDirForReorg(category);
+        for (const [entity, entityBullets] of entityGroups) {
+            const slug = entity.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+            const entityPath = `pages/${categoryDir}/${slug}.md`;
+            const existing = readPage(entityPath);
+            const REORG_MARKER = `<!-- reorg:${entity.toLowerCase()}:v1 -->`;
+            if (existing) {
+                if (existing.includes(REORG_MARKER)) {
+                    // Already reorganized into this entity page; skip duplicate append.
+                    continue;
+                }
+                // Append to existing entity page
+                const updated = existing.replace(/^(---[\s\S]*?updated:\s*)[\d-]+/m, `$1${now}`);
+                writePage(entityPath, updated.trimEnd() + `\n${REORG_MARKER}\n` + entityBullets.join("\n") + "\n");
+            }
+            else {
+                const page = [
+                    "---",
+                    `title: ${entity}`,
+                    `tags: [${category}, migrated]`,
+                    `created: ${now}`,
+                    `updated: ${now}`,
+                    "related: []",
+                    "---",
+                    "",
+                    `# ${entity}`,
+                    "",
+                    REORG_MARKER,
+                    "",
+                    ...entityBullets,
+                    "",
+                ].join("\n");
+                writePage(entityPath, page);
+                pagesCreated++;
+            }
+            addToIndex({
+                path: entityPath,
+                title: entity,
+                summary: `${entityBullets.length} entries about ${entity}`,
+                section: "Knowledge",
+                tags: [category, "migrated"],
+                updated: now,
+            });
+        }
+        // Keep ungrouped bullets in the category page (rewritten clean)
+        if (ungrouped.length > 0) {
+            const title = category.charAt(0).toUpperCase() + category.slice(1);
+            const page = [
+                "---",
+                `title: ${title}`,
+                `tags: [${category}]`,
+                `created: ${now}`,
+                `updated: ${now}`,
+                "related: []",
+                "---",
+                "",
+                `# ${title}`,
+                "",
+                ...ungrouped,
+                "",
+            ].join("\n");
+            writePage(pagePath, page);
+            addToIndex({
+                path: pagePath,
+                title,
+                summary: `${ungrouped.length} ${category} entries`,
+                section: "Knowledge",
+                tags: [category],
+                updated: now,
+            });
+        }
+        else {
+            // All bullets were entity-routed, remove the dump page
+            deletePage(pagePath);
+            removeFromIndex(pagePath);
+        }
+    }
+    setState(REORG_KEY, "true");
+    appendLog("reorg", `Wiki reorganized: ${pagesCreated} entity pages created`);
+    console.log(`[chapterhouse] Wiki reorganization complete: ${pagesCreated} entity pages created`);
+    return pagesCreated;
+}
+function getCategoryDirForReorg(category) {
+    const map = {
+        person: "people",
+        people: "people",
+        project: "projects",
+        projects: "projects",
+        preference: "preferences",
+        preferences: "preferences",
+        fact: "facts",
+        facts: "facts",
+        routine: "routines",
+        routines: "routines",
+        decision: "decisions",
+        task: "tasks",
+    };
+    return map[category] || category;
+}
+//# sourceMappingURL=migrate.js.map

package/dist/wiki/okr.test.js

@@ -0,0 +1,101 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+async function loadOkrTemplateModule() {
+    try {
+        return await import(new URL(`./templates/okr.js?cachebust=${Date.now()}-${Math.random()}`, import.meta.url).href);
+    }
+    catch {
+        return null;
+    }
+}
+test("generateOKRQuarterPage renders objectives, key results, and quarter period", async () => {
+    const okrTemplateModule = await loadOkrTemplateModule();
+    assert.ok(okrTemplateModule, "OKR template module should exist");
+    const page = okrTemplateModule.generateOKRQuarterPage("2026-Q2", [
+        {
+            id: "O1",
+            title: "Raise Azure platform delivery confidence",
+            owner: "Ava Wilson",
+            keyResults: [
+                {
+                    id: "O1-KR1",
+                    title: "Reduce Sev2 incidents in regional deployments",
+                    owner: "Noah Patel",
+                    targetValue: 95,
+                    currentValue: 12,
+                    unit: "%",
+                    dueDate: "2026-06-30",
+                },
+            ],
+        },
+    ]);
+    assert.match(page, /^# OKRs — 2026 Q2/m);
+    assert.match(page, /> Period: 2026-04-01 to 2026-06-30/);
+    assert.match(page, /## O1: Raise Azure platform delivery confidence/);
+    assert.match(page, /\*\*Owner\*\*: Ava Wilson/);
+    assert.match(page, /### O1-KR1: Reduce Sev2 incidents in regional deployments/);
+    assert.match(page, /- \*\*Target\*\*: 95%/);
+    assert.match(page, /- \*\*Current\*\*: 12%/);
+    assert.match(page, /- \*\*ADO Work Item\*\*: <!-- fill in after ADO setup -->/);
+});
+test("generateKPIPage renders a team KPI table", async () => {
+    const okrTemplateModule = await loadOkrTemplateModule();
+    assert.ok(okrTemplateModule, "OKR template module should exist");
+    const page = okrTemplateModule.generateKPIPage([
+        {
+            id: "kpi-release-cadence",
+            name: "Release cadence",
+            owner: "Ava Wilson",
+            target: 8,
+            current: 5,
+            unit: "deployments",
+            frequency: "monthly",
+        },
+    ]);
+    assert.match(page, /^# Team KPIs/m);
+    assert.match(page, /\| KPI \| Owner \| Target \| Current \| Unit \| Frequency \|/);
+    assert.match(page, /\| Release cadence \| Ava Wilson \| 8 \| 5 \| deployments \| monthly \|/);
+});
+test("generateTeamMemberPage renders ownership metadata for a team member", async () => {
+    const okrTemplateModule = await loadOkrTemplateModule();
+    assert.ok(okrTemplateModule, "OKR template module should exist");
+    const page = okrTemplateModule.generateTeamMemberPage({
+        name: "Ava Wilson",
+        email: "ava.wilson@example.com",
+        role: "team-lead",
+        entraObjectId: "11111111-2222-3333-4444-555555555555",
+        okrOwnership: ["O1-KR1", "O2-KR2"],
+    });
+    assert.match(page, /^# Ava Wilson/m);
+    assert.match(page, /\*\*Email\*\*: ava\.wilson@example\.com/);
+    assert.match(page, /\*\*Role\*\*: team-lead/);
+    assert.match(page, /\*\*Entra Object ID\*\*: 11111111-2222-3333-4444-555555555555/);
+    assert.match(page, /## OKR Ownership/);
+    assert.match(page, /- O1-KR1/);
+    assert.match(page, /- O2-KR2/);
+});
+test("generateTeamIndexPage renders a team roster table", async () => {
+    const okrTemplateModule = await loadOkrTemplateModule();
+    assert.ok(okrTemplateModule, "OKR template module should exist");
+    const page = okrTemplateModule.generateTeamIndexPage([
+        {
+            name: "Ava Wilson",
+            email: "ava.wilson@example.com",
+            role: "team-lead",
+            entraObjectId: "11111111-2222-3333-4444-555555555555",
+            okrOwnership: ["O1-KR1", "O2-KR2"],
+        },
+        {
+            name: "Noah Patel",
+            email: "noah.patel@example.com",
+            role: "engineer",
+            entraObjectId: "66666666-7777-8888-9999-000000000000",
+            okrOwnership: ["O1-KR3"],
+        },
+    ]);
+    assert.match(page, /^# Team Directory/m);
+    assert.match(page, /\| Name \| Role \| Email \| Entra Object ID \| OKR Ownership \|/);
+    assert.match(page, /\| Ava Wilson \| team-lead \| ava\.wilson@example\.com \| 11111111-2222-3333-4444-555555555555 \| O1-KR1, O2-KR2 \|/);
+    assert.match(page, /\| Noah Patel \| engineer \| noah\.patel@example\.com \| 66666666-7777-8888-9999-000000000000 \| O1-KR3 \|/);
+});
+//# sourceMappingURL=okr.test.js.map

package/dist/wiki/path-utils.js

@@ -0,0 +1,4 @@
+export function normalizeWikiPath(path) {
+    return path.replace(/\\/g, "/");
+}
+//# sourceMappingURL=path-utils.js.map

package/dist/wiki/path-utils.test.js

@@ -0,0 +1,8 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { normalizeWikiPath } from "./path-utils.js";
+test("normalizeWikiPath converts Windows separators in logical wiki IDs", () => {
+    assert.equal(normalizeWikiPath("pages\\standups\\2026-05-06.md"), "pages/standups/2026-05-06.md");
+    assert.equal(normalizeWikiPath("pages/conversations/2026-05-06.md"), "pages/conversations/2026-05-06.md");
+});
+//# sourceMappingURL=path-utils.test.js.map