@aisystemresources/emdee 0.1.0

package/src/lib/mcp/activity.ts

@@ -0,0 +1,254 @@
+import { adminClient } from "../supabase/admin";
+
+export type ActionKind =
+  | "read"
+  | "write"
+  | "delete"
+  | "rename"
+  | "search"
+  | "lint"
+  | "other";
+
+export interface ActivityRouting {
+  /** Tool name as exposed by the MCP server. */
+  tool_name: string;
+  /** Classification for the visual pulse colour mapping. */
+  action_kind: ActionKind;
+  /** Extract the focal doc path from the tool's args. Return null for
+   *  tools without a focal (search, list_docs). */
+  doc_path: (args: unknown) => string | null;
+  /** Optional: extract supplementary info to store in args_summary jsonb. */
+  args_summary?: (args: unknown) => Record<string, unknown>;
+}
+
+function asRecord(args: unknown): Record<string, unknown> {
+  return args && typeof args === "object" ? (args as Record<string, unknown>) : {};
+}
+
+function strField(args: unknown, key: string): string | null {
+  const v = asRecord(args)[key];
+  return typeof v === "string" ? v : null;
+}
+
+export const ACTIVITY_ROUTING: Record<string, ActivityRouting> = {
+  // ── Reads ───────────────────────────────────────────────────────────────
+  get_doc: {
+    tool_name: "get_doc",
+    action_kind: "read",
+    doc_path: (a) => strField(a, "path"),
+  },
+  get_summary: {
+    tool_name: "get_summary",
+    action_kind: "read",
+    doc_path: (a) => strField(a, "path"),
+  },
+  get_neighbors: {
+    tool_name: "get_neighbors",
+    action_kind: "read",
+    doc_path: (a) => strField(a, "path"),
+  },
+  get_context: {
+    tool_name: "get_context",
+    action_kind: "read",
+    doc_path: (a) => strField(a, "path"),
+    args_summary: (a) => {
+      const r = asRecord(a);
+      const out: Record<string, unknown> = {};
+      if (typeof r.hops === "number") out.hops = r.hops;
+      if (typeof r.budget_tokens === "number") out.budget_tokens = r.budget_tokens;
+      return out;
+    },
+  },
+  read_doc_section: {
+    tool_name: "read_doc_section",
+    action_kind: "read",
+    doc_path: (a) => strField(a, "path"),
+    args_summary: (a) => {
+      const r = asRecord(a);
+      const out: Record<string, unknown> = {};
+      if (typeof r.heading === "string") out.heading = r.heading;
+      if (typeof r.section_id === "string") out.section_id = r.section_id;
+      return out;
+    },
+  },
+  // ── Searches ────────────────────────────────────────────────────────────
+  list_docs: {
+    tool_name: "list_docs",
+    action_kind: "search",
+    doc_path: () => null,
+  },
+  search: {
+    tool_name: "search",
+    action_kind: "search",
+    doc_path: () => null,
+    args_summary: (a) => {
+      const r = asRecord(a);
+      const out: Record<string, unknown> = {};
+      if (typeof r.query === "string") out.query = r.query;
+      if (typeof r.limit === "number") out.limit = r.limit;
+      return out;
+    },
+  },
+  // ── Writes ──────────────────────────────────────────────────────────────
+  write_doc: {
+    tool_name: "write_doc",
+    action_kind: "write",
+    doc_path: (a) => strField(a, "path"),
+  },
+  // Preview is non-destructive — treat as a read.
+  write_doc_preview: {
+    tool_name: "write_doc_preview",
+    action_kind: "read",
+    doc_path: (a) => strField(a, "path"),
+  },
+  append_doc: {
+    tool_name: "append_doc",
+    action_kind: "write",
+    doc_path: (a) => strField(a, "path"),
+  },
+  append_section: {
+    tool_name: "append_section",
+    action_kind: "write",
+    doc_path: (a) => strField(a, "path"),
+    args_summary: (a) => {
+      const r = asRecord(a);
+      return typeof r.heading === "string" ? { heading: r.heading } : {};
+    },
+  },
+  patch_section: {
+    tool_name: "patch_section",
+    action_kind: "write",
+    doc_path: (a) => strField(a, "path"),
+    args_summary: (a) => {
+      const r = asRecord(a);
+      return typeof r.heading === "string" ? { heading: r.heading } : {};
+    },
+  },
+  patch_preamble: {
+    tool_name: "patch_preamble",
+    action_kind: "write",
+    doc_path: (a) => strField(a, "path"),
+  },
+  // ── Deletes / Renames ───────────────────────────────────────────────────
+  delete_doc: {
+    tool_name: "delete_doc",
+    action_kind: "delete",
+    doc_path: (a) => strField(a, "path"),
+  },
+  rename_doc: {
+    tool_name: "rename_doc",
+    action_kind: "rename",
+    doc_path: (a) => strField(a, "new_path") ?? strField(a, "old_path"),
+    args_summary: (a) => {
+      const r = asRecord(a);
+      return typeof r.old_path === "string" ? { old_path: r.old_path } : {};
+    },
+  },
+  // ── Compound atomic writes ──────────────────────────────────────────────
+  split_doc: {
+    tool_name: "split_doc",
+    action_kind: "write",
+    doc_path: (a) => strField(a, "source_path"),
+    args_summary: (a) => {
+      const r = asRecord(a);
+      const extracts = Array.isArray(r.extracts) ? r.extracts.length : undefined;
+      return extracts !== undefined ? { extracts } : {};
+    },
+  },
+  distill_doc: {
+    tool_name: "distill_doc",
+    action_kind: "read",
+    doc_path: (a) => strField(a, "path"),
+  },
+  materialize_subgroup: {
+    tool_name: "materialize_subgroup",
+    action_kind: "write",
+    doc_path: (a) => strField(a, "source_path"),
+    args_summary: (a) => {
+      const r = asRecord(a);
+      return typeof r.subgroup_heading === "string"
+        ? { subgroup_heading: r.subgroup_heading }
+        : {};
+    },
+  },
+  // ── Lint / quality ──────────────────────────────────────────────────────
+  lint_doc: {
+    tool_name: "lint_doc",
+    action_kind: "lint",
+    doc_path: (a) => strField(a, "path"),
+  },
+  // ── Compound atomic writes (SPRINT-019) ─────────────────────────────────
+  create_child: {
+    tool_name: "create_child",
+    action_kind: "write",
+    doc_path: (a) => strField(a, "parent_path"),
+    args_summary: (a) => {
+      const r = asRecord(a);
+      const out: Record<string, unknown> = {};
+      if (typeof r.title === "string") out.title = r.title;
+      if (typeof r.child_path === "string") out.child_path = r.child_path;
+      return out;
+    },
+  },
+  add_association: {
+    tool_name: "add_association",
+    action_kind: "write",
+    doc_path: (a) => strField(a, "a_path"),
+    args_summary: (a) => {
+      const r = asRecord(a);
+      return typeof r.b_path === "string" ? { b_path: r.b_path } : {};
+    },
+  },
+};
+
+/**
+ * Fire-and-forget insert. Logging failure must never block the tool call,
+ * so we swallow errors with a console.warn. If the path resolves to a
+ * shared doc (__shared__/<owner>/...), the row is logged against the
+ * OWNER'S namespace so the owner sees the pulse — the caller's clerk_id
+ * is still recorded so they can tell self-vs-other.
+ *
+ * Caller must guard on ctx.mode === "cloud" before invoking — local-dev
+ * stdio sessions have no clerk_id and aren't worth logging.
+ */
+export async function logMcpActivity(
+  callerNamespace: string,
+  clerkId: string,
+  toolName: string,
+  args: unknown,
+): Promise<void> {
+  const routing = ACTIVITY_ROUTING[toolName];
+  if (!routing) return; // unknown tool — don't log
+
+  const rawPath = routing.doc_path(args);
+  // Resolve shared-doc owner namespace.
+  let targetNs = callerNamespace;
+  let docPath = rawPath;
+  if (rawPath && rawPath.startsWith("__shared__/")) {
+    const parts = rawPath.split("/");
+    if (parts.length >= 3) {
+      targetNs = parts[1]; // <owner_id>
+      docPath = parts.slice(2).join("/");
+    }
+  }
+
+  let argsSummary: Record<string, unknown> | undefined;
+  if (routing.args_summary) {
+    const s = routing.args_summary(args);
+    if (s && Object.keys(s).length > 0) argsSummary = s;
+  }
+
+  try {
+    const { error } = await adminClient().from("mcp_activity").insert({
+      namespace: targetNs,
+      clerk_id: clerkId,
+      tool_name: routing.tool_name,
+      doc_path: docPath,
+      action_kind: routing.action_kind,
+      args_summary: argsSummary,
+    });
+    if (error) console.warn("[mcp_activity] insert failed:", error.message);
+  } catch (e) {
+    console.warn("[mcp_activity] insert threw:", (e as Error).message);
+  }
+}

package/src/lib/mcp/tools/add_association.ts

@@ -0,0 +1,311 @@
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { validatePath, readVaultFile, writeVaultFile, loadVaultIndex } from "./vault";
+import { lintDocContent } from "./lint";
+import { buildLintVaultContext } from "./lint_doc";
+import { evaluateLintGate, type LintFix } from "./lint_gate";
+import type { LintWarning, LintVaultContext } from "./lint";
+import { resolveWikiLink } from "../../../core/resolveLink";
+import type { ToolContext } from "./types";
+import { validateArgs } from "./validate_args";
+
+const ARG_SPEC = {
+  allowed: ["a_path", "b_path", "label", "gate_on_warnings"],
+  required: ["a_path", "b_path"],
+} as const;
+
+const H1_RE = /^#\s+(.+?)\s*$/m;
+const H2_RE = /^##\s+(.+?)\s*$/;
+const FENCE_RE = /^\s*(?:```|~~~)/;
+
+function deriveTitle(content: string, fallbackPath: string): string {
+  const m = content.match(H1_RE);
+  if (m) return m[1].trim();
+  return path.basename(fallbackPath, ".md");
+}
+
+function hashBody(body: string): string {
+  return createHash("sha256").update(body, "utf8").digest("hex").slice(0, 16);
+}
+
+interface SectionLoc {
+  heading: string;
+  headingLineIdx: number;
+  bodyStartLineIdx: number;
+  bodyEndLineIdx: number;
+}
+
+function parseSections(content: string): SectionLoc[] {
+  const lines = content.split("\n");
+  const sections: SectionLoc[] = [];
+  let inFence = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (FENCE_RE.test(lines[i])) { inFence = !inFence; continue; }
+    if (inFence) continue;
+    const m = lines[i].match(H2_RE);
+    if (!m) continue;
+    if (sections.length > 0) sections[sections.length - 1].bodyEndLineIdx = i;
+    sections.push({ heading: m[1].trim(), headingLineIdx: i, bodyStartLineIdx: i + 1, bodyEndLineIdx: lines.length });
+  }
+  return sections;
+}
+
+function findSection(sections: SectionLoc[], heading: string): SectionLoc | undefined {
+  const target = heading.trim().toLowerCase();
+  return sections.find((s) => s.heading.toLowerCase() === target);
+}
+
+function extractBody(content: string, loc: SectionLoc): string {
+  return content.split("\n")
+    .slice(loc.bodyStartLineIdx, loc.bodyEndLineIdx)
+    .join("\n")
+    .replace(/^\s*\n+/, "")
+    .replace(/\n+\s*$/, "");
+}
+
+/**
+ * Insert `* [[<otherTitle>]] — <label>` into the doc's `## Associated
+ * with` section. Creates the section if missing. Returns { newContent,
+ * alreadyPresent } so the caller can short-circuit on idempotent retry.
+ */
+function patchAssociatedWith(content: string, otherTitle: string, label?: string): {
+  newContent: string;
+  alreadyPresent: boolean;
+  assocBody: string;
+} {
+  const lines = content.split("\n");
+  const sections = parseSections(content);
+  const assoc = findSection(sections, "Associated with");
+  const bullet = label ? `* [[${otherTitle}]] — ${label}` : `* [[${otherTitle}]]`;
+
+  if (!assoc) {
+    const sep = content.endsWith("\n") ? "" : "\n";
+    const newContent = content + sep + `\n## Associated with\n\n${bullet}\n`;
+    return { newContent, alreadyPresent: false, assocBody: bullet };
+  }
+
+  // Idempotency: existing bullet with this target (alias-tolerant).
+  const sectionLines = lines.slice(assoc.headingLineIdx, assoc.bodyEndLineIdx);
+  const escaped = otherTitle.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const existsRe = new RegExp(`^\\s*[-*]\\s+\\[\\[${escaped}(\\|[^\\]]+)?\\]\\]`, "i");
+  if (sectionLines.some((l) => existsRe.test(l))) {
+    return {
+      newContent: content,
+      alreadyPresent: true,
+      assocBody: extractBody(content, assoc),
+    };
+  }
+
+  const newSectionLines = [...sectionLines];
+  while (newSectionLines.length > 1 && newSectionLines[newSectionLines.length - 1].trim() === "") newSectionLines.pop();
+  newSectionLines.push("", bullet, "");
+  const newContent = [
+    ...lines.slice(0, assoc.headingLineIdx),
+    ...newSectionLines,
+    ...lines.slice(assoc.bodyEndLineIdx),
+  ].join("\n");
+  const newSections = parseSections(newContent);
+  const newAssoc = findSection(newSections, "Associated with");
+  return {
+    newContent,
+    alreadyPresent: false,
+    assocBody: newAssoc ? extractBody(newContent, newAssoc) : "",
+  };
+}
+
+function fixesFromWarnings(warnings: LintWarning[], codes: string[]): LintFix[] {
+  const codeSet = new Set(codes);
+  return warnings.filter((w) => codeSet.has(w.code)).map((w) => ({
+    code: w.code,
+    line: w.line ?? null,
+    fix_suggestion: w.suggestion,
+    original_message: w.message,
+  }));
+}
+
+function json(value: unknown) {
+  return { content: [{ type: "text" as const, text: JSON.stringify(value, null, 2) }] };
+}
+
+/**
+ * Atomic two-sided assoc. Patches both docs' `## Associated with` to
+ * mention the other (with optional shared label, same on both bullets).
+ *
+ * Hard-gates internally on `associate_duplicates_hierarchy` and
+ * `sibling_assoc_redundant` for both sides — these are the exact codes
+ * this tool exists to prevent. A pair already linked via Child of /
+ * Parent of, or sharing a parent (i.e. siblings), gets refused with a
+ * structured `would_duplicate_hierarchy` error.
+ *
+ * Idempotent: if both docs already declare the other in `## Associated
+ * with`, returns ok with `a_updated: false, b_updated: false` and
+ * doesn't touch either file.
+ *
+ * Label drift caveat: if the first call passes label X and the second
+ * passes label Y, the second is a no-op (idempotency check fires on
+ * presence-of-bullet alone). Use a future `update_association_label` for
+ * label edits.
+ */
+export async function addAssociation(ctx: ToolContext, args: Record<string, unknown>): Promise<unknown> {
+  const argErr = validateArgs(args, ARG_SPEC);
+  if (argErr) return json(argErr);
+  const aPath = String(args.a_path ?? "");
+  const bPath = String(args.b_path ?? "");
+  const label = args.label !== undefined ? String(args.label).trim() : "";
+  const gateCodes = Array.isArray(args.gate_on_warnings)
+    ? (args.gate_on_warnings as unknown[]).filter((c): c is string => typeof c === "string")
+    : [];
+
+  if (!aPath) return json({ error: "a_path required" });
+  if (!bPath) return json({ error: "b_path required" });
+  if (aPath === bPath) return json({ error: "self_association", path: aPath });
+  validatePath(aPath);
+  validatePath(bPath);
+
+  const aContent = await readVaultFile(ctx, aPath);
+  if (aContent === null) return json({ error: "a_not_found", path: aPath });
+  const bContent = await readVaultFile(ctx, bPath);
+  if (bContent === null) return json({ error: "b_not_found", path: bPath });
+
+  const aTitle = deriveTitle(aContent, aPath);
+  const bTitle = deriveTitle(bContent, bPath);
+
+  const index = await loadVaultIndex(ctx);
+  const aCtx: LintVaultContext = buildLintVaultContext(index, aPath);
+  const bCtx: LintVaultContext = buildLintVaultContext(index, bPath);
+
+  // Build proposed contents (insert bullet on each side).
+  const aPatch = patchAssociatedWith(aContent, bTitle, label || undefined);
+  const bPatch = patchAssociatedWith(bContent, aTitle, label || undefined);
+
+  // Idempotent short-circuit: if both already present, nothing to do.
+  if (aPatch.alreadyPresent && bPatch.alreadyPresent) {
+    return json({
+      ok: true,
+      a_path: aPath,
+      b_path: bPath,
+      label: label || undefined,
+      a_updated: false,
+      b_updated: false,
+      a_associated_with_hash: hashBody(aPatch.assocBody),
+      b_associated_with_hash: hashBody(bPatch.assocBody),
+    });
+  }
+
+  // Hard-gate: lint each proposed side. If associate_duplicates_hierarchy
+  // or sibling_assoc_redundant fires for the assoc target we just added,
+  // refuse with a structured error.
+  const HARD_CODES = ["associate_duplicates_hierarchy", "sibling_assoc_redundant"] as const;
+  const checkSide = (
+    side: "a" | "b",
+    proposed: string,
+    selfCtx: LintVaultContext,
+    targetTitle: string,
+    targetPath: string,
+  ): { error: "would_duplicate_hierarchy"; side: "a" | "b"; reason: string; existing_edge: { from: string; to: string; kind: string; shared_parent_path?: string }; fix_suggestion: string } | null => {
+    const { warnings } = lintDocContent(proposed, selfCtx);
+    const hit = warnings.find((w) =>
+      HARD_CODES.includes(w.code as typeof HARD_CODES[number]) &&
+      w.title && w.title.toLowerCase() === targetTitle.toLowerCase()
+    );
+    if (!hit) return null;
+    if (hit.code === "associate_duplicates_hierarchy") {
+      // Determine which direction (parent_of / child_of) from the linking doc's perspective.
+      const selfDoc = index.docs.find((d) => d.path === selfCtx.selfPath);
+      const isParent = selfDoc?.children.some((l) => resolveWikiLink(index, l.title, selfCtx.selfPath)?.path === targetPath);
+      const isChild = selfDoc?.parents.some((l) => resolveWikiLink(index, l.title, selfCtx.selfPath)?.path === targetPath);
+      return {
+        error: "would_duplicate_hierarchy",
+        side,
+        reason: "associate_duplicates_hierarchy",
+        existing_edge: {
+          from: selfCtx.selfPath,
+          to: targetPath,
+          kind: isParent ? "parent_of" : isChild ? "child_of" : "hierarchy",
+        },
+        fix_suggestion: hit.suggestion,
+      };
+    }
+    // sibling_assoc_redundant: pull the shared parent from the warning message format.
+    const targetInfo = selfCtx.resolveTarget(targetTitle);
+    const sharedParent = targetInfo?.declaredParents.find((p) => selfCtx.selfDeclaredParents.includes(p));
+    return {
+      error: "would_duplicate_hierarchy",
+      side,
+      reason: "sibling_assoc_redundant",
+      existing_edge: {
+        from: selfCtx.selfPath,
+        to: targetPath,
+        kind: "shared_parent",
+        ...(sharedParent ? { shared_parent_path: sharedParent } : {}),
+      },
+      fix_suggestion: hit.suggestion,
+    };
+  };
+
+  if (!aPatch.alreadyPresent) {
+    const aHardFail = checkSide("a", aPatch.newContent, aCtx, bTitle, bPath);
+    if (aHardFail) return json(aHardFail);
+  }
+  if (!bPatch.alreadyPresent) {
+    const bHardFail = checkSide("b", bPatch.newContent, bCtx, aTitle, aPath);
+    if (bHardFail) return json(bHardFail);
+  }
+
+  // Soft gate: caller-provided codes.
+  if (gateCodes.length > 0) {
+    if (!aPatch.alreadyPresent) {
+      const aGate = evaluateLintGate(aPatch.newContent, gateCodes, aCtx);
+      if (!aGate.ok) return json({ error: "lint_gate_failed", side: "a", fixes: aGate.fixes, original_warnings: aGate.original_warnings });
+    }
+    if (!bPatch.alreadyPresent) {
+      const bGate = evaluateLintGate(bPatch.newContent, gateCodes, bCtx);
+      if (!bGate.ok) return json({ error: "lint_gate_failed", side: "b", fixes: bGate.fixes, original_warnings: bGate.original_warnings });
+    }
+  }
+
+  // Write A then B. Partial failure path documents the asymmetry; retry
+  // is idempotent because each side's existing-bullet check fires on the
+  // re-run.
+  let aWritten = aPatch.alreadyPresent;
+  if (!aPatch.alreadyPresent) {
+    try {
+      await writeVaultFile(ctx, aPath, aPatch.newContent);
+      aWritten = true;
+    } catch (err) {
+      return json({
+        error: "partial_write",
+        a_written: false,
+        b_written: false,
+        message: (err as Error).message,
+      });
+    }
+  }
+
+  let bWritten = bPatch.alreadyPresent;
+  if (!bPatch.alreadyPresent) {
+    try {
+      await writeVaultFile(ctx, bPath, bPatch.newContent);
+      bWritten = true;
+    } catch (err) {
+      return json({
+        error: "partial_write",
+        a_written: aWritten,
+        b_written: false,
+        message: (err as Error).message,
+        retry_hint: "Re-run add_association with the same args; the A-side write is idempotent (already-declared bullets are detected and skipped).",
+      });
+    }
+  }
+
+  return json({
+    ok: true,
+    a_path: aPath,
+    b_path: bPath,
+    label: label || undefined,
+    a_updated: !aPatch.alreadyPresent,
+    b_updated: !bPatch.alreadyPresent,
+    a_associated_with_hash: hashBody(aPatch.assocBody),
+    b_associated_with_hash: hashBody(bPatch.assocBody),
+  });
+}

package/src/lib/mcp/tools/append_doc.ts

@@ -0,0 +1,70 @@
+import { createHash } from "node:crypto";
+import { validatePath, readVaultFile, writeVaultFile, loadVaultIndex } from "./vault";
+import { evaluateLintGate } from "./lint_gate";
+import { buildLintVaultContext } from "./lint_doc";
+import type { ToolContext } from "./types";
+import { validateArgs } from "./validate_args";
+
+const CROSS_DOC_CODES = new Set([
+  "asymmetric_parent_edge",
+  "asymmetric_child_edge",
+  "sibling_assoc_redundant",
+]);
+
+const ARG_SPEC = {
+  allowed: ["path", "body", "gate_on_warnings"],
+  required: ["path", "body"],
+} as const;
+
+function parseGateCodes(raw: unknown): string[] {
+  if (!Array.isArray(raw)) return [];
+  return raw.filter((c): c is string => typeof c === "string");
+}
+
+function json(value: unknown) {
+  return { content: [{ type: "text" as const, text: JSON.stringify(value, null, 2) }] };
+}
+
+function hashBody(body: string): string {
+  return createHash("sha256").update(body, "utf8").digest("hex").slice(0, 16);
+}
+
+/**
+ * Append content to the very end of a doc — after every existing section.
+ *
+ * Separate from `append_section`, which lands inside a named section's body
+ * (which is *mid-doc* whenever that section isn't last). For chronological
+ * note-taking — LOGS entries, daily notes, anywhere new content should land
+ * at the bottom of the page regardless of section structure — this is the
+ * right primitive. The body may include its own `##` headings to introduce
+ * new sections at the end.
+ */
+export async function appendDoc(ctx: ToolContext, args: Record<string, unknown>): Promise<unknown> {
+  const argErr = validateArgs(args, ARG_SPEC);
+  if (argErr) return json(argErr);
+  const rel = String(args.path);
+  validatePath(rel);
+  const body = String(args.body ?? "");
+  if (!body.trim()) throw new Error("body required");
+
+  const content = await readVaultFile(ctx, rel);
+  if (content === null) return json({ error: "doc_not_found", path: rel });
+
+  // Normalise trailing whitespace so the new content starts on its own
+  // paragraph, regardless of whether the existing doc ended cleanly.
+  const trimmed = content.replace(/\s+$/, "");
+  const newContent = trimmed + "\n\n" + body.replace(/\s+$/, "") + "\n";
+
+  const gateCodes = parseGateCodes(args.gate_on_warnings);
+  if (gateCodes.length > 0) {
+    const needsVault = gateCodes.some((c) => CROSS_DOC_CODES.has(c));
+    const vaultCtx = needsVault ? buildLintVaultContext(await loadVaultIndex(ctx), rel) : undefined;
+    const gate = evaluateLintGate(newContent, gateCodes, vaultCtx);
+    if (!gate.ok) {
+      return json({ error: "lint_gate_failed", fixes: gate.fixes, original_warnings: gate.original_warnings });
+    }
+  }
+
+  await writeVaultFile(ctx, rel, newContent);
+  return json({ ok: true, content_hash: hashBody(body.trim()) });
+}