chapterhouse 0.7.0 → 0.8.0

package/dist/copilot/tools.memory.test.js

@@ -555,4 +555,36 @@ test("memory_promote and memory_demote are orchestrator-only manual tier control
     assert.equal(demoted.ok, true);
     assert.equal(db.prepare(`SELECT tier FROM mem_observations WHERE id = ?`).get(observationId).tier, "cold");
 });
+test("memory_remember dual-writes decisions to the wiki timeline when an entity is provided", async () => {
+    const { toolsModule, agentsModule, dbModule } = await loadModules();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const wikiFs = await import(new URL("../wiki/fs.js", import.meta.url).href);
+    wikiFs.ensureWikiStructure();
+    wikiFs.writePage("pages/projects/project-x/index.md", "---\ntitle: Project X\nsummary: Project X summary\nupdated: 2026-05-14\ntags: []\n---\n\n# Project X\n\n## Summary\n\nCurrent state.\n");
+    const bindToolsToAgent = agentsModule.bindToolsToAgent;
+    const chapterhouseTools = bindToolsToAgent("chapterhouse", tools);
+    const memoryRemember = findTool(chapterhouseTools, "memory_remember");
+    const result = await memoryRemember.handler({
+        scope: "chapterhouse",
+        kind: "decision",
+        entity_name: "project-x",
+        entity_kind: "project",
+        title: "Ship append-only decisions",
+        content: "Store the decision in SQLite and mirror it into the project timeline.",
+    }, {});
+    assert.equal(result.ok, true);
+    const db = dbModule.getDb();
+    const decision = db.prepare(`SELECT title, rationale FROM mem_decisions WHERE title = ?`).get("Ship append-only decisions");
+    assert.deepEqual(decision, {
+        title: "Ship append-only decisions",
+        rationale: "Store the decision in SQLite and mirror it into the project timeline.",
+    });
+    const page = wikiFs.readPage("pages/projects/project-x/index.md") ?? "";
+    assert.match(page, /## Timeline/);
+    assert.match(page, /Ship append-only decisions/);
+    assert.match(page, /Store the decision in SQLite and mirror it into the project timeline\./);
+});
 //# sourceMappingURL=tools.memory.test.js.map

package/dist/copilot/tools.wiki.test.js

@@ -1,7 +1,6 @@
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
 import { join } from "node:path";
-import { tmpdir } from "node:os";
 import test from "node:test";
 async function loadToolsModule() {
     return await import(new URL(`./tools.js?cachebust=${Date.now()}-${Math.random()}`, import.meta.url).href);
@@ -9,10 +8,14 @@ async function loadToolsModule() {
 async function readWikiArtifacts() {
     const nonce = `${Date.now()}-${Math.random()}`;
     const wikiFs = await import(new URL(`../wiki/fs.js?case=${nonce}`, import.meta.url).href);
-    return wikiFs;
+    const indexManager = await import(new URL(`../wiki/index-manager.js?case=${nonce}`, import.meta.url).href);
+    return { wikiFs, indexManager };
 }
+test.before(() => {
+    mkdirSync(join(process.cwd(), ".test-work"), { recursive: true });
+});
 test.beforeEach(() => {
-    process.env.CHAPTERHOUSE_HOME = mkdtempSync(join(tmpdir(), "chapterhouse-tools-wiki-"));
+    process.env.CHAPTERHOUSE_HOME = mkdtempSync(join(process.cwd(), ".test-work", "chapterhouse-tools-wiki-"));
     process.env.CHAPTERHOUSE_AGENT_NAME = "tools-test-agent";
 });
 test.afterEach(async () => {
@@ -38,9 +41,9 @@ test("wiki_update returns validation errors instead of throwing for invalid fron
         content: "# Chapterhouse\n\nRuntime notes.\n",
     });
     assert.deepEqual(result, {
-        error: "Wiki page frontmatter violates the required shape: missing YAML frontmatter. Use:\n---\ntitle: <title>\nsummary: <plain-text one-line summary, max 200 chars>\nupdated: YYYY-MM-DD\ntags: []\nrelated: []\n---",
+        error: "Wiki page frontmatter violates the required shape: missing 'summary'. Use:\n---\ntitle: <title>\nsummary: <plain-text one-line summary, max 200 chars>\nupdated: YYYY-MM-DD\ntags: []\nrelated: []\n---",
     });
-    const wikiFs = await readWikiArtifacts();
+    const { wikiFs } = await readWikiArtifacts();
     assert.equal(wikiFs.readPage("pages/shared/chapterhouse.md"), undefined);
 });
 test("wiki_update returns descriptive validation errors for malformed summaries and unknown tags", async () => {
@@ -99,22 +102,28 @@ Runtime notes.
 `,
     });
     assert.equal(result, "Wiki page updated: Chapterhouse (pages/shared/chapterhouse.md)");
-    const wikiFs = await readWikiArtifacts();
+    const { wikiFs, indexManager } = await readWikiArtifacts();
+    const today = new Date().toISOString().slice(0, 10);
     assert.match(wikiFs.readPage("pages/shared/chapterhouse.md") ?? "", /summary: Runtime notes/);
-    assert.match(wikiFs.readIndexFile(), /\[Chapterhouse\]\(pages\/shared\/chapterhouse\.md\) — Runtime notes/);
+    assert.deepEqual(indexManager.parseIndex(), [
+        {
+            path: "pages/shared/chapterhouse.md",
+            title: "Chapterhouse",
+            summary: "Runtime notes",
+            section: "shared",
+            tags: ["engineering"],
+            updated: today,
+        },
+    ]);
 });
-test("wiki tools append audit entries to pages/_meta/log.md", async () => {
+test("retained wiki tools append audit entries to pages/_meta/log.md", async () => {
     const toolsModule = await loadToolsModule();
     const tools = toolsModule.createTools({
         client: { async listModels() { return []; } },
         onAgentTaskComplete: () => { },
     });
     const wikiUpdate = tools.find((entry) => entry.name === "wiki_update");
-    const wikiIngest = tools.find((entry) => entry.name === "wiki_ingest");
-    const wikiLint = tools.find((entry) => entry.name === "wiki_lint");
-    const wikiRebuildIndex = tools.find((entry) => entry.name === "wiki_rebuild_index");
-    const forget = tools.find((entry) => entry.name === "forget");
-    assert.ok(wikiUpdate && wikiIngest && wikiLint && wikiRebuildIndex && forget);
+    assert.ok(wikiUpdate);
     await wikiUpdate.handler({
         path: "pages/shared/chapterhouse.md",
         title: "Chapterhouse",
@@ -133,66 +142,51 @@ tags: [engineering]
 Runtime notes with enough content to avoid incidental lint noise in the audit-log test.
 `,
     });
-    await wikiIngest.handler({
-        type: "text",
-        source: "Source content for the wiki ingest audit log test.",
-        name: "audit-log-source",
-    });
-    await wikiLint.handler({});
-    await wikiRebuildIndex.handler({});
-    await forget.handler({ page_path: "pages/shared/chapterhouse.md" });
-    const wikiFs = await readWikiArtifacts();
+    const { wikiFs } = await readWikiArtifacts();
     const log = wikiFs.readLogFile();
     assert.match(log, /update \| wiki_update: Chapterhouse \(pages\/shared\/chapterhouse\.md\) \| tools-test-agent/);
-    assert.match(log, /ingest \| Ingested text: audit-log-source \(\d+ chars\) \| tools-test-agent/);
-    assert.match(log, /lint \| .* \| tools-test-agent/);
-    assert.match(log, /rebuild-index \| wiki_rebuild_index: rebuilt \d+ entries from pages on disk \| tools-test-agent/);
-    assert.match(log, /delete \| forget: deleted page pages\/shared\/chapterhouse\.md \| tools-test-agent/);
 });
-test("wiki_fix defaults to dry-run previews and logs applied fixes in write mode", async () => {
+test("removed legacy wiki tools return helpful stub messages without mutating wiki pages", async () => {
     const toolsModule = await loadToolsModule();
     const tools = toolsModule.createTools({
         client: { async listModels() { return []; } },
         onAgentTaskComplete: () => { },
     });
+    const wikiUpdate = tools.find((entry) => entry.name === "wiki_update");
+    const remember = tools.find((entry) => entry.name === "remember");
+    const recall = tools.find((entry) => entry.name === "recall");
+    const forget = tools.find((entry) => entry.name === "forget");
+    const wikiIngest = tools.find((entry) => entry.name === "wiki_ingest");
+    const wikiLint = tools.find((entry) => entry.name === "wiki_lint");
+    const wikiRebuildIndex = tools.find((entry) => entry.name === "wiki_rebuild_index");
     const wikiFix = tools.find((entry) => entry.name === "wiki_fix");
-    assert.ok(wikiFix);
-    const wikiFs = await readWikiArtifacts();
-    wikiFs.writePage("pages/_meta/taxonomy.md", `## Process
-- runbook
-`);
-    wikiFs.writePage("pages/projects/chapterhouse/index.md", `---
+    assert.ok(wikiUpdate && remember && recall && forget && wikiIngest && wikiLint && wikiRebuildIndex && wikiFix);
+    await wikiUpdate.handler({
+        path: "pages/shared/chapterhouse.md",
+        title: "Chapterhouse",
+        summary: "Runtime notes",
+        content: `---
 title: Chapterhouse
 summary: Runtime notes
 updated: 2026-05-12
-tags: [Run Book]
+tags: [engineering]
 ---
 
 # Chapterhouse
 
-Runtime notes with enough content to avoid incidental stub handling.
-
-## Details
-
-One
-Two
-Three
-Four
-Five
-Six
-Seven
-Eight
-`);
-    const before = wikiFs.readPage("pages/projects/chapterhouse/index.md");
-    const preview = await wikiFix.handler({});
-    assert.equal(typeof preview, "object");
-    assert.equal(preview.dryRun, true);
-    assert.equal(preview.changedFiles, 1);
-    assert.match(preview.diff, /--- a\/pages\/projects\/chapterhouse\/index\.md/);
-    assert.equal(wikiFs.readPage("pages/projects/chapterhouse/index.md"), before);
-    const applied = await wikiFix.handler({ dry_run: false });
-    assert.equal(applied.dryRun, false);
-    assert.match(wikiFs.readPage("pages/projects/chapterhouse/index.md") ?? "", /tags: \[runbook\]/);
-    assert.match(wikiFs.readLogFile(), /fix-tags \| pages\/projects\/chapterhouse\/index\.md \| tools-test-agent/);
+Runtime notes.
+`,
+    });
+    assert.equal(await remember.handler({ category: "fact", content: "The sky is blue" }), "This tool has been removed. Use wiki_update to write to wiki pages, or memory_remember for agent memory.");
+    assert.equal(await recall.handler({ keyword: "sky" }), "This tool has been removed. Use wiki_search to search wiki pages, or memory_recall for agent memory.");
+    assert.equal(await forget.handler({ page_path: "pages/shared/chapterhouse.md" }), "This tool has been removed. Use wiki_update to modify wiki pages.");
+    assert.equal(await wikiRebuildIndex.handler({}), "This tool has been removed. The wiki index is now maintained automatically via SQLite FTS5.");
+    assert.equal(await wikiLint.handler({}), "This tool has been removed. Wiki health checks are no longer needed with SQLite-backed storage.");
+    assert.equal(await wikiFix.handler({}), "This tool has been removed. Use wiki_update to correct wiki pages.");
+    assert.equal(await wikiIngest.handler({ source: "hello" }), "This tool has been removed. Use wiki_ingest_source instead.");
+    const { wikiFs } = await readWikiArtifacts();
+    assert.equal(wikiFs.readPage("pages/facts.md"), undefined);
+    assert.match(wikiFs.readPage("pages/shared/chapterhouse.md") ?? "", /Runtime notes\./);
+    assert.doesNotMatch(wikiFs.readLogFile(), /forget: deleted page|wiki_rebuild_index|wiki_lint|wiki_fix|wiki_ingest:/);
 });
 //# sourceMappingURL=tools.wiki.test.js.map

package/dist/daemon.js

@@ -21,9 +21,12 @@ import { logger } from "./util/logger.js";
 import { CHAPTERHOUSE_VERSION } from "./version.js";
 import { isWorkiqAutoInstallEnabled, ensureWorkiqMcpEntry } from "./copilot/workiq-installer.js";
 import { MemoryHousekeepingScheduler } from "./memory/housekeeping-scheduler.js";
+import { runP6Migration } from "./memory/migration.js";
+import { WikiConsolidationScheduler } from "./wiki/scheduler.js";
 const log = logger.child({ module: "daemon" });
 const modeContext = new ModeContext(config);
 let memoryHousekeepingScheduler;
+let wikiConsolidationScheduler;
 const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
 /**
  * How long the daemon waits for in-flight work to finish before forcing an exit.
@@ -126,6 +129,8 @@ async function main() {
         const moved = enforceTopicStructure();
         log.info({ moved }, "Topic-structure migration complete");
     }
+    const p6Migration = await runP6Migration(getDb());
+    log.info({ p6Migration }, "P6 wiki seed migration complete");
     // Prune orphaned session folders older than 7 days
     pruneOldSessions();
     // One-time deprecation note for legacy Telegram users (v1 → v2)
@@ -158,6 +163,8 @@ async function main() {
     await startApiServer();
     memoryHousekeepingScheduler = new MemoryHousekeepingScheduler();
     memoryHousekeepingScheduler.start();
+    wikiConsolidationScheduler = new WikiConsolidationScheduler();
+    wikiConsolidationScheduler.start();
     if (modeContext.canLogToAdo() && (config.adoPat || config.teamChapterhouseUrl)) {
         new StandupScheduler().schedule();
     }
@@ -212,6 +219,7 @@ async function shutdown() {
     // Destroy all active agent sessions
     await shutdownAgents();
     await memoryHousekeepingScheduler?.stop();
+    await wikiConsolidationScheduler?.stop();
     try {
         stopEpisodeWriter();
     }
@@ -234,6 +242,7 @@ export async function restartDaemon() {
     // Destroy all active agent sessions
     await shutdownAgents();
     await memoryHousekeepingScheduler?.stop();
+    await wikiConsolidationScheduler?.stop();
     try {
         stopEpisodeWriter();
     }

package/dist/memory/decisions.js

@@ -7,6 +7,7 @@ function toDecision(row) {
         title: row.title,
         rationale: row.rationale,
         decidedAt: row.decided_at,
+        source: row.source ?? undefined,
         tier: row.tier,
         supersededBy: row.superseded_by ?? undefined,
         archivedAt: row.archived_at ?? undefined,
@@ -15,14 +16,14 @@ function toDecision(row) {
 }
 export function recordDecision(input) {
     const result = getDb().prepare(`
-    INSERT INTO mem_decisions (scope_id, entity_id, title, rationale, decided_at, tier, created_at)
-    VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
-  `).run(input.scope_id, input.entity_id ?? null, input.title, input.rationale, input.decided_at ?? new Date().toISOString().slice(0, 10), input.tier ?? "warm");
+    INSERT INTO mem_decisions (scope_id, entity_id, title, rationale, decided_at, source, tier, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+  `).run(input.scope_id, input.entity_id ?? null, input.title, input.rationale, input.decided_at ?? new Date().toISOString().slice(0, 10), input.source ?? null, input.tier ?? "warm");
     return getDecision(Number(result.lastInsertRowid));
 }
 export function getDecision(id) {
     const row = getDb().prepare(`
-    SELECT id, scope_id, entity_id, title, rationale, decided_at, tier, superseded_by, archived_at, created_at
+    SELECT id, scope_id, entity_id, title, rationale, decided_at, source, tier, superseded_by, archived_at, created_at
     FROM mem_decisions
     WHERE id = ?
   `).get(id);
@@ -30,7 +31,7 @@ export function getDecision(id) {
 }
 export function listDecisions(input = {}) {
     const rows = getDb().prepare(`
-    SELECT id, scope_id, entity_id, title, rationale, decided_at, tier, superseded_by, archived_at, created_at
+    SELECT id, scope_id, entity_id, title, rationale, decided_at, source, tier, superseded_by, archived_at, created_at
     FROM mem_decisions
     WHERE (? IS NULL OR scope_id = ?)
       AND (? IS NULL OR entity_id = ?)

package/dist/memory/entities.js

@@ -3,6 +3,7 @@ function toEntity(row) {
     return {
         id: row.id,
         scopeId: row.scope_id,
+        slug: row.slug ?? undefined,
         kind: row.kind,
         name: row.name,
         summary: row.summary ?? undefined,
@@ -14,7 +15,7 @@ function toEntity(row) {
 }
 export function getEntity(id) {
     const row = getDb().prepare(`
-    SELECT id, scope_id, kind, name, summary, tier, confidence, created_at, updated_at
+    SELECT id, scope_id, slug, kind, name, summary, tier, confidence, created_at, updated_at
     FROM mem_entities
     WHERE id = ?
   `).get(id);
@@ -22,32 +23,42 @@ export function getEntity(id) {
 }
 export function findEntityByName(scopeId, kind, name) {
     const row = getDb().prepare(`
-    SELECT id, scope_id, kind, name, summary, tier, confidence, created_at, updated_at
+    SELECT id, scope_id, slug, kind, name, summary, tier, confidence, created_at, updated_at
     FROM mem_entities
     WHERE scope_id = ? AND kind = ? AND name = ?
   `).get(scopeId, kind, name);
     return row ? toEntity(row) : undefined;
 }
+export function findEntityBySlug(scopeId, slug) {
+    const row = getDb().prepare(`
+    SELECT id, scope_id, slug, kind, name, summary, tier, confidence, created_at, updated_at
+    FROM mem_entities
+    WHERE scope_id = ? AND slug = ?
+  `).get(scopeId, slug);
+    return row ? toEntity(row) : undefined;
+}
 export function upsertEntity(input) {
     const db = getDb();
-    const existing = findEntityByName(input.scope_id, input.kind, input.name);
+    const existing = input.slug
+        ? findEntityBySlug(input.scope_id, input.slug) ?? findEntityByName(input.scope_id, input.kind, input.name)
+        : findEntityByName(input.scope_id, input.kind, input.name);
     if (existing) {
         db.prepare(`
       UPDATE mem_entities
-      SET summary = ?, tier = ?, confidence = ?, updated_at = CURRENT_TIMESTAMP
+      SET slug = COALESCE(?, slug), summary = ?, tier = ?, confidence = ?, updated_at = CURRENT_TIMESTAMP
       WHERE id = ?
-    `).run(input.summary ?? existing.summary ?? null, input.tier ?? existing.tier, input.confidence ?? existing.confidence, existing.id);
+    `).run(input.slug ?? null, input.summary ?? existing.summary ?? null, input.tier ?? existing.tier, input.confidence ?? existing.confidence, existing.id);
         return getEntity(existing.id);
     }
     const result = db.prepare(`
-    INSERT INTO mem_entities (scope_id, kind, name, summary, tier, confidence, created_at, updated_at)
-    VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
-  `).run(input.scope_id, input.kind, input.name, input.summary ?? null, input.tier ?? "warm", input.confidence ?? 1.0);
+    INSERT INTO mem_entities (scope_id, slug, kind, name, summary, tier, confidence, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+  `).run(input.scope_id, input.slug ?? null, input.kind, input.name, input.summary ?? null, input.tier ?? "warm", input.confidence ?? 1.0);
     return getEntity(Number(result.lastInsertRowid));
 }
 export function listEntities(input = {}) {
     const rows = getDb().prepare(`
-    SELECT id, scope_id, kind, name, summary, tier, confidence, created_at, updated_at
+    SELECT id, scope_id, slug, kind, name, summary, tier, confidence, created_at, updated_at
     FROM mem_entities
     WHERE (? IS NULL OR scope_id = ?)
       AND (? IS NULL OR kind = ?)

package/dist/memory/hooks.js

@@ -0,0 +1,151 @@
+import { childLogger } from "../util/logger.js";
+import { getActiveScope } from "./active-scope.js";
+import { recordObservation } from "./observations.js";
+import { getScope } from "./scopes.js";
+const log = childLogger("memory.hooks");
+// ---------------------------------------------------------------------------
+// Env knob
+// ---------------------------------------------------------------------------
+function isHooksEnabled() {
+    const raw = process.env.CHAPTERHOUSE_MEMORY_HOOKS_ENABLED?.trim();
+    if (raw === "false" || raw === "0")
+        return false;
+    return true;
+}
+// ---------------------------------------------------------------------------
+// Dispatcher
+// ---------------------------------------------------------------------------
+export class MemoryHookDispatcher {
+    handlers = new Map();
+    register(event, handler) {
+        const bucket = this.handlers.get(event) ?? [];
+        bucket.push(handler);
+        this.handlers.set(event, bucket);
+    }
+    async dispatch(event, payload) {
+        if (!isHooksEnabled()) {
+            log.debug({ event }, "memory.hooks.skip.disabled");
+            return;
+        }
+        const bucket = this.handlers.get(event) ?? [];
+        if (bucket.length === 0) {
+            log.debug({ event }, "memory.hooks.no_handlers");
+            return;
+        }
+        log.info({ event, handlerCount: bucket.length }, "memory.hooks.dispatch");
+        for (const handler of bucket) {
+            try {
+                await handler(payload);
+            }
+            catch (err) {
+                log.error({ err, event }, "memory.hooks.handler_error");
+            }
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Singleton dispatcher — shared across the process
+// ---------------------------------------------------------------------------
+export const hookDispatcher = new MemoryHookDispatcher();
+// ---------------------------------------------------------------------------
+// Built-in handler: git:commit → observation in active scope
+// ---------------------------------------------------------------------------
+function buildGitCommitContent(payload) {
+    const lines = [`Git commit: ${payload.message}`];
+    if (payload.stat?.trim()) {
+        lines.push("", "Changed files:", payload.stat.trim());
+    }
+    return lines.join("\n");
+}
+function resolveGlobalOrActiveScope() {
+    const active = getActiveScope();
+    if (active)
+        return active;
+    return getScope("global") ?? null;
+}
+export async function handleGitCommitHook(payload) {
+    if (!isHooksEnabled()) {
+        log.debug("memory.hooks.git_commit.disabled");
+        return { observation_id: "disabled" };
+    }
+    const scope = resolveGlobalOrActiveScope();
+    if (!scope) {
+        throw new Error("No active or global memory scope found. Create a scope before using memory hooks.");
+    }
+    const content = buildGitCommitContent(payload);
+    const observation = recordObservation({
+        scope_id: scope.id,
+        content,
+        source: "git:commit",
+        tier: "warm",
+        confidence: 1.0,
+    });
+    log.info({ scope: scope.slug, observation_id: observation.id }, "memory.hooks.git_commit.recorded");
+    return { observation_id: String(observation.id) };
+}
+// ---------------------------------------------------------------------------
+// Built-in handler: pr:merge → observation
+// ---------------------------------------------------------------------------
+function buildPrMergeContent(payload) {
+    const lines = [`PR #${payload.number} merged: ${payload.title}`];
+    if (payload.body?.trim()) {
+        lines.push("", payload.body.trim());
+    }
+    if (payload.files_changed && payload.files_changed.length > 0) {
+        lines.push("", "Files changed:");
+        for (const file of payload.files_changed) {
+            lines.push(`  ${file}`);
+        }
+    }
+    return lines.join("\n");
+}
+export async function handlePrMergeHook(payload) {
+    if (!isHooksEnabled()) {
+        log.debug("memory.hooks.pr_merge.disabled");
+        return { observation_id: "disabled" };
+    }
+    const scope = resolveGlobalOrActiveScope();
+    if (!scope) {
+        throw new Error("No active or global memory scope found. Create a scope before using memory hooks.");
+    }
+    const content = buildPrMergeContent(payload);
+    const observation = recordObservation({
+        scope_id: scope.id,
+        content,
+        source: "pr:merge",
+        tier: "warm",
+        confidence: 1.0,
+    });
+    log.info({ scope: scope.slug, observation_id: observation.id, pr: payload.number }, "memory.hooks.pr_merge.recorded");
+    return { observation_id: String(observation.id) };
+}
+// ---------------------------------------------------------------------------
+// Built-in handler: scope:created → observation in global scope
+// ---------------------------------------------------------------------------
+hookDispatcher.register("scope:created", async (payload) => {
+    const globalScope = getScope("global");
+    if (!globalScope) {
+        log.debug("memory.hooks.scope_created.no_global_scope");
+        return;
+    }
+    const content = `Scope '${payload.slug}' created: ${payload.description || payload.title}`;
+    const observation = recordObservation({
+        scope_id: globalScope.id,
+        content,
+        source: "scope:created",
+        tier: "warm",
+        confidence: 1.0,
+    });
+    log.info({ scope: payload.slug, observation_id: observation.id }, "memory.hooks.scope_created.recorded");
+});
+// ---------------------------------------------------------------------------
+// Built-in handler: memory:decision → structured log event
+// ---------------------------------------------------------------------------
+hookDispatcher.register("memory:decision", async (payload) => {
+    log.info({
+        decision_id: payload.id,
+        scope_id: payload.scope_id,
+        title: payload.title,
+    }, "memory.hooks.decision.recorded");
+});
+//# sourceMappingURL=hooks.js.map