chapterhouse 0.13.1 → 0.14.0

package/dist/memory/manager.js

@@ -0,0 +1,84 @@
+// MemoryManager owns the memory subsystem: directory layout, the write-lock,
+// startup scaffolding, the hot-tier block, and the conversation-history source.
+// Ported from chgo's manager.go, with graceful degradation when git is absent.
+import { homedir } from "os";
+import { join } from "path";
+import { Mutex } from "./mutex.js";
+import { newMemoryPaths } from "./paths.js";
+import { gitAvailable } from "./git.js";
+import { scaffold } from "./scaffold.js";
+import { hotTier } from "./hottier.js";
+import { memorySystemInstructions } from "./instructions.js";
+import { ConversationLogSessionSource } from "./history.js";
+import { childLogger } from "../util/logger.js";
+/**
+ * Resolves the Chapterhouse data directory. Inlined here (rather than imported
+ * from ../paths.js) so the memory manager stays usable when test suites mock
+ * the paths module with a partial export set.
+ */
+function resolveDataDir() {
+    const configured = process.env.CHAPTERHOUSE_HOME?.trim();
+    if (!configured)
+        return join(homedir(), ".chapterhouse");
+    return configured.endsWith(".chapterhouse") ? configured : join(configured, ".chapterhouse");
+}
+const log = childLogger("memory");
+export class MemoryManager {
+    paths;
+    /** Serializes mutating operations across concurrent agent sessions. */
+    mutex = new Mutex();
+    sessionSource = new ConversationLogSessionSource();
+    ready = false;
+    disabled = false;
+    constructor(dataDir) {
+        this.paths = newMemoryPaths(dataDir);
+    }
+    /** Installs a conversation-history provider (overrides the default). */
+    setSessionSource(src) {
+        this.sessionSource = src;
+    }
+    getSessionSource() {
+        return this.sessionSource;
+    }
+    /** True once the memory tree is scaffolded and usable. */
+    isReady() {
+        return this.ready && !this.disabled;
+    }
+    /**
+     * Startup entry point: verifies git, then scaffolds and reconciles the tree.
+     * When git is unavailable the memory subsystem is disabled for this run
+     * rather than crashing the daemon.
+     */
+    async ensureReady() {
+        if (!gitAvailable()) {
+            this.disabled = true;
+            log.error("git not found on PATH — the memory system requires git; memory is disabled for this run");
+            return;
+        }
+        await scaffold(this.paths);
+        this.ready = true;
+    }
+    /** The always-loaded hot-tier block, or "" when memory is unavailable. */
+    hotTier() {
+        if (!this.isReady())
+            return "";
+        return hotTier(this.paths.memoryRoot);
+    }
+    /** The memory operating instructions for the system message. */
+    systemInstructions() {
+        return memorySystemInstructions();
+    }
+}
+let singleton;
+/** Returns the process-wide MemoryManager, rooted at the Chapterhouse home. */
+export function getMemoryManager() {
+    if (!singleton) {
+        singleton = new MemoryManager(resolveDataDir());
+    }
+    return singleton;
+}
+/** Resets the singleton — for tests only. */
+export function resetMemoryManagerForTests() {
+    singleton = undefined;
+}
+//# sourceMappingURL=manager.js.map

package/dist/memory/markdown.js

@@ -0,0 +1,78 @@
+// Pure markdown helpers for memory files: L0 headers, section extraction, and
+// line ranges. Ported from helpers in chgo's tools_read.go / tools_write.go.
+/** Returns the text inside the first `<!-- L0: ... -->` comment, or "". */
+export function extractL0(content) {
+    for (const line of content.split("\n")) {
+        const t = line.trim();
+        if (t.startsWith("<!-- L0:")) {
+            let inner = t.slice("<!-- L0:".length).trim();
+            if (inner.endsWith("-->"))
+                inner = inner.slice(0, -"-->".length);
+            return inner.trim();
+        }
+    }
+    return "";
+}
+/** Reports whether content has an `<!-- L0: -->` line within the first 4 lines. */
+export function hasL0Header(content) {
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length && i <= 3; i++) {
+        if (lines[i].includes("<!-- L0:"))
+            return true;
+    }
+    return false;
+}
+/**
+ * Returns lines [start, end] (1-based, inclusive). A zero or out-of-range
+ * bound is treated as the file edge.
+ */
+export function extractLines(content, start, end) {
+    const lines = content.split("\n");
+    let s = start;
+    let e = end;
+    if (s < 1)
+        s = 1;
+    if (e < 1 || e > lines.length)
+        e = lines.length;
+    if (s > lines.length)
+        return "";
+    return lines.slice(s - 1, e).join("\n");
+}
+/** Counts the leading `#` characters of a trimmed heading line. */
+function headingLevel(trimmed) {
+    return (trimmed.match(/^#+/)?.[0].length) ?? 0;
+}
+/**
+ * Returns a heading line plus its body, up to the next heading at the same or
+ * higher level. Heading match is a case-insensitive substring.
+ */
+export function extractSection(content, heading) {
+    const lines = content.split("\n");
+    const want = heading.trim().toLowerCase();
+    let startIdx = -1;
+    let startLevel = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const t = lines[i].trim();
+        if (!t.startsWith("#"))
+            continue;
+        const level = headingLevel(t);
+        const text = t.replace(/^#+/, "").trim().toLowerCase();
+        if (text.includes(want)) {
+            startIdx = i;
+            startLevel = level;
+            break;
+        }
+    }
+    if (startIdx < 0)
+        return `(section "${heading}" not found)`;
+    let end = lines.length;
+    for (let i = startIdx + 1; i < lines.length; i++) {
+        const t = lines[i].trim();
+        if (t.startsWith("#") && headingLevel(t) <= startLevel) {
+            end = i;
+            break;
+        }
+    }
+    return lines.slice(startIdx, end).join("\n");
+}
+//# sourceMappingURL=markdown.js.map

package/dist/memory/markdown.test.js

@@ -0,0 +1,42 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { extractL0, extractLines, extractSection, hasL0Header } from "./markdown.js";
+test("extractL0 returns the summary text", () => {
+    assert.equal(extractL0("<!-- L0: a quick summary -->\n# Title"), "a quick summary");
+});
+test("extractL0 returns empty string when absent", () => {
+    assert.equal(extractL0("# Title\nbody"), "");
+});
+test("extractL0 finds an L0 header beyond line 1", () => {
+    assert.equal(extractL0("# Title\n<!-- L0: second line -->\n"), "second line");
+});
+test("hasL0Header is true within the first 4 lines, false beyond", () => {
+    assert.equal(hasL0Header("<!-- L0: x -->\n"), true);
+    assert.equal(hasL0Header("a\nb\nc\n<!-- L0: x -->"), true);
+    assert.equal(hasL0Header("a\nb\nc\nd\n<!-- L0: x -->"), false);
+    assert.equal(hasL0Header("# Title only"), false);
+});
+test("extractLines returns a 1-based inclusive range", () => {
+    const content = "one\ntwo\nthree\nfour";
+    assert.equal(extractLines(content, 2, 3), "two\nthree");
+});
+test("extractLines treats zero bounds as file edges", () => {
+    const content = "one\ntwo\nthree";
+    assert.equal(extractLines(content, 0, 0), content);
+    assert.equal(extractLines(content, 2, 0), "two\nthree");
+});
+test("extractLines returns empty when start is past the end", () => {
+    assert.equal(extractLines("one\ntwo", 9, 0), "");
+});
+test("extractSection extracts a heading and its body", () => {
+    const content = "# Top\n## Current State\nbody line\n## Next\nother";
+    assert.equal(extractSection(content, "current state"), "## Current State\nbody line");
+});
+test("extractSection stops at a same-or-higher level heading", () => {
+    const content = "## A\n### A.1\nnested\n## B\ndone";
+    assert.equal(extractSection(content, "A"), "## A\n### A.1\nnested");
+});
+test("extractSection reports a missing section", () => {
+    assert.equal(extractSection("# Top\nbody", "nowhere"), '(section "nowhere" not found)');
+});
+//# sourceMappingURL=markdown.test.js.map

package/dist/memory/mutex.js

@@ -0,0 +1,18 @@
+// A minimal promise-chain mutex. Serializes mutating memory operations across
+// concurrent agent sessions that share one memory tree — the TypeScript
+// analogue of chgo's sync.Mutex.
+export class Mutex {
+    tail = Promise.resolve();
+    /** Acquires the lock; resolves with a release function. */
+    async acquire() {
+        let release;
+        const next = new Promise((resolve) => {
+            release = resolve;
+        });
+        const previous = this.tail;
+        this.tail = previous.then(() => next);
+        await previous;
+        return release;
+    }
+}
+//# sourceMappingURL=mutex.js.map

package/dist/memory/path-guard.js

@@ -0,0 +1,26 @@
+// Path-traversal protection for memory tools. Resolves a caller-supplied path
+// against the memory root, tolerating a leading "memory/" and rejecting any
+// path that escapes the root. Ported from chgo's tool.go resolveMemoryPath.
+import { isAbsolute, join, normalize, sep } from "path";
+/**
+ * Resolves `rel` against `root`. Throws if the path is empty, absolute, or
+ * escapes the memory root.
+ */
+export function resolveMemoryPath(root, rel) {
+    const trimmed = (rel ?? "").trim();
+    if (trimmed === "")
+        throw new Error("path is required");
+    let p = trimmed.split("\\").join("/");
+    if (p.startsWith("memory/"))
+        p = p.slice("memory/".length);
+    if (isAbsolute(p)) {
+        throw new Error(`path must be relative to the memory root: ${rel}`);
+    }
+    const abs = join(root, p);
+    const rootClean = normalize(root).replace(new RegExp(`\\${sep}+$`), "");
+    if (abs !== rootClean && !abs.startsWith(rootClean + sep)) {
+        throw new Error(`path "${rel}" escapes the memory root`);
+    }
+    return abs;
+}
+//# sourceMappingURL=path-guard.js.map

package/dist/memory/path-guard.test.js

@@ -0,0 +1,27 @@
+import assert from "node:assert/strict";
+import { join } from "node:path";
+import test from "node:test";
+import { resolveMemoryPath } from "./path-guard.js";
+const root = "/tmp/chapterhouse-memory-root";
+test("resolveMemoryPath resolves a relative path under the root", () => {
+    assert.equal(resolveMemoryPath(root, "personal/hot-memory.md"), join(root, "personal/hot-memory.md"));
+});
+test("resolveMemoryPath tolerates a leading memory/ prefix", () => {
+    assert.equal(resolveMemoryPath(root, "memory/personal/entities.md"), join(root, "personal/entities.md"));
+});
+test("resolveMemoryPath keeps interior .. inside the root", () => {
+    assert.equal(resolveMemoryPath(root, "cog-meta/x/../patterns.md"), join(root, "cog-meta/patterns.md"));
+});
+test("resolveMemoryPath allows nested domain paths", () => {
+    assert.equal(resolveMemoryPath(root, "work/acme/observations.md"), join(root, "work/acme/observations.md"));
+});
+test("resolveMemoryPath rejects an empty path", () => {
+    assert.throws(() => resolveMemoryPath(root, "  "), /path is required/);
+});
+test("resolveMemoryPath rejects an absolute path", () => {
+    assert.throws(() => resolveMemoryPath(root, "/etc/passwd"), /must be relative/);
+});
+test("resolveMemoryPath rejects a path that escapes the root", () => {
+    assert.throws(() => resolveMemoryPath(root, "../../etc/passwd"), /escapes the memory root/);
+});
+//# sourceMappingURL=path-guard.test.js.map

package/dist/memory/paths.js

@@ -0,0 +1,12 @@
+// Directory layout for the file-based memory subsystem, derived from the
+// Chapterhouse data directory. Ported from chgo's internal/memory/paths.go.
+import { join } from "path";
+/** Derives the memory directory layout from the data directory. */
+export function newMemoryPaths(dataDir) {
+    return {
+        dataDir,
+        memoryRoot: join(dataDir, "memory"),
+        skillsDomains: join(dataDir, "skills", "domains"),
+    };
+}
+//# sourceMappingURL=paths.js.map

package/dist/memory/reconcile.js

@@ -0,0 +1,75 @@
+// Reconciles the filesystem with the domain manifest: creates each domain's
+// directory and starter files, regenerates each non-system domain's skill, and
+// prunes orphan generated skills. Ported from chgo's reconcile.go + skills.go.
+import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+import { domainSkillTemplate, readAsset } from "./assets.js";
+/** Files that have a dedicated starter template; others use the generic one. */
+const NAMED_STARTERS = new Set(["hot-memory", "observations", "action-items", "entities"]);
+/**
+ * Makes the filesystem match the manifest. Existing memory files are never
+ * overwritten; domain skills are always regenerated; orphan skills are pruned.
+ */
+export function reconcile(paths, manifest) {
+    const tmpl = domainSkillTemplate();
+    const keep = new Set();
+    for (const domain of manifest.domains) {
+        reconcileDomainFiles(paths, domain);
+        if (domain.type === "system")
+            continue;
+        keep.add(domain.id);
+        writeDomainSkill(paths, tmpl, domain);
+    }
+    pruneOrphanSkills(paths, keep);
+}
+/** Creates the domain directory and any missing starter files. */
+function reconcileDomainFiles(paths, domain) {
+    const domainDir = join(paths.memoryRoot, ...domain.path.split("/"));
+    mkdirSync(domainDir, { recursive: true });
+    for (const file of domain.files) {
+        const dest = join(domainDir, `${file}.md`);
+        if (existsSync(dest))
+            continue;
+        writeFileSync(dest, renderStarter(file, domain.label), "utf8");
+    }
+}
+/** Regenerates the domain's SKILL.md from the template. */
+function writeDomainSkill(paths, tmpl, domain) {
+    const skillDir = join(paths.skillsDomains, domain.id);
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(join(skillDir, "SKILL.md"), renderDomainSkill(tmpl, domain), "utf8");
+}
+/**
+ * Removes generated skill directories with no matching non-system domain.
+ * Memory directories are never pruned.
+ */
+function pruneOrphanSkills(paths, keep) {
+    let entries;
+    try {
+        entries = readdirSync(paths.skillsDomains, { withFileTypes: true });
+    }
+    catch {
+        return; // skills/domains/ does not exist yet
+    }
+    for (const entry of entries) {
+        if (entry.isDirectory() && !keep.has(entry.name)) {
+            rmSync(join(paths.skillsDomains, entry.name), { recursive: true, force: true });
+        }
+    }
+}
+/** Renders the starter template for a domain file. */
+export function renderStarter(file, label) {
+    const name = NAMED_STARTERS.has(file) ? file : "generic";
+    const tmpl = readAsset(`templates/${name}.md`);
+    return tmpl.split("{{LABEL}}").join(label).split("{{FILE}}").join(file);
+}
+/** Substitutes domain fields into the per-domain skill template. */
+export function renderDomainSkill(tmpl, domain) {
+    return tmpl
+        .split("{{ID}}").join(domain.id)
+        .split("{{LABEL}}").join(domain.label)
+        .split("{{PATH}}").join(domain.path)
+        .split("{{TRIGGER_LINE}}").join(domain.triggers.join(", "))
+        .split("{{FILES}}").join(domain.files.join(", "));
+}
+//# sourceMappingURL=reconcile.js.map

package/dist/memory/reconcile.test.js

@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+import { gitAvailable } from "./git.js";
+import { MemoryManager } from "./manager.js";
+import { parseManifest } from "./domains.js";
+import { reconcile } from "./reconcile.js";
+const sandbox = join(process.cwd(), ".test-work", `mem-reconcile-${process.pid}`);
+const acme = {
+    id: "acme",
+    path: "work/acme",
+    type: "work",
+    label: "Acme work",
+    triggers: ["acme"],
+    files: ["hot-memory", "observations"],
+};
+test.beforeEach(() => {
+    rmSync(sandbox, { recursive: true, force: true });
+    mkdirSync(sandbox, { recursive: true });
+});
+test.after(() => rmSync(sandbox, { recursive: true, force: true }));
+test("reconcile creates a new domain's directory, files, and skill", async () => {
+    if (!gitAvailable())
+        return;
+    const mgr = new MemoryManager(sandbox);
+    await mgr.ensureReady();
+    const manifest = parseManifest(readFileSync(join(mgr.paths.memoryRoot, "domains.yml"), "utf8"));
+    manifest.domains.push(acme);
+    reconcile(mgr.paths, manifest);
+    assert.ok(existsSync(join(mgr.paths.memoryRoot, "work/acme/hot-memory.md")));
+    assert.ok(existsSync(join(mgr.paths.memoryRoot, "work/acme/observations.md")));
+    assert.ok(existsSync(join(mgr.paths.skillsDomains, "acme", "SKILL.md")));
+});
+test("reconcile prunes an orphan skill but keeps the memory directory", async () => {
+    if (!gitAvailable())
+        return;
+    const mgr = new MemoryManager(sandbox);
+    await mgr.ensureReady();
+    const withAcme = parseManifest(readFileSync(join(mgr.paths.memoryRoot, "domains.yml"), "utf8"));
+    withAcme.domains.push(acme);
+    reconcile(mgr.paths, withAcme);
+    assert.ok(existsSync(join(mgr.paths.skillsDomains, "acme", "SKILL.md")));
+    // Reconcile again without acme — its skill is pruned, its memory is kept.
+    const withoutAcme = parseManifest(readFileSync(join(mgr.paths.memoryRoot, "domains.yml"), "utf8"));
+    reconcile(mgr.paths, withoutAcme);
+    assert.ok(!existsSync(join(mgr.paths.skillsDomains, "acme")), "orphan skill pruned");
+    assert.ok(existsSync(join(mgr.paths.memoryRoot, "work/acme/hot-memory.md")), "memory kept");
+});
+//# sourceMappingURL=reconcile.test.js.map

package/dist/memory/scaffold.js

@@ -0,0 +1,37 @@
+// Builds and maintains the memory tree. On first run it copies the seed files,
+// initializes a git repo, and reconciles the manifest. On every subsequent run
+// it reconciles only — so manifest edits take effect — but never overwrites
+// files. Ported from chgo's scaffold.go.
+import { existsSync, mkdirSync, readFileSync } from "fs";
+import { join } from "path";
+import { copySeedTree } from "./assets.js";
+import { parseManifest } from "./domains.js";
+import { reconcile } from "./reconcile.js";
+import { gitCommitAll, gitInit } from "./git.js";
+import { childLogger } from "../util/logger.js";
+const log = childLogger("memory");
+/** Scaffolds (when fresh) or reconciles (when existing) the memory tree. */
+export async function scaffold(paths) {
+    const fresh = !existsSync(paths.memoryRoot);
+    if (fresh) {
+        log.info({ root: paths.memoryRoot }, "scaffolding fresh memory tree");
+    }
+    mkdirSync(paths.memoryRoot, { recursive: true });
+    copySeedTree(paths.memoryRoot);
+    mkdirSync(join(paths.memoryRoot, "cog-meta", "scenarios"), { recursive: true });
+    const manifestData = readFileSync(join(paths.memoryRoot, "domains.yml"), "utf8");
+    try {
+        const manifest = parseManifest(manifestData);
+        reconcile(paths, manifest);
+    }
+    catch (err) {
+        if (fresh)
+            throw err;
+        log.warn({ err }, "memory: domains.yml malformed, skipping reconcile");
+    }
+    if (fresh) {
+        await gitInit(paths.memoryRoot);
+    }
+    await gitCommitAll(paths.memoryRoot, "chore: scaffold memory");
+}
+//# sourceMappingURL=scaffold.js.map

package/dist/memory/scaffold.test.js

@@ -0,0 +1,52 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+import { gitAvailable } from "./git.js";
+import { MemoryManager } from "./manager.js";
+const sandbox = join(process.cwd(), ".test-work", `mem-scaffold-${process.pid}`);
+test.beforeEach(() => {
+    rmSync(sandbox, { recursive: true, force: true });
+    mkdirSync(sandbox, { recursive: true });
+});
+test.after(() => rmSync(sandbox, { recursive: true, force: true }));
+test("ensureReady scaffolds a fresh memory tree", async () => {
+    if (!gitAvailable())
+        return;
+    const mgr = new MemoryManager(sandbox);
+    await mgr.ensureReady();
+    assert.equal(mgr.isReady(), true);
+    const root = mgr.paths.memoryRoot;
+    for (const rel of [
+        "domains.yml",
+        "hot-memory.md",
+        "glacier/index.md",
+        "cog-meta/patterns.md",
+        "cog-meta/reflect-cursor.md",
+    ]) {
+        assert.ok(existsSync(join(root, rel)), `expected ${rel}`);
+    }
+    assert.ok(existsSync(join(root, "cog-meta", "scenarios")), "cog-meta/scenarios dir");
+    assert.ok(existsSync(join(root, ".git")), ".git repo");
+    // The personal domain is generated from the manifest.
+    for (const rel of ["personal/hot-memory.md", "personal/observations.md", "personal/entities.md"]) {
+        assert.ok(existsSync(join(root, rel)), `expected ${rel}`);
+    }
+    // personal gets a generated skill; the system domain cog-meta does not.
+    assert.ok(existsSync(join(mgr.paths.skillsDomains, "personal", "SKILL.md")), "personal skill");
+    assert.ok(!existsSync(join(mgr.paths.skillsDomains, "cog-meta")), "cog-meta must not get a skill");
+});
+test("scaffold is idempotent and never overwrites edited files", async () => {
+    if (!gitAvailable())
+        return;
+    const first = new MemoryManager(sandbox);
+    await first.ensureReady();
+    const hot = join(first.paths.memoryRoot, "hot-memory.md");
+    writeFileSync(hot, "<!-- L0: edited -->\nhand-edited content");
+    const second = new MemoryManager(sandbox);
+    await second.ensureReady();
+    assert.equal(readFileSync(hot, "utf8"), "<!-- L0: edited -->\nhand-edited content");
+    const manifest = readFileSync(join(second.paths.memoryRoot, "domains.yml"), "utf8");
+    assert.equal(manifest.match(/id: personal/g)?.length, 1, "no duplicate domains");
+});
+//# sourceMappingURL=scaffold.test.js.map

package/dist/memory/tools/commit-wrapper.js

@@ -0,0 +1,32 @@
+// Write-lock + auto-commit wrapper for mutating memory tools. Every memory
+// write goes through withMemoryWrite so the tree stays consistent and every
+// change is committed to git.
+import { gitCommitAll } from "../git.js";
+/**
+ * Runs `fn` under the memory write-lock, then commits the tree with `message`.
+ */
+export async function withMemoryWrite(manager, message, fn) {
+    const release = await manager.mutex.acquire();
+    try {
+        const result = await fn();
+        await gitCommitAll(manager.paths.memoryRoot, message);
+        return result;
+    }
+    finally {
+        release();
+    }
+}
+/**
+ * Runs `fn` under the memory write-lock without an automatic commit — for
+ * operations that commit themselves with a custom message.
+ */
+export async function withMemoryLock(manager, fn) {
+    const release = await manager.mutex.acquire();
+    try {
+        return await fn();
+    }
+    finally {
+        release();
+    }
+}
+//# sourceMappingURL=commit-wrapper.js.map

package/dist/memory/tools/domains.js

@@ -0,0 +1,73 @@
+// Domain tools: cog_domains, cog_domain_create. Ported from chgo's tools_domains.go.
+import { defineTool } from "@github/copilot-sdk";
+import { z } from "zod";
+import { readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { DOMAIN_TYPES, defaultFilesForType, findDomain, marshalManifest, parseManifest, } from "../domains.js";
+import { reconcile } from "../reconcile.js";
+import { gitCommitAll } from "../git.js";
+import { withMemoryLock } from "./commit-wrapper.js";
+import { toolError } from "./shared.js";
+export function createDomainTools(manager) {
+    const root = manager.paths.memoryRoot;
+    const manifestPath = join(root, "domains.yml");
+    return [
+        defineTool("cog_domains", {
+            description: "Return the domain manifest (memory/domains.yml).",
+            parameters: z.object({}),
+            handler: async () => {
+                try {
+                    return readFileSync(manifestPath, "utf8");
+                }
+                catch (err) {
+                    return toolError(err);
+                }
+            },
+        }),
+        defineTool("cog_domain_create", {
+            description: "Add a domain: append it to domains.yml, create its memory directory and " +
+                "starter files, generate its skill, and commit. Used by the setup skill.",
+            parameters: z.object({
+                id: z.string().describe("Unique slug, e.g. acme"),
+                path: z.string().describe("Memory path, may be nested, e.g. work/acme"),
+                type: z.string().describe("personal | work | side-project | system"),
+                label: z.string().describe("One-line description"),
+                triggers: z.array(z.string()).optional().describe("Routing keywords for this domain"),
+                files: z.array(z.string()).optional().describe("Optional: memory files to create; defaults by type"),
+            }),
+            handler: async (args) => {
+                try {
+                    if (!args.id || !args.path || !args.type) {
+                        return "Error: id, path, and type are required";
+                    }
+                    if (!DOMAIN_TYPES.includes(args.type)) {
+                        return `Error: invalid type "${args.type}"`;
+                    }
+                    return await withMemoryLock(manager, async () => {
+                        const manifest = parseManifest(readFileSync(manifestPath, "utf8"));
+                        if (findDomain(manifest, args.id)) {
+                            return `Error: domain "${args.id}" already exists`;
+                        }
+                        const domain = {
+                            id: args.id,
+                            path: args.path,
+                            type: args.type,
+                            label: args.label,
+                            triggers: args.triggers ?? [],
+                            files: args.files && args.files.length > 0 ? args.files : defaultFilesForType(args.type),
+                        };
+                        manifest.domains.push(domain);
+                        writeFileSync(manifestPath, marshalManifest(manifest), "utf8");
+                        reconcile(manager.paths, manifest);
+                        await gitCommitAll(root, `feat: add domain ${args.id}`);
+                        return `created domain "${args.id}" at memory/${args.path} with skill ${args.id}`;
+                    });
+                }
+                catch (err) {
+                    return toolError(err);
+                }
+            },
+        }),
+    ];
+}
+//# sourceMappingURL=domains.js.map