chapterhouse 0.1.1

package/dist/copilot/client.test.js

@@ -0,0 +1,100 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+test("getClient creates and caches a started Copilot client", async (t) => {
+    const instances = [];
+    class FakeCopilotClient {
+        options;
+        startCalls = 0;
+        stopCalls = 0;
+        constructor(options) {
+            this.options = options;
+            instances.push(this);
+        }
+        async start() {
+            this.startCalls++;
+        }
+        async stop() {
+            this.stopCalls++;
+        }
+    }
+    t.mock.module("@github/copilot-sdk", {
+        namedExports: { CopilotClient: FakeCopilotClient },
+    });
+    t.mock.module("../config.js", {
+        namedExports: {
+            config: { copilotAuthToken: "ghu_test_token" },
+        },
+    });
+    const clientModule = await import(new URL(`./client.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
+    const first = await clientModule.getClient();
+    const second = await clientModule.getClient();
+    assert.strictEqual(first, second);
+    assert.equal(instances.length, 1);
+    assert.deepEqual(instances[0]?.options, {
+        autoStart: true,
+        autoRestart: true,
+        gitHubToken: "ghu_test_token",
+    });
+    assert.equal(instances[0]?.startCalls, 1);
+});
+test("resetClient stops the current client best-effort and replaces it", async (t) => {
+    let stopFailures = 1;
+    const instances = [];
+    class FakeCopilotClient {
+        stopCalls = 0;
+        constructor(_options) {
+            instances.push(this);
+        }
+        async start() { }
+        async stop() {
+            this.stopCalls++;
+            if (stopFailures > 0) {
+                stopFailures--;
+                throw new Error("stop failed");
+            }
+        }
+    }
+    t.mock.module("@github/copilot-sdk", {
+        namedExports: { CopilotClient: FakeCopilotClient },
+    });
+    t.mock.module("../config.js", {
+        namedExports: {
+            config: { copilotAuthToken: "" },
+        },
+    });
+    const clientModule = await import(new URL(`./client.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
+    const first = await clientModule.getClient();
+    const second = await clientModule.resetClient();
+    assert.notStrictEqual(first, second);
+    assert.equal(instances.length, 2);
+    assert.equal(instances[0]?.stopCalls, 1);
+});
+test("stopClient tears down the cached client so the next getClient call recreates it", async (t) => {
+    const instances = [];
+    class FakeCopilotClient {
+        stopCalls = 0;
+        constructor(_options) {
+            instances.push(this);
+        }
+        async start() { }
+        async stop() {
+            this.stopCalls++;
+        }
+    }
+    t.mock.module("@github/copilot-sdk", {
+        namedExports: { CopilotClient: FakeCopilotClient },
+    });
+    t.mock.module("../config.js", {
+        namedExports: {
+            config: { copilotAuthToken: "" },
+        },
+    });
+    const clientModule = await import(new URL(`./client.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
+    const first = await clientModule.getClient();
+    await clientModule.stopClient();
+    const second = await clientModule.getClient();
+    assert.notStrictEqual(first, second);
+    assert.equal(instances.length, 2);
+    assert.equal(instances[0]?.stopCalls, 1);
+});
+//# sourceMappingURL=client.test.js.map

package/dist/copilot/episode-writer.js

@@ -0,0 +1,219 @@
+// ---------------------------------------------------------------------------
+// Episode writer — deterministic conversation summary backstop
+// Generates daily wiki pages from conversation_log entries.
+// Runs asynchronously after responses — never blocks the user.
+// ---------------------------------------------------------------------------
+import { existsSync } from "fs";
+import { join } from "path";
+import { approveAll } from "@github/copilot-sdk";
+import { getDb, getState, setState } from "../store/db.js";
+import { ensureWikiStructure, getWikiDir, readPage, writePage } from "../wiki/fs.js";
+import { addToIndex } from "../wiki/index-manager.js";
+import { appendLog } from "../wiki/log-manager.js";
+import { withWikiWrite } from "../wiki/lock.js";
+import { setBusy, setIdle } from "../status.js";
+const EPISODE_MODEL = "gpt-4.1";
+const EPISODE_TIMEOUT_MS = 30_000;
+const MIN_TURNS_FOR_SUMMARY = 10;
+const MIN_MINUTES_BETWEEN_SUMMARIES = 30;
+const MAX_TURNS_PER_SUMMARY = 200;
+const LAST_SUMMARIZED_KEY = "last_episode_log_id";
+const LAST_SUMMARY_TIME_KEY = "last_episode_time";
+const IN_PROGRESS_KEY = "episode_in_progress_range";
+export const SYSTEM_PROMPT = `You are a conversation summarizer for an AI assistant called Chapterhouse. You receive conversation log entries and produce a concise, structured summary.
+
+Output format — markdown with YAML frontmatter:
+- Title: "Conversations on YYYY-MM-DD"
+- Key topics discussed (as bullet points)
+- Decisions made
+- Action items or follow-ups
+- Do NOT invent or suggest wiki page links. Only include a cross-references section if you are referencing pages that were explicitly mentioned in this conversation as already existing. If in doubt, omit the cross-references section entirely.
+
+Be concise but capture all important information. Include names, specifics, and context — not vague summaries. Write in third person ("the user asked about...", "Chapterhouse suggested...").`;
+let episodeSession;
+let episodeClient;
+// Single-flight guard: only one episode write can run at a time, and a session
+// crash-recovery on startup will resume any in-progress range marked durably.
+let inFlight;
+async function ensureSession(client) {
+    if (episodeSession && episodeClient === client) {
+        return episodeSession;
+    }
+    if (episodeSession) {
+        episodeSession.destroy().catch(() => { });
+        episodeSession = undefined;
+    }
+    episodeSession = await client.createSession({
+        model: EPISODE_MODEL,
+        streaming: false,
+        systemMessage: { content: SYSTEM_PROMPT },
+        onPermissionRequest: approveAll,
+    });
+    episodeClient = client;
+    return episodeSession;
+}
+export function stripDeadWikiLinks(content, wikiRoot) {
+    const sanitized = content.replace(/\[\[([^\]]+)\]\]/g, (match, rawLinkText) => {
+        const linkText = rawLinkText.trim().replace(/\.md$/i, "");
+        const slugified = linkText
+            .split("/")
+            .map((segment) => segment.trim().toLowerCase().replace(/\s+/g, "-"))
+            .join("/");
+        const candidates = [
+            join(wikiRoot, `${linkText}.md`),
+            join(wikiRoot, `${slugified}.md`),
+            join(wikiRoot, "pages", `${linkText}.md`),
+            join(wikiRoot, "pages", `${slugified}.md`),
+        ];
+        return candidates.some((candidate) => existsSync(candidate)) ? match : linkText;
+    });
+    return stripEmptyCrossReferencesSections(sanitized);
+}
+function stripEmptyCrossReferencesSections(content) {
+    return content
+        .replace(/(^|\n)\*\*Cross-references:\*\*\s*\n([\s\S]*?)(?=\n(?:\*\*[^*\n]+:\*\*|#{1,6}\s|---\s*$)|$)/gi, (match, prefix, body) => (/\[\[[^\]]+\]\]/.test(body) ? match : prefix))
+        .replace(/(^|\n)#{1,6}\s*Cross[- ]references\s*\n([\s\S]*?)(?=\n(?:\*\*[^*\n]+:\*\*|#{1,6}\s|---\s*$)|$)/gi, (match, prefix, body) => (/\[\[[^\]]+\]\]/.test(body) ? match : prefix))
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+/**
+ * Check if a conversation summary is due, and if so, generate one.
+ * Call this after delivering a response — it runs asynchronously.
+ *
+ * Single-flight: overlapping calls coalesce into the in-flight promise so
+ * we never summarize the same log range twice. The "in-progress" range is
+ * recorded BEFORE the LLM call so a crash mid-summary lets us recover or
+ * skip rather than silently re-summarize on next boot.
+ */
+export function maybeWriteEpisode(client) {
+    if (inFlight)
+        return inFlight;
+    inFlight = runEpisode(client).finally(() => { inFlight = undefined; });
+    return inFlight;
+}
+async function runEpisode(client) {
+    let dreaming = false;
+    try {
+        const db = getDb();
+        const lastId = parseInt(getState(LAST_SUMMARIZED_KEY) || "0", 10);
+        const lastTime = parseInt(getState(LAST_SUMMARY_TIME_KEY) || "0", 10);
+        const now = Date.now();
+        // Check time gate
+        if (now - lastTime < MIN_MINUTES_BETWEEN_SUMMARIES * 60 * 1000)
+            return;
+        // If a previous run crashed mid-write, the in-progress marker tells us
+        // which range was being summarized. Skip past it on the next attempt
+        // so we don't repeat work.
+        const prevRange = getState(IN_PROGRESS_KEY);
+        let effectiveLastId = lastId;
+        if (prevRange) {
+            const m = prevRange.match(/^(\d+):(\d+)$/);
+            if (m) {
+                const prevEnd = parseInt(m[2], 10);
+                if (prevEnd > effectiveLastId)
+                    effectiveLastId = prevEnd;
+            }
+        }
+        // Get unsummarized turns (windowed to bound LLM input cost)
+        const rows = db.prepare(`SELECT id, role, content, source, ts FROM conversation_log WHERE id > ? ORDER BY id ASC LIMIT ?`).all(effectiveLastId, MAX_TURNS_PER_SUMMARY);
+        if (rows.length < MIN_TURNS_FOR_SUMMARY)
+            return;
+        const startId = rows[0].id;
+        const endId = rows[rows.length - 1].id;
+        // Durably record the range we're about to summarize, BEFORE any LLM call
+        // or page write. If we crash, the next run will skip past endId.
+        setState(IN_PROGRESS_KEY, `${startId}:${endId}`);
+        // Format conversation for summarization
+        const transcript = rows.map((r) => {
+            const tag = r.role === "user" ? `[${r.source}] User` : r.role === "system" ? `[system]` : "Chapterhouse";
+            const content = r.content.length > 500 ? r.content.slice(0, 500) + "…" : r.content;
+            return `${tag} (${r.ts}): ${content}`;
+        }).join("\n");
+        setBusy("dreaming", "Consolidating memories...");
+        dreaming = true;
+        const session = await ensureSession(client);
+        const result = await session.sendAndWait({ prompt: `Summarize this conversation:\n\n${transcript}` }, EPISODE_TIMEOUT_MS);
+        const generatedSummary = result?.data?.content || "";
+        const summary = stripDeadWikiLinks(generatedSummary, getWikiDir());
+        if (!summary || summary.length < 50) {
+            // Nothing useful — clear the in-progress marker so we can retry later.
+            setState(IN_PROGRESS_KEY, "");
+            return;
+        }
+        // All page+index+state writes go through the wiki write lock so they
+        // can't interleave with remember/forget/wiki_update calls.
+        await withWikiWrite(async () => {
+            ensureWikiStructure();
+            const today = new Date().toISOString().slice(0, 10);
+            const pagePath = `pages/conversations/${today}.md`;
+            const existing = readPage(pagePath);
+            // Idempotency marker: bail out if this exact id-range has already been written.
+            const rangeMarker = `<!-- episode-range:${startId}-${endId} -->`;
+            if (existing && existing.includes(rangeMarker)) {
+                // Already persisted; just advance the checkpoint.
+                setState(LAST_SUMMARIZED_KEY, String(endId));
+                setState(LAST_SUMMARY_TIME_KEY, String(now));
+                setState(IN_PROGRESS_KEY, "");
+                return;
+            }
+            if (existing) {
+                const updated = existing.replace(/^(---[\s\S]*?updated:\s*)[\d-]+/m, `$1${today}`);
+                writePage(pagePath, updated.trimEnd() + `\n\n---\n\n${rangeMarker}\n${summary}\n`);
+            }
+            else {
+                const page = [
+                    "---",
+                    `title: Conversations on ${today}`,
+                    `tags: [conversation, episode]`,
+                    `created: ${today}`,
+                    `updated: ${today}`,
+                    "related: []",
+                    "---",
+                    "",
+                    `# Conversations on ${today}`,
+                    "",
+                    rangeMarker,
+                    "",
+                    summary,
+                    "",
+                ].join("\n");
+                writePage(pagePath, page);
+            }
+            addToIndex({
+                path: pagePath,
+                title: `Conversations on ${today}`,
+                summary: `Daily conversation summary for ${today}`,
+                section: "Conversations",
+                tags: ["conversation", "episode"],
+                updated: today,
+            });
+            appendLog("update", `episode-writer: summarized ${rows.length} turns (ids ${startId}-${endId}) → ${pagePath}`);
+            // Advance checkpoint and clear the in-progress marker atomically (within the lock).
+            setState(LAST_SUMMARIZED_KEY, String(endId));
+            setState(LAST_SUMMARY_TIME_KEY, String(now));
+            setState(IN_PROGRESS_KEY, "");
+        });
+        console.log(`[chapterhouse] Episode writer: summarized ${rows.length} turns (ids ${startId}-${endId}) → pages/conversations/${new Date().toISOString().slice(0, 10)}.md`);
+    }
+    catch (err) {
+        console.log(`[chapterhouse] Episode writer error (non-fatal): ${err instanceof Error ? err.message : err}`);
+        if (episodeSession) {
+            episodeSession.destroy().catch(() => { });
+            episodeSession = undefined;
+        }
+    }
+    finally {
+        if (dreaming) {
+            setIdle();
+        }
+    }
+}
+/** Tear down the episode writer session. */
+export function stopEpisodeWriter() {
+    if (episodeSession) {
+        episodeSession.destroy().catch(() => { });
+        episodeSession = undefined;
+        episodeClient = undefined;
+    }
+}
+//# sourceMappingURL=episode-writer.js.map

package/dist/copilot/episode-writer.test.js

@@ -0,0 +1,41 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import test from "node:test";
+import * as episodeWriter from "./episode-writer.js";
+const tmpRoot = mkdtempSync(join(tmpdir(), "chapterhouse-episode-writer-"));
+test.after(() => {
+    rmSync(tmpRoot, { recursive: true, force: true });
+});
+test("SYSTEM_PROMPT forbids invented wiki links", () => {
+    assert.match(episodeWriter.SYSTEM_PROMPT, /Do NOT invent or suggest wiki page links\./);
+    assert.match(episodeWriter.SYSTEM_PROMPT, /Only include a cross-references section if you are referencing pages that were explicitly mentioned in this conversation as already existing\./);
+});
+test("stripDeadWikiLinks removes missing wiki links and empty cross-references sections", () => {
+    const wikiRoot = join(tmpRoot, "wiki");
+    mkdirSync(join(wikiRoot, "pages"), { recursive: true });
+    writeFileSync(join(wikiRoot, "pages", "existing-page.md"), "# Existing\n");
+    const summary = [
+        "## Summary",
+        "",
+        "**Cross-references:**",
+        "- [[Existing Page]]",
+        "- [[Missing Page]]",
+        "",
+    ].join("\n");
+    const sanitized = episodeWriter.stripDeadWikiLinks(summary, wikiRoot);
+    assert.match(sanitized, /\[\[Existing Page\]\]/);
+    assert.doesNotMatch(sanitized, /\[\[Missing Page\]\]/);
+    assert.match(sanitized, /- Missing Page/);
+    assert.match(sanitized, /\*\*Cross-references:\*\*/);
+    const withoutLiveLinks = episodeWriter.stripDeadWikiLinks([
+        "## Summary",
+        "",
+        "**Cross-references:**",
+        "- [[Missing Page]]",
+        "",
+    ].join("\n"), wikiRoot);
+    assert.doesNotMatch(withoutLiveLinks, /\*\*Cross-references:\*\*/);
+});
+//# sourceMappingURL=episode-writer.test.js.map

package/dist/copilot/mcp-config.js

@@ -0,0 +1,22 @@
+import { readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+/**
+ * Load MCP server configs from ~/.copilot/mcp-config.json.
+ * Returns an empty record if the file doesn't exist or is invalid.
+ */
+export function loadMcpConfig() {
+    const configPath = join(homedir(), ".copilot", "mcp-config.json");
+    try {
+        const raw = readFileSync(configPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed.mcpServers && typeof parsed.mcpServers === "object") {
+            return parsed.mcpServers;
+        }
+        return {};
+    }
+    catch {
+        return {};
+    }
+}
+//# sourceMappingURL=mcp-config.js.map

package/dist/copilot/okr-mapper.js

@@ -0,0 +1,196 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const STOP_WORDS = new Set([
+    "about", "after", "against", "been", "from", "into", "just", "that", "their", "them",
+    "then", "they", "this", "today", "work", "worked", "yesterday",
+]);
+const MIN_HISTORY_CONFIDENCE = 2;
+export class OKRMapper {
+    teamWikiSync;
+    _adoClient;
+    learnedMappings;
+    constructor(teamWikiSync, _adoClient) {
+        this.teamWikiSync = teamWikiSync;
+        this._adoClient = _adoClient;
+        this.learnedMappings = loadLearnedMappings();
+    }
+    recordConfirmedMapping(activity, krId) {
+        const now = new Date().toISOString();
+        for (const token of tokenize(activity)) {
+            const existing = this.learnedMappings[token];
+            this.learnedMappings[token] = {
+                krId,
+                confirmedCount: existing?.krId === krId ? existing.confirmedCount + 1 : 1,
+                lastUsed: now,
+            };
+        }
+        saveLearnedMappings(this.learnedMappings);
+    }
+    async findMatchingKRs(activity, period) {
+        const okrPage = await this.teamWikiSync.fetchPage(`pages/okrs/${period ?? getCurrentQuarter()}.md`);
+        if (!okrPage) {
+            return [];
+        }
+        const activityTokens = tokenize(activity);
+        return parseOKRPageContent(okrPage)
+            .map((kr) => {
+            const score = scoreMatch(activityTokens, kr, this.learnedMappings);
+            const historyBacked = hasHistoricalMatch(activityTokens, kr.krId, this.learnedMappings);
+            return {
+                krId: kr.krId,
+                title: kr.title,
+                objectiveTitle: kr.objectiveTitle,
+                confidence: historyBacked ? "high" : scoreToConfidence(score),
+                score,
+            };
+        })
+            .filter((kr) => kr.score > 0)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, 3)
+            .map(({ score: _score, ...match }) => match);
+    }
+    formatUpdatePrompt(activity, matches) {
+        if (matches.length === 0) {
+            return `You mentioned: "${activity}". I couldn't confidently map that to a team key result yet. Tell me the KR id and delta (0-100), and I'll log it.`;
+        }
+        const [best, ...rest] = matches;
+        if (!best) {
+            return `You mentioned: "${activity}". Tell me the KR id and delta (0-100), and I'll log it.`;
+        }
+        if (rest.length === 0) {
+            return `You mentioned: "${activity}". This looks like it maps to ${best.krId} (${best.title}). Shall I log this as progress? If so, what's the delta (0-100)?`;
+        }
+        const alternatives = rest.map((match) => `${match.krId} (${match.title}, ${match.confidence} confidence)`).join("; ");
+        return `You mentioned: "${activity}". The best match looks like ${best.krId} (${best.title}). I also found ${alternatives}. Which KR should I log this against, and what's the delta (0-100)?`;
+    }
+}
+export function parseOKRPageContent(content) {
+    const lines = content.split("\n");
+    const keyResults = [];
+    let currentObjectiveTitle = "";
+    let currentKeyResult;
+    for (const line of lines) {
+        const objectiveMatch = line.match(/^##\s+[^:]+:\s+(.+)$/);
+        if (objectiveMatch) {
+            currentObjectiveTitle = objectiveMatch[1]?.trim() ?? "";
+            continue;
+        }
+        const keyResultMatch = line.match(/^###\s+([^:]+):\s+(.+)$/);
+        if (keyResultMatch) {
+            currentKeyResult = {
+                krId: keyResultMatch[1]?.trim() ?? "",
+                title: keyResultMatch[2]?.trim() ?? "",
+                objectiveTitle: currentObjectiveTitle,
+                confidence: "low",
+                owner: "",
+            };
+            keyResults.push(currentKeyResult);
+            continue;
+        }
+        if (!currentKeyResult) {
+            continue;
+        }
+        const ownerMatch = line.match(/^- \*\*Owner\*\*:\s+(.+)$/);
+        if (ownerMatch) {
+            currentKeyResult.owner = ownerMatch[1]?.trim() ?? "";
+            continue;
+        }
+        const targetMatch = line.match(/^- \*\*Target\*\*:\s+([0-9.]+)\s*(.*)$/);
+        if (targetMatch) {
+            currentKeyResult.targetValue = Number(targetMatch[1]);
+            currentKeyResult.unit = targetMatch[2]?.trim() || currentKeyResult.unit;
+            continue;
+        }
+        const currentMatch = line.match(/^- \*\*Current\*\*:\s+([0-9.]+)\s*(.*)$/);
+        if (currentMatch) {
+            currentKeyResult.currentValue = Number(currentMatch[1]);
+            currentKeyResult.unit = currentMatch[2]?.trim() || currentKeyResult.unit;
+            continue;
+        }
+        const unitMatch = line.match(/^- \*\*Unit\*\*:\s+(.+)$/);
+        if (unitMatch) {
+            currentKeyResult.unit = unitMatch[1]?.trim() ?? currentKeyResult.unit;
+        }
+    }
+    return keyResults.filter((kr) => kr.krId.length > 0 && kr.title.length > 0);
+}
+function getCurrentQuarter(now = new Date()) {
+    return `${now.getUTCFullYear()}-Q${Math.floor(now.getUTCMonth() / 3) + 1}`;
+}
+function tokenize(value) {
+    return [...new Set(value
+            .toLowerCase()
+            .split(/[^a-z0-9]+/)
+            .map((token) => token.trim())
+            .filter((token) => token.length >= 3)
+            .map((token) => token.replace(/(ing|ed|es|s)$/i, ""))
+            .filter((token) => token.length >= 3)
+            .filter((token) => !STOP_WORDS.has(token))
+            .filter(Boolean))];
+}
+function scoreMatch(activityTokens, keyResult, learnedMappings) {
+    const titleTokens = new Set(tokenize(keyResult.title));
+    const objectiveTokens = new Set(tokenize(keyResult.objectiveTitle));
+    let score = 0;
+    for (const token of activityTokens) {
+        if (titleTokens.has(token)) {
+            score += 2;
+        }
+        if (objectiveTokens.has(token)) {
+            score += 1;
+        }
+        const learned = learnedMappings[token];
+        if (learned?.krId === keyResult.krId && learned.confirmedCount >= MIN_HISTORY_CONFIDENCE) {
+            score += Math.max(3, learned.confirmedCount * 2);
+        }
+    }
+    return score;
+}
+function hasHistoricalMatch(activityTokens, krId, learnedMappings) {
+    return activityTokens.some((token) => {
+        const learned = learnedMappings[token];
+        return learned?.krId === krId && learned.confirmedCount >= MIN_HISTORY_CONFIDENCE;
+    });
+}
+function scoreToConfidence(score) {
+    if (score >= 4) {
+        return "high";
+    }
+    if (score >= 2) {
+        return "medium";
+    }
+    return "low";
+}
+function loadLearnedMappings() {
+    const okrMemoryPath = getOkrMemoryPath();
+    if (!existsSync(okrMemoryPath)) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(okrMemoryPath, "utf-8"));
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function saveLearnedMappings(store) {
+    const wikiDir = getWikiDir();
+    mkdirSync(wikiDir, { recursive: true });
+    writeFileSync(join(wikiDir, ".okr-memory.json"), `${JSON.stringify(store, null, 2)}\n`);
+}
+function getWikiDir() {
+    const configuredHome = process.env.CHAPTERHOUSE_HOME?.trim();
+    if (!configuredHome) {
+        return join(homedir(), ".chapterhouse", "wiki");
+    }
+    const chapterhouseHome = configuredHome.endsWith(".chapterhouse")
+        ? configuredHome
+        : join(configuredHome, ".chapterhouse");
+    return join(chapterhouseHome, "wiki");
+}
+function getOkrMemoryPath() {
+    return join(getWikiDir(), ".okr-memory.json");
+}
+//# sourceMappingURL=okr-mapper.js.map