obsidian-second-brain 0.1.0 → 0.2.0

package/dist/code-ingest.js

@@ -0,0 +1,289 @@
+import { readdir, readFile, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { compareBytewise } from "./code-boundaries.js";
+import { scanCodeEvidence } from "./code-classify.js";
+import { renderCodePage, tryParseCodePage } from "./code-frontmatter.js";
+import { ensureDirectory, writeFileAtomic } from "./filesystem.js";
+import { appendLogEntry } from "./ingest-writer.js";
+import { applyManagedBlock, CODE_MAPS_MARKERS } from "./managed-section.js";
+import { loadManifest, saveManifest, withManifestEntries } from "./manifest.js";
+export async function runCodeMapIngest(input) {
+    const scan = await scanCodeEvidence(input.rawCodeRoot);
+    const manifest = await loadManifest(input.manifestPath);
+    const captureFailures = input.captureFailures ?? [];
+    const freshQuarantined = scan.quarantined.filter((entry) => manifest.entries[quarantineKey(entry)] === undefined);
+    const byProject = groupByProject(scan.sources);
+    const failures = [...captureFailures];
+    const pagesRendered = [];
+    const pagesPruned = [];
+    const advancedEntries = {};
+    const now = input.now();
+    const date = now.toISOString().slice(0, 10);
+    const ingestedAt = now.toISOString();
+    // PLANNING — pure reads; decides per project whether any work exists.
+    const plans = new Map();
+    for (const [project, evidence] of byProject) {
+        try {
+            plans.set(project, await planProject(input, manifest, project, evidence));
+        }
+        catch (error) {
+            failures.push({
+                project,
+                reason: error instanceof Error ? error.message : "Unknown error"
+            });
+        }
+    }
+    const hasRenderWork = [...plans.values()].some((plan) => plan.renderModules.length > 0 || plan.renderOverview || plan.prunePages.length > 0);
+    if (!hasRenderWork &&
+        failures.length === 0 &&
+        freshQuarantined.length === 0 &&
+        input.evidenceCaptured === 0) {
+        return {
+            failures: [],
+            pagesPruned: [],
+            pagesRendered: [],
+            projects: [...byProject.keys()],
+            quarantined: [],
+            skipped: true
+        };
+    }
+    // RENDER — per-project isolation: a throw records a failure and skips the
+    // manifest advance for THAT project only (design 10).
+    for (const [project, plan] of [...plans.entries()].sort((a, b) => compareBytewise(a[0], b[0]))) {
+        try {
+            const rendered = await renderProject(input, project, plan, date);
+            pagesRendered.push(...rendered.pagesRendered);
+            pagesPruned.push(...rendered.pagesPruned);
+            for (const source of [
+                ...(plan.evidence.skeleton === undefined ? [] : [plan.evidence.skeleton]),
+                ...plan.evidence.modules
+            ]) {
+                advancedEntries[source.key] = {
+                    contentHash: source.bodyHash,
+                    ingestedAt
+                };
+            }
+        }
+        catch (error) {
+            failures.push({
+                project,
+                reason: error instanceof Error ? error.message : "Unknown error"
+            });
+        }
+    }
+    // BOOKKEEPING — pages (index) -> report -> log -> manifest LAST.
+    await updateIndex(input.indexPath, byProject, failures);
+    let report;
+    if (input.reportWriter) {
+        report = await input.reportWriter.addCodeMap({
+            evidenceCaptured: input.evidenceCaptured,
+            failures,
+            pagesPruned,
+            pagesRendered,
+            quarantined: freshQuarantined
+        });
+    }
+    if (pagesRendered.length > 0 ||
+        pagesPruned.length > 0 ||
+        failures.length > 0 ||
+        freshQuarantined.length > 0 ||
+        report !== undefined) {
+        await appendLogEntry(input.logPath, buildLogEntry({ date, failures, pagesPruned, pagesRendered, quarantined: freshQuarantined, reportLink: report?.wikiLink }));
+    }
+    const quarantineEntries = Object.fromEntries(freshQuarantined.map((entry) => [
+        quarantineKey(entry),
+        { contentHash: entry.contentHash, ingestedAt }
+    ]));
+    await saveManifest(input.manifestPath, withManifestEntries(manifest, { ...advancedEntries, ...quarantineEntries }));
+    return {
+        failures,
+        pagesPruned,
+        pagesRendered,
+        projects: [...byProject.keys()],
+        quarantined: freshQuarantined,
+        ...(report ? { reportPath: report.path } : {}),
+        skipped: false
+    };
+}
+function quarantineKey(entry) {
+    return `quarantine:code:${entry.contentHash}`;
+}
+function groupByProject(sources) {
+    const projects = new Map();
+    for (const source of sources) {
+        const entry = projects.get(source.project) ?? { modules: [] };
+        if (source.kind === "skeleton") {
+            entry.skeleton = source;
+        }
+        else {
+            entry.modules.push(source);
+        }
+        projects.set(source.project, entry);
+    }
+    for (const entry of projects.values()) {
+        entry.modules.sort((a, b) => compareBytewise(a.slug ?? "", b.slug ?? ""));
+    }
+    return new Map([...projects.entries()].sort((a, b) => compareBytewise(a[0], b[0])));
+}
+async function planProject(input, manifest, project, evidence) {
+    if (evidence.skeleton === undefined) {
+        throw new Error("Missing skeleton evidence — re-run `second-brain map`");
+    }
+    const projectDir = join(input.wikiCodeRoot, project);
+    const existingPages = await listMarkdownFiles(projectDir);
+    const parsedPages = new Map();
+    for (const page of existingPages) {
+        const content = await readFile(join(projectDir, page), "utf8");
+        parsedPages.set(page, tryParseCodePage(content) !== undefined);
+    }
+    // Ownership (design 4): a non-empty directory where NOTHING carries our
+    // generated frontmatter was not produced by this tool.
+    if (existingPages.length > 0 && ![...parsedPages.values()].some(Boolean)) {
+        throw new Error(`wiki/code/${project}/ exists but was not produced by this tool — move or remove it`);
+    }
+    const desired = new Set([
+        "overview.md",
+        ...evidence.modules.map((source) => `${source.slug ?? ""}.md`)
+    ]);
+    const changed = (source) => manifest.entries[source.key]?.contentHash !== source.bodyHash;
+    // Render work (design 6.3): changed digest, missing page, or unparseable
+    // page (self-healing).
+    const renderModules = evidence.modules.filter((source) => {
+        const pageName = `${source.slug ?? ""}.md`;
+        return (changed(source) ||
+            !parsedPages.has(pageName) ||
+            parsedPages.get(pageName) === false);
+    });
+    // Prune only OUR pages outside the desired set; foreign files in a mixed
+    // directory are left untouched (design 4).
+    const prunePages = existingPages.filter((page) => !desired.has(page) && parsedPages.get(page) === true);
+    const overviewMissing = !parsedPages.has("overview.md") || parsedPages.get("overview.md") === false;
+    const renderOverview = changed(evidence.skeleton) ||
+        overviewMissing ||
+        renderModules.length > 0 ||
+        prunePages.length > 0;
+    return { evidence, prunePages, renderModules, renderOverview };
+}
+async function renderProject(input, project, plan, date) {
+    const projectDir = join(input.wikiCodeRoot, project);
+    const pagesRendered = [];
+    const pagesPruned = [];
+    if (plan.renderModules.length > 0 || plan.renderOverview) {
+        await ensureDirectory(projectDir);
+    }
+    for (const source of plan.renderModules) {
+        const slug = source.slug ?? "";
+        const coverage = source.frontmatter.coverage;
+        const body = await input.backend.renderModulePage({
+            ...(coverage === undefined ? {} : { coverage }),
+            digestBody: source.body,
+            module: slug,
+            project
+        });
+        const frontmatter = {
+            ...(coverage === undefined ? {} : { coverage }),
+            generated: date,
+            module: slug,
+            project,
+            source_commit: source.frontmatter.commit,
+            type: "code-map"
+        };
+        await writeFileAtomic(join(projectDir, `${slug}.md`), renderCodePage(frontmatter, body));
+        pagesRendered.push(`${project}/${slug}`);
+    }
+    for (const page of plan.prunePages) {
+        await rm(join(projectDir, page), { force: true });
+        pagesPruned.push(`${project}/${page.replace(/\.md$/u, "")}`);
+    }
+    if (plan.renderOverview) {
+        const skeleton = plan.evidence.skeleton;
+        if (skeleton === undefined) {
+            throw new Error("Missing skeleton evidence — re-run `second-brain map`");
+        }
+        // Overview input = current module PAGE bodies (summaries of summaries),
+        // never the raw digests again (design 6.4).
+        const modulePages = [];
+        for (const source of plan.evidence.modules) {
+            const slug = source.slug ?? "";
+            const content = await readFile(join(projectDir, `${slug}.md`), "utf8");
+            const parsed = tryParseCodePage(content);
+            if (parsed === undefined) {
+                throw new Error(`Module page ${slug}.md unreadable after render`);
+            }
+            modulePages.push({ body: parsed.body, slug });
+        }
+        const body = await input.backend.renderOverview({
+            modulePages,
+            project,
+            skeletonBody: skeleton.body
+        });
+        const frontmatter = {
+            generated: date,
+            project,
+            source_commit: skeleton.frontmatter.commit,
+            type: "code-map"
+        };
+        await writeFileAtomic(join(projectDir, "overview.md"), renderCodePage(frontmatter, body));
+        pagesRendered.push(`${project}/overview`);
+    }
+    return { pagesPruned, pagesRendered };
+}
+async function updateIndex(indexPath, byProject, failures) {
+    const failedProjects = new Set(failures.map((failure) => failure.project));
+    const lines = ["## Code maps", ""];
+    for (const [project, evidence] of byProject) {
+        const suffix = failedProjects.has(project) ? " (last run failed)" : "";
+        lines.push(`- [[code/${project}/overview|${project}]] — ${evidence.modules.length} modules${suffix}`);
+    }
+    let existing;
+    try {
+        existing = await readFile(indexPath, "utf8");
+    }
+    catch (error) {
+        if (!isMissingFileError(error)) {
+            throw error;
+        }
+    }
+    const next = applyManagedBlock(existing, CODE_MAPS_MARKERS, lines.join("\n"));
+    if (next !== existing) {
+        await writeFileAtomic(indexPath, next);
+    }
+}
+function buildLogEntry(input) {
+    const lines = [`## [${input.date}] code map | hourly pages`];
+    if (input.reportLink !== undefined) {
+        lines.push(`Run report: [[${input.reportLink}]]`);
+    }
+    if (input.pagesRendered.length > 0) {
+        lines.push(`Pages rendered: ${input.pagesRendered.map((page) => `[[code/${page}]]`).join(", ")}`);
+    }
+    if (input.pagesPruned.length > 0) {
+        lines.push(`Pages pruned: ${input.pagesPruned.map((page) => `\`code/${page}\``).join(", ")}`);
+    }
+    for (const failure of input.failures) {
+        lines.push(`Failed project (manifest not advanced): ${failure.project} — ${failure.reason}`);
+    }
+    for (const entry of input.quarantined) {
+        lines.push(`Quarantined evidence: ${entry.path} — ${entry.reason}`);
+    }
+    return lines.join("\n");
+}
+async function listMarkdownFiles(directory) {
+    try {
+        return (await readdir(directory))
+            .filter((entry) => entry.endsWith(".md"))
+            .sort(compareBytewise);
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return [];
+        }
+        throw error;
+    }
+}
+function isMissingFileError(error) {
+    return (error instanceof Error &&
+        "code" in error &&
+        typeof error.code === "string" &&
+        error.code === "ENOENT");
+}

package/dist/code-map-backend.js

@@ -0,0 +1,70 @@
+import { join } from "node:path";
+import { createClaudeRunner } from "./claude-runner.js";
+import { buildModulePagePrompt, buildOverviewPrompt } from "./code-map-prompt.js";
+import { ensureDirectory, writeFileAtomic } from "./filesystem.js";
+export function createCliClaudeCodeMapBackend(options, dependencies = {}) {
+    const runner = dependencies.runner ??
+        createClaudeRunner({
+            ...(options.claudeBin === undefined ? {} : { claudeBin: options.claudeBin }),
+            delivery: "stdin"
+        });
+    return {
+        name: "cli-claude",
+        renderModulePage: async (input) => {
+            const prompt = buildModulePagePrompt(input);
+            const raw = await runner({ model: options.models.pages, prompt });
+            return validateOrPreserve(raw, `${input.project}-${input.module}`, options.logsRoot);
+        },
+        renderOverview: async (input) => {
+            const prompt = buildOverviewPrompt(input);
+            const raw = await runner({ model: options.models.structure, prompt });
+            return validateOrPreserve(raw, `${input.project}-overview`, options.logsRoot);
+        }
+    };
+}
+// Failed output is debugging evidence, not garbage (design 10): preserve it
+// under logsRoot, then fail so the manifest does not advance.
+async function validateOrPreserve(raw, label, logsRoot) {
+    try {
+        return validatePageBody(raw);
+    }
+    catch (error) {
+        if (logsRoot === undefined) {
+            throw error;
+        }
+        const stamp = new Date().toISOString().replaceAll(":", "-");
+        const dumpPath = join(logsRoot, `code-map-${label}-${stamp}.txt`);
+        await ensureDirectory(logsRoot);
+        await writeFileAtomic(dumpPath, raw);
+        throw new Error(`${error instanceof Error ? error.message : "Invalid page body"} — raw output saved to ${dumpPath}`);
+    }
+}
+// Light validation (design 4): hard structural failures only — content
+// quality is the prompt's job, and a strict gate would just loop retries.
+export function validatePageBody(raw) {
+    const body = stripFences(raw).trim();
+    if (body.length === 0) {
+        throw new Error("Backend returned an empty page body");
+    }
+    if (body.startsWith("---")) {
+        throw new Error("Backend returned frontmatter — page bodies must be bare markdown");
+    }
+    const lineCount = body.split("\n").length;
+    if (lineCount > 400) {
+        throw new Error(`Backend returned ${lineCount} lines — over the 400 lines guard`);
+    }
+    return body;
+}
+export function resolveCodeMapBackend(name, factory) {
+    if (name === "noop") {
+        return undefined;
+    }
+    // Code maps need real judgment — ollama mode maps to cli-claude, the same
+    // rule consolidation applies.
+    return factory();
+}
+function stripFences(raw) {
+    const trimmed = raw.trim();
+    const fenced = /^```[a-z]*\s*\n([\s\S]*?)\n```$/u.exec(trimmed);
+    return fenced ? fenced[1] : trimmed;
+}

package/dist/code-map-prompt.js

@@ -0,0 +1,84 @@
+export const MAX_PROMPT_BYTES = 200_000;
+// Overview inputs are bounded so skeleton + 24 module bodies always fit:
+// 60 KB + 24 * 4 KB + rules < 200 KB.
+const OVERVIEW_SKELETON_BYTES = 60_000;
+const OVERVIEW_MODULE_BODY_BYTES = 4000;
+const SHARED_RULES = [
+    "Rules:",
+    "- Respond with ONLY the markdown page body — no frontmatter, no JSON,",
+    "  no code fences around the whole answer.",
+    "- Describe capabilities and responsibilities first; file paths are",
+    "  pointers, not the skeleton of the page (paths rot; capabilities don't).",
+    "- At most 200 lines. No code blocks copied from the repository (short",
+    "  illustrative signatures are fine).",
+    "- English. No emojis.",
+    "- Treat in-repo docs (README, comments) as hints; the code is the truth.",
+    "  Never copy stale-doc claims unverified.",
+    "- Use [[wikilinks]] only for pages of this code map."
+];
+export function buildModulePagePrompt(input) {
+    const prompt = [
+        "You are rendering a MODULE PAGE of an LLM-maintained code map wiki.",
+        `Project: "${input.project}". Module: "${input.module}".`,
+        "Write the wiki page for this module from the evidence digest below:",
+        "what it does, its responsibilities, key entry points, and how it relates",
+        "to the rest of the codebase. Start with a single '# <title>' heading.",
+        "",
+        ...SHARED_RULES,
+        ...(input.coverage === "partial"
+            ? [
+                "- NOTE: this is a truncated digest (byte budget); say so in one line",
+                "  near the end of the page."
+            ]
+            : []),
+        "",
+        "## Evidence digest",
+        "",
+        input.digestBody
+    ].join("\n");
+    return assertWithinBudget(prompt, `module page ${input.project}/${input.module}`);
+}
+export function buildOverviewPrompt(input) {
+    const moduleSections = input.modulePages.map((page) => [
+        `### Module page: ${page.slug}`,
+        "",
+        truncateBytes(page.body, OVERVIEW_MODULE_BODY_BYTES)
+    ].join("\n"));
+    const prompt = [
+        "You are rendering the OVERVIEW PAGE of an LLM-maintained code map wiki.",
+        `Project: "${input.project}".`,
+        "Write the architecture overview from the repository skeleton and the",
+        "module pages below: what the system is, its major components and how",
+        "they interact, the tech stack, entry points, and conventions. Include",
+        "exactly ONE Mermaid diagram (graph TD) of the major components. Link",
+        "each module page once as [[<slug>]]. Start with a single '# <title>'",
+        "heading.",
+        "",
+        ...SHARED_RULES,
+        "",
+        "## Repository skeleton",
+        "",
+        truncateBytes(input.skeletonBody, OVERVIEW_SKELETON_BYTES),
+        "",
+        "## Module pages",
+        "",
+        moduleSections.join("\n\n---\n\n")
+    ].join("\n");
+    return assertWithinBudget(prompt, `overview ${input.project}`);
+}
+function truncateBytes(text, maxBytes) {
+    if (Buffer.byteLength(text, "utf8") <= maxBytes) {
+        return text;
+    }
+    // Slicing by chars can overshoot multi-byte runes slightly; Buffer slice
+    // then lossy decode keeps it deterministic and within budget.
+    const sliced = Buffer.from(text, "utf8").subarray(0, maxBytes).toString("utf8");
+    return `${sliced.replace(/�+$/u, "")}\n[truncated]`;
+}
+function assertWithinBudget(prompt, label) {
+    const bytes = Buffer.byteLength(prompt, "utf8");
+    if (bytes > MAX_PROMPT_BYTES) {
+        throw new Error(`Prompt for ${label} exceeds ${MAX_PROMPT_BYTES} bytes (${bytes})`);
+    }
+    return prompt;
+}

package/dist/code-scan.js

@@ -0,0 +1,168 @@
+import { lstat, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { compareBytewise } from "./code-boundaries.js";
+import { runCommand } from "./shell.js";
+const defaultDependencies = {
+    fileSize: async (absolutePath) => {
+        try {
+            const stat = await lstat(absolutePath);
+            return stat.isFile() ? stat.size : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    },
+    readHead: async (absolutePath, maxBytes) => {
+        try {
+            return (await readFile(absolutePath, "utf8")).slice(0, maxBytes);
+        }
+        catch {
+            return undefined;
+        }
+    },
+    run: runCommand
+};
+const MANIFEST_FILENAMES = new Set([
+    "CMakeLists.txt",
+    "Cargo.toml",
+    "Dockerfile",
+    "Gemfile",
+    "Makefile",
+    "build.gradle",
+    "build.gradle.kts",
+    "composer.json",
+    "docker-compose.yml",
+    "go.mod",
+    "mix.exs",
+    "package.json",
+    "pom.xml",
+    "pyproject.toml",
+    "setup.py"
+]);
+const DOC_FILENAMES = new Set(["AGENTS.md", "CLAUDE.md", "README", "README.md"]);
+const MANIFEST_LIMIT = 12;
+const MANIFEST_HEAD_BYTES = 4096;
+const DOC_HEAD_BYTES = 8192;
+const EXCLUDED_FILENAMES = new Set([
+    ".DS_Store",
+    "Cargo.lock",
+    "Gemfile.lock",
+    "Pipfile.lock",
+    "bun.lock",
+    "bun.lockb",
+    "composer.lock",
+    "go.sum",
+    "package-lock.json",
+    "pnpm-lock.yaml",
+    "poetry.lock",
+    "uv.lock",
+    "yarn.lock"
+]);
+const EXCLUDED_EXTENSIONS = new Set([
+    "7z", "a", "avi", "avif", "bin", "bmp", "class", "dat", "db", "dll", "dylib",
+    "eot", "exe", "flac", "gif", "gz", "icns", "ico", "jar", "jpeg", "jpg",
+    "map", "mov", "mp3", "mp4", "o", "ogg", "otf", "pdf", "png", "rar", "so",
+    "sqlite", "sqlite3", "tar", "tgz", "tiff", "ttf", "war", "wasm", "wav",
+    "webm", "webp", "woff", "woff2", "zip"
+]);
+const EXCLUDED_DIR_SEGMENTS = new Set([
+    ".cache", ".next", ".nuxt", ".turbo", ".venv", "__pycache__", "build",
+    "coverage", "dist", "node_modules", "out", "target", "vendor"
+]);
+export function isExcludedPath(path) {
+    const segments = path.split("/");
+    const filename = segments[segments.length - 1];
+    if (EXCLUDED_FILENAMES.has(filename)) {
+        return true;
+    }
+    if (filename.endsWith(".min.js") || filename.endsWith(".min.css")) {
+        return true;
+    }
+    const dotIndex = filename.lastIndexOf(".");
+    if (dotIndex > 0 && EXCLUDED_EXTENSIONS.has(filename.slice(dotIndex + 1).toLowerCase())) {
+        return true;
+    }
+    return segments.slice(0, -1).some((segment) => EXCLUDED_DIR_SEGMENTS.has(segment));
+}
+export async function scanRepository(input, dependencies = defaultDependencies) {
+    const { repoPath, scope } = input;
+    const scopeArgs = scope === undefined ? [] : ["--", scope];
+    const workTree = await dependencies.run("git", ["rev-parse", "--is-inside-work-tree"], repoPath);
+    if (workTree.stdout.trim() !== "true") {
+        throw new Error(`Not a git work tree: ${repoPath}`);
+    }
+    const commit = (await dependencies.run("git", ["rev-parse", "HEAD"], repoPath)).stdout.trim();
+    const lsFiles = await dependencies.run("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard", ...scopeArgs], repoPath);
+    const allPaths = lsFiles.stdout
+        .split("\u0000")
+        .filter((entry) => entry.length > 0)
+        .sort(compareBytewise);
+    const keptPaths = allPaths.filter((path) => !isExcludedPath(path));
+    const files = [];
+    for (const path of keptPaths) {
+        const size = await dependencies.fileSize(join(repoPath, path));
+        // ls-files lists cached entries deleted from the work tree; nothing to
+        // digest there.
+        if (size !== undefined) {
+            files.push({ path, size });
+        }
+    }
+    const lastCommitIso = (await dependencies.run("git", ["log", "-1", "--format=%cI"], repoPath)).stdout.trim();
+    const log90 = await dependencies.run("git", ["log", "--since=90 days ago", "--name-only", "--pretty=format:%cI", ...scopeArgs], repoPath);
+    const activity = parseActivity(log90.stdout);
+    const manifests = [];
+    for (const file of files) {
+        if (manifests.length >= MANIFEST_LIMIT) {
+            break;
+        }
+        if (MANIFEST_FILENAMES.has(file.path.split("/").at(-1) ?? "")) {
+            const text = await dependencies.readHead(join(repoPath, file.path), MANIFEST_HEAD_BYTES);
+            if (text !== undefined) {
+                manifests.push({ path: file.path, text });
+            }
+        }
+    }
+    const docs = [];
+    const scopePrefix = scope === undefined ? "" : `${scope}/`;
+    for (const file of files) {
+        const relative = file.path.startsWith(scopePrefix)
+            ? file.path.slice(scopePrefix.length)
+            : file.path;
+        // Only scope-root docs — nested READMEs belong to module digests.
+        if (!relative.includes("/") && DOC_FILENAMES.has(relative)) {
+            const text = await dependencies.readHead(join(repoPath, file.path), DOC_HEAD_BYTES);
+            if (text !== undefined) {
+                docs.push({ path: file.path, text });
+            }
+        }
+    }
+    return {
+        activity,
+        commit,
+        docs,
+        excludedCount: allPaths.length - keptPaths.length,
+        files,
+        lastCommitDate: lastCommitIso.slice(0, 10),
+        manifests
+    };
+}
+const ISO_LINE = /^\d{4}-\d{2}-\d{2}T/u;
+function parseActivity(stdout) {
+    const activity = new Map();
+    let currentDate = "";
+    for (const line of stdout.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0) {
+            continue;
+        }
+        if (ISO_LINE.test(trimmed)) {
+            currentDate = trimmed.slice(0, 10);
+            continue;
+        }
+        // git log is newest-first: the first date seen for a path is its last touch.
+        if (currentDate !== "" && !activity.has(trimmed)) {
+            activity.set(trimmed, currentDate);
+        }
+    }
+    return activity;
+}

package/dist/config.js

@@ -1,6 +1,7 @@
 import { readFile } from "node:fs/promises";
 import { isAbsolute, normalize, resolve } from "node:path";
 import { z } from "zod";
+import { codeMapSectionSchema, resolveCodeMapConfig } from "./code-map-config.js";
 const providerNameSchema = z.enum(["codex", "claude", "gemini"]);
 const runKindSchema = z.enum(["hourly", "manual", "weekly"]);
 const syncProviderSchema = z.object({
@@ -16,6 +17,7 @@ const synthesisConfigSchema = z.object({
     ollamaModel: z.string().trim().min(1).optional()
 });
 const syncConfigSchema = z.object({
+    codeMap: codeMapSectionSchema.optional(),
     logsRoot: z.string().trim().min(1).optional(),
     providers: z.array(syncProviderSchema),
     synthesis: synthesisConfigSchema.optional(),
@@ -65,6 +67,9 @@ export async function loadConfig(configPath) {
     const vaultRoot = resolveConfigPath(parsedConfig.vaultRoot, configDirectory);
     const logsRoot = resolveConfigPath(parsedConfig.logsRoot ?? "logs", configDirectory);
     return {
+        ...(parsedConfig.codeMap === undefined
+            ? {}
+            : { codeMap: resolveCodeMapConfig(parsedConfig.codeMap, configDirectory) }),
         logsRoot,
         providers: parsedConfig.providers.map((provider) => ({
             destinationPath: normalizeRelativePath(provider.destinationPath),

package/dist/consolidation.js

@@ -7,7 +7,7 @@ import { appendLogEntry } from "./ingest-writer.js";
 import { buildSourceKey, loadManifest, saveManifest, withManifestEntries } from "./manifest.js";
 const CONSOLIDATION_PROVIDER = "consolidation";
 // Structural wiki files a project page must never collide with (design 7.2).
-const RESERVED_PAGES = new Set(["episodes", "index", "log", "reports"]);
+const RESERVED_PAGES = new Set(["code", "episodes", "index", "log", "reports"]);
 export async function runConsolidation(input) {
     const scan = await scanEpisodes(input.episodesRoot);
     const manifest = await loadManifest(input.manifestPath);