chapterhouse 0.7.0 → 0.8.1

package/dist/memory/migration.js

@@ -0,0 +1,244 @@
+import { createHash } from "node:crypto";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { WIKI_PAGES_DIR } from "../paths.js";
+import { parseWikiFrontmatter } from "../wiki/frontmatter.js";
+const MIGRATION_NAME = "p6-wiki-seed";
+const MIGRATION_SOURCE = "migration:p6";
+export async function runP6Migration(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS mem_migrations (
+      id INTEGER PRIMARY KEY,
+      name TEXT UNIQUE,
+      run_at TEXT
+    )
+  `);
+    const alreadyRan = db.prepare(`SELECT 1 FROM mem_migrations WHERE name = ?`).get(MIGRATION_NAME);
+    if (alreadyRan) {
+        return {
+            entitiesCreated: 0,
+            observationsCreated: 0,
+            decisionsCreated: 0,
+            skipped: -1,
+        };
+    }
+    const globalScopeId = getScopeId(db, "global");
+    if (!globalScopeId) {
+        throw new Error("Missing required memory scope 'global'.");
+    }
+    const chapterhouseScopeId = getScopeId(db, "chapterhouse") ?? globalScopeId;
+    const result = {
+        entitiesCreated: 0,
+        observationsCreated: 0,
+        decisionsCreated: 0,
+        skipped: 0,
+    };
+    if (existsSync(WIKI_PAGES_DIR)) {
+        for (const kindDir of ["projects", "people", "topics"]) {
+            for (const pagePath of findFiles(join(WIKI_PAGES_DIR, kindDir), "index.md")) {
+                const relativeSlug = normalizeRelativePageSlug(pagePath);
+                const content = readFileSync(pagePath, "utf-8");
+                const { parsed, body } = parseWikiFrontmatter(content);
+                const kind = toEntityKind(kindDir);
+                const title = parsed.title?.trim() || deriveTitleFromSlug(relativeSlug);
+                const summary = parsed.summary?.trim() || null;
+                const entityId = upsertEntityBySlug(db, {
+                    scopeId: globalScopeId,
+                    slug: relativeSlug,
+                    kind,
+                    title,
+                    summary,
+                });
+                if (entityId.created) {
+                    result.entitiesCreated += 1;
+                }
+                const compiledTruth = extractCompiledTruth(body, title);
+                if (!compiledTruth) {
+                    result.skipped += 1;
+                    continue;
+                }
+                const observationContent = compiledTruth.slice(0, 500);
+                if (insertObservationIfMissing(db, {
+                    scopeId: globalScopeId,
+                    entityId: entityId.id,
+                    content: observationContent,
+                })) {
+                    result.observationsCreated += 1;
+                }
+            }
+        }
+        for (const decisionPath of findFiles(WIKI_PAGES_DIR, "decisions.md")) {
+            const entries = parseDecisionEntries(readFileSync(decisionPath, "utf-8"));
+            for (const entry of entries) {
+                if (!entry.rationale) {
+                    result.skipped += 1;
+                    continue;
+                }
+                if (insertDecisionIfMissing(db, {
+                    scopeId: chapterhouseScopeId,
+                    title: entry.title,
+                    rationale: entry.rationale,
+                })) {
+                    result.decisionsCreated += 1;
+                }
+            }
+        }
+    }
+    db.prepare(`INSERT INTO mem_migrations (name, run_at) VALUES (?, ?)`)
+        .run(MIGRATION_NAME, new Date().toISOString());
+    return result;
+}
+function getScopeId(db, slug) {
+    const row = db.prepare(`SELECT id FROM mem_scopes WHERE slug = ?`).get(slug);
+    return row?.id;
+}
+function findFiles(root, targetName) {
+    if (!existsSync(root)) {
+        return [];
+    }
+    const matches = [];
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        const fullPath = join(root, entry.name);
+        if (entry.isDirectory()) {
+            matches.push(...findFiles(fullPath, targetName));
+            continue;
+        }
+        if (entry.isFile() && entry.name === targetName) {
+            matches.push(fullPath);
+        }
+    }
+    return matches.sort((left, right) => left.localeCompare(right));
+}
+function normalizeRelativePageSlug(fullPath) {
+    return relative(WIKI_PAGES_DIR, fullPath).replace(/\\/g, "/");
+}
+function toEntityKind(directory) {
+    switch (directory) {
+        case "projects": return "project";
+        case "people": return "person";
+        case "topics": return "topic";
+    }
+}
+function deriveTitleFromSlug(slug) {
+    const parts = slug.split("/").filter(Boolean);
+    const base = parts[parts.length - 2] || parts[parts.length - 1] || slug;
+    return base.split(/[-_]+/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+function extractCompiledTruth(body, fallback) {
+    let text = body.replace(/\r\n/g, "\n").trim();
+    text = text.replace(/^#\s+.+?(\n+|$)/, "").trim();
+    const summaryMatch = text.match(/^##\s+Summary\s*\n+([\s\S]*?)(?=\n##\s+|$)/m);
+    if (summaryMatch?.[1]?.trim()) {
+        text = summaryMatch[1].trim();
+    }
+    const beforeTimeline = text.split(/\n##\s+Timeline\b/m)[0]?.trim() ?? "";
+    return beforeTimeline || fallback;
+}
+function upsertEntityBySlug(db, input) {
+    const existingBySlug = db.prepare(`SELECT id FROM mem_entities WHERE scope_id = ? AND slug = ?`).get(input.scopeId, input.slug);
+    if (existingBySlug) {
+        db.prepare(`
+      UPDATE mem_entities
+      SET kind = ?, name = ?, summary = ?, updated_at = CURRENT_TIMESTAMP
+      WHERE id = ?
+    `).run(input.kind, input.title, input.summary, existingBySlug.id);
+        return { id: existingBySlug.id, created: false };
+    }
+    const existingByName = db.prepare(`
+    SELECT id
+    FROM mem_entities
+    WHERE scope_id = ? AND kind = ? AND name = ?
+  `).get(input.scopeId, input.kind, input.title);
+    if (existingByName) {
+        db.prepare(`
+      UPDATE mem_entities
+      SET slug = ?, summary = ?, updated_at = CURRENT_TIMESTAMP
+      WHERE id = ?
+    `).run(input.slug, input.summary, existingByName.id);
+        return { id: existingByName.id, created: false };
+    }
+    const inserted = db.prepare(`
+    INSERT INTO mem_entities (scope_id, slug, kind, name, summary, tier, confidence, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, 'warm', 1.0, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+  `).run(input.scopeId, input.slug, input.kind, input.title, input.summary);
+    return { id: Number(inserted.lastInsertRowid), created: true };
+}
+function insertObservationIfMissing(db, input) {
+    const hash = contentHash(input.content);
+    const existing = db.prepare(`
+    SELECT id
+    FROM mem_observations
+    WHERE scope_id = ? AND entity_id = ? AND source = ? AND content = ?
+  `).get(input.scopeId, input.entityId, MIGRATION_SOURCE, input.content);
+    if (existing) {
+        return false;
+    }
+    const duplicateByHash = db.prepare(`
+    SELECT id, content
+    FROM mem_observations
+    WHERE scope_id = ? AND entity_id = ? AND source = ?
+  `).all(input.scopeId, input.entityId, MIGRATION_SOURCE);
+    if (duplicateByHash.some((row) => contentHash(row.content) === hash)) {
+        return false;
+    }
+    db.prepare(`
+    INSERT INTO mem_observations (scope_id, entity_id, content, source, tier, confidence, created_at)
+    VALUES (?, ?, ?, ?, 'warm', 1.0, CURRENT_TIMESTAMP)
+  `).run(input.scopeId, input.entityId, input.content, MIGRATION_SOURCE);
+    return true;
+}
+function insertDecisionIfMissing(db, input) {
+    const hash = contentHash(`${input.title}\n${input.rationale}`);
+    const rows = db.prepare(`
+    SELECT id, title, rationale
+    FROM mem_decisions
+    WHERE scope_id = ?
+  `).all(input.scopeId);
+    if (rows.some((row) => contentHash(`${row.title}\n${row.rationale}`) === hash)) {
+        return false;
+    }
+    db.prepare(`
+    INSERT INTO mem_decisions (scope_id, title, rationale, decided_at, source, tier, created_at)
+    VALUES (?, ?, ?, ?, ?, 'warm', CURRENT_TIMESTAMP)
+  `).run(input.scopeId, input.title, input.rationale, new Date().toISOString().slice(0, 10), MIGRATION_SOURCE);
+    return true;
+}
+function parseDecisionEntries(content) {
+    const lines = content.replace(/\r\n/g, "\n").split("\n");
+    const entries = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const match = lines[index]?.match(/^###?\s+(.+)$/);
+        if (!match) {
+            continue;
+        }
+        const paragraph = [];
+        let cursor = index + 1;
+        while (cursor < lines.length && !lines[cursor]?.trim()) {
+            cursor += 1;
+        }
+        while (cursor < lines.length) {
+            const line = lines[cursor] ?? "";
+            if (/^###?\s+/.test(line)) {
+                break;
+            }
+            if (!line.trim()) {
+                if (paragraph.length > 0) {
+                    break;
+                }
+                cursor += 1;
+                continue;
+            }
+            paragraph.push(line.trim());
+            cursor += 1;
+        }
+        entries.push({
+            title: match[1].trim(),
+            rationale: paragraph.join(" ").trim(),
+        });
+    }
+    return entries;
+}
+function contentHash(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+//# sourceMappingURL=migration.js.map

package/dist/memory/migration.test.js

@@ -0,0 +1,108 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+import { resetSingletons } from "../test/helpers/reset-singletons.js";
+let sandboxRoot;
+let chapterhouseHome;
+let dbModule;
+let migrationModule;
+function resetSandbox() {
+    rmSync(chapterhouseHome, { recursive: true, force: true });
+    mkdirSync(chapterhouseHome, { recursive: true });
+}
+function writePage(relativePath, content) {
+    const fullPath = join(chapterhouseHome, "wiki", relativePath);
+    mkdirSync(join(fullPath, ".."), { recursive: true });
+    writeFileSync(fullPath, content, "utf-8");
+}
+test.before(async () => {
+    mkdirSync(join(process.cwd(), ".test-work"), { recursive: true });
+    sandboxRoot = mkdtempSync(join(process.cwd(), ".test-work", "memory-migration-"));
+    process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+    chapterhouseHome = join(sandboxRoot, ".chapterhouse");
+    resetSingletons();
+    const nonce = `${Date.now()}-${Math.random()}`;
+    dbModule = await import(new URL(`../store/db.js?case=${nonce}`, import.meta.url).href);
+    migrationModule = await import(new URL(`./migration.js?case=${nonce}`, import.meta.url).href);
+});
+test.beforeEach(() => {
+    process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+    dbModule.closeDb();
+    resetSingletons();
+    resetSandbox();
+});
+test.after(() => {
+    try {
+        dbModule.closeDb();
+    }
+    catch { }
+    try {
+        resetSingletons();
+    }
+    catch { }
+    try {
+        rmSync(sandboxRoot, { recursive: true, force: true });
+    }
+    catch { }
+});
+test("runP6Migration seeds project, person, topic, and decision pages from the wiki", async () => {
+    const longTruth = `${"Compiled truth. ".repeat(60)}Detailed migration note.`;
+    writePage("pages/projects/project-x/index.md", `---\ntitle: Project X\nsummary: Flagship delivery program\ntags: [alpha, backend]\n---\n\n# Project X\n\n${longTruth}\n`);
+    writePage("pages/people/alice-example/index.md", `---\ntitle: Alice Example\nsummary: Principal engineer\ntags: [people]\n---\n\n# Alice Example\n\nAlice leads backend delivery.\n`);
+    writePage("pages/topics/observability/index.md", `---\ntitle: Observability\nsummary: Shared telemetry topic\ntags: [topic]\n---\n\n# Observability\n\nTracing, logs, and metrics.\n`);
+    writePage("pages/projects/chapterhouse/decisions.md", `# Decisions\n\n## Keep SQLite for memory\nSQLite keeps the daemon self-contained.\n\n### Append-only timelines\nTimeline history remains append-only for auditability.\n`);
+    const db = dbModule.getDb();
+    const result = await migrationModule.runP6Migration(db);
+    assert.deepEqual(result, {
+        entitiesCreated: 3,
+        observationsCreated: 3,
+        decisionsCreated: 2,
+        skipped: 0,
+    });
+    const entities = db.prepare(`SELECT slug, kind, name, summary FROM mem_entities ORDER BY slug`).all();
+    assert.deepEqual(entities.filter((row) => row.slug?.startsWith("projects/") || row.slug?.startsWith("people/") || row.slug?.startsWith("topics/")), [
+        { slug: "people/alice-example/index.md", kind: "person", name: "Alice Example", summary: "Principal engineer" },
+        { slug: "projects/project-x/index.md", kind: "project", name: "Project X", summary: "Flagship delivery program" },
+        { slug: "topics/observability/index.md", kind: "topic", name: "Observability", summary: "Shared telemetry topic" },
+    ]);
+    const observation = db.prepare(`SELECT content, source, tier FROM mem_observations WHERE source = 'migration:p6' ORDER BY id LIMIT 1`).get();
+    assert.equal(observation.source, "migration:p6");
+    assert.equal(observation.tier, "warm");
+    assert.equal(observation.content.length, 500);
+    assert.equal(observation.content, longTruth.slice(0, 500));
+    const chapterhouseScope = db.prepare(`SELECT id FROM mem_scopes WHERE slug = 'chapterhouse'`).get();
+    const decisions = db.prepare(`SELECT title, rationale, scope_id FROM mem_decisions WHERE title IN (?, ?) ORDER BY title`).all("Append-only timelines", "Keep SQLite for memory");
+    assert.deepEqual(decisions, [
+        { title: "Append-only timelines", rationale: "Timeline history remains append-only for auditability.", scope_id: chapterhouseScope.id },
+        { title: "Keep SQLite for memory", rationale: "SQLite keeps the daemon self-contained.", scope_id: chapterhouseScope.id },
+    ]);
+    const migrationRow = db.prepare(`SELECT name FROM mem_migrations WHERE name = 'p6-wiki-seed'`).get();
+    assert.deepEqual(migrationRow, { name: "p6-wiki-seed" });
+});
+test("runP6Migration is idempotent across repeated runs", async () => {
+    writePage("pages/projects/project-x/index.md", `---\ntitle: Project X\nsummary: Flagship delivery program\ntags: []\n---\n\n# Project X\n\nCompiled truth lives here.\n`);
+    const db = dbModule.getDb();
+    const first = await migrationModule.runP6Migration(db);
+    const second = await migrationModule.runP6Migration(db);
+    assert.equal(first.entitiesCreated, 1);
+    assert.equal(first.observationsCreated, 1);
+    assert.equal(second.skipped, -1);
+    assert.equal(db.prepare(`SELECT COUNT(*) AS count FROM mem_entities WHERE slug = 'projects/project-x/index.md'`).get().count, 1);
+    assert.equal(db.prepare(`SELECT COUNT(*) AS count FROM mem_observations WHERE source = 'migration:p6'`).get().count, 1);
+    assert.equal(db.prepare(`SELECT COUNT(*) AS count FROM mem_migrations WHERE name = 'p6-wiki-seed'`).get().count, 1);
+});
+test("runP6Migration skips gracefully when the wiki skeleton exists but contains no migratable pages", async () => {
+    const db = dbModule.getDb();
+    assert.equal(existsSync(join(chapterhouseHome, "wiki", "pages")), true);
+    const result = await migrationModule.runP6Migration(db);
+    assert.deepEqual(result, {
+        entitiesCreated: 0,
+        observationsCreated: 0,
+        decisionsCreated: 0,
+        skipped: 0,
+    });
+    assert.equal(db.prepare(`SELECT COUNT(*) AS count FROM mem_entities`).get().count >= 0, true);
+    assert.equal(db.prepare(`SELECT COUNT(*) AS count FROM mem_migrations WHERE name = 'p6-wiki-seed'`).get().count, 1);
+});
+//# sourceMappingURL=migration.test.js.map

package/dist/memory/reflect.js

@@ -0,0 +1,273 @@
+import { config } from "../config.js";
+import { getClient } from "../copilot/client.js";
+import { runOneShotPrompt } from "../copilot/oneshot.js";
+import { childLogger } from "../util/logger.js";
+import { getScope, listScopes } from "./scopes.js";
+const log = childLogger("memory.reflect");
+const MIN_GROUP_SIZE = 3;
+const SIMILARITY_THRESHOLD = 0.35;
+const MAX_GROUP_OBSERVATIONS = 8;
+const GLOBAL_SCOPE_SLUG = "global";
+function normalizeText(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function tokenize(value) {
+    return new Set(normalizeText(value)
+        .split(" ")
+        .map((token) => token.replace(/s$/u, ""))
+        .filter((token) => token.length > 2));
+}
+function overlapCount(left, right) {
+    let overlap = 0;
+    for (const token of left) {
+        if (right.has(token)) {
+            overlap++;
+        }
+    }
+    return overlap;
+}
+function jaccard(left, right) {
+    if (left.size === 0 || right.size === 0) {
+        return 0;
+    }
+    const overlap = overlapCount(left, right);
+    const union = left.size + right.size - overlap;
+    return union === 0 ? 0 : overlap / union;
+}
+function compareObservation(left, right) {
+    if (left.created_at !== right.created_at) {
+        return left.created_at.localeCompare(right.created_at);
+    }
+    return left.id - right.id;
+}
+function canonicalObservationIds(observations) {
+    return observations
+        .map((observation) => observation.id)
+        .sort((left, right) => left - right)
+        .join(",");
+}
+function buildEntityGroups(observations) {
+    const grouped = new Map();
+    for (const observation of observations) {
+        if (!observation.entity_id) {
+            continue;
+        }
+        const existing = grouped.get(observation.entity_id) ?? [];
+        existing.push(observation);
+        grouped.set(observation.entity_id, existing);
+    }
+    return [...grouped.entries()]
+        .map(([entityId, rows]) => ({
+        kind: "entity",
+        key: `entity:${entityId}`,
+        observations: rows.sort(compareObservation),
+    }))
+        .filter((group) => group.observations.length >= MIN_GROUP_SIZE);
+}
+function buildTopicGroups(observations) {
+    const tokensByObservation = new Map();
+    for (const observation of observations) {
+        tokensByObservation.set(observation.id, tokenize(observation.content));
+    }
+    const groups = [];
+    const seenKeys = new Set();
+    const ordered = [...observations].sort(compareObservation);
+    for (const seed of ordered) {
+        const seedTokens = tokensByObservation.get(seed.id) ?? new Set();
+        const cluster = ordered.filter((candidate) => {
+            const candidateTokens = tokensByObservation.get(candidate.id) ?? new Set();
+            return overlapCount(seedTokens, candidateTokens) >= 3
+                && jaccard(seedTokens, candidateTokens) >= SIMILARITY_THRESHOLD;
+        });
+        if (cluster.length < MIN_GROUP_SIZE) {
+            continue;
+        }
+        const key = `topic:${canonicalObservationIds(cluster)}`;
+        if (seenKeys.has(key)) {
+            continue;
+        }
+        seenKeys.add(key);
+        groups.push({ kind: "topic", key, observations: cluster.sort(compareObservation) });
+    }
+    return groups;
+}
+function buildGroups(observations) {
+    const groups = [...buildEntityGroups(observations), ...buildTopicGroups(observations)];
+    const deduped = new Map();
+    for (const group of groups) {
+        const key = canonicalObservationIds(group.observations);
+        if (!deduped.has(key)) {
+            deduped.set(key, group);
+        }
+    }
+    return [...deduped.values()];
+}
+function buildFallbackPattern(group) {
+    const [first] = group.observations;
+    const entityTitle = first?.entity_name ? `${first.entity_name} pattern` : "Observed pattern";
+    return {
+        title: entityTitle,
+        summary: group.observations.slice(0, 3).map((observation) => observation.content).join(" "),
+        confidence: Math.max(0.5, Math.min(0.95, Number((group.observations.reduce((sum, observation) => sum + observation.confidence, 0) / group.observations.length).toFixed(2)))),
+    };
+}
+function parseSynthesizedPattern(raw, group) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.title === "string" && typeof parsed.summary === "string") {
+            return {
+                title: parsed.title.trim() || buildFallbackPattern(group).title,
+                summary: parsed.summary.trim() || buildFallbackPattern(group).summary,
+                confidence: typeof parsed.confidence === "number"
+                    ? Math.max(0, Math.min(1, parsed.confidence))
+                    : buildFallbackPattern(group).confidence,
+            };
+        }
+    }
+    catch {
+        // Fall through to the heuristic fallback.
+    }
+    return buildFallbackPattern(group);
+}
+async function synthesizePattern(scopeSlug, group) {
+    const client = await getClient();
+    const system = [
+        "You synthesize durable memory patterns from repeated observations.",
+        "Return JSON only with keys: title, summary, confidence.",
+        "title should be short and specific.",
+        "summary should describe the stable pattern in 1-2 sentences.",
+        "confidence must be a number between 0 and 1.",
+    ].join("\n");
+    const user = JSON.stringify({
+        scope: scopeSlug,
+        group_kind: group.kind,
+        observations: group.observations.slice(0, MAX_GROUP_OBSERVATIONS).map((observation) => ({
+            id: observation.id,
+            scope: observation.scope_slug,
+            entity: observation.entity_name,
+            content: observation.content,
+            source: observation.source,
+            confidence: observation.confidence,
+            created_at: observation.created_at,
+        })),
+    }, null, 2);
+    const response = await runOneShotPrompt({
+        client,
+        model: config.copilotModel,
+        system,
+        user,
+        expectJson: true,
+    });
+    return parseSynthesizedPattern(response.content, group);
+}
+function containsContradictionSignal(value) {
+    return /\b(?:no longer|changed to|now uses|now use|moved to|switched to|was .+ now .+)\b/i.test(value);
+}
+function countContradictions(groups) {
+    let contradictions = 0;
+    for (const group of groups) {
+        if (group.kind !== "entity") {
+            continue;
+        }
+        if (group.observations.some((observation) => containsContradictionSignal(observation.content))) {
+            contradictions++;
+        }
+    }
+    return contradictions;
+}
+function loadObservations(scopeSlug, db) {
+    const scope = getScope(scopeSlug);
+    if (!scope) {
+        throw new Error(`Unknown memory scope '${scopeSlug}'.`);
+    }
+    const globalScope = scopeSlug === GLOBAL_SCOPE_SLUG ? null : getScope(GLOBAL_SCOPE_SLUG);
+    const scopeIds = globalScope ? [scope.id, globalScope.id] : [scope.id];
+    const placeholders = scopeIds.map(() => "?").join(", ");
+    return db.prepare(`
+    SELECT
+      o.id,
+      o.scope_id,
+      s.slug AS scope_slug,
+      o.entity_id,
+      e.name AS entity_name,
+      e.kind AS entity_kind,
+      o.content,
+      o.source,
+      o.tier,
+      o.confidence,
+      o.created_at
+    FROM mem_observations o
+    JOIN mem_scopes s ON s.id = o.scope_id
+    LEFT JOIN mem_entities e ON e.id = o.entity_id
+    WHERE o.scope_id IN (${placeholders})
+      AND o.tier IN ('hot', 'warm')
+      AND o.superseded_by IS NULL
+      AND o.archived_at IS NULL
+    ORDER BY o.created_at ASC, o.id ASC
+  `).all(...scopeIds);
+}
+function upsertPattern(db, scopeId, synthesized, observations) {
+    const sourceObservationIds = JSON.stringify(observations.map((observation) => observation.id));
+    const existing = db.prepare(`
+    SELECT id, title, source_observation_ids
+    FROM mem_patterns
+    WHERE scope_id = ? AND title = ?
+    ORDER BY id DESC
+    LIMIT 1
+  `).get(scopeId, synthesized.title);
+    if (existing) {
+        db.prepare(`
+      UPDATE mem_patterns
+      SET summary = ?,
+          source_observation_ids = ?,
+          confidence = ?,
+          tier = 'warm',
+          last_updated = CURRENT_TIMESTAMP
+      WHERE id = ?
+    `).run(synthesized.summary, sourceObservationIds, synthesized.confidence, existing.id);
+        return "updated";
+    }
+    db.prepare(`
+    INSERT INTO mem_patterns (
+      scope_id, title, summary, source_observation_ids, confidence, tier, created_at, last_updated
+    )
+    VALUES (?, ?, ?, ?, ?, 'warm', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+  `).run(scopeId, synthesized.title, synthesized.summary, sourceObservationIds, synthesized.confidence);
+    return "created";
+}
+export async function reflectOnScope(scopeSlug, db) {
+    const scope = getScope(scopeSlug);
+    if (!scope) {
+        throw new Error(`Unknown memory scope '${scopeSlug}'.`);
+    }
+    const observations = loadObservations(scopeSlug, db);
+    const groups = buildGroups(observations);
+    const contradictionsFound = countContradictions(groups);
+    let patternsCreated = 0;
+    let patternsUpdated = 0;
+    for (const group of groups) {
+        const synthesized = await synthesizePattern(scopeSlug, group);
+        const outcome = upsertPattern(db, scope.id, synthesized, group.observations);
+        if (outcome === "created") {
+            patternsCreated++;
+        }
+        else {
+            patternsUpdated++;
+        }
+    }
+    const result = { patternsCreated, patternsUpdated, contradictionsFound };
+    log.info({ scope: scopeSlug, ...result }, "memory.reflect.scope.complete");
+    return result;
+}
+export async function reflectAllScopes(db) {
+    const results = {};
+    for (const scope of listScopes().filter((entry) => entry.active)) {
+        results[scope.slug] = await reflectOnScope(scope.slug, db);
+    }
+    return results;
+}
+//# sourceMappingURL=reflect.js.map