@mandays/obsidian-memory-mcp 0.1.0

package/dist/chunk-5U2LXK3W.js

@@ -0,0 +1,2655 @@
+// src/core/vault.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as yaml from "js-yaml";
+var Vault = class {
+  paths;
+  config;
+  constructor(config) {
+    this.config = config;
+    const root = path.resolve(config.vaultPath);
+    const memory = path.join(root, "memory");
+    this.paths = {
+      root,
+      memory,
+      facts: path.join(memory, "facts"),
+      events: path.join(memory, "events"),
+      schema: path.join(memory, "schema"),
+      views: path.join(memory, "_views"),
+      inbox: path.join(memory, "_inbox"),
+      claims: path.join(memory, "_claims"),
+      ops: path.join(memory, "_ops"),
+      opsApplied: path.join(memory, "_ops", "applied"),
+      archive: path.join(memory, "_archive"),
+      entities: path.join(memory, "entities.md"),
+      predicates: path.join(memory, "schema", "predicates.yaml"),
+      versionYaml: path.join(memory, "schema", "version.yaml"),
+      sources: path.join(root, "sources"),
+      people: path.join(memory, "people"),
+      projects: path.join(memory, "projects"),
+      decisions: path.join(memory, "decisions"),
+      insights: path.join(memory, "insights"),
+      context: path.join(memory, "context")
+    };
+  }
+  /**
+   * Assert that the vault path exists and contains a valid v3 version marker.
+   */
+  async assertValid() {
+    try {
+      await fs.access(this.paths.root);
+    } catch {
+      throw new VaultError(
+        `Vault path does not exist: ${this.paths.root}`,
+        "VAULT_NOT_FOUND"
+      );
+    }
+    try {
+      await fs.access(this.paths.memory);
+    } catch {
+      throw new VaultError(
+        `No memory/ directory found in vault: ${this.paths.root}`,
+        "VAULT_INVALID"
+      );
+    }
+    try {
+      const versionContent = await fs.readFile(
+        this.paths.versionYaml,
+        "utf-8"
+      );
+      const version = yaml.load(versionContent);
+      if (version?.spec_version !== "3.0") {
+        throw new VaultError(
+          `Expected spec_version: "3.0" in ${this.paths.versionYaml}, got: ${version?.spec_version}`,
+          "VAULT_VERSION_MISMATCH"
+        );
+      }
+    } catch (err) {
+      if (err instanceof VaultError) throw err;
+      throw new VaultError(
+        `Cannot read version marker: ${this.paths.versionYaml}`,
+        "VAULT_INVALID"
+      );
+    }
+  }
+  /**
+   * Get the relative path from vault root.
+   */
+  relativePath(absolutePath) {
+    return path.relative(this.paths.root, absolutePath);
+  }
+  /**
+   * Resolve a relative path to absolute from vault root.
+   */
+  resolvePath(relativePath) {
+    return path.resolve(this.paths.root, relativePath);
+  }
+  /**
+   * Get the fact file path for a given entity and predicate.
+   */
+  factPath(entity, predicate, suffix) {
+    const filename = suffix ? `${predicate}--${suffix}.md` : `${predicate}.md`;
+    return path.join(this.paths.facts, entity, filename);
+  }
+  /**
+   * Get the event directory path for a given date.
+   */
+  eventDir(date) {
+    return path.join(this.paths.events, date);
+  }
+  /**
+   * Get the inbox ops path for a given agent and operation.
+   */
+  inboxOpPath(agentId, operationId) {
+    return path.join(this.paths.inbox, agentId, "ops", `${operationId}.md`);
+  }
+  /**
+   * Get the applied operation receipt path.
+   */
+  appliedOpPath(operationId) {
+    return path.join(this.paths.opsApplied, `${operationId}.md`);
+  }
+  /**
+   * Get the claim path for a target ID.
+   */
+  claimPath(targetId) {
+    return path.join(this.paths.claims, `${targetId}.yaml`);
+  }
+  /**
+   * Get the archive path for a fact.
+   */
+  archivePath(year, entity, predicate) {
+    return path.join(this.paths.archive, year, "facts", entity, `${predicate}.md`);
+  }
+  /**
+   * Get the view path for a named view.
+   */
+  viewPath(viewName) {
+    return path.join(this.paths.views, `${viewName}.md`);
+  }
+  /**
+   * Get entity-specific view path.
+   */
+  entityViewPath(entity) {
+    return path.join(this.paths.views, "by-entity", `${entity}.md`);
+  }
+};
+var VaultError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "VaultError";
+    this.code = code;
+  }
+};
+
+// src/core/markdown.ts
+import matter from "gray-matter";
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+function normalizeDates(obj) {
+  if (obj instanceof Date) {
+    return obj.toISOString();
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(normalizeDates);
+  }
+  if (obj !== null && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = normalizeDates(value);
+    }
+    return result;
+  }
+  return obj;
+}
+async function parseMarkdownFile(filePath) {
+  const raw = await fs2.readFile(filePath, "utf-8");
+  const { data, content } = matter(raw);
+  const normalized = normalizeDates(data);
+  return { data: normalized, content, path: filePath };
+}
+function serializeMarkdown(data, body) {
+  const content = body ?? "";
+  return matter.stringify(content, data);
+}
+async function writeMarkdownFile(filePath, data, body) {
+  const dir = path2.dirname(filePath);
+  await fs2.mkdir(dir, { recursive: true });
+  const content = serializeMarkdown(data, body);
+  const tmpPath = `${filePath}.tmp`;
+  await fs2.writeFile(tmpPath, content, "utf-8");
+  await fs2.rename(tmpPath, filePath);
+}
+async function readFrontmatter(filePath) {
+  const raw = await fs2.readFile(filePath, "utf-8");
+  const { data } = matter(raw);
+  return data;
+}
+async function fileExists(filePath) {
+  try {
+    await fs2.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/core/entity-registry.ts
+import * as fs3 from "fs/promises";
+import matter2 from "gray-matter";
+var EntityRegistry = class {
+  cache = null;
+  vault;
+  constructor(vault) {
+    this.vault = vault;
+  }
+  /**
+   * Load all entities from entities.md. Uses cache if available.
+   */
+  async getAll() {
+    if (this.cache) return this.cache;
+    const raw = await fs3.readFile(this.vault.paths.entities, "utf-8");
+    const { data } = matter2(raw);
+    const index = data;
+    this.cache = index.entities ?? [];
+    return this.cache;
+  }
+  /**
+   * Get entities filtered by kind.
+   */
+  async getByKind(kind) {
+    const all = await this.getAll();
+    return all.filter((e) => e.kind === kind);
+  }
+  /**
+   * Find a single entity by ID.
+   */
+  async findById(id) {
+    const all = await this.getAll();
+    return all.find((e) => e.id === id);
+  }
+  /**
+   * Check if an entity exists.
+   */
+  async exists(id) {
+    const entity = await this.findById(id);
+    return entity !== void 0;
+  }
+  /**
+   * Add a new entity. Returns the updated list.
+   */
+  async add(entity) {
+    const all = await this.getAll();
+    if (all.some((e) => e.id === entity.id)) {
+      throw new Error(`Entity already exists: ${entity.id}`);
+    }
+    all.push(entity);
+    await this.save(all);
+    return all;
+  }
+  /**
+   * Invalidate the in-memory cache.
+   */
+  invalidate() {
+    this.cache = null;
+  }
+  async save(entities) {
+    const raw = await fs3.readFile(this.vault.paths.entities, "utf-8");
+    const { content } = matter2(raw);
+    const data = {
+      type: "entity-index",
+      entities
+    };
+    await writeMarkdownFile(
+      this.vault.paths.entities,
+      data,
+      content
+    );
+    this.cache = entities;
+  }
+};
+
+// src/core/predicate-registry.ts
+import * as fs4 from "fs/promises";
+import * as yaml2 from "js-yaml";
+var PredicateRegistry = class {
+  cache = null;
+  vault;
+  constructor(vault) {
+    this.vault = vault;
+  }
+  /**
+   * Load all predicates from predicates.yaml.
+   * Supports both formats:
+   * - Flat array: ["role", "base", ...]
+   * - Object with entries: { predicates: [{id: "role", description: "..."}] }
+   */
+  async getAll() {
+    if (this.cache) return this.cache;
+    const raw = await fs4.readFile(this.vault.paths.predicates, "utf-8");
+    const parsed = yaml2.load(raw);
+    if (Array.isArray(parsed)) {
+      this.cache = parsed;
+    } else if (parsed && typeof parsed === "object" && "predicates" in parsed) {
+      const entries = parsed.predicates;
+      this.cache = entries.map((e) => typeof e === "string" ? e : e.id);
+    } else {
+      this.cache = [];
+    }
+    return this.cache;
+  }
+  /**
+   * Check if a predicate exists.
+   */
+  async exists(predicate) {
+    const all = await this.getAll();
+    return all.includes(predicate);
+  }
+  /**
+   * Add a new predicate. Returns the updated list.
+   */
+  async add(predicate) {
+    const all = await this.getAll();
+    if (all.includes(predicate)) {
+      throw new Error(`Predicate already exists: ${predicate}`);
+    }
+    all.push(predicate);
+    all.sort();
+    await this.save(all);
+    return all;
+  }
+  /**
+   * Invalidate the in-memory cache.
+   */
+  invalidate() {
+    this.cache = null;
+  }
+  async save(predicates) {
+    const raw = await fs4.readFile(this.vault.paths.predicates, "utf-8");
+    const parsed = yaml2.load(raw);
+    let content;
+    if (parsed && typeof parsed === "object" && "predicates" in parsed) {
+      const existing = parsed.predicates;
+      const existingMap = new Map(existing.map((e) => [typeof e === "string" ? e : e.id, e]));
+      const entries = predicates.map((id) => {
+        const existing2 = existingMap.get(id);
+        if (existing2 && typeof existing2 === "object") return existing2;
+        return { id };
+      });
+      content = yaml2.dump({ predicates: entries }, { flowLevel: -1 });
+    } else {
+      content = yaml2.dump(predicates, { flowLevel: -1 });
+    }
+    const tmpPath = `${this.vault.paths.predicates}.tmp`;
+    await fs4.writeFile(tmpPath, content, "utf-8");
+    await fs4.rename(tmpPath, this.vault.paths.predicates);
+    this.cache = predicates;
+  }
+};
+
+// src/core/query-engine.ts
+import * as fs5 from "fs/promises";
+import * as path3 from "path";
+import { glob } from "glob";
+import { parseISO, isValid, isBefore, isAfter } from "date-fns";
+var QueryEngine = class {
+  vault;
+  constructor(vault) {
+    this.vault = vault;
+  }
+  /**
+   * Find facts matching the given filters.
+   */
+  async findFacts(filter) {
+    if (filter.entity && filter.predicate && !filter.id) {
+      const directPath = this.vault.factPath(filter.entity, filter.predicate);
+      try {
+        await fs5.access(directPath);
+        const parsed = await parseMarkdownFile(directPath);
+        const fact = parsed.data;
+        if (this.matchesFactFilter(fact, filter)) {
+          return [{ data: fact, content: parsed.content, path: directPath }];
+        }
+      } catch {
+      }
+      const pattern2 = path3.join(
+        this.vault.paths.facts,
+        filter.entity,
+        `${filter.predicate}*.md`
+      );
+      const files2 = await glob(pattern2);
+      const results2 = [];
+      for (const file of files2) {
+        const parsed = await parseMarkdownFile(file);
+        const fact = parsed.data;
+        if (this.matchesFactFilter(fact, filter)) {
+          results2.push({ data: fact, content: parsed.content, path: file });
+        }
+      }
+      return this.applyLimit(results2, filter.limit);
+    }
+    if (filter.id) {
+      const result = await this.findFactById(filter.id);
+      return result ? [result] : [];
+    }
+    const pattern = filter.entity ? path3.join(this.vault.paths.facts, filter.entity, "*.md") : path3.join(this.vault.paths.facts, "**", "*.md");
+    const files = await glob(pattern);
+    const results = [];
+    for (const file of files) {
+      const parsed = await parseMarkdownFile(file);
+      const fact = parsed.data;
+      if (fact.type !== "fact") continue;
+      if (this.matchesFactFilter(fact, filter)) {
+        results.push({ data: fact, content: parsed.content, path: file });
+      }
+    }
+    return this.applyLimit(results, filter.limit);
+  }
+  /**
+   * Find a fact by its stable ID.
+   */
+  async findFactById(id) {
+    const files = await glob(path3.join(this.vault.paths.facts, "**", "*.md"));
+    for (const file of files) {
+      const parsed = await parseMarkdownFile(file);
+      const fact = parsed.data;
+      if (fact.id === id) {
+        return { data: fact, content: parsed.content, path: file };
+      }
+    }
+    return null;
+  }
+  /**
+   * Find events matching the given filters.
+   */
+  async findEvents(filter) {
+    const pattern = path3.join(this.vault.paths.events, "**", "*.md");
+    const files = await glob(pattern);
+    const results = [];
+    for (const file of files) {
+      const parsed = await parseMarkdownFile(file);
+      const event = parsed.data;
+      if (event.type !== "event") continue;
+      if (this.matchesEventFilter(event, filter)) {
+        results.push({ data: event, content: parsed.content, path: file });
+      }
+    }
+    results.sort((a, b) => {
+      const dateA = String(a.data.occurred_at);
+      const dateB = String(b.data.occurred_at);
+      return dateB.localeCompare(dateA);
+    });
+    return this.applyLimit(results, filter.limit);
+  }
+  /**
+   * Find any record (fact, event, operation) by its stable ID.
+   */
+  async findById(id) {
+    const fact = await this.findFactById(id);
+    if (fact) return { type: "fact", path: fact.path, data: fact.data };
+    const eventFiles = await glob(path3.join(this.vault.paths.events, "**", "*.md"));
+    for (const file of eventFiles) {
+      const parsed = await parseMarkdownFile(file);
+      if (parsed.data.id === id) {
+        return { type: "event", path: file, data: parsed.data };
+      }
+    }
+    const inboxFiles = await glob(path3.join(this.vault.paths.inbox, "**", "*.md"));
+    for (const file of inboxFiles) {
+      const parsed = await parseMarkdownFile(file);
+      const data = parsed.data;
+      if (data.operation_id === id || data.id === id) {
+        return { type: "operation", path: file, data };
+      }
+    }
+    const appliedFiles = await glob(path3.join(this.vault.paths.opsApplied, "*.md"));
+    for (const file of appliedFiles) {
+      const parsed = await parseMarkdownFile(file);
+      const data = parsed.data;
+      if (data.operation_id === id || data.id === id) {
+        return { type: "operation", path: file, data };
+      }
+    }
+    return null;
+  }
+  matchesFactFilter(fact, filter) {
+    if (filter.entity && fact.entity !== filter.entity) return false;
+    if (filter.predicate && fact.predicate !== filter.predicate) return false;
+    if (filter.confidence && fact.confidence !== filter.confidence) return false;
+    if (filter.tags && filter.tags.length > 0) {
+      if (!fact.tags || !filter.tags.some((t) => fact.tags.includes(t))) {
+        return false;
+      }
+    }
+    if (filter.query) {
+      const q = filter.query.toLowerCase();
+      const inValue = String(fact.value).toLowerCase().includes(q);
+      const inEntity = fact.entity.toLowerCase().includes(q);
+      const inPredicate = fact.predicate.toLowerCase().includes(q);
+      if (!inValue && !inEntity && !inPredicate) return false;
+    }
+    if (filter.onDate) {
+      if (!this.isTemporallyValid(fact, filter.onDate)) return false;
+    }
+    return true;
+  }
+  matchesEventFilter(event, filter) {
+    if (filter.entity) {
+      if (!event.entities || !event.entities.includes(filter.entity)) {
+        return false;
+      }
+    }
+    if (filter.kind && event.kind !== filter.kind) return false;
+    if (filter.since) {
+      const since = parseISO(filter.since);
+      const occurred = parseISO(String(event.occurred_at));
+      if (isValid(since) && isValid(occurred) && isBefore(occurred, since)) {
+        return false;
+      }
+    }
+    if (filter.until) {
+      const until = parseISO(filter.until);
+      const occurred = parseISO(String(event.occurred_at));
+      if (isValid(until) && isValid(occurred) && isAfter(occurred, until)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Check if a fact is temporally valid on a given date.
+   * valid_from <= date <= valid_to (with null meaning unbounded)
+   */
+  isTemporallyValid(fact, dateStr) {
+    const date = parseISO(dateStr);
+    if (!isValid(date)) return true;
+    if (fact.valid_from) {
+      const from = parseISO(fact.valid_from);
+      if (isValid(from) && isBefore(date, from)) return false;
+    }
+    if (fact.valid_to) {
+      const to = parseISO(fact.valid_to);
+      if (isValid(to) && isAfter(date, to)) return false;
+    }
+    return true;
+  }
+  applyLimit(results, limit) {
+    if (limit && limit > 0) {
+      return results.slice(0, limit);
+    }
+    return results;
+  }
+};
+
+// src/core/hash.ts
+import * as crypto from "crypto";
+import * as fs6 from "fs/promises";
+async function computeFileHash(filePath) {
+  const content = await fs6.readFile(filePath);
+  const hash = crypto.createHash("sha256").update(content).digest("hex");
+  return `sha256:${hash}`;
+}
+function computeStringHash(content) {
+  const hash = crypto.createHash("sha256").update(content, "utf-8").digest("hex");
+  return `sha256:${hash}`;
+}
+function isValidHash(hash) {
+  return /^sha256:[0-9a-f]{64}$/.test(hash);
+}
+
+// src/core/id-generator.ts
+import * as crypto2 from "crypto";
+function generateOperationId() {
+  const now = /* @__PURE__ */ new Date();
+  const timestamp = now.toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "z").toLowerCase();
+  const hex = crypto2.randomBytes(4).toString("hex").slice(0, 4);
+  return `op-${timestamp}-${hex}`;
+}
+function generateAgentId(name) {
+  const slug = (name ?? "mcp").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 20);
+  const hex = crypto2.randomBytes(4).toString("hex");
+  return `agent-${slug}-${hex}`;
+}
+function generateFactId(entity, predicate) {
+  return `fact-${entity}-${predicate}`;
+}
+function generateEventId(date, slug) {
+  return `event-${date}-${slug}`;
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
+}
+
+// src/core/operation-manager.ts
+import * as fs7 from "fs/promises";
+import * as path4 from "path";
+import { glob as glob2 } from "glob";
+import * as yaml3 from "js-yaml";
+import { format } from "date-fns";
+var OperationManager = class {
+  vault;
+  agentId;
+  constructor(vault, agentId) {
+    this.vault = vault;
+    this.agentId = agentId;
+  }
+  /**
+   * Create a fact directly (single-agent mode).
+   */
+  async createFactDirect(params) {
+    const factId = params.id ?? generateFactId(params.entity, params.predicate);
+    const factPath = this.vault.factPath(params.entity, params.predicate);
+    if (await fileExists(factPath)) {
+      throw new OperationError(
+        `Fact already exists at ${this.vault.relativePath(factPath)}. Use update_fact instead.`,
+        "FACT_EXISTS"
+      );
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const data = {
+      type: "fact",
+      id: factId,
+      entity: params.entity,
+      predicate: params.predicate,
+      value: params.value,
+      valid_from: params.valid_from ?? null,
+      valid_to: params.valid_to ?? null,
+      recorded_at: now,
+      confidence: params.confidence ?? "medium",
+      sources: params.sources ?? [],
+      last_reviewed: format(/* @__PURE__ */ new Date(), "yyyy-MM-dd"),
+      tags: params.tags ?? []
+    };
+    await writeMarkdownFile(factPath, data);
+    return { path: this.vault.relativePath(factPath), id: factId };
+  }
+  /**
+   * Create an operation envelope for creating a fact (inbox mode).
+   */
+  async createFactEnvelope(params) {
+    const operationId = generateOperationId();
+    const factId = params.id ?? generateFactId(params.entity, params.predicate);
+    const targetPath = `memory/facts/${params.entity}/${params.predicate}.md`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const data = {
+      type: "operation",
+      operation_id: operationId,
+      op: "create_fact",
+      agent_id: this.agentId,
+      created_at: now,
+      target_id: factId,
+      target_path: targetPath,
+      precondition_hash: null,
+      status: "proposed",
+      reason: params.reason,
+      sources: params.sources ?? [],
+      payload: {
+        type: "fact",
+        id: factId,
+        entity: params.entity,
+        predicate: params.predicate,
+        value: params.value,
+        recorded_at: now,
+        confidence: params.confidence ?? "medium",
+        sources: params.sources ?? [],
+        valid_from: params.valid_from ?? null,
+        valid_to: params.valid_to ?? null,
+        tags: params.tags ?? []
+      }
+    };
+    const opPath = this.vault.inboxOpPath(this.agentId, operationId);
+    await writeMarkdownFile(opPath, data, `
+# Create fact: ${params.entity}/${params.predicate}
+
+${params.reason}
+`);
+    return { path: this.vault.relativePath(opPath), operationId };
+  }
+  /**
+   * Update a fact directly (single-agent mode).
+   */
+  async updateFactDirect(params) {
+    const factPath = await this.resolveFactPath(params);
+    const currentHash = await computeFileHash(factPath);
+    const parsed = await parseMarkdownFile(factPath);
+    const data = parsed.data;
+    if (params.value !== void 0) data.value = params.value;
+    if (params.valid_to !== void 0) data.valid_to = params.valid_to;
+    if (params.confidence !== void 0) data.confidence = params.confidence;
+    if (params.tags !== void 0) data.tags = params.tags;
+    if (params.last_reviewed !== void 0) {
+      data.last_reviewed = params.last_reviewed;
+    } else {
+      data.last_reviewed = format(/* @__PURE__ */ new Date(), "yyyy-MM-dd");
+    }
+    await writeMarkdownFile(factPath, data, parsed.content);
+    const newHash = await computeFileHash(factPath);
+    return { path: this.vault.relativePath(factPath), hash: newHash };
+  }
+  /**
+   * Create an operation envelope for updating a fact (inbox mode).
+   */
+  async updateFactEnvelope(params) {
+    const factPath = await this.resolveFactPath(params);
+    const operationId = generateOperationId();
+    const currentHash = await computeFileHash(factPath);
+    const parsed = await parseMarkdownFile(factPath);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const payload = { ...parsed.data };
+    if (params.value !== void 0) payload.value = params.value;
+    if (params.valid_to !== void 0) payload.valid_to = params.valid_to;
+    if (params.confidence !== void 0) payload.confidence = params.confidence;
+    if (params.tags !== void 0) payload.tags = params.tags;
+    const data = {
+      type: "operation",
+      operation_id: operationId,
+      op: "update_fact",
+      agent_id: this.agentId,
+      created_at: now,
+      target_id: parsed.data.id ?? null,
+      target_path: this.vault.relativePath(factPath),
+      precondition_hash: currentHash,
+      status: "proposed",
+      reason: params.reason,
+      sources: parsed.data.sources ?? [],
+      payload
+    };
+    const opPath = this.vault.inboxOpPath(this.agentId, operationId);
+    await writeMarkdownFile(opPath, data, `
+# Update fact
+
+${params.reason}
+`);
+    return { path: this.vault.relativePath(opPath), operationId };
+  }
+  /**
+   * Add an event directly.
+   */
+  async addEventDirect(params) {
+    const now = /* @__PURE__ */ new Date();
+    const dateStr = format(now, "yyyy-MM-dd");
+    const slug = slugify(params.summary);
+    const eventId = generateEventId(dateStr, slug);
+    const eventDir = this.vault.eventDir(dateStr);
+    const eventPath = path4.join(eventDir, `${slug}.md`);
+    const data = {
+      type: "event",
+      id: eventId,
+      occurred_at: now.toISOString(),
+      summary: params.summary,
+      entities: params.entities ?? [],
+      kind: params.kind ?? "observation",
+      sources: params.sources ?? [],
+      derived_facts: []
+    };
+    await writeMarkdownFile(eventPath, data, params.body ? `
+${params.body}
+` : "");
+    return { path: this.vault.relativePath(eventPath), id: eventId };
+  }
+  /**
+   * Create an operation envelope for adding an event (inbox mode).
+   */
+  async addEventEnvelope(params) {
+    const operationId = generateOperationId();
+    const now = /* @__PURE__ */ new Date();
+    const dateStr = format(now, "yyyy-MM-dd");
+    const slug = slugify(params.summary);
+    const data = {
+      type: "operation",
+      operation_id: operationId,
+      op: "add_event",
+      agent_id: this.agentId,
+      created_at: now.toISOString(),
+      target_id: generateEventId(dateStr, slug),
+      target_path: `memory/events/${dateStr}/${slug}.md`,
+      precondition_hash: null,
+      status: "proposed",
+      reason: params.reason ?? params.summary,
+      sources: params.sources ?? [],
+      payload: {
+        type: "event",
+        occurred_at: now.toISOString(),
+        summary: params.summary,
+        entities: params.entities ?? [],
+        kind: params.kind ?? "observation",
+        sources: params.sources ?? [],
+        body: params.body ?? ""
+      }
+    };
+    const opPath = this.vault.inboxOpPath(this.agentId, operationId);
+    await writeMarkdownFile(opPath, data, `
+# Add event
+
+${params.summary}
+`);
+    return { path: this.vault.relativePath(opPath), operationId };
+  }
+  /**
+   * Archive a fact directly.
+   */
+  async archiveFactDirect(params) {
+    const factPath = await this.resolveFactPath(params);
+    const parsed = await parseMarkdownFile(factPath);
+    const fact = parsed.data;
+    const year = format(/* @__PURE__ */ new Date(), "yyyy");
+    const archiveDest = this.vault.archivePath(year, fact.entity, fact.predicate);
+    await fs7.mkdir(path4.dirname(archiveDest), { recursive: true });
+    await fs7.rename(factPath, archiveDest);
+    return { archivePath: this.vault.relativePath(archiveDest) };
+  }
+  /**
+   * Compact inbox: validate and apply all proposed operations.
+   */
+  async compact(autoApply = true) {
+    const result = { applied: 0, conflicts: 0, archived: 0, errors: [] };
+    const opFiles = await glob2(path4.join(this.vault.paths.inbox, "**", "ops", "*.md"));
+    for (const opFile of opFiles) {
+      const parsed = await parseMarkdownFile(opFile);
+      const op = parsed.data;
+      if (op.status !== "proposed") continue;
+      if (op.target_id) {
+        const claimConflict = await this.checkClaim(op.target_id, op.agent_id);
+        if (claimConflict) {
+          await this.markConflict(opFile, parsed, `Blocked by active claim: ${claimConflict}`);
+          result.conflicts++;
+          continue;
+        }
+      }
+      if (op.precondition_hash && op.target_path) {
+        const targetAbsPath = this.vault.resolvePath(op.target_path);
+        if (await fileExists(targetAbsPath)) {
+          const currentHash = await computeFileHash(targetAbsPath);
+          if (currentHash !== op.precondition_hash) {
+            await this.markConflict(opFile, parsed, "precondition hash mismatch");
+            result.conflicts++;
+            continue;
+          }
+        }
+      }
+      if (!autoApply) continue;
+      try {
+        await this.applyOperation(op, parsed.content);
+        await this.moveToApplied(opFile, parsed);
+        result.applied++;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        await this.markConflict(opFile, parsed, msg);
+        result.conflicts++;
+        result.errors.push(`${op.operation_id}: ${msg}`);
+      }
+    }
+    const factFiles = await glob2(path4.join(this.vault.paths.facts, "**", "*.md"));
+    const today = process.env.MEMORY_TODAY ?? format(/* @__PURE__ */ new Date(), "yyyy-MM-dd");
+    for (const file of factFiles) {
+      const parsed = await parseMarkdownFile(file);
+      const fact = parsed.data;
+      if (fact.valid_to && fact.valid_to < today) {
+        const year = fact.valid_to.slice(0, 4);
+        const archiveDest = this.vault.archivePath(year, fact.entity, fact.predicate);
+        await fs7.mkdir(path4.dirname(archiveDest), { recursive: true });
+        await fs7.rename(file, archiveDest);
+        result.archived++;
+      }
+    }
+    return result;
+  }
+  async applyOperation(op, body) {
+    const payload = op.payload;
+    switch (op.op) {
+      case "create_fact": {
+        const targetPath = this.vault.resolvePath(op.target_path);
+        if (await fileExists(targetPath)) {
+          throw new Error(`Target already exists: ${op.target_path}`);
+        }
+        const factData = { ...payload };
+        if (!factData.last_reviewed) {
+          factData.last_reviewed = format(/* @__PURE__ */ new Date(), "yyyy-MM-dd");
+        }
+        await writeMarkdownFile(targetPath, factData);
+        break;
+      }
+      case "update_fact": {
+        const targetPath = this.vault.resolvePath(op.target_path);
+        if (!await fileExists(targetPath)) {
+          throw new Error(`Target not found: ${op.target_path}`);
+        }
+        const existing = await parseMarkdownFile(targetPath);
+        const updated = { ...existing.data, ...payload };
+        updated.last_reviewed = format(/* @__PURE__ */ new Date(), "yyyy-MM-dd");
+        const bodyContent = payload.body ?? existing.content;
+        await writeMarkdownFile(targetPath, updated, bodyContent);
+        break;
+      }
+      case "add_event": {
+        const targetPath = this.vault.resolvePath(op.target_path);
+        const eventBody = payload.body ?? "";
+        const eventData = { ...payload };
+        delete eventData.body;
+        await writeMarkdownFile(targetPath, eventData, eventBody ? `
+${eventBody}
+` : "");
+        break;
+      }
+      case "archive_fact": {
+        const targetPath = this.vault.resolvePath(op.target_path);
+        if (!await fileExists(targetPath)) {
+          throw new Error(`Target not found for archival: ${op.target_path}`);
+        }
+        const parsed = await parseMarkdownFile(targetPath);
+        const fact = parsed.data;
+        const year = format(/* @__PURE__ */ new Date(), "yyyy");
+        const archiveDest = this.vault.archivePath(year, fact.entity, fact.predicate);
+        await fs7.mkdir(path4.dirname(archiveDest), { recursive: true });
+        await fs7.rename(targetPath, archiveDest);
+        break;
+      }
+      default:
+        throw new Error(`Unsupported operation type: ${op.op}`);
+    }
+  }
+  async markConflict(opFile, parsed, reason) {
+    parsed.data.status = "conflict";
+    parsed.data.conflict_reason = reason;
+    await writeMarkdownFile(opFile, parsed.data, parsed.content);
+  }
+  async moveToApplied(opFile, parsed) {
+    const opId = parsed.data.operation_id;
+    parsed.data.status = "applied";
+    parsed.data.applied_at = (/* @__PURE__ */ new Date()).toISOString();
+    const receiptPath = this.vault.appliedOpPath(opId);
+    await writeMarkdownFile(receiptPath, parsed.data, parsed.content);
+    await fs7.unlink(opFile);
+  }
+  async checkClaim(targetId, agentId) {
+    const claimPath = this.vault.claimPath(targetId);
+    if (!await fileExists(claimPath)) return null;
+    const raw = await fs7.readFile(claimPath, "utf-8");
+    const claim = yaml3.load(raw);
+    if (claim.status !== "active") return null;
+    const now = /* @__PURE__ */ new Date();
+    const expires = new Date(claim.expires_at);
+    if (now > expires) return null;
+    if (claim.agent_id === agentId) return null;
+    return `${claim.agent_id} (expires ${claim.expires_at})`;
+  }
+  async resolveFactPath(params) {
+    if (params.targetPath) {
+      const absPath = this.vault.resolvePath(params.targetPath);
+      if (await fileExists(absPath)) return absPath;
+      throw new OperationError(`Fact not found: ${params.targetPath}`, "FACT_NOT_FOUND");
+    }
+    if (params.targetId) {
+      const files = await glob2(path4.join(this.vault.paths.facts, "**", "*.md"));
+      for (const file of files) {
+        const parsed = await parseMarkdownFile(file);
+        if (parsed.data.id === params.targetId) {
+          return file;
+        }
+      }
+      throw new OperationError(`Fact not found with id: ${params.targetId}`, "FACT_NOT_FOUND");
+    }
+    throw new OperationError("Either targetId or targetPath is required", "INVALID_PARAMS");
+  }
+};
+var OperationError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "OperationError";
+    this.code = code;
+  }
+};
+
+// src/core/schema-validator.ts
+import * as fs8 from "fs/promises";
+import * as path5 from "path";
+import { glob as glob3 } from "glob";
+import * as yaml4 from "js-yaml";
+var SchemaValidator = class {
+  vault;
+  entities;
+  predicates;
+  constructor(vault, entities, predicates) {
+    this.vault = vault;
+    this.entities = entities;
+    this.predicates = predicates;
+  }
+  /**
+   * Run full vault validation. Returns findings array. Empty = valid.
+   */
+  async lint() {
+    const findings = [];
+    await this.checkVersion(findings);
+    await this.validateFacts(findings);
+    await this.validateEvents(findings);
+    await this.validateOperations(findings);
+    await this.checkDuplicateIds(findings);
+    await this.checkContradictions(findings);
+    await this.validateWikilinks(findings);
+    return findings;
+  }
+  async checkVersion(findings) {
+    try {
+      const content = await fs8.readFile(this.vault.paths.versionYaml, "utf-8");
+      const version = yaml4.load(content);
+      if (version?.spec_version !== "3.0") {
+        findings.push({
+          level: "ERROR",
+          path: this.vault.relativePath(this.vault.paths.versionYaml),
+          message: `missing v3 schema version marker (expected spec_version: "3.0")`
+        });
+      }
+    } catch {
+      findings.push({
+        level: "ERROR",
+        path: "memory/schema/version.yaml",
+        message: "missing v3 schema version marker"
+      });
+    }
+  }
+  async validateFacts(findings) {
+    const factFiles = await glob3(path5.join(this.vault.paths.facts, "**", "*.md"));
+    for (const file of factFiles) {
+      const relPath = this.vault.relativePath(file);
+      try {
+        const parsed = await parseMarkdownFile(file);
+        const data = parsed.data;
+        if (data.type !== "fact") {
+          findings.push({ level: "ERROR", path: relPath, message: `expected type: fact, got: ${data.type}` });
+          continue;
+        }
+        if (!data.entity) {
+          findings.push({ level: "ERROR", path: relPath, message: "missing required field: entity" });
+        }
+        if (!data.predicate) {
+          findings.push({ level: "ERROR", path: relPath, message: "missing required field: predicate" });
+        }
+        if (data.value === void 0 || data.value === null) {
+          findings.push({ level: "ERROR", path: relPath, message: "missing required field: value" });
+        }
+        if (!data.recorded_at) {
+          findings.push({ level: "ERROR", path: relPath, message: "missing required field: recorded_at" });
+        }
+        if (data.entity && !await this.entities.exists(data.entity)) {
+          findings.push({ level: "ERROR", path: relPath, message: `unknown entity '${data.entity}'` });
+        }
+        if (data.predicate && !await this.predicates.exists(data.predicate)) {
+          findings.push({
+            level: "ERROR",
+            path: relPath,
+            message: `unknown predicate '${data.predicate}' -- add it to memory/schema/predicates.yaml`
+          });
+        }
+        const expectedDir = path5.join(this.vault.paths.facts, data.entity);
+        const actualDir = path5.dirname(file);
+        if (actualDir !== expectedDir) {
+          findings.push({
+            level: "ERROR",
+            path: relPath,
+            message: `fact for entity '${data.entity}' should be in memory/facts/${data.entity}/`
+          });
+        }
+        if (data.valid_from && data.valid_to && data.valid_from > data.valid_to) {
+          findings.push({
+            level: "ERROR",
+            path: relPath,
+            message: `valid_from (${data.valid_from}) must be <= valid_to (${data.valid_to})`
+          });
+        }
+        if (data.sources) {
+          for (const source of data.sources) {
+            const sourcePath = this.vault.resolvePath(source);
+            if (!await fileExists(sourcePath)) {
+              findings.push({ level: "WARN", path: relPath, message: `source not found: ${source}` });
+            }
+          }
+        }
+      } catch (err) {
+        findings.push({
+          level: "ERROR",
+          path: relPath,
+          message: `parse error: ${err instanceof Error ? err.message : String(err)}`
+        });
+      }
+    }
+  }
+  async validateEvents(findings) {
+    const eventFiles = await glob3(path5.join(this.vault.paths.events, "**", "*.md"));
+    for (const file of eventFiles) {
+      const relPath = this.vault.relativePath(file);
+      try {
+        const parsed = await parseMarkdownFile(file);
+        const data = parsed.data;
+        if (data.type !== "event") {
+          findings.push({ level: "ERROR", path: relPath, message: `expected type: event, got: ${data.type}` });
+          continue;
+        }
+        if (!data.occurred_at) {
+          findings.push({ level: "ERROR", path: relPath, message: "missing required field: occurred_at" });
+        }
+        if (!data.summary) {
+          findings.push({ level: "ERROR", path: relPath, message: "missing required field: summary" });
+        }
+        if (Array.isArray(data.entities)) {
+          for (const entity of data.entities) {
+            if (!await this.entities.exists(entity)) {
+              findings.push({ level: "WARN", path: relPath, message: `event references unknown entity '${entity}'` });
+            }
+          }
+        }
+      } catch (err) {
+        findings.push({
+          level: "ERROR",
+          path: relPath,
+          message: `parse error: ${err instanceof Error ? err.message : String(err)}`
+        });
+      }
+    }
+  }
+  async validateOperations(findings) {
+    const opFiles = await glob3(path5.join(this.vault.paths.inbox, "**", "ops", "*.md"));
+    const appliedFiles = await glob3(path5.join(this.vault.paths.opsApplied, "*.md"));
+    for (const file of [...opFiles, ...appliedFiles]) {
+      const relPath = this.vault.relativePath(file);
+      try {
+        const parsed = await parseMarkdownFile(file);
+        const data = parsed.data;
+        if (data.type !== "operation") continue;
+        if (!data.operation_id) {
+          findings.push({ level: "ERROR", path: relPath, message: "missing required field: operation_id" });
+        }
+        if (!data.op) {
+          findings.push({ level: "ERROR", path: relPath, message: "missing required field: op" });
+        }
+        if (!data.agent_id) {
+          findings.push({ level: "ERROR", path: relPath, message: "missing required field: agent_id" });
+        }
+        if (!data.reason) {
+          findings.push({ level: "ERROR", path: relPath, message: "missing required field: reason" });
+        }
+        if (data.agent_id && !/^agent-[a-z0-9-]+-[a-f0-9]{8}$/.test(data.agent_id)) {
+          findings.push({
+            level: "WARN",
+            path: relPath,
+            message: `agent_id '${data.agent_id}' doesn't match pattern: agent-{slug}-{8hex}`
+          });
+        }
+        if (data.op === "create_fact" && data.payload) {
+          const payload = data.payload;
+          if (payload.predicate && typeof payload.predicate === "string") {
+            if (!await this.predicates.exists(payload.predicate)) {
+              findings.push({
+                level: "ERROR",
+                path: relPath,
+                message: `payload unknown predicate '${payload.predicate}' -- add it to memory/schema/predicates.yaml`
+              });
+            }
+          }
+        }
+      } catch (err) {
+        findings.push({
+          level: "ERROR",
+          path: relPath,
+          message: `parse error: ${err instanceof Error ? err.message : String(err)}`
+        });
+      }
+    }
+  }
+  async checkDuplicateIds(findings) {
+    const idMap = /* @__PURE__ */ new Map();
+    const allFiles = [
+      ...await glob3(path5.join(this.vault.paths.facts, "**", "*.md")),
+      ...await glob3(path5.join(this.vault.paths.events, "**", "*.md"))
+    ];
+    for (const file of allFiles) {
+      try {
+        const parsed = await parseMarkdownFile(file);
+        const id = parsed.data.id;
+        if (id) {
+          const existing = idMap.get(id);
+          if (existing) {
+            findings.push({
+              level: "ERROR",
+              path: this.vault.relativePath(file),
+              message: `duplicate id '${id}' (first seen in ${existing})`
+            });
+          } else {
+            idMap.set(id, this.vault.relativePath(file));
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  async checkContradictions(findings) {
+    const factFiles = await glob3(path5.join(this.vault.paths.facts, "**", "*.md"));
+    const factsByKey = /* @__PURE__ */ new Map();
+    for (const file of factFiles) {
+      try {
+        const parsed = await parseMarkdownFile(file);
+        const fact = parsed.data;
+        if (fact.type !== "fact") continue;
+        const key = `${fact.entity}/${fact.predicate}`;
+        if (!factsByKey.has(key)) factsByKey.set(key, []);
+        factsByKey.get(key).push({ fact, path: file });
+      } catch {
+      }
+    }
+    for (const [key, facts] of factsByKey) {
+      if (facts.length < 2) continue;
+      for (let i = 0; i < facts.length; i++) {
+        for (let j = i + 1; j < facts.length; j++) {
+          const a = facts[i];
+          const b = facts[j];
+          if (a.fact.superseded_by || b.fact.superseded_by) continue;
+          if (String(a.fact.value) === String(b.fact.value)) continue;
+          if (this.temporalOverlap(a.fact, b.fact)) {
+            findings.push({
+              level: "ERROR",
+              path: this.vault.relativePath(b.path),
+              message: `contradicts overlapping fact at ${this.vault.relativePath(a.path)}`
+            });
+          }
+        }
+      }
+    }
+  }
+  temporalOverlap(a, b) {
+    const aFrom = a.valid_from ?? "0000-01-01";
+    const aTo = a.valid_to ?? "9999-12-31";
+    const bFrom = b.valid_from ?? "0000-01-01";
+    const bTo = b.valid_to ?? "9999-12-31";
+    return aFrom <= bTo && bFrom <= aTo;
+  }
+  async validateWikilinks(findings) {
+    const allFiles = await glob3(path5.join(this.vault.paths.memory, "**", "*.md"));
+    const stemMap = /* @__PURE__ */ new Map();
+    const fullPathSet = /* @__PURE__ */ new Set();
+    for (const file of allFiles) {
+      const relPath = this.vault.relativePath(file);
+      fullPathSet.add(relPath);
+      const noExt = relPath.replace(/\.md$/, "");
+      fullPathSet.add(noExt);
+      const stem = path5.basename(file, ".md");
+      if (!stemMap.has(stem)) stemMap.set(stem, []);
+      stemMap.get(stem).push(relPath);
+    }
+    const wikilinkRegex = /\[\[([^\]|#]+)(?:#[^\]|]*)?\|?[^\]]*\]\]/g;
+    for (const file of allFiles) {
+      if (file.startsWith(this.vault.paths.views)) continue;
+      const relPath = this.vault.relativePath(file);
+      try {
+        const content = await fs8.readFile(file, "utf-8");
+        let match;
+        wikilinkRegex.lastIndex = 0;
+        while ((match = wikilinkRegex.exec(content)) !== null) {
+          const target = match[1].trim();
+          if (fullPathSet.has(target) || fullPathSet.has(`${target}.md`)) continue;
+          const stem = path5.basename(target, ".md");
+          const candidates = stemMap.get(stem);
+          if (!candidates || candidates.length === 0) {
+            findings.push({
+              level: "ERROR",
+              path: relPath,
+              message: `unresolved wikilink: ${target}`
+            });
+          } else if (candidates.length > 1) {
+            findings.push({
+              level: "ERROR",
+              path: relPath,
+              message: `ambiguous wikilink: ${target} (resolves to ${candidates.length} files)`
+            });
+          }
+        }
+      } catch {
+      }
+    }
+  }
+};
+
+// src/core/view-generator.ts
+import * as fs9 from "fs/promises";
+import * as path6 from "path";
+import { glob as glob4 } from "glob";
+import { format as format2, differenceInDays, parseISO as parseISO2 } from "date-fns";
+var ViewGenerator = class {
+  vault;
+  staleDays;
+  constructor(vault, staleDays = 180) {
+    this.vault = vault;
+    this.staleDays = staleDays;
+  }
+  /**
+   * Rebuild all materialized views. Returns list of files written.
+   */
+  async rebuildAll() {
+    const written = [];
+    await fs9.mkdir(this.vault.paths.views, { recursive: true });
+    await fs9.mkdir(path6.join(this.vault.paths.views, "by-entity"), { recursive: true });
+    const facts = await this.loadAllFacts();
+    const events = await this.loadAllEvents();
+    const operations = await this.loadAllOperations();
+    const claims = await this.loadAllClaims();
+    const byEntity = this.groupByEntity(facts);
+    for (const [entity, entityFacts] of byEntity) {
+      const filePath = this.vault.entityViewPath(entity);
+      await this.writeView(filePath, this.renderByEntity(entity, entityFacts));
+      written.push(this.vault.relativePath(filePath));
+    }
+    const byIdPath = this.vault.viewPath("by-id");
+    await this.writeView(byIdPath, this.renderById(facts, events, operations));
+    written.push(this.vault.relativePath(byIdPath));
+    const byPredPath = this.vault.viewPath("by-predicate");
+    await this.writeView(byPredPath, this.renderByPredicate(facts));
+    written.push(this.vault.relativePath(byPredPath));
+    const timelinePath = this.vault.viewPath("timeline");
+    await this.writeView(timelinePath, this.renderTimeline(events));
+    written.push(this.vault.relativePath(timelinePath));
+    const contradictionsPath = this.vault.viewPath("contradictions");
+    await this.writeView(contradictionsPath, this.renderContradictions(facts));
+    written.push(this.vault.relativePath(contradictionsPath));
+    const stalePath = this.vault.viewPath("stale");
+    await this.writeView(stalePath, this.renderStale(facts));
+    written.push(this.vault.relativePath(stalePath));
+    const graphPath = this.vault.viewPath("graph");
+    await this.writeView(graphPath, await this.renderGraph());
+    written.push(this.vault.relativePath(graphPath));
+    const inboxPath = this.vault.viewPath("inbox");
+    await this.writeView(inboxPath, this.renderInbox(operations));
+    written.push(this.vault.relativePath(inboxPath));
+    const opsPath = this.vault.viewPath("operations");
+    await this.writeView(opsPath, this.renderOperations(operations));
+    written.push(this.vault.relativePath(opsPath));
+    const claimsPath = this.vault.viewPath("claims");
+    await this.writeView(claimsPath, this.renderClaims(claims));
+    written.push(this.vault.relativePath(claimsPath));
+    const conflictsPath = this.vault.viewPath("conflicts");
+    await this.writeView(conflictsPath, this.renderConflicts(operations));
+    written.push(this.vault.relativePath(conflictsPath));
+    return written;
+  }
+  async writeView(filePath, content) {
+    await fs9.mkdir(path6.dirname(filePath), { recursive: true });
+    await fs9.writeFile(filePath, content, "utf-8");
+  }
+  async loadAllFacts() {
+    const files = await glob4(path6.join(this.vault.paths.facts, "**", "*.md"));
+    const results = [];
+    for (const file of files.sort()) {
+      try {
+        const parsed = await parseMarkdownFile(file);
+        const fact = parsed.data;
+        if (fact.type === "fact") {
+          results.push({ fact, path: this.vault.relativePath(file) });
+        }
+      } catch {
+      }
+    }
+    return results;
+  }
+  async loadAllEvents() {
+    const files = await glob4(path6.join(this.vault.paths.events, "**", "*.md"));
+    const results = [];
+    for (const file of files.sort()) {
+      try {
+        const parsed = await parseMarkdownFile(file);
+        const event = parsed.data;
+        if (event.type === "event") {
+          results.push({ event, path: this.vault.relativePath(file) });
+        }
+      } catch {
+      }
+    }
+    return results;
+  }
+  async loadAllOperations() {
+    const inboxFiles = await glob4(path6.join(this.vault.paths.inbox, "**", "ops", "*.md"));
+    const appliedFiles = await glob4(path6.join(this.vault.paths.opsApplied, "*.md"));
+    const results = [];
+    for (const file of [...inboxFiles, ...appliedFiles].sort()) {
+      try {
+        const parsed = await parseMarkdownFile(file);
+        const op = parsed.data;
+        if (op.type === "operation") {
+          results.push({ op, path: this.vault.relativePath(file) });
+        }
+      } catch {
+      }
+    }
+    return results;
+  }
+  async loadAllClaims() {
+    const files = await glob4(path6.join(this.vault.paths.claims, "*.yaml"));
+    const results = [];
+    for (const file of files.sort()) {
+      try {
+        const raw = await fs9.readFile(file, "utf-8");
+        const claim = (await import("js-yaml")).load(raw);
+        if (claim.type === "claim") {
+          results.push({ claim, path: this.vault.relativePath(file) });
+        }
+      } catch {
+      }
+    }
+    return results;
+  }
+  groupByEntity(facts) {
+    const map = /* @__PURE__ */ new Map();
+    for (const entry of facts) {
+      const entity = entry.fact.entity;
+      if (!map.has(entity)) map.set(entity, []);
+      map.get(entity).push(entry);
+    }
+    return map;
+  }
+  renderByEntity(entity, facts) {
+    const lines = [`# Facts \u2014 ${entity}
+`];
+    const sorted = [...facts].sort((a, b) => a.fact.predicate.localeCompare(b.fact.predicate));
+    for (const { fact, path: fpath } of sorted) {
+      const from = fact.valid_from ?? "unknown";
+      const to = fact.valid_to ?? "present";
+      lines.push(`- **${fact.predicate}**: ${fact.value} (${from} \u2192 ${to}) \u2014 \`${fpath}\``);
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  renderById(facts, events, operations) {
+    const lines = ["# Records by ID\n"];
+    const allRecords = [];
+    for (const { fact, path: p } of facts) {
+      if (fact.id) allRecords.push({ id: fact.id, type: "fact", path: p });
+    }
+    for (const { event, path: p } of events) {
+      if (event.id) allRecords.push({ id: event.id, type: "event", path: p });
+    }
+    for (const { op, path: p } of operations) {
+      if (op.operation_id) allRecords.push({ id: op.operation_id, type: "operation", path: p });
+    }
+    allRecords.sort((a, b) => a.id.localeCompare(b.id));
+    for (const rec of allRecords) {
+      lines.push(`- \`${rec.id}\`: ${rec.type} \u2014 \`${rec.path}\``);
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  renderByPredicate(facts) {
+    const lines = ["# Facts by Predicate\n"];
+    const byPred = /* @__PURE__ */ new Map();
+    for (const entry of facts) {
+      const pred = entry.fact.predicate;
+      if (!byPred.has(pred)) byPred.set(pred, []);
+      byPred.get(pred).push(entry);
+    }
+    const sortedPreds = [...byPred.keys()].sort();
+    for (const pred of sortedPreds) {
+      lines.push(`## ${pred}
+`);
+      const entries = byPred.get(pred).sort((a, b) => a.fact.entity.localeCompare(b.fact.entity));
+      for (const { fact, path: p } of entries) {
+        lines.push(`- ${fact.entity} = ${fact.value} \u2014 \`${p}\``);
+      }
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  renderTimeline(events) {
+    const lines = ["# Timeline\n"];
+    const sorted = [...events].sort((a, b) => String(b.event.occurred_at).localeCompare(String(a.event.occurred_at)));
+    for (const { event, path: p } of sorted) {
+      const date = String(event.occurred_at).slice(0, 10);
+      const entities = event.entities?.join(", ") ?? "";
+      lines.push(`- **${date}** ${event.summary}${entities ? ` [${entities}]` : ""} \u2014 \`${p}\``);
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  renderContradictions(facts) {
+    const lines = ["# Contradictions\n"];
+    const byKey = /* @__PURE__ */ new Map();
+    for (const entry of facts) {
+      const key = `${entry.fact.entity}/${entry.fact.predicate}`;
+      if (!byKey.has(key)) byKey.set(key, []);
+      byKey.get(key).push(entry);
+    }
+    let found = false;
+    for (const [key, entries] of byKey) {
+      if (entries.length < 2) continue;
+      for (let i = 0; i < entries.length; i++) {
+        for (let j = i + 1; j < entries.length; j++) {
+          const a = entries[i];
+          const b = entries[j];
+          if (a.fact.superseded_by || b.fact.superseded_by) continue;
+          if (String(a.fact.value) === String(b.fact.value)) continue;
+          const aFrom = a.fact.valid_from ?? "0000-01-01";
+          const aTo = a.fact.valid_to ?? "9999-12-31";
+          const bFrom = b.fact.valid_from ?? "0000-01-01";
+          const bTo = b.fact.valid_to ?? "9999-12-31";
+          if (aFrom <= bTo && bFrom <= aTo) {
+            lines.push(`- **${key}**: "${a.fact.value}" vs "${b.fact.value}"`);
+            lines.push(`  - \`${a.path}\` vs \`${b.path}\``);
+            found = true;
+          }
+        }
+      }
+    }
+    if (!found) lines.push("No contradictions found.\n");
+    lines.push("");
+    return lines.join("\n");
+  }
+  renderStale(facts) {
+    const lines = ["# Stale Facts\n"];
+    const today = process.env.MEMORY_TODAY ?? format2(/* @__PURE__ */ new Date(), "yyyy-MM-dd");
+    const todayDate = parseISO2(today);
+    let found = false;
+    for (const { fact, path: p } of facts) {
+      if (!fact.last_reviewed) {
+        lines.push(`- \`${p}\` \u2014 no last_reviewed date`);
+        found = true;
+        continue;
+      }
+      const reviewed = parseISO2(fact.last_reviewed);
+      const days = differenceInDays(todayDate, reviewed);
+      if (days > this.staleDays) {
+        lines.push(`- \`${p}\` \u2014 last reviewed ${fact.last_reviewed} (${days} days ago)`);
+        found = true;
+      }
+    }
+    if (!found) lines.push("No stale facts found.\n");
+    lines.push("");
+    return lines.join("\n");
+  }
+  async renderGraph() {
+    const lines = ["# Wikilink Graph\n"];
+    const allFiles = await glob4(path6.join(this.vault.paths.memory, "**", "*.md"));
+    const wikilinkRegex = /\[\[([^\]|#]+)(?:#[^\]|]*)?\|?[^\]]*\]\]/g;
+    const edges = [];
+    for (const file of allFiles.sort()) {
+      if (file.startsWith(this.vault.paths.views)) continue;
+      const relPath = this.vault.relativePath(file);
+      try {
+        const content = await fs9.readFile(file, "utf-8");
+        let match;
+        wikilinkRegex.lastIndex = 0;
+        while ((match = wikilinkRegex.exec(content)) !== null) {
+          edges.push({ from: relPath, to: match[1].trim() });
+        }
+      } catch {
+      }
+    }
+    if (edges.length === 0) {
+      lines.push("No wikilinks found.\n");
+    } else {
+      for (const edge of edges) {
+        lines.push(`- \`${edge.from}\` \u2192 [[${edge.to}]]`);
+      }
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  renderInbox(operations) {
+    const lines = ["# Inbox\n"];
+    const proposed = operations.filter((o) => o.op.status === "proposed");
+    if (proposed.length === 0) {
+      lines.push("No pending operations.\n");
+    } else {
+      for (const { op, path: p } of proposed) {
+        lines.push(`- **${op.op}** ${op.target_id ?? ""} (${op.agent_id}) \u2014 \`${p}\``);
+      }
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  renderOperations(operations) {
+    const lines = ["# Operations\n"];
+    const sorted = [...operations].sort((a, b) => b.op.created_at.localeCompare(a.op.created_at));
+    if (sorted.length === 0) {
+      lines.push("No operations.\n");
+    } else {
+      for (const { op, path: p } of sorted) {
+        lines.push(`- [${op.status}] **${op.op}** ${op.target_id ?? ""} (${op.agent_id}, ${op.created_at.slice(0, 10)}) \u2014 \`${p}\``);
+      }
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  renderClaims(claims) {
+    const lines = ["# Claims\n"];
+    const active = claims.filter((c) => c.claim.status === "active");
+    if (active.length === 0) {
+      lines.push("No active claims.\n");
+    } else {
+      for (const { claim, path: p } of active) {
+        lines.push(`- **${claim.target_id}** by ${claim.agent_id} (expires ${claim.expires_at}) \u2014 \`${p}\``);
+      }
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  renderConflicts(operations) {
+    const lines = ["# Conflicts\n"];
+    const conflicts = operations.filter((o) => o.op.status === "conflict");
+    if (conflicts.length === 0) {
+      lines.push("No conflicts.\n");
+    } else {
+      for (const { op, path: p } of conflicts) {
+        lines.push(`- **${op.op}** ${op.target_id ?? ""} \u2014 ${op.conflict_reason ?? "unknown reason"}`);
+        lines.push(`  \`${p}\``);
+      }
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+};
+
+// src/core/scaffold.ts
+import * as fs10 from "fs/promises";
+import * as path7 from "path";
+import * as yaml5 from "js-yaml";
+var DEFAULT_PREDICATES = [
+  "base",
+  "collaborator",
+  "employer",
+  "language",
+  "primary-project",
+  "publication-channel",
+  "role",
+  "tool"
+];
+var FACT_SCHEMA = `type: object
+required: [type, entity, predicate, value, recorded_at]
+properties:
+  type: { const: fact }
+  id: { pattern: "^[a-z0-9][a-z0-9_-]*$" }
+  entity: { pattern: "^[a-z0-9-]+$" }
+  predicate: { pattern: "^[a-z0-9-]+$" }
+  value: {}
+  valid_from: { format: date, nullable: true }
+  valid_to: { format: date, nullable: true }
+  recorded_at: { format: date-time }
+  confidence: { enum: [high, medium, low] }
+  sources: { type: array }
+  last_reviewed: { format: date }
+  superseded_by: { type: string }
+  tags: { type: array }
+  decay: { type: object }
+`;
+var EVENT_SCHEMA = `type: object
+required: [type, occurred_at, summary]
+properties:
+  type: { const: event }
+  id: { pattern: "^[a-z0-9][a-z0-9_-]*$" }
+  occurred_at: { format: date-time }
+  summary: { type: string }
+  entities: { type: array }
+  kind: { enum: [conversation, decision, ingest, action, observation] }
+  sources: { type: array }
+  derived_facts: { type: array }
+`;
+var OPERATION_SCHEMA = `type: object
+required: [type, operation_id, op, agent_id, created_at, status, reason]
+properties:
+  type: { const: operation }
+  operation_id: { pattern: "^op-[a-z0-9][a-z0-9_-]*$" }
+  op: { enum: [create_fact, update_fact, add_event, archive_fact, review_fact, rename_entity, add_entity, add_predicate] }
+  agent_id: { pattern: "^agent-[a-z0-9-]+-[a-f0-9]{8}$" }
+  created_at: { format: date-time }
+  target_id: { type: string }
+  target_path: { type: string }
+  precondition_hash: { pattern: "^sha256:[0-9a-f]{64}$", nullable: true }
+  status: { enum: [proposed, validated, applied, rejected, conflict, superseded] }
+  reason: { type: string }
+  sources: { type: array }
+  payload: { type: object }
+`;
+var CLAIM_SCHEMA = `type: object
+required: [type, target_id, operation_id, agent_id, created_at, expires_at, heartbeat_at]
+properties:
+  type: { const: claim }
+  target_id: { pattern: "^[a-z0-9][a-z0-9_-]*$" }
+  operation_id: { pattern: "^op-[a-z0-9][a-z0-9_-]*$" }
+  agent_id: { pattern: "^agent-[a-z0-9-]+-[a-f0-9]{8}$" }
+  created_at: { format: date-time }
+  expires_at: { format: date-time }
+  heartbeat_at: { format: date-time }
+  status: { enum: [active, released, broken] }
+`;
+var ENTITY_SCHEMA = `type: object
+required: [type, id, kind]
+properties:
+  type: { const: entity-index }
+  id: { pattern: "^[a-z0-9-]+$" }
+  kind: { enum: [person, project, org, place, concept, tool] }
+  display: { type: string }
+  aliases: { type: array }
+`;
+var DECISION_SCHEMA = `type: object
+required: [type, id, status, decided_at, title]
+properties:
+  type: { const: decision }
+  id: { pattern: "^DEC-[0-9]{3}$" }
+  status: { enum: [accepted, pending, deprecated, superseded] }
+  decided_at: { format: date }
+  title: { type: string }
+  entities: { type: array }
+  sources: { type: array }
+`;
+var INSIGHT_SCHEMA = `type: object
+required: [type, title, recorded_at, summary]
+properties:
+  type: { const: insight }
+  id: { pattern: "^[a-z0-9][a-z0-9_-]*$" }
+  title: { type: string }
+  recorded_at: { format: date-time }
+  summary: { type: string }
+  entities: { type: array }
+  sources: { type: array }
+  confidence: { enum: [high, medium, low] }
+`;
+async function scaffoldVault(options) {
+  const { vaultPath } = options;
+  const predicates = options.predicates ?? DEFAULT_PREDICATES;
+  const entities = options.entities ?? [];
+  const created = [];
+  const dirs = [
+    "memory/schema",
+    "memory/facts",
+    "memory/events",
+    "memory/decisions",
+    "memory/insights",
+    "memory/people",
+    "memory/projects",
+    "memory/context",
+    "memory/_views/by-entity",
+    "memory/_inbox",
+    "memory/_claims",
+    "memory/_ops/applied",
+    "memory/_archive",
+    "sources/articles",
+    "sources/notes",
+    "sources/assets"
+  ];
+  for (const dir of dirs) {
+    const fullPath = path7.join(vaultPath, dir);
+    await fs10.mkdir(fullPath, { recursive: true });
+    const gitkeep = path7.join(fullPath, ".gitkeep");
+    try {
+      await fs10.access(gitkeep);
+    } catch {
+      await fs10.writeFile(gitkeep, "", "utf-8");
+    }
+    created.push(dir);
+  }
+  const versionPath = path7.join(vaultPath, "memory/schema/version.yaml");
+  await fs10.writeFile(
+    versionPath,
+    yaml5.dump({ spec_version: "3.0", schema_status: "stable", frozen_at: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10) }),
+    "utf-8"
+  );
+  created.push("memory/schema/version.yaml");
+  const predicatesPath = path7.join(vaultPath, "memory/schema/predicates.yaml");
+  await fs10.writeFile(predicatesPath, yaml5.dump(predicates, { flowLevel: -1 }), "utf-8");
+  created.push("memory/schema/predicates.yaml");
+  const schemas = {
+    "fact.schema.yaml": FACT_SCHEMA,
+    "event.schema.yaml": EVENT_SCHEMA,
+    "operation.schema.yaml": OPERATION_SCHEMA,
+    "claim.schema.yaml": CLAIM_SCHEMA,
+    "entity.schema.yaml": ENTITY_SCHEMA,
+    "decision.schema.yaml": DECISION_SCHEMA,
+    "insight.schema.yaml": INSIGHT_SCHEMA
+  };
+  for (const [filename, content] of Object.entries(schemas)) {
+    const filePath = path7.join(vaultPath, "memory/schema", filename);
+    await fs10.writeFile(filePath, content, "utf-8");
+    created.push(`memory/schema/${filename}`);
+  }
+  const entitiesPath = path7.join(vaultPath, "memory/entities.md");
+  const entitiesData = {
+    type: "entity-index",
+    entities
+  };
+  await writeMarkdownFile(
+    entitiesPath,
+    entitiesData,
+    "\n# Entities\n\nCanonical entity list for this vault.\n"
+  );
+  created.push("memory/entities.md");
+  const agentsPath = path7.join(vaultPath, "AGENTS.md");
+  const agentsContent = `# Agent Instructions
+
+## Memory Protocol (v3 Atomic Markdown Memory)
+
+This vault uses the v3 Atomic Markdown Memory system.
+
+### Key Rules
+- Facts live in \`memory/facts/{entity}/{predicate}.md\` (one fact per file)
+- Events are append-only in \`memory/events/YYYY-MM-DD/{slug}.md\`
+- Views in \`memory/_views/\` are generated \u2014 never edit them directly
+- Schemas in \`memory/schema/\` define allowed types and predicates
+- All entities must be registered in \`memory/entities.md\`
+- All predicates must be registered in \`memory/schema/predicates.yaml\`
+
+### Update Protocol
+1. To add a fact: use the \`create_fact\` MCP tool (or write to \`memory/facts/\`)
+2. To record an event: use the \`add_event\` MCP tool
+3. After writes: run \`lint_vault\` to validate, then \`rebuild_views\` to update views
+4. For multi-agent: write to \`memory/_inbox/{agent-id}/ops/\` and use \`compact_inbox\`
+`;
+  await fs10.writeFile(agentsPath, agentsContent, "utf-8");
+  created.push("AGENTS.md");
+  const sourcesReadme = path7.join(vaultPath, "sources/README.md");
+  await fs10.writeFile(
+    sourcesReadme,
+    "# Sources\n\nImmutable inputs. Drop articles, notes, and assets here.\nAgents read but never modify source files.\n",
+    "utf-8"
+  );
+  created.push("sources/README.md");
+  return created;
+}
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/tools/read.ts
+import { z } from "zod";
+import * as fs11 from "fs/promises";
+function registerReadTools(server, vault, queryEngine) {
+  server.tool(
+    "read_fact",
+    "Read a specific fact by entity+predicate or by ID. Optionally filter by temporal validity on a given date.",
+    {
+      entity: z.string().optional().describe("Entity ID (e.g. 'elena-voss')"),
+      predicate: z.string().optional().describe("Predicate name (e.g. 'role')"),
+      id: z.string().optional().describe("Stable fact ID (e.g. 'fact-elena-voss-role')"),
+      on_date: z.string().optional().describe("Filter to facts valid on this date (YYYY-MM-DD)")
+    },
+    async (params) => {
+      const facts = await queryEngine.findFacts({
+        entity: params.entity,
+        predicate: params.predicate,
+        id: params.id,
+        onDate: params.on_date
+      });
+      if (facts.length === 0) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: "No matching fact found", code: "NOT_FOUND" }) }],
+          isError: true
+        };
+      }
+      const results = facts.map((f) => ({
+        ...f.data,
+        _path: vault.relativePath(f.path),
+        _body: f.content.trim() || void 0
+      }));
+      return {
+        content: [{ type: "text", text: JSON.stringify(results.length === 1 ? results[0] : results, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "read_entity",
+    "Get all facts for a given entity. Returns a snapshot of everything known about the entity.",
+    {
+      entity: z.string().describe("Entity ID (e.g. 'elena-voss')"),
+      on_date: z.string().optional().describe("Temporal snapshot date (YYYY-MM-DD)")
+    },
+    async (params) => {
+      const facts = await queryEngine.findFacts({
+        entity: params.entity,
+        onDate: params.on_date
+      });
+      if (facts.length === 0) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ entity: params.entity, facts: [], message: "No facts found for this entity" }) }]
+        };
+      }
+      const result = {
+        entity: params.entity,
+        on_date: params.on_date ?? "current",
+        facts: facts.map((f) => ({
+          predicate: f.data.predicate,
+          value: f.data.value,
+          valid_from: f.data.valid_from,
+          valid_to: f.data.valid_to,
+          confidence: f.data.confidence,
+          path: vault.relativePath(f.path)
+        }))
+      };
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server.tool(
+    "read_event",
+    "Read events filtered by entity, date range, or kind.",
+    {
+      entity: z.string().optional().describe("Filter events involving this entity"),
+      since: z.string().optional().describe("Events after this date (YYYY-MM-DD or ISO 8601)"),
+      until: z.string().optional().describe("Events before this date"),
+      kind: z.string().optional().describe("Event kind: conversation, decision, ingest, action, observation"),
+      limit: z.number().optional().describe("Maximum number of events to return")
+    },
+    async (params) => {
+      const events = await queryEngine.findEvents({
+        entity: params.entity,
+        since: params.since,
+        until: params.until,
+        kind: params.kind,
+        limit: params.limit
+      });
+      const results = events.map((e) => ({
+        ...e.data,
+        _path: vault.relativePath(e.path),
+        _body: e.content.trim() || void 0
+      }));
+      return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+    }
+  );
+  server.tool(
+    "search_memory",
+    "Search facts with flexible filters: text query, entity, predicate, date, confidence, tags.",
+    {
+      query: z.string().optional().describe("Text search in fact values, entity names, and predicates"),
+      entity: z.string().optional().describe("Filter by entity"),
+      predicate: z.string().optional().describe("Filter by predicate"),
+      on_date: z.string().optional().describe("Filter to facts valid on this date (YYYY-MM-DD)"),
+      confidence: z.string().optional().describe("Filter by confidence: high, medium, low"),
+      tags: z.array(z.string()).optional().describe("Filter by tags (any match)"),
+      limit: z.number().optional().describe("Maximum results to return")
+    },
+    async (params) => {
+      const facts = await queryEngine.findFacts({
+        query: params.query,
+        entity: params.entity,
+        predicate: params.predicate,
+        onDate: params.on_date,
+        confidence: params.confidence,
+        tags: params.tags,
+        limit: params.limit
+      });
+      const results = facts.map((f) => ({
+        entity: f.data.entity,
+        predicate: f.data.predicate,
+        value: f.data.value,
+        confidence: f.data.confidence,
+        valid_from: f.data.valid_from,
+        valid_to: f.data.valid_to,
+        path: vault.relativePath(f.path)
+      }));
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ count: results.length, results }, null, 2)
+        }]
+      };
+    }
+  );
+  server.tool(
+    "get_view",
+    "Read a materialized view. Views are pre-generated summaries of vault data.",
+    {
+      view: z.enum([
+        "by-entity",
+        "by-id",
+        "by-predicate",
+        "timeline",
+        "contradictions",
+        "stale",
+        "graph",
+        "inbox",
+        "operations",
+        "claims",
+        "conflicts"
+      ]).describe("View name"),
+      entity: z.string().optional().describe("For by-entity view, the entity ID")
+    },
+    async (params) => {
+      let viewPath;
+      if (params.view === "by-entity" || params.entity) {
+        if (!params.entity) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ error: "entity parameter required for by-entity view" }) }],
+            isError: true
+          };
+        }
+        viewPath = vault.entityViewPath(params.entity);
+      } else {
+        viewPath = vault.viewPath(params.view);
+      }
+      try {
+        const content = await fs11.readFile(viewPath, "utf-8");
+        return { content: [{ type: "text", text: content }] };
+      } catch {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: `View not found: ${params.view}. Run rebuild_views to generate.`, code: "VIEW_NOT_FOUND" }) }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/write.ts
+import { z as z2 } from "zod";
+function registerWriteTools(server, vault, operationManager, entities, predicates, config) {
+  server.tool(
+    "create_fact",
+    "Create a new atomic fact about an entity. In direct mode, writes immediately. In inbox mode, creates an operation envelope for later application.",
+    {
+      entity: z2.string().describe("Entity ID (must be registered in entities.md)"),
+      predicate: z2.string().describe("Predicate (must be in predicates.yaml)"),
+      value: z2.string().describe("The fact value"),
+      confidence: z2.enum(["high", "medium", "low"]).optional().describe("Confidence level"),
+      valid_from: z2.string().nullable().optional().describe("Date when this fact became true (YYYY-MM-DD)"),
+      valid_to: z2.string().nullable().optional().describe("Date when this fact stops being true (YYYY-MM-DD)"),
+      sources: z2.array(z2.string()).optional().describe("Source file paths (relative to vault root)"),
+      tags: z2.array(z2.string()).optional().describe("Tags for categorization"),
+      reason: z2.string().describe("Why this fact is being recorded")
+    },
+    async (params) => {
+      if (!await entities.exists(params.entity)) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: `Unknown entity '${params.entity}'. Use add_entity first.`, code: "ENTITY_NOT_FOUND" }) }],
+          isError: true
+        };
+      }
+      if (!await predicates.exists(params.predicate)) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: `Unknown predicate '${params.predicate}'. Use add_predicate first.`, code: "PREDICATE_NOT_FOUND" }) }],
+          isError: true
+        };
+      }
+      try {
+        if (config.writeMode === "direct") {
+          const result = await operationManager.createFactDirect({
+            entity: params.entity,
+            predicate: params.predicate,
+            value: params.value,
+            confidence: params.confidence,
+            valid_from: params.valid_from,
+            valid_to: params.valid_to,
+            sources: params.sources,
+            tags: params.tags,
+            reason: params.reason
+          });
+          return {
+            content: [{ type: "text", text: JSON.stringify({ success: true, mode: "direct", ...result }, null, 2) }]
+          };
+        } else {
+          const result = await operationManager.createFactEnvelope({
+            entity: params.entity,
+            predicate: params.predicate,
+            value: params.value,
+            confidence: params.confidence,
+            valid_from: params.valid_from,
+            valid_to: params.valid_to,
+            sources: params.sources,
+            tags: params.tags,
+            reason: params.reason
+          });
+          return {
+            content: [{ type: "text", text: JSON.stringify({ success: true, mode: "inbox", ...result }, null, 2) }]
+          };
+        }
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: err instanceof Error ? err.message : String(err), code: "OPERATION_FAILED" }) }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "update_fact",
+    "Update an existing fact. Computes precondition hash for safety. Specify the fact by ID or path.",
+    {
+      id: z2.string().optional().describe("Stable fact ID"),
+      path: z2.string().optional().describe("Relative path to the fact file"),
+      value: z2.string().optional().describe("New value"),
+      valid_to: z2.string().nullable().optional().describe("Update valid_to date"),
+      confidence: z2.enum(["high", "medium", "low"]).optional().describe("Update confidence"),
+      tags: z2.array(z2.string()).optional().describe("Replace tags"),
+      reason: z2.string().describe("Why this fact is being updated")
+    },
+    async (params) => {
+      if (!params.id && !params.path) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: "Either 'id' or 'path' is required", code: "INVALID_PARAMS" }) }],
+          isError: true
+        };
+      }
+      try {
+        if (config.writeMode === "direct") {
+          const result = await operationManager.updateFactDirect({
+            targetId: params.id,
+            targetPath: params.path,
+            value: params.value,
+            valid_to: params.valid_to,
+            confidence: params.confidence,
+            tags: params.tags,
+            reason: params.reason
+          });
+          return {
+            content: [{ type: "text", text: JSON.stringify({ success: true, mode: "direct", ...result }, null, 2) }]
+          };
+        } else {
+          const result = await operationManager.updateFactEnvelope({
+            targetId: params.id,
+            targetPath: params.path,
+            value: params.value,
+            valid_to: params.valid_to,
+            confidence: params.confidence,
+            tags: params.tags,
+            reason: params.reason
+          });
+          return {
+            content: [{ type: "text", text: JSON.stringify({ success: true, mode: "inbox", ...result }, null, 2) }]
+          };
+        }
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: err instanceof Error ? err.message : String(err), code: "OPERATION_FAILED" }) }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "add_event",
+    "Record an episodic event. Events are append-only and never edited after creation.",
+    {
+      summary: z2.string().describe("Short summary of what happened"),
+      entities: z2.array(z2.string()).optional().describe("Entity IDs involved in this event"),
+      kind: z2.enum(["conversation", "decision", "ingest", "action", "observation"]).optional().describe("Event kind"),
+      sources: z2.array(z2.string()).optional().describe("Source file paths"),
+      body: z2.string().optional().describe("Extended markdown body for the event"),
+      reason: z2.string().optional().describe("Why this event is being recorded (for inbox mode)")
+    },
+    async (params) => {
+      try {
+        if (config.writeMode === "direct") {
+          const result = await operationManager.addEventDirect({
+            summary: params.summary,
+            entities: params.entities,
+            kind: params.kind,
+            sources: params.sources,
+            body: params.body
+          });
+          return {
+            content: [{ type: "text", text: JSON.stringify({ success: true, mode: "direct", ...result }, null, 2) }]
+          };
+        } else {
+          const result = await operationManager.addEventEnvelope({
+            summary: params.summary,
+            entities: params.entities,
+            kind: params.kind,
+            sources: params.sources,
+            body: params.body,
+            reason: params.reason
+          });
+          return {
+            content: [{ type: "text", text: JSON.stringify({ success: true, mode: "inbox", ...result }, null, 2) }]
+          };
+        }
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: err instanceof Error ? err.message : String(err), code: "OPERATION_FAILED" }) }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "archive_fact",
+    "Archive a fact (move to _archive/). Use when a fact is no longer current.",
+    {
+      id: z2.string().optional().describe("Stable fact ID"),
+      path: z2.string().optional().describe("Relative path to the fact file"),
+      reason: z2.string().describe("Why this fact is being archived")
+    },
+    async (params) => {
+      if (!params.id && !params.path) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: "Either 'id' or 'path' is required", code: "INVALID_PARAMS" }) }],
+          isError: true
+        };
+      }
+      try {
+        const result = await operationManager.archiveFactDirect({
+          targetId: params.id,
+          targetPath: params.path,
+          reason: params.reason
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify({ success: true, ...result }, null, 2) }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: err instanceof Error ? err.message : String(err), code: "OPERATION_FAILED" }) }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/maintenance.ts
+import { z as z3 } from "zod";
+import { format as format3 } from "date-fns";
+function registerMaintenanceTools(server, vault, validator, viewGenerator, operationManager, config) {
+  server.tool(
+    "lint_vault",
+    "Run full schema validation on the vault. Checks version, schemas, entities, predicates, temporal validity, wikilinks, contradictions, and duplicate IDs.",
+    {},
+    async () => {
+      try {
+        const findings = await validator.lint();
+        const errors = findings.filter((f) => f.level === "ERROR");
+        const warnings = findings.filter((f) => f.level === "WARN");
+        const passed = errors.length === 0;
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              passed,
+              errors: errors.length,
+              warnings: warnings.length,
+              findings
+            }, null, 2)
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: err instanceof Error ? err.message : String(err), code: "LINT_FAILED" }) }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "rebuild_views",
+    "Regenerate all materialized views in memory/_views/. Views are derived from facts, events, and operations.",
+    {},
+    async () => {
+      try {
+        const written = await viewGenerator.rebuildAll();
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ success: true, files_written: written.length, files: written }, null, 2)
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: err instanceof Error ? err.message : String(err), code: "REBUILD_FAILED" }) }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "compact_inbox",
+    "Apply proposed operations from the inbox. Validates precondition hashes and claim conflicts before applying.",
+    {
+      auto_apply: z3.boolean().optional().describe("Automatically apply valid operations (default: true)")
+    },
+    async (params) => {
+      try {
+        const result = await operationManager.compact(params.auto_apply ?? true);
+        if (result.applied > 0) {
+          await viewGenerator.rebuildAll();
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              success: true,
+              applied: result.applied,
+              conflicts: result.conflicts,
+              archived: result.archived,
+              errors: result.errors.length > 0 ? result.errors : void 0
+            }, null, 2)
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: err instanceof Error ? err.message : String(err), code: "COMPACT_FAILED" }) }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "reflect",
+    "Create a reflection/observation event. Records a session summary or insight as an operation envelope.",
+    {
+      summary: z3.string().describe("Reflection summary text"),
+      entities: z3.array(z3.string()).optional().describe("Entities mentioned in the reflection")
+    },
+    async (params) => {
+      try {
+        const operationId = generateOperationId();
+        const now = /* @__PURE__ */ new Date();
+        const dateStr = format3(now, "yyyy-MM-dd");
+        const slug = slugify(params.summary);
+        const data = {
+          type: "operation",
+          operation_id: operationId,
+          op: "add_event",
+          agent_id: config.agentId,
+          created_at: now.toISOString(),
+          target_id: generateEventId(dateStr, slug),
+          target_path: `memory/events/${dateStr}/${slug}.md`,
+          precondition_hash: null,
+          status: "proposed",
+          reason: "Session reflection",
+          sources: [],
+          payload: {
+            type: "event",
+            occurred_at: now.toISOString(),
+            summary: params.summary,
+            entities: params.entities ?? [],
+            kind: "observation",
+            sources: []
+          }
+        };
+        const opPath = vault.inboxOpPath(config.agentId, operationId);
+        await writeMarkdownFile(opPath, data, `
+# Reflection
+
+${params.summary}
+`);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              success: true,
+              operationId,
+              path: vault.relativePath(opPath),
+              message: "Reflection created as operation envelope. Run compact_inbox to apply."
+            }, null, 2)
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: err instanceof Error ? err.message : String(err), code: "REFLECT_FAILED" }) }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/schema.ts
+import { z as z4 } from "zod";
+import * as fs12 from "fs/promises";
+function registerSchemaTools(server, vault, entities, predicates) {
+  server.tool(
+    "list_entities",
+    "List all registered entities in the vault.",
+    {
+      kind: z4.enum(["person", "project", "org", "place", "concept", "tool"]).optional().describe("Filter by entity kind")
+    },
+    async (params) => {
+      const all = params.kind ? await entities.getByKind(params.kind) : await entities.getAll();
+      return {
+        content: [{ type: "text", text: JSON.stringify({ count: all.length, entities: all }, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "list_predicates",
+    "List all allowed predicates defined in the vault schema.",
+    {},
+    async () => {
+      const all = await predicates.getAll();
+      return {
+        content: [{ type: "text", text: JSON.stringify({ count: all.length, predicates: all }, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "add_entity",
+    "Register a new entity in the vault's entity index.",
+    {
+      id: z4.string().regex(/^[a-z0-9-]+$/).describe("Entity ID in kebab-case (e.g. 'john-doe')"),
+      kind: z4.enum(["person", "project", "org", "place", "concept", "tool"]).describe("Entity kind"),
+      display: z4.string().describe("Display name (e.g. 'John Doe')"),
+      aliases: z4.array(z4.string()).optional().describe("Alternative names")
+    },
+    async (params) => {
+      try {
+        const updated = await entities.add({
+          id: params.id,
+          kind: params.kind,
+          display: params.display,
+          aliases: params.aliases
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify({ success: true, entity: params.id, total: updated.length }, null, 2) }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: err instanceof Error ? err.message : String(err), code: "ADD_ENTITY_FAILED" }) }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "add_predicate",
+    "Register a new predicate in the vault schema.",
+    {
+      id: z4.string().regex(/^[a-z0-9-]+$/).describe("Predicate ID in kebab-case (e.g. 'favorite-color')")
+    },
+    async (params) => {
+      try {
+        const updated = await predicates.add(params.id);
+        return {
+          content: [{ type: "text", text: JSON.stringify({ success: true, predicate: params.id, total: updated.length }, null, 2) }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: err instanceof Error ? err.message : String(err), code: "ADD_PREDICATE_FAILED" }) }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "get_schema",
+    "Get the YAML schema definition for a given memory type.",
+    {
+      type: z4.enum(["fact", "event", "operation", "claim", "entity", "decision", "insight"]).describe("Schema type to retrieve")
+    },
+    async (params) => {
+      const schemaFile = `${params.type}.schema.yaml`;
+      const schemaPath = `${vault.paths.schema}/${schemaFile}`;
+      try {
+        const content = await fs12.readFile(schemaPath, "utf-8");
+        return {
+          content: [{ type: "text", text: content }]
+        };
+      } catch {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: `Schema not found: ${schemaFile}`, code: "SCHEMA_NOT_FOUND" }) }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/vault.ts
+import { z as z5 } from "zod";
+import { glob as glob5 } from "glob";
+import * as path8 from "path";
+function registerVaultTools(server, vault) {
+  server.tool(
+    "vault_init",
+    "Scaffold a new v3 Atomic Markdown Memory vault with all required directories, schemas, and configuration.",
+    {
+      path: z5.string().optional().describe("Vault path (defaults to configured vault path)"),
+      entities: z5.array(
+        z5.object({
+          id: z5.string(),
+          kind: z5.enum(["person", "project", "org", "place", "concept", "tool"]),
+          display: z5.string(),
+          aliases: z5.array(z5.string()).optional()
+        })
+      ).optional().describe("Initial entities to register"),
+      predicates: z5.array(z5.string()).optional().describe("Initial predicates (defaults to standard set)")
+    },
+    async (params) => {
+      const vaultPath = params.path ?? vault.paths.root;
+      try {
+        const created = await scaffoldVault({
+          vaultPath,
+          entities: params.entities?.map((e) => ({
+            id: e.id,
+            kind: e.kind,
+            display: e.display,
+            aliases: e.aliases
+          })),
+          predicates: params.predicates
+        });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ success: true, vault_path: vaultPath, created_count: created.length, created }, null, 2)
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: err instanceof Error ? err.message : String(err), code: "INIT_FAILED" }) }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "vault_status",
+    "Get vault health overview: counts, version, pending operations, and last modification info.",
+    {},
+    async () => {
+      try {
+        await vault.assertValid();
+        const factFiles = await glob5(path8.join(vault.paths.facts, "**", "*.md"));
+        const eventFiles = await glob5(path8.join(vault.paths.events, "**", "*.md"));
+        const inboxFiles = await glob5(path8.join(vault.paths.inbox, "**", "ops", "*.md"));
+        const appliedFiles = await glob5(path8.join(vault.paths.opsApplied, "*.md"));
+        const archiveFiles = await glob5(path8.join(vault.paths.archive, "**", "*.md"));
+        let pending = 0;
+        for (const file of inboxFiles) {
+          try {
+            const parsed = await parseMarkdownFile(file);
+            if (parsed.data.status === "proposed") pending++;
+          } catch {
+          }
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              valid: true,
+              vault_path: vault.paths.root,
+              counts: {
+                facts: factFiles.length,
+                events: eventFiles.length,
+                pending_operations: pending,
+                applied_operations: appliedFiles.length,
+                archived_facts: archiveFiles.length
+              }
+            }, null, 2)
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              valid: false,
+              error: err instanceof Error ? err.message : String(err)
+            }, null, 2)
+          }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/index.ts
+function registerAllTools(server, services) {
+  registerReadTools(server, services.vault, services.queryEngine);
+  registerWriteTools(
+    server,
+    services.vault,
+    services.operationManager,
+    services.entities,
+    services.predicates,
+    services.config
+  );
+  registerMaintenanceTools(
+    server,
+    services.vault,
+    services.validator,
+    services.viewGenerator,
+    services.operationManager,
+    services.config
+  );
+  registerSchemaTools(server, services.vault, services.entities, services.predicates);
+  registerVaultTools(server, services.vault);
+}
+
+// src/server.ts
+function createServer(config) {
+  const server = new McpServer({
+    name: "obsidian-memory",
+    version: "0.1.0"
+  });
+  const vault = new Vault(config);
+  const entities = new EntityRegistry(vault);
+  const predicates = new PredicateRegistry(vault);
+  const queryEngine = new QueryEngine(vault);
+  const operationManager = new OperationManager(vault, config.agentId);
+  const validator = new SchemaValidator(vault, entities, predicates);
+  const viewGenerator = new ViewGenerator(vault, config.staleDays);
+  registerAllTools(server, {
+    vault,
+    queryEngine,
+    operationManager,
+    validator,
+    viewGenerator,
+    entities,
+    predicates,
+    config
+  });
+  return server;
+}
+
+// src/config.ts
+import * as os from "os";
+
+// src/types/config.ts
+var DEFAULT_CONFIG = {
+  transport: "stdio",
+  writeMode: "direct",
+  port: 3100,
+  staleDays: 180
+};
+
+// src/config.ts
+function resolveConfig(input) {
+  const vaultPath = input.vault ?? process.env.VAULT_PATH ?? process.env.OBSIDIAN_VAULT_PATH;
+  if (!vaultPath) {
+    throw new Error(
+      "Vault path is required. Provide --vault flag or set VAULT_PATH environment variable."
+    );
+  }
+  const transport = input.transport ?? process.env.TRANSPORT ?? DEFAULT_CONFIG.transport;
+  const agentId = input.agentId ?? process.env.AGENT_ID ?? generateAgentId(os.hostname().split(".")[0]);
+  const writeMode = input.mode ?? process.env.WRITE_MODE ?? DEFAULT_CONFIG.writeMode;
+  const port = input.port ?? (process.env.PORT ? parseInt(process.env.PORT, 10) : DEFAULT_CONFIG.port);
+  const staleDays = input.staleDays ?? (process.env.STALE_DAYS ? parseInt(process.env.STALE_DAYS, 10) : DEFAULT_CONFIG.staleDays);
+  return {
+    vaultPath,
+    transport,
+    agentId,
+    writeMode,
+    port,
+    apiKey: input.apiKey ?? process.env.API_KEY,
+    staleDays
+  };
+}
+
+export {
+  Vault,
+  VaultError,
+  parseMarkdownFile,
+  serializeMarkdown,
+  writeMarkdownFile,
+  readFrontmatter,
+  fileExists,
+  EntityRegistry,
+  PredicateRegistry,
+  QueryEngine,
+  computeFileHash,
+  computeStringHash,
+  isValidHash,
+  generateOperationId,
+  generateAgentId,
+  generateFactId,
+  generateEventId,
+  slugify,
+  OperationManager,
+  OperationError,
+  SchemaValidator,
+  ViewGenerator,
+  scaffoldVault,
+  createServer,
+  resolveConfig
+};
+//# sourceMappingURL=chunk-5U2LXK3W.js.map