@remnic/core 1.0.0

package/dist/chunk-QY2BHY5O.js

@@ -0,0 +1,2378 @@
+import {
+  canReadNamespace,
+  canWriteNamespace,
+  resolvePrincipal
+} from "./chunk-N5AKDXAI.js";
+import {
+  getTrustZoneStoreStatus,
+  isTrustZoneName,
+  listTrustZoneRecords,
+  promoteTrustZoneRecord,
+  scoreTrustZoneProvenance,
+  seedTrustZoneDemoDataset,
+  summarizeTrustZonePromotionReadiness
+} from "./chunk-EQINRHYR.js";
+import {
+  buildProposedActions,
+  buildQualityScore,
+  groupActionsByStatus,
+  listMemoryGovernanceRuns,
+  readMemoryGovernanceRunArtifact,
+  runMemoryGovernance
+} from "./chunk-J3BT33K7.js";
+import {
+  wrapWorkLayerContext
+} from "./chunk-EEQLFRUM.js";
+import {
+  parseEntityFile
+} from "./chunk-QWUUMMIK.js";
+import {
+  inferMemoryStatus,
+  toMemoryPathRel
+} from "./chunk-TP4FZJIZ.js";
+import {
+  normalizeProjectionPreview,
+  normalizeProjectionTags
+} from "./chunk-SCU65EZI.js";
+import {
+  getMemoryProjectionPath
+} from "./chunk-BOUYNNYD.js";
+import {
+  persistExplicitCapture,
+  queueExplicitCaptureForReview,
+  validateExplicitCaptureInput
+} from "./chunk-YNCQ7E4M.js";
+import {
+  log
+} from "./chunk-KWBU5S5U.js";
+import {
+  AccessIdempotencyStore,
+  hashAccessIdempotencyPayload
+} from "./chunk-XKECPATV.js";
+
+// src/access-service.ts
+import { stat } from "fs/promises";
+
+// src/work/storage.ts
+import path from "path";
+import { randomUUID } from "crypto";
+import { mkdir, readdir, readFile, rm, writeFile } from "fs/promises";
+var TASK_TRANSITIONS = {
+  todo: /* @__PURE__ */ new Set(["in_progress", "blocked", "cancelled"]),
+  in_progress: /* @__PURE__ */ new Set(["todo", "blocked", "done", "cancelled"]),
+  blocked: /* @__PURE__ */ new Set(["todo", "in_progress", "cancelled"]),
+  done: /* @__PURE__ */ new Set(),
+  cancelled: /* @__PURE__ */ new Set()
+};
+function serializeFrontmatter(values) {
+  const lines = Object.entries(values).map(([k, v]) => `${k}: ${JSON.stringify(v)}`);
+  return `---
+${lines.join("\n")}
+---`;
+}
+function parseFrontmatter(raw) {
+  const match = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) return null;
+  const fm = match[1] ?? "";
+  const body = match[2] ?? "";
+  const data = {};
+  for (const line of fm.split("\n")) {
+    if (!line.trim()) continue;
+    const idx = line.indexOf(":");
+    if (idx <= 0) continue;
+    const key = line.slice(0, idx).trim();
+    const rawValue = line.slice(idx + 1).trim();
+    try {
+      data[key] = JSON.parse(rawValue);
+    } catch {
+      data[key] = rawValue;
+    }
+  }
+  return { data, body };
+}
+function toSafeSlug(value) {
+  let slug = value.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-");
+  let start = 0;
+  while (start < slug.length && slug[start] === "-") start++;
+  let end = slug.length;
+  while (end > start && slug[end - 1] === "-") end--;
+  return slug.slice(start, end).slice(0, 80);
+}
+var WORK_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9-]{0,127}$/;
+function makeId(prefix, titleOrName, now) {
+  const slug = toSafeSlug(titleOrName) || "item";
+  const nonce = randomUUID().slice(0, 8);
+  return `${prefix}-${now.getTime()}-${slug}-${nonce}`;
+}
+function assertValidWorkId(id, kind) {
+  if (!WORK_ID_PATTERN.test(id)) {
+    throw new Error(`invalid ${kind} id: ${id}`);
+  }
+}
+function ensureString(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function ensureStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "string");
+}
+function ensureNullableString(value) {
+  return typeof value === "string" ? value : null;
+}
+function ensureTaskStatus(value) {
+  if (value === "todo" || value === "in_progress" || value === "blocked" || value === "done" || value === "cancelled") {
+    return value;
+  }
+  return "todo";
+}
+function ensureTaskPriority(value) {
+  if (value === "low" || value === "medium" || value === "high") return value;
+  return "medium";
+}
+function ensureProjectStatus(value) {
+  if (value === "active" || value === "on_hold" || value === "completed" || value === "archived") return value;
+  return "active";
+}
+var WorkStorage = class {
+  constructor(memoryDir) {
+    this.memoryDir = memoryDir;
+    this.tasksDir = path.join(memoryDir, "work", "tasks");
+    this.projectsDir = path.join(memoryDir, "work", "projects");
+  }
+  memoryDir;
+  tasksDir;
+  projectsDir;
+  async ensureDirectories() {
+    await mkdir(this.tasksDir, { recursive: true });
+    await mkdir(this.projectsDir, { recursive: true });
+  }
+  taskPath(id) {
+    assertValidWorkId(id, "task");
+    return path.join(this.tasksDir, `${id}.md`);
+  }
+  projectPath(id) {
+    assertValidWorkId(id, "project");
+    return path.join(this.projectsDir, `${id}.md`);
+  }
+  serializeTask(task) {
+    return `${serializeFrontmatter(task)}
+
+${task.description}
+`;
+  }
+  serializeProject(project) {
+    return `${serializeFrontmatter(project)}
+
+${project.description}
+`;
+  }
+  parseTask(raw) {
+    const parsed = parseFrontmatter(raw);
+    if (!parsed) return null;
+    const d = parsed.data;
+    return {
+      id: ensureString(d.id),
+      title: ensureString(d.title),
+      description: ensureString(d.description, parsed.body.trim()),
+      status: ensureTaskStatus(d.status),
+      priority: ensureTaskPriority(d.priority),
+      owner: ensureNullableString(d.owner),
+      assignee: ensureNullableString(d.assignee),
+      projectId: ensureNullableString(d.projectId),
+      tags: ensureStringArray(d.tags),
+      dueAt: ensureNullableString(d.dueAt),
+      createdAt: ensureString(d.createdAt),
+      updatedAt: ensureString(d.updatedAt)
+    };
+  }
+  parseProject(raw) {
+    const parsed = parseFrontmatter(raw);
+    if (!parsed) return null;
+    const d = parsed.data;
+    return {
+      id: ensureString(d.id),
+      name: ensureString(d.name),
+      description: ensureString(d.description, parsed.body.trim()),
+      status: ensureProjectStatus(d.status),
+      owner: ensureNullableString(d.owner),
+      tags: ensureStringArray(d.tags),
+      taskIds: ensureStringArray(d.taskIds),
+      createdAt: ensureString(d.createdAt),
+      updatedAt: ensureString(d.updatedAt)
+    };
+  }
+  async createTask(input, now = /* @__PURE__ */ new Date()) {
+    await this.ensureDirectories();
+    const timestamp = now.toISOString();
+    const task = {
+      id: input.id ?? makeId("task", input.title, now),
+      title: input.title,
+      description: input.description ?? "",
+      status: input.status ?? "todo",
+      priority: input.priority ?? "medium",
+      owner: input.owner ?? null,
+      assignee: input.assignee ?? null,
+      projectId: input.projectId ?? null,
+      tags: input.tags ?? [],
+      dueAt: input.dueAt ?? null,
+      createdAt: timestamp,
+      updatedAt: timestamp
+    };
+    if (task.projectId) {
+      const project = await this.getProject(task.projectId);
+      if (!project) {
+        throw new Error(`project not found: ${task.projectId}`);
+      }
+    }
+    await writeFile(this.taskPath(task.id), this.serializeTask(task), "utf-8");
+    if (task.projectId) {
+      await this.addTaskIdToProject(task.projectId, task.id, now);
+    }
+    return task;
+  }
+  async getTask(id) {
+    try {
+      const raw = await readFile(this.taskPath(id), "utf-8");
+      return this.parseTask(raw);
+    } catch {
+      return null;
+    }
+  }
+  async listTasks(filter) {
+    await this.ensureDirectories();
+    const entries = await readdir(this.tasksDir, { withFileTypes: true });
+    const out = [];
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+      const raw = await readFile(path.join(this.tasksDir, entry.name), "utf-8");
+      const task = this.parseTask(raw);
+      if (!task) continue;
+      if (filter?.status && task.status !== filter.status) continue;
+      if (filter?.owner && task.owner !== filter.owner) continue;
+      if (filter?.assignee && task.assignee !== filter.assignee) continue;
+      if (filter?.projectId && task.projectId !== filter.projectId) continue;
+      out.push(task);
+    }
+    out.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    return out;
+  }
+  async updateTask(id, patch, now = /* @__PURE__ */ new Date(), options) {
+    const existing = await this.getTask(id);
+    if (!existing) return null;
+    const projectIdPatched = Object.prototype.hasOwnProperty.call(patch, "projectId");
+    const statusPatched = Object.prototype.hasOwnProperty.call(patch, "status");
+    const nextProjectId = projectIdPatched ? patch.projectId ?? null : existing.projectId;
+    if (statusPatched && patch.status && existing.status !== patch.status && options?.skipStatusTransitionValidation !== true && !TASK_TRANSITIONS[existing.status].has(patch.status)) {
+      throw new Error(`invalid task status transition: ${existing.status} -> ${patch.status}`);
+    }
+    if (projectIdPatched && nextProjectId) {
+      const nextProject = await this.getProject(nextProjectId);
+      if (!nextProject) {
+        throw new Error(`project not found: ${nextProjectId}`);
+      }
+    }
+    if (projectIdPatched && existing.projectId !== nextProjectId) {
+      if (existing.projectId) {
+        await this.removeTaskIdFromProject(existing.projectId, id, now);
+      }
+      if (nextProjectId) {
+        await this.addTaskIdToProject(nextProjectId, id, now);
+      }
+    }
+    const next = {
+      ...existing,
+      ...patch,
+      projectId: nextProjectId,
+      tags: patch.tags ?? existing.tags,
+      updatedAt: now.toISOString()
+    };
+    await writeFile(this.taskPath(id), this.serializeTask(next), "utf-8");
+    return next;
+  }
+  async transitionTask(id, nextStatus, now = /* @__PURE__ */ new Date()) {
+    const existing = await this.getTask(id);
+    if (!existing) throw new Error(`task not found: ${id}`);
+    if (existing.status === nextStatus) return existing;
+    if (!TASK_TRANSITIONS[existing.status].has(nextStatus)) {
+      throw new Error(`invalid task status transition: ${existing.status} -> ${nextStatus}`);
+    }
+    const updated = await this.updateTask(id, { status: nextStatus }, now);
+    if (!updated) throw new Error(`task not found after update: ${id}`);
+    return updated;
+  }
+  async deleteTask(id) {
+    try {
+      const existing = await this.getTask(id);
+      await rm(this.taskPath(id));
+      if (existing?.projectId) {
+        await this.removeTaskIdFromProject(existing.projectId, id);
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async createProject(input, now = /* @__PURE__ */ new Date()) {
+    await this.ensureDirectories();
+    const timestamp = now.toISOString();
+    const project = {
+      id: input.id ?? makeId("project", input.name, now),
+      name: input.name,
+      description: input.description ?? "",
+      status: input.status ?? "active",
+      owner: input.owner ?? null,
+      tags: input.tags ?? [],
+      taskIds: [],
+      createdAt: timestamp,
+      updatedAt: timestamp
+    };
+    await writeFile(this.projectPath(project.id), this.serializeProject(project), "utf-8");
+    return project;
+  }
+  async getProject(id) {
+    try {
+      const raw = await readFile(this.projectPath(id), "utf-8");
+      return this.parseProject(raw);
+    } catch {
+      return null;
+    }
+  }
+  async listProjects() {
+    await this.ensureDirectories();
+    const entries = await readdir(this.projectsDir, { withFileTypes: true });
+    const out = [];
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+      const raw = await readFile(path.join(this.projectsDir, entry.name), "utf-8");
+      const project = this.parseProject(raw);
+      if (project) out.push(project);
+    }
+    out.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    return out;
+  }
+  async updateProject(id, patch, now = /* @__PURE__ */ new Date()) {
+    const existing = await this.getProject(id);
+    if (!existing) return null;
+    const next = {
+      ...existing,
+      ...patch,
+      tags: patch.tags ?? existing.tags,
+      taskIds: patch.taskIds ? [...patch.taskIds].sort() : existing.taskIds,
+      updatedAt: now.toISOString()
+    };
+    await writeFile(this.projectPath(id), this.serializeProject(next), "utf-8");
+    return next;
+  }
+  async deleteProject(id) {
+    try {
+      const existing = await this.getProject(id);
+      if (existing) {
+        for (const taskId of existing.taskIds) {
+          await this.updateTask(taskId, { projectId: null });
+        }
+      }
+      await rm(this.projectPath(id));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async linkTaskToProject(taskId, projectId, now = /* @__PURE__ */ new Date()) {
+    const task = await this.getTask(taskId);
+    if (!task) throw new Error(`task not found: ${taskId}`);
+    const project = await this.getProject(projectId);
+    if (!project) throw new Error(`project not found: ${projectId}`);
+    const updatedTask = await this.updateTask(taskId, { projectId }, now);
+    if (!updatedTask) throw new Error(`task not found after update: ${taskId}`);
+    const updatedProject = await this.getProject(projectId);
+    if (!updatedProject) throw new Error(`project not found after update: ${projectId}`);
+    return { task: updatedTask, project: updatedProject };
+  }
+  async removeTaskIdFromProject(projectId, taskId, now = /* @__PURE__ */ new Date()) {
+    const project = await this.getProject(projectId);
+    if (!project) return;
+    const filtered = project.taskIds.filter((id) => id !== taskId);
+    if (filtered.length === project.taskIds.length) return;
+    await this.updateProject(projectId, { taskIds: filtered }, now);
+  }
+  async addTaskIdToProject(projectId, taskId, now = /* @__PURE__ */ new Date()) {
+    const project = await this.getProject(projectId);
+    if (!project) return;
+    const taskIds = new Set(project.taskIds);
+    taskIds.add(taskId);
+    await this.updateProject(projectId, { taskIds: Array.from(taskIds) }, now);
+  }
+};
+
+// src/work/board.ts
+var BOARD_STATUS_ORDER = [
+  "todo",
+  "in_progress",
+  "blocked",
+  "done",
+  "cancelled"
+];
+var BOARD_STATUS_LABEL = {
+  todo: "Todo",
+  in_progress: "In Progress",
+  blocked: "Blocked",
+  done: "Done",
+  cancelled: "Cancelled"
+};
+var PRIORITY_WEIGHT = {
+  high: 0,
+  medium: 1,
+  low: 2
+};
+function stableSortTasks(tasks) {
+  return [...tasks].sort((a, b) => {
+    const priorityCmp = PRIORITY_WEIGHT[a.priority] - PRIORITY_WEIGHT[b.priority];
+    if (priorityCmp !== 0) return priorityCmp;
+    const createdCmp = a.createdAt.localeCompare(b.createdAt);
+    if (createdCmp !== 0) return createdCmp;
+    return a.id.localeCompare(b.id);
+  });
+}
+function projectMatches(task, projectId) {
+  if (!projectId) return true;
+  return task.projectId === projectId;
+}
+function assertValidImportEnums(item) {
+  if (!["todo", "in_progress", "blocked", "done", "cancelled"].includes(item.status)) {
+    throw new Error(`invalid task status in snapshot for ${item.id}: ${item.status}`);
+  }
+  if (!["low", "medium", "high"].includes(item.priority)) {
+    throw new Error(`invalid task priority in snapshot for ${item.id}: ${item.priority}`);
+  }
+}
+function normalizeImportedProjectId(rawValue, taskId, fallbackForUndefined) {
+  if (rawValue === void 0) return fallbackForUndefined;
+  if (rawValue === null) return null;
+  if (typeof rawValue === "string") {
+    const trimmed = rawValue.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  }
+  throw new Error(`invalid task projectId in snapshot for ${taskId}`);
+}
+function normalizeImportedTags(rawValue, taskId) {
+  if (rawValue === void 0 || rawValue === null) return [];
+  if (!Array.isArray(rawValue)) {
+    throw new Error(`invalid task tags in snapshot for ${taskId}`);
+  }
+  if (!rawValue.every((entry) => typeof entry === "string")) {
+    throw new Error(`invalid task tags in snapshot for ${taskId}`);
+  }
+  return [...rawValue];
+}
+function assertValidImportedTaskId(rawValue) {
+  if (typeof rawValue !== "string") {
+    throw new Error("invalid task id in snapshot");
+  }
+  const trimmed = rawValue.trim();
+  if (!WORK_ID_PATTERN.test(trimmed)) {
+    throw new Error(`invalid task id in snapshot: ${trimmed}`);
+  }
+  return trimmed;
+}
+function normalizeImportedNullableField(rawValue, taskId, fieldName, fallbackForUndefined) {
+  if (rawValue === void 0) return fallbackForUndefined;
+  if (rawValue === null) return null;
+  if (typeof rawValue === "string") return rawValue;
+  throw new Error(`invalid task ${fieldName} in snapshot for ${taskId}`);
+}
+function normalizeImportedTitle(rawValue, taskId) {
+  if (typeof rawValue !== "string") {
+    throw new Error(`invalid task title in snapshot for ${taskId}`);
+  }
+  const trimmed = rawValue.trim();
+  if (trimmed.length === 0) {
+    throw new Error(`invalid task title in snapshot for ${taskId}`);
+  }
+  return trimmed;
+}
+function normalizeImportedDescription(rawValue, taskId) {
+  if (typeof rawValue !== "string") {
+    throw new Error(`invalid task description in snapshot for ${taskId}`);
+  }
+  return rawValue;
+}
+function asBoardItem(task) {
+  return {
+    id: task.id,
+    title: task.title,
+    description: task.description,
+    status: task.status,
+    priority: task.priority,
+    owner: task.owner,
+    assignee: task.assignee,
+    projectId: task.projectId,
+    tags: [...task.tags],
+    dueAt: task.dueAt
+  };
+}
+function formatTaskLine(task) {
+  const bits = [`id:${task.id}`, `priority:${task.priority}`];
+  if (task.assignee) bits.push(`assignee:${task.assignee}`);
+  if (task.owner) bits.push(`owner:${task.owner}`);
+  if (task.dueAt) bits.push(`due:${task.dueAt}`);
+  if (task.tags.length > 0) bits.push(`tags:${task.tags.join(",")}`);
+  const checked = task.status === "done";
+  return `- [${checked ? "x" : " "}] ${task.title} \`[${bits.join(" ")}]\``;
+}
+async function exportWorkBoardSnapshot(options) {
+  const storage = new WorkStorage(options.memoryDir);
+  await storage.ensureDirectories();
+  const projectId = options.projectId?.trim() || void 0;
+  let project = null;
+  if (projectId) {
+    project = await storage.getProject(projectId);
+    if (!project) throw new Error(`project not found: ${projectId}`);
+  }
+  const allTasks = await storage.listTasks();
+  const filtered = stableSortTasks(allTasks.filter((task) => projectMatches(task, projectId)));
+  return {
+    version: 1,
+    generatedAt: (options.now ?? /* @__PURE__ */ new Date()).toISOString(),
+    projectId: projectId ?? null,
+    projectName: project?.name ?? null,
+    items: filtered.map(asBoardItem)
+  };
+}
+function renderWorkBoardMarkdown(snapshot) {
+  const lines = [];
+  lines.push("# Work Board");
+  lines.push("");
+  lines.push(`Generated: ${snapshot.generatedAt}`);
+  lines.push(`Project: ${snapshot.projectName ?? "all"} (${snapshot.projectId ?? "all"})`);
+  lines.push("");
+  for (const status of BOARD_STATUS_ORDER) {
+    const bucket = snapshot.items.filter((item) => item.status === status);
+    lines.push(`## ${BOARD_STATUS_LABEL[status]} (${bucket.length})`);
+    if (bucket.length === 0) {
+      lines.push("_none_");
+    } else {
+      for (const item of bucket) {
+        lines.push(formatTaskLine(item));
+      }
+    }
+    lines.push("");
+  }
+  return `${lines.join("\n").trim()}
+`;
+}
+async function exportWorkBoardMarkdown(options) {
+  const snapshot = await exportWorkBoardSnapshot(options);
+  return renderWorkBoardMarkdown(snapshot);
+}
+async function importWorkBoardSnapshot(options) {
+  if (options.snapshot.version !== 1) {
+    throw new Error(`unsupported work board snapshot version: ${options.snapshot.version}`);
+  }
+  const storage = new WorkStorage(options.memoryDir);
+  await storage.ensureDirectories();
+  const forcedProjectId = options.projectId === void 0 ? void 0 : options.projectId?.trim() || null;
+  const snapshotProjectId = normalizeImportedProjectId(
+    options.snapshot.projectId,
+    "snapshot",
+    null
+  );
+  const preparedRows = [];
+  const seenItemIds = /* @__PURE__ */ new Set();
+  for (const item of options.snapshot.items) {
+    const id = assertValidImportedTaskId(item.id);
+    if (seenItemIds.has(id)) {
+      throw new Error(`duplicate task id in snapshot: ${id}`);
+    }
+    seenItemIds.add(id);
+    assertValidImportEnums(item);
+    const existing = await storage.getTask(id);
+    const title = normalizeImportedTitle(item.title, id);
+    const description = normalizeImportedDescription(item.description, id);
+    const fallbackProjectId = existing ? existing.projectId : snapshotProjectId;
+    const projectId = forcedProjectId === void 0 ? normalizeImportedProjectId(
+      item.projectId,
+      item.id,
+      fallbackProjectId
+    ) : forcedProjectId;
+    const hasTagsField = Object.prototype.hasOwnProperty.call(
+      item,
+      "tags"
+    );
+    const tags = hasTagsField ? normalizeImportedTags(item.tags, item.id) : existing ? [...existing.tags] : [];
+    const owner = normalizeImportedNullableField(
+      item.owner,
+      id,
+      "owner",
+      existing?.owner ?? null
+    );
+    const assignee = normalizeImportedNullableField(
+      item.assignee,
+      id,
+      "assignee",
+      existing?.assignee ?? null
+    );
+    const dueAt = normalizeImportedNullableField(
+      item.dueAt,
+      id,
+      "dueAt",
+      existing?.dueAt ?? null
+    );
+    preparedRows.push({ item, existing, id, title, description, projectId, tags, owner, assignee, dueAt });
+  }
+  const projectIdsToValidate = new Set(
+    preparedRows.map((row) => row.projectId).filter((projectId) => typeof projectId === "string")
+  );
+  for (const projectId of projectIdsToValidate) {
+    const project = await storage.getProject(projectId);
+    if (!project) throw new Error(`project not found: ${projectId}`);
+  }
+  let created = 0;
+  let updated = 0;
+  for (const row of preparedRows) {
+    const { item, existing, id, title, description, projectId, tags, owner, assignee, dueAt } = row;
+    if (existing) {
+      await storage.updateTask(id, {
+        title,
+        description,
+        status: item.status,
+        priority: item.priority,
+        owner,
+        assignee,
+        projectId,
+        tags,
+        dueAt
+      }, options.now, { skipStatusTransitionValidation: true });
+      updated += 1;
+      continue;
+    }
+    await storage.createTask({
+      id,
+      title,
+      description,
+      status: item.status,
+      priority: item.priority,
+      owner,
+      assignee,
+      projectId,
+      tags,
+      dueAt
+    }, options.now);
+    created += 1;
+  }
+  return { created, updated };
+}
+
+// src/access-service.ts
+var EngramAccessInputError = class extends Error {
+};
+function normalizeTrustZoneInputError(error) {
+  const message = error instanceof Error ? error.message : null;
+  if (!message) {
+    return null;
+  }
+  if (/^sourceRecordId must /.test(message) || /^promotionReason must /.test(message) || /^recordedAt must /.test(message) || /^trust zone promotion requires /.test(message) || /^source trust-zone record not found: /.test(message) || /^trust-zone promotion denied: /.test(message) || /^trust zone demo seed requires /.test(message) || /^unsupported trust-zone demo scenario: /.test(message)) {
+    return new EngramAccessInputError(message);
+  }
+  return null;
+}
+var ENGRAM_ACCESS_WRITE_SCHEMA_VERSION = 1;
+async function buildProjectedGovernanceProposedActions(storage, projected) {
+  const reviewQueue = projected.reviewQueueRows.map((row) => ({
+    entryId: row.entryId,
+    memoryId: row.memoryId,
+    path: row.path,
+    reasonCode: row.reasonCode,
+    severity: row.severity,
+    suggestedAction: row.suggestedAction,
+    suggestedStatus: row.suggestedStatus,
+    relatedMemoryIds: row.relatedMemoryIds
+  }));
+  const memories = (await Promise.all(projected.reviewQueueRows.map((row) => storage.getMemoryById(row.memoryId)))).filter((memory) => Boolean(memory));
+  return buildProposedActions(reviewQueue, memories);
+}
+function hasGroupedGovernanceActions(grouped) {
+  if (!grouped) return false;
+  return Object.values(grouped).some((actions) => Array.isArray(actions) && actions.length > 0);
+}
+function normalizePagination(limit, offset) {
+  const normalizedLimit = Number.isFinite(limit) ? Math.max(1, Math.min(200, Math.floor(limit ?? 50))) : 50;
+  const normalizedOffset = Number.isFinite(offset) ? Math.max(0, Math.floor(offset ?? 0)) : 0;
+  return { limit: normalizedLimit, offset: normalizedOffset };
+}
+function normalizeBrowseSort(sort) {
+  switch (sort) {
+    case "updated_asc":
+    case "created_desc":
+    case "created_asc":
+      return sort;
+    case "updated_desc":
+    default:
+      return "updated_desc";
+  }
+}
+function bucketMemoryAge(referenceIso, nowMs) {
+  const referenceMs = referenceIso ? Date.parse(referenceIso) : Number.NaN;
+  if (!Number.isFinite(referenceMs)) return "unknown";
+  const ageDays = Math.floor((nowMs - referenceMs) / 864e5);
+  if (ageDays <= 7) return "0_7_days";
+  if (ageDays <= 30) return "8_30_days";
+  if (ageDays <= 90) return "31_90_days";
+  return "91_plus_days";
+}
+function incrementCount(counts, key) {
+  counts[key] = (counts[key] ?? 0) + 1;
+}
+function summarizeTrustZoneRecord(record, filePath, allRecords, poisoningDefenseEnabled, trustZonesEnabled, promotionEnabled) {
+  const trustScore = poisoningDefenseEnabled ? scoreTrustZoneProvenance(record) : void 0;
+  const readiness = summarizeTrustZonePromotionReadiness({
+    record,
+    allRecords,
+    poisoningDefenseEnabled
+  });
+  const promotionReasons = [...readiness.reasons];
+  const promotionAllowed = readiness.allowed && trustZonesEnabled === true && promotionEnabled === true;
+  if (trustZonesEnabled !== true) {
+    promotionReasons.push("trust zone promotion requires trustZonesEnabled=true");
+  }
+  if (promotionEnabled !== true) {
+    promotionReasons.push("trust zone promotion requires quarantinePromotionEnabled=true");
+  }
+  return {
+    recordId: record.recordId,
+    filePath,
+    zone: record.zone,
+    recordedAt: record.recordedAt,
+    kind: record.kind,
+    summary: record.summary,
+    sourceClass: record.provenance.sourceClass,
+    sessionKey: record.provenance.sessionKey,
+    sourceId: record.provenance.sourceId,
+    evidenceHashPresent: typeof record.provenance.evidenceHash === "string",
+    anchored: Boolean(record.provenance.sourceId && record.provenance.evidenceHash),
+    entityRefs: [...record.entityRefs ?? []],
+    tags: [...record.tags ?? []],
+    metadata: record.metadata,
+    trustScore,
+    nextPromotionTarget: readiness.nextTargetZone,
+    nextPromotionAllowed: promotionAllowed,
+    nextPromotionReasons: promotionReasons,
+    corroborationCount: readiness.requiresCorroboration ? readiness.corroborationCount : void 0,
+    corroborationSourceClasses: readiness.requiresCorroboration ? readiness.corroborationSourceClasses : void 0
+  };
+}
+function compareBrowseMemory(sort, left, right) {
+  const leftUpdated = left.frontmatter.updated ?? left.frontmatter.created ?? "";
+  const rightUpdated = right.frontmatter.updated ?? right.frontmatter.created ?? "";
+  const leftCreated = left.frontmatter.created ?? "";
+  const rightCreated = right.frontmatter.created ?? "";
+  switch (sort) {
+    case "updated_asc":
+      return leftUpdated.localeCompare(rightUpdated) || leftCreated.localeCompare(rightCreated) || left.frontmatter.id.localeCompare(right.frontmatter.id);
+    case "created_desc":
+      return rightCreated.localeCompare(leftCreated) || rightUpdated.localeCompare(leftUpdated) || left.frontmatter.id.localeCompare(right.frontmatter.id);
+    case "created_asc":
+      return leftCreated.localeCompare(rightCreated) || leftUpdated.localeCompare(rightUpdated) || left.frontmatter.id.localeCompare(right.frontmatter.id);
+    case "updated_desc":
+    default:
+      return rightUpdated.localeCompare(leftUpdated) || rightCreated.localeCompare(leftCreated) || left.frontmatter.id.localeCompare(right.frontmatter.id);
+  }
+}
+var EngramAccessService = class {
+  constructor(orchestrator) {
+    this.orchestrator = orchestrator;
+    this.idempotency = new AccessIdempotencyStore(orchestrator.config.memoryDir);
+  }
+  orchestrator;
+  idempotency;
+  idempotencyLocks = /* @__PURE__ */ new Map();
+  resolveNamespace(namespace) {
+    const requested = namespace?.trim();
+    if (!requested) return this.orchestrator.config.defaultNamespace;
+    if (!this.orchestrator.config.namespacesEnabled && requested !== this.orchestrator.config.defaultNamespace) {
+      throw new EngramAccessInputError(`unsupported namespace: ${requested}`);
+    }
+    return requested;
+  }
+  normalizeRecallMode(mode) {
+    if (!mode || mode === "auto") return void 0;
+    if (mode === "no_recall" || mode === "minimal" || mode === "full" || mode === "graph_mode") {
+      return mode;
+    }
+    throw new EngramAccessInputError(`unsupported recall mode: ${mode}`);
+  }
+  resolveRecallNamespace(namespace, sessionKey) {
+    const requested = namespace?.trim();
+    if (!requested) return void 0;
+    const resolved = this.resolveNamespace(requested);
+    const principal = resolvePrincipal(sessionKey, this.orchestrator.config);
+    if (!canReadNamespace(principal, resolved, this.orchestrator.config)) {
+      throw new EngramAccessInputError(`namespace override is not readable: ${resolved}`);
+    }
+    return resolved;
+  }
+  resolveWritePrincipal(sessionKey, authenticatedPrincipal) {
+    const trusted = authenticatedPrincipal?.trim();
+    if (trusted) return trusted;
+    return resolvePrincipal(sessionKey, this.orchestrator.config);
+  }
+  resolveWritableNamespace(namespace, sessionKey, authenticatedPrincipal) {
+    const resolved = this.resolveNamespace(namespace);
+    const principal = this.resolveWritePrincipal(sessionKey, authenticatedPrincipal);
+    if (!canWriteNamespace(principal, resolved, this.orchestrator.config)) {
+      throw new EngramAccessInputError(`namespace is not writable: ${resolved}`);
+    }
+    return resolved;
+  }
+  resolveReadableNamespace(namespace, principal) {
+    const resolved = this.resolveNamespace(namespace);
+    if (principal && !canReadNamespace(principal, resolved, this.orchestrator.config)) {
+      throw new EngramAccessInputError(`namespace is not readable: ${resolved}`);
+    }
+    return resolved;
+  }
+  async buildRecallDebug(snapshot, namespace, includeDebug, sessionKey) {
+    if (!includeDebug) return void 0;
+    if (!sessionKey?.trim()) return void 0;
+    const [intent, graph] = await Promise.all([
+      this.orchestrator.getLastIntentSnapshot(namespace),
+      this.orchestrator.getLastGraphRecallSnapshot(namespace)
+    ]);
+    return snapshot || intent || graph ? {
+      snapshot: snapshot ?? void 0,
+      intent,
+      graph
+    } : void 0;
+  }
+  async serializeRecallResults(snapshot) {
+    if (!snapshot) return [];
+    const namespace = snapshot.namespace ? this.resolveNamespace(snapshot.namespace) : this.orchestrator.config.defaultNamespace;
+    const storage = await this.orchestrator.getStorage(namespace);
+    const storageDir = storage.dir;
+    const results = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const memoryPath of snapshot.resultPaths ?? []) {
+      if (!memoryPath || seen.has(memoryPath)) continue;
+      const memory = await storage.readMemoryByPath(memoryPath);
+      if (!memory) continue;
+      seen.add(memoryPath);
+      results.push(this.serializeMemorySummary(memory, storageDir));
+    }
+    if (results.length > 0) return results;
+    for (const memoryId of snapshot.memoryIds) {
+      const memory = await storage.getMemoryById(memoryId);
+      if (!memory || seen.has(memory.path)) continue;
+      seen.add(memory.path);
+      results.push(this.serializeMemorySummary(memory, storageDir));
+    }
+    return results;
+  }
+  async handleIdempotentWrite(options) {
+    if (options.skip === true) {
+      return options.execute();
+    }
+    const key = options.idempotencyKey?.trim();
+    if (!key) {
+      return options.execute();
+    }
+    return this.withIdempotencyLock(key, async () => {
+      return this.idempotency.withKeyLock(key, async () => {
+        const requestHash = hashAccessIdempotencyPayload({
+          operation: options.operation,
+          request: options.requestFingerprint
+        });
+        const existing = await this.idempotency.get(key, requestHash);
+        if (existing.conflict) {
+          throw new EngramAccessInputError(`idempotencyKey reuse conflict: ${key}`);
+        }
+        if (existing.response) {
+          return {
+            ...existing.response,
+            idempotencyReplay: true
+          };
+        }
+        const response = await options.execute();
+        await this.idempotency.put(key, requestHash, response);
+        return response;
+      });
+    });
+  }
+  async peekIdempotentWrite(options) {
+    if (options.skip === true) {
+      return "miss";
+    }
+    const key = options.idempotencyKey?.trim();
+    if (!key) {
+      return "miss";
+    }
+    return this.withIdempotencyLock(key, async () => {
+      return this.idempotency.withKeyLock(key, async () => {
+        const requestHash = hashAccessIdempotencyPayload({
+          operation: options.operation,
+          request: options.requestFingerprint
+        });
+        const existing = await this.idempotency.get(key, requestHash);
+        if (existing.conflict) {
+          return "conflict";
+        }
+        return existing.response ? "replay" : "miss";
+      });
+    });
+  }
+  async withIdempotencyLock(key, fn) {
+    const previous = this.idempotencyLocks.get(key) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+      release = resolve;
+    });
+    const queued = previous.then(() => current, () => current);
+    this.idempotencyLocks.set(key, queued);
+    await previous.catch(() => {
+    });
+    try {
+      return await fn();
+    } finally {
+      release();
+      if (this.idempotencyLocks.get(key) === queued) {
+        this.idempotencyLocks.delete(key);
+      }
+    }
+  }
+  async health(namespace) {
+    const resolvedNamespace = this.resolveNamespace(namespace);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    let projectionAvailable = false;
+    try {
+      await stat(getMemoryProjectionPath(storage.dir));
+      projectionAvailable = true;
+    } catch {
+      projectionAvailable = false;
+    }
+    return {
+      ok: true,
+      memoryDir: storage.dir,
+      namespacesEnabled: this.orchestrator.config.namespacesEnabled === true,
+      defaultNamespace: this.orchestrator.config.defaultNamespace,
+      searchBackend: this.orchestrator.config.searchBackend ?? "qmd",
+      qmdEnabled: this.orchestrator.config.qmdEnabled === true,
+      nativeKnowledgeEnabled: this.orchestrator.config.nativeKnowledge?.enabled === true,
+      projectionAvailable
+    };
+  }
+  async daySummary(request) {
+    if (!this.orchestrator.config.daySummaryEnabled) {
+      throw new EngramAccessInputError("day summary is disabled");
+    }
+    const memories = (request.memories ?? "").trim();
+    const namespace = this.resolveRecallNamespace(request.namespace, request.sessionKey);
+    if (memories.length === 0) {
+      return this.orchestrator.generateDaySummaryAuto(namespace);
+    }
+    return this.orchestrator.generateDaySummary(memories);
+  }
+  async recall(request) {
+    const query = request.query.trim();
+    if (query.length === 0) {
+      throw new EngramAccessInputError("query is required");
+    }
+    const namespaceOverride = this.resolveRecallNamespace(request.namespace, request.sessionKey);
+    const namespace = namespaceOverride ?? this.orchestrator.config.defaultNamespace;
+    const mode = this.normalizeRecallMode(request.mode);
+    const topK = Number.isFinite(request.topK) ? Math.max(0, Math.floor(request.topK ?? 0)) : void 0;
+    const recallOptions = {
+      namespace: namespaceOverride,
+      topK,
+      mode
+    };
+    const startedAt = Date.now();
+    const context = await this.orchestrator.recall(query, request.sessionKey, recallOptions);
+    const snapshot = request.sessionKey ? this.orchestrator.lastRecall.get(request.sessionKey) : null;
+    const effectiveNamespace = snapshot?.namespace ? this.resolveNamespace(snapshot.namespace) : namespace;
+    const results = await this.serializeRecallResults(snapshot);
+    const debug = await this.buildRecallDebug(
+      snapshot,
+      effectiveNamespace,
+      request.includeDebug === true,
+      request.sessionKey
+    );
+    return {
+      query,
+      sessionKey: request.sessionKey,
+      namespace: effectiveNamespace,
+      context,
+      count: snapshot?.memoryIds.length ?? results.length,
+      memoryIds: snapshot?.memoryIds ?? [],
+      results,
+      recordedAt: snapshot?.recordedAt,
+      traceId: snapshot?.traceId,
+      plannerMode: snapshot?.plannerMode ?? mode,
+      fallbackUsed: snapshot?.fallbackUsed ?? false,
+      sourcesUsed: snapshot?.sourcesUsed ?? [],
+      budgetsApplied: snapshot?.budgetsApplied,
+      latencyMs: snapshot?.latencyMs ?? Date.now() - startedAt,
+      debug
+    };
+  }
+  async recallExplain(request = {}) {
+    const requestedNamespace = request.namespace?.trim() ? this.resolveNamespace(request.namespace) : void 0;
+    if (requestedNamespace) {
+      const principal = resolvePrincipal(request.sessionKey, this.orchestrator.config);
+      if (!canReadNamespace(principal, requestedNamespace, this.orchestrator.config)) {
+        return { found: false };
+      }
+    }
+    const snapshot = request.sessionKey ? (() => {
+      const candidate = this.orchestrator.lastRecall.get(request.sessionKey);
+      if (!candidate) return null;
+      if (!requestedNamespace) return candidate;
+      return candidate.namespace === requestedNamespace ? candidate : null;
+    })() : (() => {
+      const candidate = this.orchestrator.lastRecall.getMostRecent();
+      if (!candidate) return null;
+      if (!requestedNamespace) return candidate;
+      return candidate.namespace === requestedNamespace ? candidate : null;
+    })();
+    const namespace = requestedNamespace ?? snapshot?.namespace ?? this.orchestrator.config.defaultNamespace;
+    const [intent, graph] = await Promise.all([
+      this.orchestrator.getLastIntentSnapshot(namespace),
+      this.orchestrator.getLastGraphRecallSnapshot(namespace)
+    ]);
+    if (!snapshot && !intent && !graph) return { found: false };
+    return { found: true, snapshot: snapshot ?? void 0, intent, graph };
+  }
+  async memoryStore(request) {
+    const namespace = this.resolveWritableNamespace(
+      request.namespace,
+      request.sessionKey,
+      request.authenticatedPrincipal
+    );
+    const schemaVersion = request.schemaVersion ?? ENGRAM_ACCESS_WRITE_SCHEMA_VERSION;
+    if (schemaVersion !== ENGRAM_ACCESS_WRITE_SCHEMA_VERSION) {
+      throw new EngramAccessInputError(`unsupported schemaVersion: ${schemaVersion}`);
+    }
+    const execute = async () => {
+      const candidate = this.validateWriteCandidate(request, namespace);
+      if (request.dryRun === true) {
+        return {
+          schemaVersion: ENGRAM_ACCESS_WRITE_SCHEMA_VERSION,
+          operation: "memory_store",
+          namespace,
+          dryRun: true,
+          accepted: true,
+          queued: false,
+          status: "validated",
+          idempotencyKey: request.idempotencyKey?.trim() || void 0
+        };
+      }
+      const result = await persistExplicitCapture(this.orchestrator, candidate, "memory_store");
+      const response = {
+        schemaVersion: ENGRAM_ACCESS_WRITE_SCHEMA_VERSION,
+        operation: "memory_store",
+        namespace,
+        dryRun: false,
+        accepted: true,
+        queued: false,
+        status: result.duplicateOf ? "duplicate" : "stored",
+        memoryId: result.id,
+        duplicateOf: result.duplicateOf,
+        idempotencyKey: request.idempotencyKey?.trim() || void 0
+      };
+      log.info(
+        `access-write op=memory_store namespace=${namespace} dryRun=false status=${response.status} memoryId=${response.memoryId ?? "-"} idempotency=${response.idempotencyKey ? "yes" : "no"}`
+      );
+      return response;
+    };
+    return this.handleIdempotentWrite({
+      operation: "memory_store",
+      idempotencyKey: request.idempotencyKey,
+      requestFingerprint: {
+        schemaVersion,
+        content: request.content,
+        category: request.category,
+        confidence: request.confidence,
+        namespace,
+        tags: request.tags,
+        entityRef: request.entityRef,
+        ttl: request.ttl,
+        sourceReason: request.sourceReason
+      },
+      skip: request.dryRun === true,
+      execute
+    });
+  }
+  async peekMemoryStoreIdempotency(request) {
+    const namespace = this.resolveWritableNamespace(
+      request.namespace,
+      request.sessionKey,
+      request.authenticatedPrincipal
+    );
+    const schemaVersion = request.schemaVersion ?? ENGRAM_ACCESS_WRITE_SCHEMA_VERSION;
+    if (schemaVersion !== ENGRAM_ACCESS_WRITE_SCHEMA_VERSION) {
+      throw new EngramAccessInputError(`unsupported schemaVersion: ${schemaVersion}`);
+    }
+    return this.peekIdempotentWrite({
+      operation: "memory_store",
+      idempotencyKey: request.idempotencyKey,
+      requestFingerprint: {
+        schemaVersion,
+        content: request.content,
+        category: request.category,
+        confidence: request.confidence,
+        namespace,
+        tags: request.tags,
+        entityRef: request.entityRef,
+        ttl: request.ttl,
+        sourceReason: request.sourceReason
+      },
+      skip: request.dryRun === true
+    });
+  }
+  async suggestionSubmit(request) {
+    const namespace = this.resolveWritableNamespace(
+      request.namespace,
+      request.sessionKey,
+      request.authenticatedPrincipal
+    );
+    const schemaVersion = request.schemaVersion ?? ENGRAM_ACCESS_WRITE_SCHEMA_VERSION;
+    if (schemaVersion !== ENGRAM_ACCESS_WRITE_SCHEMA_VERSION) {
+      throw new EngramAccessInputError(`unsupported schemaVersion: ${schemaVersion}`);
+    }
+    const execute = async () => {
+      const candidate = this.validateWriteCandidate(request, namespace);
+      if (request.dryRun === true) {
+        return {
+          schemaVersion: ENGRAM_ACCESS_WRITE_SCHEMA_VERSION,
+          operation: "suggestion_submit",
+          namespace,
+          dryRun: true,
+          accepted: true,
+          queued: true,
+          status: "validated",
+          idempotencyKey: request.idempotencyKey?.trim() || void 0
+        };
+      }
+      const result = await queueExplicitCaptureForReview(
+        this.orchestrator,
+        candidate,
+        "suggestion_submit",
+        new Error(request.sourceReason?.trim() || "submitted via engram suggestion_submit")
+      );
+      const response = {
+        schemaVersion: ENGRAM_ACCESS_WRITE_SCHEMA_VERSION,
+        operation: "suggestion_submit",
+        namespace,
+        dryRun: false,
+        accepted: true,
+        queued: true,
+        status: "queued_for_review",
+        memoryId: result.id,
+        duplicateOf: result.duplicateOf,
+        idempotencyKey: request.idempotencyKey?.trim() || void 0
+      };
+      log.info(
+        `access-write op=suggestion_submit namespace=${namespace} dryRun=false status=${response.status} memoryId=${response.memoryId ?? "-"} idempotency=${response.idempotencyKey ? "yes" : "no"}`
+      );
+      return response;
+    };
+    return this.handleIdempotentWrite({
+      operation: "suggestion_submit",
+      idempotencyKey: request.idempotencyKey,
+      requestFingerprint: {
+        schemaVersion,
+        content: request.content,
+        category: request.category,
+        confidence: request.confidence,
+        namespace,
+        tags: request.tags,
+        entityRef: request.entityRef,
+        ttl: request.ttl,
+        sourceReason: request.sourceReason
+      },
+      skip: request.dryRun === true,
+      execute
+    });
+  }
+  async peekSuggestionSubmitIdempotency(request) {
+    const namespace = this.resolveWritableNamespace(
+      request.namespace,
+      request.sessionKey,
+      request.authenticatedPrincipal
+    );
+    const schemaVersion = request.schemaVersion ?? ENGRAM_ACCESS_WRITE_SCHEMA_VERSION;
+    if (schemaVersion !== ENGRAM_ACCESS_WRITE_SCHEMA_VERSION) {
+      throw new EngramAccessInputError(`unsupported schemaVersion: ${schemaVersion}`);
+    }
+    return this.peekIdempotentWrite({
+      operation: "suggestion_submit",
+      idempotencyKey: request.idempotencyKey,
+      requestFingerprint: {
+        schemaVersion,
+        content: request.content,
+        category: request.category,
+        confidence: request.confidence,
+        namespace,
+        tags: request.tags,
+        entityRef: request.entityRef,
+        ttl: request.ttl,
+        sourceReason: request.sourceReason
+      },
+      skip: request.dryRun === true
+    });
+  }
+  validateWriteCandidate(request, namespace) {
+    try {
+      return validateExplicitCaptureInput(
+        {
+          ...request,
+          namespace
+        },
+        "legacy_tool"
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new EngramAccessInputError(message);
+    }
+  }
+  async memoryGet(memoryId, namespace, principal) {
+    const resolvedNamespace = this.resolveReadableNamespace(namespace, principal);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const memory = await storage.getMemoryById(memoryId);
+    if (!memory) {
+      return { found: false, namespace: resolvedNamespace };
+    }
+    return {
+      found: true,
+      namespace: resolvedNamespace,
+      memory: this.serializeMemory(memory)
+    };
+  }
+  async memoryBrowse(request = {}) {
+    const storage = await this.orchestrator.getStorage(request.namespace);
+    const resolvedNamespace = request.namespace?.trim() || this.orchestrator.config.defaultNamespace;
+    const { limit, offset } = normalizePagination(request.limit, request.offset);
+    const sort = normalizeBrowseSort(request.sort);
+    const query = request.query?.trim().toLowerCase() ?? "";
+    const statusFilter = request.status?.trim().toLowerCase();
+    const categoryFilter = request.category?.trim().toLowerCase();
+    const projected = await storage.browseProjectedMemories({
+      query,
+      status: statusFilter,
+      category: categoryFilter,
+      sort,
+      limit,
+      offset
+    });
+    if (projected) {
+      return {
+        namespace: resolvedNamespace,
+        sort,
+        total: projected.total,
+        count: projected.memories.length,
+        limit,
+        offset,
+        memories: projected.memories.map((row) => ({ ...row }))
+      };
+    }
+    let memories = [...await storage.readAllMemories(), ...await storage.readArchivedMemories()];
+    memories = memories.filter((memory) => {
+      const status = inferMemoryStatus(memory.frontmatter, toMemoryPathRel(storage.dir, memory.path)).toLowerCase();
+      if (statusFilter && status !== statusFilter) return false;
+      if (categoryFilter && memory.frontmatter.category.toLowerCase() !== categoryFilter) return false;
+      if (!query) return true;
+      const haystack = [
+        memory.frontmatter.id,
+        memory.path,
+        memory.content,
+        memory.frontmatter.entityRef ?? "",
+        ...memory.frontmatter.tags
+      ].join("\n").toLowerCase();
+      return haystack.includes(query);
+    });
+    memories.sort((left, right) => compareBrowseMemory(sort, left, right));
+    const page = memories.slice(offset, offset + limit).map((memory) => this.serializeMemorySummary(memory, storage.dir));
+    return {
+      namespace: resolvedNamespace,
+      sort,
+      total: memories.length,
+      count: page.length,
+      limit,
+      offset,
+      memories: page
+    };
+  }
+  async memoryTimeline(memoryId, namespace, limit = 200, principal) {
+    const resolvedNamespace = this.resolveReadableNamespace(namespace, principal);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const timeline = await storage.getMemoryTimeline(memoryId, limit);
+    return {
+      found: timeline.length > 0,
+      namespace: resolvedNamespace,
+      count: timeline.length,
+      timeline
+    };
+  }
+  async entityList(options = {}) {
+    const storage = await this.orchestrator.getStorage(options.namespace);
+    const resolvedNamespace = options.namespace?.trim() || this.orchestrator.config.defaultNamespace;
+    const { limit, offset } = normalizePagination(options.limit, options.offset);
+    const query = options.query?.trim().toLowerCase() ?? "";
+    const names = await storage.listEntityNames();
+    const entities = [];
+    for (const name of names) {
+      const raw = await storage.readEntity(name);
+      if (!raw) continue;
+      const entity = parseEntityFile(raw);
+      if (query) {
+        const haystack = [
+          entity.name,
+          entity.type,
+          entity.summary ?? "",
+          ...entity.aliases,
+          ...entity.facts
+        ].join("\n").toLowerCase();
+        if (!haystack.includes(query)) continue;
+      }
+      entities.push({
+        name: entity.name,
+        type: entity.type,
+        updated: entity.updated,
+        summary: entity.summary,
+        aliases: entity.aliases
+      });
+    }
+    entities.sort((left, right) => left.name.localeCompare(right.name));
+    const page = entities.slice(offset, offset + limit);
+    return {
+      namespace: resolvedNamespace,
+      total: entities.length,
+      count: page.length,
+      limit,
+      offset,
+      entities: page
+    };
+  }
+  async entityGet(name, namespace) {
+    const storage = await this.orchestrator.getStorage(namespace);
+    const resolvedNamespace = namespace?.trim() || this.orchestrator.config.defaultNamespace;
+    const raw = await storage.readEntity(name);
+    if (!raw) return { found: false, namespace: resolvedNamespace };
+    return {
+      found: true,
+      namespace: resolvedNamespace,
+      entity: parseEntityFile(raw)
+    };
+  }
+  async reviewQueue(runId, namespace, principal) {
+    const resolvedNamespace = this.resolveReadableNamespace(namespace, principal);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const projected = await storage.getProjectedGovernanceRecord();
+    if (projected && (!runId || projected.runId === runId.trim())) {
+      const projectedAppliedActions = projected.appliedActionRows.map((row) => ({
+        action: row.action,
+        memoryId: row.memoryId,
+        reasonCode: row.reasonCode,
+        beforeStatus: row.beforeStatus,
+        afterStatus: row.afterStatus,
+        originalPath: row.originalPath,
+        currentPath: row.currentPath
+      }));
+      const projectedProposedActions = await buildProjectedGovernanceProposedActions(storage, projected);
+      const projectedArtifact = await (async () => {
+        try {
+          return await readMemoryGovernanceRunArtifact(storage.dir, projected.runId);
+        } catch {
+          return null;
+        }
+      })();
+      const metrics = projected.metrics;
+      const fallbackTransitionReport = {
+        proposed: groupActionsByStatus(projectedProposedActions),
+        applied: groupActionsByStatus(projectedAppliedActions)
+      };
+      const transitionReport = projectedArtifact?.transitionReport ? {
+        proposed: hasGroupedGovernanceActions(projectedArtifact.transitionReport.proposed) || projectedProposedActions.length === 0 ? projectedArtifact.transitionReport.proposed : fallbackTransitionReport.proposed,
+        applied: hasGroupedGovernanceActions(projectedArtifact.transitionReport.applied) || projectedAppliedActions.length === 0 ? projectedArtifact.transitionReport.applied : fallbackTransitionReport.applied
+      } : fallbackTransitionReport;
+      const qualityScore = projectedArtifact?.qualityScore ?? metrics?.qualityScore ?? buildQualityScore(metrics?.reviewReasons ?? {
+        exact_duplicate: 0,
+        semantic_duplicate_candidate: 0,
+        disputed_memory: 0,
+        speculative_low_confidence: 0,
+        archive_candidate: 0,
+        explicit_capture_review: 0,
+        malformed_import: 0
+      });
+      const effectiveMetrics = metrics ? { ...metrics, qualityScore: metrics.qualityScore ?? qualityScore } : metrics;
+      return {
+        found: true,
+        namespace: resolvedNamespace,
+        runId: projected.runId,
+        summary: projected.summary,
+        metrics: effectiveMetrics,
+        qualityScore,
+        reviewQueue: projected.reviewQueueRows.map((row) => ({
+          entryId: row.entryId,
+          memoryId: row.memoryId,
+          path: row.path,
+          reasonCode: row.reasonCode,
+          severity: row.severity,
+          suggestedAction: row.suggestedAction,
+          suggestedStatus: row.suggestedStatus,
+          relatedMemoryIds: row.relatedMemoryIds
+        })),
+        appliedActions: projectedAppliedActions,
+        transitionReport,
+        report: projected.report
+      };
+    }
+    const resolvedRunId = runId?.trim() || (await listMemoryGovernanceRuns(storage.dir))[0];
+    if (!resolvedRunId) return { found: false, namespace: resolvedNamespace };
+    const artifact = await readMemoryGovernanceRunArtifact(storage.dir, resolvedRunId);
+    return {
+      found: true,
+      namespace: resolvedNamespace,
+      runId: resolvedRunId,
+      summary: artifact.summary,
+      metrics: artifact.metrics,
+      qualityScore: artifact.qualityScore,
+      reviewQueue: artifact.reviewQueue,
+      appliedActions: artifact.appliedActions,
+      transitionReport: artifact.transitionReport,
+      report: artifact.report
+    };
+  }
+  async maintenance(namespace, principal) {
+    const resolvedNamespace = this.resolveReadableNamespace(namespace, principal);
+    return {
+      namespace: resolvedNamespace,
+      health: await this.health(resolvedNamespace),
+      latestGovernanceRun: await this.reviewQueue(void 0, resolvedNamespace, principal)
+    };
+  }
+  async quality(namespace, principal) {
+    const resolvedNamespace = this.resolveReadableNamespace(namespace, principal);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const governance = await this.reviewQueue(void 0, resolvedNamespace, principal);
+    const nowMs = Date.now();
+    const statusCounts = {};
+    const categoryCounts = {};
+    const confidenceTierCounts = {};
+    const ageBucketCounts = {};
+    let staleActive = 0;
+    let lowConfidenceActive = 0;
+    const memories = [...await storage.readAllMemories(), ...await storage.readArchivedMemories()];
+    for (const memory of memories) {
+      const status = inferMemoryStatus(memory.frontmatter, toMemoryPathRel(storage.dir, memory.path)).toLowerCase();
+      const confidenceTier = memory.frontmatter.confidenceTier ?? "unknown";
+      const ageBucket = bucketMemoryAge(memory.frontmatter.updated ?? memory.frontmatter.created, nowMs);
+      incrementCount(statusCounts, status);
+      incrementCount(categoryCounts, memory.frontmatter.category);
+      incrementCount(confidenceTierCounts, confidenceTier);
+      incrementCount(ageBucketCounts, ageBucket);
+      if (status === "active") {
+        if (ageBucket === "91_plus_days") staleActive += 1;
+        if ((memory.frontmatter.confidence ?? 0) < 0.6) lowConfidenceActive += 1;
+      }
+    }
+    return {
+      namespace: resolvedNamespace,
+      totalMemories: memories.length,
+      statusCounts,
+      categoryCounts,
+      confidenceTierCounts,
+      ageBucketCounts,
+      archivePressure: {
+        pendingReview: statusCounts.pending_review ?? 0,
+        quarantined: statusCounts.quarantined ?? 0,
+        archived: statusCounts.archived ?? 0,
+        staleActive,
+        lowConfidenceActive
+      },
+      latestGovernanceRun: {
+        found: governance.found,
+        runId: governance.runId,
+        qualityScore: governance.qualityScore ?? governance.metrics?.qualityScore,
+        reviewQueueCount: governance.reviewQueue?.length ?? 0
+      }
+    };
+  }
+  async governanceRun(request, principal) {
+    const resolvedNamespace = this.resolveWritableNamespace(
+      request.namespace,
+      void 0,
+      request.authenticatedPrincipal ?? principal
+    );
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const result = await runMemoryGovernance({
+      memoryDir: storage.dir,
+      mode: request.mode === "apply" ? "apply" : "shadow",
+      recentDays: typeof request.recentDays === "number" && Number.isFinite(request.recentDays) ? Math.max(1, Math.floor(request.recentDays)) : void 0,
+      maxMemories: typeof request.maxMemories === "number" && Number.isFinite(request.maxMemories) ? Math.max(1, Math.floor(request.maxMemories)) : void 0,
+      batchSize: typeof request.batchSize === "number" && Number.isFinite(request.batchSize) ? Math.max(1, Math.floor(request.batchSize)) : void 0
+    });
+    return {
+      namespace: resolvedNamespace,
+      runId: result.runId,
+      traceId: result.traceId,
+      mode: result.mode,
+      reviewQueueCount: result.reviewQueue.length,
+      proposedActionCount: result.proposedActions.length,
+      appliedActionCount: result.appliedActions.length,
+      summaryPath: result.summaryPath,
+      reportPath: result.reportPath
+    };
+  }
+  async trustZoneStatus(namespace, principal) {
+    const resolvedNamespace = this.resolveReadableNamespace(namespace, principal);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    return {
+      namespace: resolvedNamespace,
+      status: await getTrustZoneStoreStatus({
+        memoryDir: storage.dir,
+        trustZoneStoreDir: this.orchestrator.config.trustZoneStoreDir,
+        enabled: this.orchestrator.config.trustZonesEnabled === true,
+        promotionEnabled: this.orchestrator.config.quarantinePromotionEnabled === true,
+        poisoningDefenseEnabled: this.orchestrator.config.memoryPoisoningDefenseEnabled === true
+      })
+    };
+  }
+  async trustZoneBrowse(request, principal) {
+    const resolvedNamespace = this.resolveReadableNamespace(request.namespace, principal);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const result = await listTrustZoneRecords({
+      memoryDir: storage.dir,
+      trustZoneStoreDir: this.orchestrator.config.trustZoneStoreDir,
+      query: request.query,
+      zone: request.zone,
+      kind: request.kind,
+      sourceClass: request.sourceClass,
+      limit: request.limit,
+      offset: request.offset
+    });
+    return {
+      namespace: resolvedNamespace,
+      total: result.total,
+      count: result.count,
+      limit: result.limit,
+      offset: result.offset,
+      records: result.records.map((entry) => summarizeTrustZoneRecord(
+        entry.record,
+        entry.filePath,
+        result.allRecords,
+        this.orchestrator.config.memoryPoisoningDefenseEnabled === true,
+        this.orchestrator.config.trustZonesEnabled === true,
+        this.orchestrator.config.quarantinePromotionEnabled === true
+      ))
+    };
+  }
+  async trustZonePromote(request) {
+    if (!isTrustZoneName(request.targetZone)) {
+      throw new EngramAccessInputError(`unsupported trust-zone target: ${String(request.targetZone)}`);
+    }
+    const resolvedNamespace = this.resolveWritableNamespace(
+      request.namespace,
+      void 0,
+      request.authenticatedPrincipal
+    );
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    let result;
+    try {
+      result = await promoteTrustZoneRecord({
+        memoryDir: storage.dir,
+        trustZoneStoreDir: this.orchestrator.config.trustZoneStoreDir,
+        enabled: this.orchestrator.config.trustZonesEnabled === true,
+        promotionEnabled: this.orchestrator.config.quarantinePromotionEnabled === true,
+        poisoningDefenseEnabled: this.orchestrator.config.memoryPoisoningDefenseEnabled === true,
+        sourceRecordId: request.recordId,
+        targetZone: request.targetZone,
+        recordedAt: request.recordedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+        promotionReason: request.promotionReason,
+        summary: request.summary,
+        dryRun: request.dryRun === true
+      });
+    } catch (error) {
+      throw normalizeTrustZoneInputError(error) ?? error;
+    }
+    return {
+      namespace: resolvedNamespace,
+      ...result,
+      dryRun: request.dryRun === true
+    };
+  }
+  async trustZoneDemoSeed(request) {
+    const resolvedNamespace = this.resolveWritableNamespace(
+      request.namespace,
+      void 0,
+      request.authenticatedPrincipal
+    );
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    let result;
+    try {
+      result = await seedTrustZoneDemoDataset({
+        memoryDir: storage.dir,
+        trustZoneStoreDir: this.orchestrator.config.trustZoneStoreDir,
+        enabled: this.orchestrator.config.trustZonesEnabled === true,
+        scenario: request.scenario,
+        recordedAt: request.recordedAt,
+        dryRun: request.dryRun === true
+      });
+    } catch (error) {
+      throw normalizeTrustZoneInputError(error) ?? error;
+    }
+    return {
+      namespace: resolvedNamespace,
+      ...result
+    };
+  }
+  async reviewDisposition(request) {
+    const memoryId = request.memoryId.trim();
+    const reasonCode = request.reasonCode.trim();
+    if (memoryId.length === 0) {
+      throw new EngramAccessInputError("memoryId is required");
+    }
+    if (reasonCode.length === 0) {
+      throw new EngramAccessInputError("reasonCode is required");
+    }
+    const resolvedNamespace = this.resolveWritableNamespace(
+      request.namespace,
+      void 0,
+      request.authenticatedPrincipal
+    );
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const memory = await storage.getMemoryById(memoryId);
+    if (!memory) {
+      throw new EngramAccessInputError(`memory not found: ${memoryId}`);
+    }
+    const previousStatus = memory.frontmatter.status ?? "active";
+    const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const lifecycle = {
+      actor: "admin-console.review-disposition",
+      reasonCode,
+      ruleVersion: "memory-governance.v1"
+    };
+    if (request.status === "archived") {
+      const archivedPath = await storage.archiveMemory(memory, {
+        at: new Date(updatedAt),
+        ...lifecycle
+      });
+      if (!archivedPath) {
+        throw new Error(`failed to archive memory disposition: ${memoryId}`);
+      }
+      return {
+        ok: true,
+        namespace: resolvedNamespace,
+        memoryId,
+        status: "archived",
+        previousStatus,
+        currentPath: archivedPath
+      };
+    }
+    const updated = await storage.writeMemoryFrontmatter(memory, {
+      status: request.status,
+      updated: updatedAt
+    }, lifecycle);
+    if (!updated) {
+      throw new Error(`failed to update memory disposition: ${memoryId}`);
+    }
+    return {
+      ok: true,
+      namespace: resolvedNamespace,
+      memoryId,
+      status: request.status,
+      previousStatus,
+      currentPath: memory.path
+    };
+  }
+  serializeMemory(memory) {
+    return {
+      id: memory.frontmatter.id,
+      path: memory.path,
+      category: memory.frontmatter.category,
+      status: memory.frontmatter.status,
+      created: memory.frontmatter.created,
+      updated: memory.frontmatter.updated,
+      content: memory.content,
+      frontmatter: memory.frontmatter
+    };
+  }
+  serializeMemorySummary(memory, baseDir) {
+    return {
+      id: memory.frontmatter.id,
+      path: memory.path,
+      category: memory.frontmatter.category,
+      status: inferMemoryStatus(memory.frontmatter, toMemoryPathRel(baseDir, memory.path)),
+      created: memory.frontmatter.created,
+      updated: memory.frontmatter.updated,
+      tags: normalizeProjectionTags(memory.frontmatter.tags),
+      entityRef: memory.frontmatter.entityRef,
+      preview: normalizeProjectionPreview(memory.content)
+    };
+  }
+  async observe(request) {
+    if (!request.sessionKey || typeof request.sessionKey !== "string" || request.sessionKey.trim().length === 0) {
+      throw new EngramAccessInputError("sessionKey is required and must be a non-empty string");
+    }
+    if (!Array.isArray(request.messages) || request.messages.length === 0) {
+      throw new EngramAccessInputError("messages is required and must be a non-empty array");
+    }
+    for (const msg of request.messages) {
+      if (!msg || typeof msg !== "object" || typeof msg.role !== "string" || typeof msg.content !== "string") {
+        throw new EngramAccessInputError("each message must have a string 'role' and 'content'");
+      }
+      if (msg.role !== "user" && msg.role !== "assistant") {
+        throw new EngramAccessInputError(`invalid message role: ${msg.role} (expected 'user' or 'assistant')`);
+      }
+    }
+    const namespace = this.resolveWritableNamespace(
+      request.namespace,
+      request.sessionKey,
+      request.authenticatedPrincipal
+    );
+    const lcmSessionKey = namespace !== this.orchestrator.config.defaultNamespace ? `${namespace}:${request.sessionKey}` : request.sessionKey;
+    let lcmArchived = false;
+    if (this.orchestrator.lcmEngine && this.orchestrator.lcmEngine.enabled) {
+      try {
+        this.orchestrator.lcmEngine.enqueueObserveMessages(lcmSessionKey, request.messages);
+        lcmArchived = true;
+      } catch (err) {
+        log.error(`access-observe LCM enqueue failed: ${err}`);
+      }
+    }
+    let extractionQueued = false;
+    if (request.skipExtraction !== true) {
+      const turns = request.messages.map((m) => ({
+        source: "openclaw",
+        sessionKey: lcmSessionKey,
+        role: m.role,
+        content: m.content,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
+      try {
+        const extractionPromise = this.orchestrator.ingestReplayBatch(turns);
+        extractionPromise.catch((err) => {
+          log.error(`access-observe background extraction failed: ${err}`);
+        });
+        extractionQueued = true;
+      } catch (err) {
+        log.error(`access-observe extraction enqueue failed: ${err}`);
+      }
+    }
+    log.info(
+      `access-observe namespace=${namespace} sessionKey=${request.sessionKey} messages=${request.messages.length} lcm=${lcmArchived} extraction=${extractionQueued}`
+    );
+    return {
+      accepted: request.messages.length,
+      sessionKey: request.sessionKey,
+      namespace,
+      lcmArchived,
+      extractionQueued
+    };
+  }
+  async lcmSearch(request) {
+    if (!request.query || typeof request.query !== "string" || request.query.trim().length === 0) {
+      throw new EngramAccessInputError("query is required and must be a non-empty string");
+    }
+    const principal = this.resolveWritePrincipal(request.sessionKey, request.authenticatedPrincipal);
+    const namespace = this.resolveReadableNamespace(request.namespace, principal);
+    if (!this.orchestrator.lcmEngine || !this.orchestrator.lcmEngine.enabled) {
+      return {
+        query: request.query,
+        namespace,
+        results: [],
+        count: 0,
+        lcmEnabled: false
+      };
+    }
+    const limit = Math.max(1, Math.min(request.limit ?? 10, 100));
+    const lcmSessionKey = request.sessionKey && namespace !== this.orchestrator.config.defaultNamespace ? `${namespace}:${request.sessionKey}` : request.sessionKey;
+    const rawResults = await this.orchestrator.lcmEngine.searchContextFull(
+      request.query,
+      limit,
+      lcmSessionKey
+    );
+    const results = rawResults.map((r) => ({
+      sessionId: r.session_id,
+      content: r.content,
+      turnIndex: r.turn_index
+    }));
+    return {
+      query: request.query,
+      namespace,
+      results,
+      count: results.length,
+      lcmEnabled: true
+    };
+  }
+  // ── Parity tools (match OpenClaw plugin feature set) ──────────────────
+  // ── Continuity / Identity ──────────────────────────────────────────────
+  async continuityAuditGenerate(request) {
+    if (!this.orchestrator.config.identityContinuityEnabled) {
+      return { enabled: false, reason: "Identity continuity is disabled. Enable `identityContinuityEnabled: true`." };
+    }
+    if (!this.orchestrator.config.continuityAuditEnabled) {
+      return { enabled: false, reason: "Continuity audits are disabled. Enable `continuityAuditEnabled: true`." };
+    }
+    if (!this.orchestrator.compounding) {
+      return { enabled: false, reason: "Compounding engine is disabled. Enable `compoundingEnabled: true`." };
+    }
+    const period = request.period === "monthly" ? "monthly" : "weekly";
+    const key = request.key?.trim() || void 0;
+    const audit = await this.orchestrator.compounding.synthesizeContinuityAudit({ period, key });
+    return { enabled: true, period: audit.period, key: audit.key, reportPath: audit.reportPath };
+  }
+  async continuityIncidentOpen(request) {
+    if (!this.orchestrator.config.identityContinuityEnabled) {
+      return { enabled: false, reason: "Identity continuity is disabled. Enable `identityContinuityEnabled: true`." };
+    }
+    if (!this.orchestrator.config.continuityIncidentLoggingEnabled) {
+      return { enabled: false, reason: "Continuity incident logging is disabled. Enable `continuityIncidentLoggingEnabled: true`." };
+    }
+    const symptom = request.symptom?.trim();
+    if (!symptom) throw new EngramAccessInputError("symptom is required");
+    const resolvedNs = this.resolveWritableNamespace(request.namespace, void 0, request.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNs);
+    const created = await storage.appendContinuityIncident({
+      symptom,
+      triggerWindow: request.triggerWindow?.trim() || void 0,
+      suspectedCause: request.suspectedCause?.trim() || void 0
+    });
+    return { created: true, incident: created };
+  }
+  async continuityIncidentClose(request) {
+    if (!this.orchestrator.config.identityContinuityEnabled) {
+      return { enabled: false, reason: "Identity continuity is disabled." };
+    }
+    if (!this.orchestrator.config.continuityIncidentLoggingEnabled) {
+      return { enabled: false, reason: "Continuity incident logging is disabled." };
+    }
+    const id = request.id?.trim();
+    if (!id) throw new EngramAccessInputError("id is required");
+    const fixApplied = request.fixApplied?.trim();
+    if (!fixApplied) throw new EngramAccessInputError("fixApplied is required");
+    const verificationResult = request.verificationResult?.trim();
+    if (!verificationResult) throw new EngramAccessInputError("verificationResult is required");
+    const resolvedNs = this.resolveWritableNamespace(request.namespace, void 0, request.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNs);
+    const closed = await storage.closeContinuityIncident(id, {
+      fixApplied,
+      verificationResult,
+      preventiveRule: request.preventiveRule?.trim() || void 0
+    });
+    if (!closed) return { closed: false, reason: `Incident not found: ${id}` };
+    return { closed: true, incident: closed };
+  }
+  async continuityIncidentList(request) {
+    if (!this.orchestrator.config.identityContinuityEnabled) {
+      return { enabled: false, reason: "Identity continuity is disabled." };
+    }
+    const state = request.state === "closed" || request.state === "all" ? request.state : "open";
+    const limit = Math.max(1, Math.min(200, Math.floor(request.limit ?? 25)));
+    const resolvedNs = this.resolveReadableNamespace(request.namespace, request.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNs);
+    const incidents = await storage.readContinuityIncidents(limit, state);
+    return { state, incidents, count: incidents.length };
+  }
+  async continuityLoopAddOrUpdate(request) {
+    if (!this.orchestrator.config.identityContinuityEnabled) {
+      return { enabled: false, reason: "Identity continuity is disabled." };
+    }
+    const resolvedNs = this.resolveWritableNamespace(request.namespace, void 0, request.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNs);
+    const loop = await storage.upsertIdentityImprovementLoop({
+      id: request.id?.trim() || "",
+      cadence: request.cadence,
+      purpose: request.purpose?.trim() || "",
+      status: request.status,
+      killCondition: request.killCondition?.trim() || "",
+      lastReviewed: request.lastReviewed?.trim() || void 0,
+      notes: request.notes?.trim() || void 0
+    });
+    return { saved: true, loop };
+  }
+  async continuityLoopReview(request) {
+    if (!this.orchestrator.config.identityContinuityEnabled) {
+      return { enabled: false, reason: "Identity continuity is disabled." };
+    }
+    const id = request.id?.trim();
+    if (!id) throw new EngramAccessInputError("id is required");
+    const resolvedNs = this.resolveWritableNamespace(request.namespace, void 0, request.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNs);
+    const reviewed = await storage.reviewIdentityImprovementLoop(id, {
+      status: request.status,
+      notes: request.notes?.trim() || void 0,
+      reviewedAt: request.reviewedAt?.trim() || void 0
+    });
+    if (!reviewed) return { reviewed: false, reason: `Continuity loop not found: ${id}` };
+    return { reviewed: true, loop: reviewed };
+  }
+  async identityAnchorGet(request) {
+    if (!this.orchestrator.config.identityContinuityEnabled) {
+      return { enabled: false, reason: "Identity continuity is disabled." };
+    }
+    const resolvedNs = this.resolveReadableNamespace(request.namespace, request.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNs);
+    const anchor = await storage.readIdentityAnchor();
+    if (!anchor) return { found: false, message: "No identity anchor found yet. Use identity_anchor_update to create one." };
+    return { found: true, anchor };
+  }
+  async identityAnchorUpdate(request) {
+    if (!this.orchestrator.config.identityContinuityEnabled) {
+      return { enabled: false, reason: "Identity continuity is disabled." };
+    }
+    const updates = {
+      "Identity Traits": request.identityTraits?.trim() || void 0,
+      "Communication Preferences": request.communicationPreferences?.trim() || void 0,
+      "Operating Principles": request.operatingPrinciples?.trim() || void 0,
+      "Continuity Notes": request.continuityNotes?.trim() || void 0
+    };
+    const hasUpdate = Object.values(updates).some((v) => typeof v === "string" && v.length > 0);
+    if (!hasUpdate) throw new EngramAccessInputError("At least one section field is required.");
+    const resolvedNs = this.resolveWritableNamespace(request.namespace, void 0, request.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNs);
+    const existing = await storage.readIdentityAnchor();
+    const merged = this.mergeIdentityAnchorSections(existing, updates);
+    await storage.writeIdentityAnchor(merged);
+    const updatedSections = Object.entries(updates).filter(([, v]) => typeof v === "string" && v.length > 0).map(([name]) => name);
+    return { updated: true, sections: updatedSections, anchor: merged };
+  }
+  async memoryIdentity(request) {
+    const resolvedNs = this.resolveReadableNamespace(request.namespace, request.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNs);
+    const identity = await storage.readIdentityReflections();
+    if (!identity) return { found: false, message: "No identity reflections found." };
+    return { found: true, identity };
+  }
+  // ── Work Layer ──────────────────────────────────────────────────────────
+  async workTask(request) {
+    const STATUSES = /* @__PURE__ */ new Set(["todo", "in_progress", "blocked", "done", "cancelled"]);
+    const PRIORITIES = /* @__PURE__ */ new Set(["low", "medium", "high"]);
+    const asStatus = (v) => v && STATUSES.has(v) ? v : void 0;
+    const asPriority = (v) => v && PRIORITIES.has(v) ? v : void 0;
+    const storage = new WorkStorage(this.orchestrator.config.memoryDir);
+    await storage.ensureDirectories();
+    const action = request.action;
+    if (action === "create") {
+      if (!request.title?.trim()) throw new EngramAccessInputError("title is required for create");
+      const task = await storage.createTask({
+        title: request.title,
+        description: request.description,
+        status: asStatus(request.status),
+        priority: asPriority(request.priority),
+        owner: request.owner?.trim() || void 0,
+        assignee: request.assignee?.trim() || void 0,
+        projectId: request.projectId?.trim() || void 0,
+        tags: request.tags,
+        dueAt: request.dueAt?.trim() || void 0
+      });
+      return { action, task };
+    }
+    if (action === "get") {
+      if (!request.id?.trim()) throw new EngramAccessInputError("id is required for get");
+      return { action, task: await storage.getTask(request.id) };
+    }
+    if (action === "list") {
+      const tasks = await storage.listTasks({
+        status: asStatus(request.status),
+        owner: request.owner?.trim() || void 0,
+        assignee: request.assignee?.trim() || void 0,
+        projectId: request.projectId?.trim() || void 0
+      });
+      return { action, count: tasks.length, tasks };
+    }
+    if (action === "update") {
+      if (!request.id?.trim()) throw new EngramAccessInputError("id is required for update");
+      const patch = {};
+      if (request.title !== void 0) patch.title = request.title;
+      if (request.description !== void 0) patch.description = request.description;
+      const st = asStatus(request.status);
+      if (st) patch.status = st;
+      const pr = asPriority(request.priority);
+      if (pr) patch.priority = pr;
+      if (request.owner !== void 0) patch.owner = request.owner || null;
+      if (request.assignee !== void 0) patch.assignee = request.assignee || null;
+      if (request.projectId !== void 0) patch.projectId = request.projectId || null;
+      if (request.tags) patch.tags = request.tags;
+      if (request.dueAt !== void 0) patch.dueAt = request.dueAt || null;
+      return { action, task: await storage.updateTask(request.id, patch) };
+    }
+    if (action === "transition") {
+      if (!request.id?.trim()) throw new EngramAccessInputError("id is required for transition");
+      const st = asStatus(request.status);
+      if (!st) throw new EngramAccessInputError("valid status is required for transition");
+      return { action, task: await storage.transitionTask(request.id, st) };
+    }
+    if (action === "delete") {
+      if (!request.id?.trim()) throw new EngramAccessInputError("id is required for delete");
+      return { action, deleted: await storage.deleteTask(request.id) };
+    }
+    throw new EngramAccessInputError(`Unsupported work_task action: ${action}`);
+  }
+  async workProject(request) {
+    const STATUSES = /* @__PURE__ */ new Set(["active", "on_hold", "completed", "archived"]);
+    const asStatus = (v) => v && STATUSES.has(v) ? v : void 0;
+    const storage = new WorkStorage(this.orchestrator.config.memoryDir);
+    await storage.ensureDirectories();
+    const action = request.action;
+    if (action === "create") {
+      if (!request.name?.trim()) throw new EngramAccessInputError("name is required for create");
+      const project = await storage.createProject({
+        name: request.name,
+        description: request.description,
+        status: asStatus(request.status),
+        owner: request.owner?.trim() || void 0,
+        tags: request.tags
+      });
+      return { action, project };
+    }
+    if (action === "get") {
+      if (!request.id?.trim()) throw new EngramAccessInputError("id is required for get");
+      return { action, project: await storage.getProject(request.id) };
+    }
+    if (action === "list") {
+      const projects = await storage.listProjects();
+      return { action, count: projects.length, projects };
+    }
+    if (action === "update") {
+      if (!request.id?.trim()) throw new EngramAccessInputError("id is required for update");
+      const patch = {};
+      if (request.name !== void 0) patch.name = request.name;
+      if (request.description !== void 0) patch.description = request.description;
+      const st = asStatus(request.status);
+      if (st) patch.status = st;
+      if (request.owner !== void 0) patch.owner = request.owner || null;
+      if (request.tags) patch.tags = request.tags;
+      return { action, project: await storage.updateProject(request.id, patch) };
+    }
+    if (action === "delete") {
+      if (!request.id?.trim()) throw new EngramAccessInputError("id is required for delete");
+      return { action, deleted: await storage.deleteProject(request.id) };
+    }
+    if (action === "link_task") {
+      if (!request.taskId?.trim() || !request.projectId?.trim()) {
+        throw new EngramAccessInputError("taskId and projectId are required for link_task");
+      }
+      return { action, linked: await storage.linkTaskToProject(request.taskId, request.projectId) };
+    }
+    throw new EngramAccessInputError(`Unsupported work_project action: ${action}`);
+  }
+  async workBoard(request) {
+    const memoryDir = this.orchestrator.config.memoryDir;
+    await new WorkStorage(memoryDir).ensureDirectories();
+    const action = request.action;
+    const projectId = request.projectId?.trim() || void 0;
+    if (action === "export_markdown") {
+      const markdown = await exportWorkBoardMarkdown({ memoryDir, projectId });
+      return { action, markdown: wrapWorkLayerContext(markdown, { linkToMemory: request.linkToMemory === true }) };
+    }
+    if (action === "export_snapshot") {
+      const snapshot = await exportWorkBoardSnapshot({ memoryDir, projectId });
+      return { action, snapshot };
+    }
+    if (action === "import_snapshot") {
+      if (!request.snapshotJson?.trim()) throw new EngramAccessInputError("snapshotJson is required for import_snapshot");
+      const snapshot = JSON.parse(request.snapshotJson);
+      const result = await importWorkBoardSnapshot({ memoryDir, snapshot, projectId });
+      return { action, result };
+    }
+    throw new EngramAccessInputError(`Unsupported work_board action: ${action}`);
+  }
+  // ── Shared Context / Compounding ────────────────────────────────────────
+  async sharedContextWriteOutput(request) {
+    if (!this.orchestrator.sharedContext) {
+      return { enabled: false, reason: "Shared context is disabled. Enable `sharedContextEnabled: true`." };
+    }
+    const fp = await this.orchestrator.sharedContext.writeAgentOutput({
+      agentId: request.agentId,
+      title: request.title,
+      content: request.content
+    });
+    return { written: true, path: fp };
+  }
+  async sharedFeedbackRecord(request) {
+    if (!this.orchestrator.sharedContext) {
+      return { enabled: false, reason: "Shared context is disabled. Enable `sharedContextEnabled: true`." };
+    }
+    await this.orchestrator.sharedContext.appendFeedback({
+      agent: request.agent,
+      decision: request.decision,
+      reason: request.reason,
+      date: request.date?.trim() || (/* @__PURE__ */ new Date()).toISOString(),
+      learning: request.learning,
+      outcome: request.outcome,
+      severity: request.severity,
+      confidence: request.confidence,
+      workflow: request.workflow,
+      tags: request.tags,
+      evidenceWindowStart: request.evidenceWindowStart,
+      evidenceWindowEnd: request.evidenceWindowEnd,
+      refs: request.refs
+    });
+    return { recorded: true };
+  }
+  async sharedPrioritiesAppend(request) {
+    if (!this.orchestrator.sharedContext) {
+      return { enabled: false, reason: "Shared context is disabled. Enable `sharedContextEnabled: true`." };
+    }
+    await this.orchestrator.sharedContext.appendPrioritiesInbox({
+      agentId: request.agentId,
+      text: request.text
+    });
+    return { appended: true };
+  }
+  async sharedContextCrossSignalsRun(request) {
+    if (!this.orchestrator.sharedContext) {
+      return { enabled: false, reason: "Shared context is disabled. Enable `sharedContextEnabled: true`." };
+    }
+    const result = await this.orchestrator.sharedContext.synthesizeCrossSignals({ date: request.date });
+    return {
+      crossSignalsMarkdownPath: result.crossSignalsMarkdownPath,
+      crossSignalsPath: result.crossSignalsPath,
+      sourceCount: result.report.sourceCount,
+      feedbackCount: result.report.feedbackCount,
+      overlapCount: result.overlapCount
+    };
+  }
+  async sharedContextCurateDaily(request) {
+    if (!this.orchestrator.sharedContext) {
+      return { enabled: false, reason: "Shared context is disabled. Enable `sharedContextEnabled: true`." };
+    }
+    const result = await this.orchestrator.sharedContext.curateDaily({ date: request.date });
+    return {
+      roundtablePath: result.roundtablePath,
+      crossSignalsMarkdownPath: result.crossSignalsMarkdownPath,
+      crossSignalsPath: result.crossSignalsPath,
+      overlapCount: result.overlapCount
+    };
+  }
+  async compoundingWeeklySynthesize(request) {
+    if (!this.orchestrator.compounding) {
+      return { enabled: false, reason: "Compounding engine is disabled. Enable `compoundingEnabled: true`." };
+    }
+    const res = await this.orchestrator.compounding.synthesizeWeekly({ weekId: request.weekId });
+    return {
+      weekId: res.weekId,
+      reportPath: res.reportPath,
+      reportJsonPath: res.reportJsonPath,
+      rubricsPath: res.rubricsPath,
+      rubricsIndexPath: res.rubricsIndexPath,
+      mistakesCount: res.mistakesCount,
+      promotionCandidateCount: res.promotionCandidateCount
+    };
+  }
+  async compoundingPromoteCandidate(request) {
+    if (!this.orchestrator.compounding) {
+      return { enabled: false, reason: "Compounding engine is disabled. Enable `compoundingEnabled: true`." };
+    }
+    return await this.orchestrator.compounding.promoteCandidate({
+      weekId: request.weekId,
+      candidateId: request.candidateId,
+      dryRun: request.dryRun
+    });
+  }
+  // ── Compression Guidelines ────────────────────────────────────────────
+  async compressionGuidelinesOptimize(request) {
+    if (!this.orchestrator.config.compressionGuidelineLearningEnabled) {
+      return { enabled: false, reason: "Compression guideline learning is disabled. Enable `compressionGuidelineLearningEnabled: true`." };
+    }
+    return await this.orchestrator.optimizeCompressionGuidelines({
+      dryRun: request.dryRun,
+      eventLimit: request.eventLimit
+    });
+  }
+  async compressionGuidelinesActivate(request) {
+    if (!this.orchestrator.config.compressionGuidelineLearningEnabled) {
+      return { enabled: false, reason: "Compression guideline learning is disabled." };
+    }
+    return await this.orchestrator.activateCompressionGuidelineDraft({
+      expectedContentHash: request.expectedContentHash,
+      expectedGuidelineVersion: request.expectedGuidelineVersion
+    });
+  }
+  /** Conservative identity anchor section merge (matches tools.ts mergeIdentityAnchor logic). */
+  mergeIdentityAnchorSections(existingRaw, updates) {
+    const TITLE = "# Identity Continuity Anchor";
+    const SECTION_ORDER = ["Identity Traits", "Communication Preferences", "Operating Principles", "Continuity Notes"];
+    const lines = (existingRaw ?? "").replace(/\r/g, "").split("\n");
+    const headerLines = [];
+    const sectionContent = /* @__PURE__ */ new Map();
+    const order = [];
+    let current = null;
+    for (const line of lines) {
+      const m = line.match(/^##\s+(.+?)\s*$/);
+      if (m) {
+        current = m[1].trim();
+        if (!sectionContent.has(current)) {
+          sectionContent.set(current, []);
+          order.push(current);
+        }
+        continue;
+      }
+      if (!current) {
+        headerLines.push(line);
+      } else {
+        sectionContent.get(current)?.push(line);
+      }
+    }
+    const sections = /* @__PURE__ */ new Map();
+    for (const [name, cLines] of sectionContent) sections.set(name, cLines.join("\n").trim());
+    const header = headerLines.join("\n").trim() || TITLE;
+    for (const sectionName of SECTION_ORDER) {
+      const prev = sections.get(sectionName)?.trim();
+      const next = updates[sectionName]?.trim();
+      const existing = prev === "- (empty)" ? "" : prev;
+      if (!next) {
+        if (!sections.has(sectionName)) sections.set(sectionName, "");
+        continue;
+      }
+      if (!existing) {
+        sections.set(sectionName, next);
+        continue;
+      }
+      if (existing.includes(next)) continue;
+      if (next.includes(existing)) {
+        sections.set(sectionName, next);
+        continue;
+      }
+      sections.set(sectionName, `${existing}
+
+${next}`);
+    }
+    const finalOrder = [...SECTION_ORDER.filter((s) => sections.has(s)), ...order.filter((s) => !SECTION_ORDER.includes(s) && sections.has(s))];
+    const out = [header, ""];
+    for (const name of finalOrder) {
+      out.push(`## ${name}`, "");
+      const body = sections.get(name)?.trim();
+      if (body) out.push(body, "");
+      else out.push("");
+    }
+    return out.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+  }
+  // ── Memory search & debug ─────────────────────────────────────────────
+  async memorySearch(request) {
+    const { query, namespace, maxResults, collection, principal } = request;
+    const resolvedNs = this.resolveReadableNamespace(namespace, principal);
+    const namespaceFilter = resolvedNs !== this.orchestrator.config.defaultNamespace ? resolvedNs : void 0;
+    const results = collection === "global" ? (await this.orchestrator.qmd.searchGlobal(query, maxResults)).filter(
+      (r) => namespaceFilter ? r.path.includes(`/namespaces/${namespaceFilter}/`) || !r.path.includes("/namespaces/") && namespaceFilter === this.orchestrator.config.defaultNamespace : true
+    ) : await this.orchestrator.searchAcrossNamespaces({
+      query,
+      namespaces: namespaceFilter ? [namespaceFilter] : void 0,
+      maxResults,
+      mode: "search"
+    });
+    return {
+      query,
+      results: results.map((r) => ({
+        path: r.path,
+        score: r.score,
+        snippet: (r.snippet ?? "").slice(0, 800)
+      })),
+      count: results.length
+    };
+  }
+  async memoryProfile(namespace, principal) {
+    const resolvedNs = this.resolveReadableNamespace(namespace, principal);
+    const storage = await this.orchestrator.getStorage(resolvedNs);
+    const profile = await storage.readProfile();
+    return {
+      profile: profile || "No profile built yet. The profile builds automatically through conversations."
+    };
+  }
+  async memoryEntitiesList(namespace, principal) {
+    const resolvedNs = this.resolveReadableNamespace(namespace, principal);
+    const storage = await this.orchestrator.getStorage(resolvedNs);
+    const entities = await storage.readEntities();
+    return { entities, count: entities.length };
+  }
+  async memoryQuestions(namespace, principal) {
+    const resolvedNs = this.resolveReadableNamespace(namespace, principal);
+    const storage = await this.orchestrator.getStorage(resolvedNs);
+    const questions = await storage.readQuestions();
+    return {
+      questions: questions.map((q) => ({ id: q.id, question: q.question, resolved: q.resolved })),
+      count: questions.length
+    };
+  }
+  async lastRecallSnapshot(sessionKey) {
+    const snapshot = sessionKey ? this.orchestrator.lastRecall.get(sessionKey) : this.orchestrator.lastRecall.getMostRecent();
+    return snapshot ?? { message: "No recall snapshot available" };
+  }
+  async intentDebug(namespace) {
+    const snapshot = await this.orchestrator.getLastIntentSnapshot(namespace);
+    return snapshot ?? { message: "No intent debug snapshot available" };
+  }
+  async qmdDebug(namespace) {
+    const snapshot = await this.orchestrator.getLastQmdRecallSnapshot(namespace);
+    return snapshot ?? { message: "No QMD debug snapshot available" };
+  }
+  async graphExplainLastRecall(namespace) {
+    const explanation = await this.orchestrator.explainLastGraphRecall({ namespace });
+    return { explanation };
+  }
+  async memoryFeedback(request) {
+    if (!this.orchestrator.config.feedbackEnabled) {
+      return {
+        recorded: false,
+        enabled: false,
+        reason: "Feedback is disabled. Enable `feedbackEnabled: true` in the Engram config to store feedback."
+      };
+    }
+    await this.orchestrator.recordMemoryFeedback(
+      request.memoryId,
+      request.vote,
+      request.note
+    );
+    return { recorded: true };
+  }
+  async memoryPromote(request) {
+    const resolvedNs = this.resolveWritableNamespace(request.namespace, request.sessionKey, request.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNs);
+    await storage.updateMemoryFrontmatter(request.memoryId, {
+      lifecycleState: "active",
+      updated: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return { promoted: true, memoryId: request.memoryId };
+  }
+  async contextCheckpoint(request) {
+    const resolvedNs = this.resolveWritableNamespace(request.namespace, request.sessionKey, request.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNs);
+    const storageDir = storage.dir;
+    const { writeFile: writeFile2, mkdir: mkdir2 } = await import("fs/promises");
+    const { join, resolve } = await import("path");
+    const safeKey = request.sessionKey.replace(/[^a-zA-Z0-9_-]/g, "_");
+    if (!safeKey) throw new EngramAccessInputError("sessionKey is required");
+    const checkpointDir = join(storageDir, "checkpoints", safeKey);
+    const resolved = resolve(checkpointDir);
+    if (!resolved.startsWith(resolve(storageDir))) {
+      throw new EngramAccessInputError("Invalid sessionKey");
+    }
+    await mkdir2(checkpointDir, { recursive: true });
+    const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const filePath = join(checkpointDir, `checkpoint-${ts}.md`);
+    await writeFile2(filePath, request.context, "utf-8");
+    return { saved: true };
+  }
+  async lcmStatus() {
+    if (!this.orchestrator.lcmEngine || !this.orchestrator.lcmEngine.enabled) {
+      return {
+        enabled: false,
+        archiveAvailable: false
+      };
+    }
+    const stats = await this.orchestrator.lcmEngine.getStats();
+    return {
+      enabled: true,
+      archiveAvailable: true,
+      stats: {
+        totalTurns: stats.totalMessages
+      }
+    };
+  }
+};
+
+export {
+  WorkStorage,
+  EngramAccessInputError,
+  ENGRAM_ACCESS_WRITE_SCHEMA_VERSION,
+  EngramAccessService
+};
+//# sourceMappingURL=chunk-QY2BHY5O.js.map