@remnic/core 9.3.689 → 9.3.690

package/dist/{chunk-XU7363OX.js → chunk-Z7KILAOU.js}

@@ -58,10 +58,10 @@ import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact,
   runMemoryGovernance
-} from "./chunk-4N3TFFPH.js";
+} from "./chunk-54PVJDO5.js";
 import {
   namespaceCollectionName
-} from "./chunk-SAEZIIID.js";
+} from "./chunk-LXIEXSHU.js";
 import {
   namespaceIdentityFromToken
 } from "./chunk-ZFXCQPNO.js";
@@ -101,10 +101,13 @@ import {
   buildBriefing,
   parseBriefingFocus,
   parseBriefingWindow
-} from "./chunk-OV4D5T7V.js";
+} from "./chunk-X7RLU5CR.js";
 import {
   parseEntityFile
-} from "./chunk-BLIWOONZ.js";
+} from "./chunk-CUNTLEJP.js";
+import {
+  stripAttributesSuffix
+} from "./chunk-SVOZFLIQ.js";
 import {
   DEFAULT_RECALL_DISCLOSURE,
   isRecallDisclosure
@@ -123,6 +126,9 @@ import {
   normalizeProjectionPreview,
   normalizeProjectionTags
 } from "./chunk-SCU65EZI.js";
+import {
+  createVersion
+} from "./chunk-VF4XKTX3.js";
 import {
   exportCapsule
 } from "./chunk-KQAFEZQX.js";
@@ -149,6 +155,9 @@ import {
   recallNamespacesForPrincipal,
   resolvePrincipal
 } from "./chunk-UZYLX7M6.js";
+import {
+  expandTildePath
+} from "./chunk-EYIEWJNI.js";
 import {
   log
 } from "./chunk-NU3CSQ4H.js";
@@ -609,10 +618,550 @@ function raiseInvalidStatus(value, ctx) {
   );
 }
 
+// src/coding/architecture-card.ts
+import { readFile, readdir, lstat } from "fs/promises";
+import path from "path";
+var ARCHITECTURE_CARD_MAX_BYTES = 4096;
+var ARCHITECTURE_CARD_TRUNCATION_MARKER = "\u2026 card truncated to fit size cap \u2026";
+var ARCHITECTURE_CARD_MAX_SUMMARY_BYTES = 1024;
+var KNOWN_MANIFEST_FILES = [
+  "package.json",
+  "Cargo.toml",
+  "go.mod",
+  "pyproject.toml",
+  "setup.py",
+  "pom.xml",
+  "build.gradle",
+  "build.gradle.kts",
+  "Gemfile",
+  "composer.json",
+  "mix.exs",
+  "deno.json"
+];
+var SCAN_IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".svn",
+  ".hg",
+  "vendor",
+  "__pycache__",
+  ".venv",
+  "venv",
+  "env",
+  "dist",
+  "build",
+  "target",
+  "out",
+  ".next",
+  ".nuxt",
+  "coverage",
+  ".cache",
+  ".turbo",
+  ".idea",
+  ".vscode"
+]);
+var ARCHITECTURE_CARD_SUMMARY_SYSTEM_PROMPT = `You write a concise overview for a repository architecture card.
+Given the deterministic card (languages, manifests, entry points), produce a 3-5 sentence plain-text overview naming the dominant language, the primary entry point, and the project's shape.
+Rules:
+- Never invent facts absent from the input.
+- No headings, no markdown \u2014 just sentences.
+- Keep it under 600 characters.`;
+function createArchitectureCardSummariser(client) {
+  if (!client) return void 0;
+  return async (deterministicCard, repoRoot) => {
+    const response = await client.chatCompletion(
+      [
+        { role: "system", content: ARCHITECTURE_CARD_SUMMARY_SYSTEM_PROMPT },
+        { role: "user", content: `Repository: ${path.basename(repoRoot) || repoRoot}
+
+${deterministicCard}` }
+      ],
+      {
+        temperature: 0.2,
+        maxTokens: 512,
+        operation: "architecture-card-summary",
+        priority: "background"
+      }
+    );
+    return response?.content ?? null;
+  };
+}
+async function buildArchitectureCard(repoRoot, options = {}) {
+  if (typeof repoRoot !== "string" || repoRoot.length === 0) {
+    return { ok: false, code: "invalid_root", detail: "repoRoot must be a non-empty string" };
+  }
+  const absoluteRoot = path.resolve(expandTildePath(repoRoot));
+  try {
+    const rootStat = await lstat(absoluteRoot);
+    if (!rootStat.isDirectory()) {
+      return { ok: false, code: "invalid_root", detail: `not a directory: ${absoluteRoot}` };
+    }
+  } catch (err) {
+    return {
+      ok: false,
+      code: "invalid_root",
+      detail: `repoRoot not accessible: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  try {
+    await readdir(absoluteRoot);
+  } catch (err) {
+    return {
+      ok: false,
+      code: "scan_failed",
+      detail: `repoRoot not readable: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  try {
+    const scan = await scanRepository(absoluteRoot);
+    const deterministic = renderCard(scan, options.now ?? /* @__PURE__ */ new Date());
+    const maxBytes = options.maxBytes ?? ARCHITECTURE_CARD_MAX_BYTES;
+    let content = deterministic;
+    if (options.llmSummary === true && options.summariser) {
+      try {
+        const summary = await options.summariser(deterministic, absoluteRoot);
+        if (typeof summary === "string" && summary.trim().length > 0) {
+          const separator = "\n\n---\n\n";
+          const detBytes = Buffer.byteLength(deterministic, "utf-8");
+          const sepBytes = Buffer.byteLength(separator, "utf-8");
+          const summaryBudget = Math.min(
+            ARCHITECTURE_CARD_MAX_SUMMARY_BYTES,
+            maxBytes - detBytes - sepBytes
+          );
+          if (summaryBudget > 0) {
+            const clampedSummary = clampSummaryToBytes(summary.trim(), summaryBudget);
+            if (clampedSummary.length > 0) {
+              content = `${clampedSummary}${separator}${deterministic}`;
+            }
+          }
+        }
+      } catch (err) {
+        void err;
+      }
+    }
+    const { text: truncatedContent, truncated } = capToBytes(content, maxBytes);
+    return {
+      ok: true,
+      card: {
+        content: truncatedContent,
+        generatedAt: (options.now ?? /* @__PURE__ */ new Date()).toISOString(),
+        byteSize: Buffer.byteLength(truncatedContent, "utf-8"),
+        truncated
+      }
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      code: "scan_failed",
+      detail: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function scanRepository(root) {
+  const topEntries = await readSortedDirEntries(root);
+  const topDirs = topEntries.filter((e) => e.isDirectory && !SCAN_IGNORE_DIRS.has(e.name)).map((e) => e.name);
+  const manifestFiles = topEntries.filter((e) => e.isFile && KNOWN_MANIFEST_FILES.includes(e.name)).map((e) => e.name);
+  const manifests = [];
+  for (const mf of sortStrings(manifestFiles)) {
+    const parsed = await parseManifest(path.join(root, mf));
+    manifests.push({ filename: mf, name: parsed.name, entryPoints: sortStrings(parsed.entryPoints) });
+  }
+  const languageHistogram = await computeLanguageHistogram(root, topEntries);
+  return {
+    root: path.basename(root) || root,
+    topDirs: sortStrings(topDirs),
+    manifests,
+    languageHistogram: sortLanguageHistogram(languageHistogram)
+  };
+}
+async function readSortedDirEntries(dir) {
+  let names;
+  try {
+    names = await readdir(dir);
+  } catch {
+    return [];
+  }
+  const entries = [];
+  for (const name of sortStrings(names)) {
+    try {
+      const s = await lstat(path.join(dir, name));
+      if (s.isSymbolicLink()) continue;
+      entries.push({ name, isDirectory: s.isDirectory(), isFile: s.isFile() });
+    } catch {
+    }
+  }
+  return entries;
+}
+async function computeLanguageHistogram(root, topEntries) {
+  const counts = /* @__PURE__ */ new Map();
+  const dirsToScan = topEntries.filter((e) => e.isDirectory && !SCAN_IGNORE_DIRS.has(e.name)).map((e) => path.join(root, e.name));
+  const rootFiles = topEntries.filter((e) => e.isFile);
+  const visitDir = async (dir, depth) => {
+    if (depth > 2) return;
+    let entries;
+    try {
+      entries = await readSortedDirEntries(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory) {
+        if (!SCAN_IGNORE_DIRS.has(entry.name)) {
+          await visitDir(path.join(dir, entry.name), depth + 1);
+        }
+      } else if (entry.isFile) {
+        const ext = path.extname(entry.name).toLowerCase();
+        if (ext.length > 0) {
+          counts.set(ext, (counts.get(ext) ?? 0) + 1);
+        }
+      }
+    }
+  };
+  for (const f of rootFiles) {
+    const ext = path.extname(f.name).toLowerCase();
+    if (ext.length > 0) counts.set(ext, (counts.get(ext) ?? 0) + 1);
+  }
+  for (const dir of dirsToScan) {
+    await visitDir(dir, 0);
+  }
+  return Array.from(counts.entries()).map(([ext, count]) => ({ ext, count }));
+}
+async function parseManifest(filePath) {
+  const filename = path.basename(filePath);
+  try {
+    const raw = await readFile(filePath, "utf-8");
+    switch (filename) {
+      case "package.json":
+        return parsePackageJson(raw);
+      case "pyproject.toml":
+      case "setup.py":
+        return parsePythonProject(raw, filename);
+      case "go.mod":
+        return parseGoMod(raw);
+      case "Cargo.toml":
+        return parseCargoToml(raw);
+      default:
+        return { name: null, entryPoints: [] };
+    }
+  } catch {
+    return { name: null, entryPoints: [] };
+  }
+}
+function parsePackageJson(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { name: null, entryPoints: [] };
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return { name: null, entryPoints: [] };
+  }
+  const obj = parsed;
+  const name = typeof obj["name"] === "string" ? obj["name"] : null;
+  const entryPoints = [];
+  const bin = obj["bin"];
+  if (typeof bin === "string") {
+    entryPoints.push(bin);
+  } else if (typeof bin === "object" && bin !== null && !Array.isArray(bin)) {
+    for (const [key, value] of Object.entries(bin)) {
+      entryPoints.push(typeof value === "string" ? value : `bin/${key}`);
+    }
+  }
+  const main = typeof obj["main"] === "string" ? obj["main"] : null;
+  if (main) entryPoints.push(main);
+  const module = typeof obj["module"] === "string" ? obj["module"] : null;
+  if (module) entryPoints.push(module);
+  const scripts = obj["scripts"];
+  if (typeof scripts === "object" && scripts !== null && !Array.isArray(scripts)) {
+    const scriptKeys = Object.keys(scripts);
+    for (const key of ["start", "dev", "serve"]) {
+      if (scriptKeys.includes(key)) entryPoints.push(`scripts.${key}`);
+    }
+  }
+  return { name, entryPoints };
+}
+function parsePythonProject(raw, _filename) {
+  const entryPoints = [];
+  let name = null;
+  const nameMatch = raw.match(/^name\s*=\s*["']([^"']+)["']/m);
+  if (nameMatch) name = nameMatch[1] ?? null;
+  const scriptsMatch = raw.match(/\[project\.scripts\]([\s\S]*?)(?:\n\[|$)/);
+  if (scriptsMatch && scriptsMatch[1]) {
+    for (const line of scriptsMatch[1].split("\n")) {
+      const m = line.match(/^([a-zA-Z0-9_-]+)\s*=/);
+      if (m && m[1]) entryPoints.push(`scripts.${m[1]}`);
+    }
+  }
+  return { name, entryPoints };
+}
+function parseGoMod(raw) {
+  const moduleMatch = raw.match(/^module\s+(\S+)/m);
+  const name = moduleMatch && moduleMatch[1] ? moduleMatch[1] : null;
+  return { name, entryPoints: name ? ["main.go"] : [] };
+}
+function parseCargoToml(raw) {
+  const nameMatch = raw.match(/^name\s*=\s*"([^"]+)"/m);
+  const name = nameMatch && nameMatch[1] ? nameMatch[1] : null;
+  const entryPoints = [];
+  if (/\[\[bin\]\]/.test(raw)) entryPoints.push("src/bin/");
+  if (name) entryPoints.push("src/main.rs");
+  return { name, entryPoints };
+}
+function renderCard(scan, now) {
+  const lines = [];
+  lines.push(`# Architecture Card \u2014 ${scan.root}`);
+  lines.push("");
+  lines.push(`_Generated ${now.toISOString()}_`);
+  lines.push("");
+  const namedManifest = scan.manifests.find((m) => m.name !== null);
+  if (namedManifest && namedManifest.name) {
+    lines.push(`**Project:** ${namedManifest.name}`);
+    lines.push("");
+  }
+  if (scan.manifests.length > 0) {
+    lines.push("## Manifests");
+    for (const m of scan.manifests) {
+      const label = m.name ? `${m.filename} (${m.name})` : m.filename;
+      lines.push(`- ${label}`);
+    }
+    lines.push("");
+  }
+  if (scan.topDirs.length > 0) {
+    lines.push("## Top-level directories");
+    const cols = 4;
+    for (let i = 0; i < scan.topDirs.length; i += cols) {
+      const row = scan.topDirs.slice(i, i + cols).join(" \xB7 ");
+      lines.push(`- ${row}`);
+    }
+    lines.push("");
+  }
+  if (scan.languageHistogram.length > 0) {
+    lines.push("## Languages (by file count)");
+    const top = scan.languageHistogram.slice(0, 10);
+    for (const entry of top) {
+      lines.push(`- ${entry.ext}: ${entry.count}`);
+    }
+    lines.push("");
+  }
+  const allEntryPoints = sortStrings(scan.manifests.flatMap((m) => m.entryPoints));
+  if (allEntryPoints.length > 0) {
+    lines.push("## Entry points");
+    for (const ep of allEntryPoints) {
+      lines.push(`- ${ep}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd() + "\n";
+}
+function sortStrings(values) {
+  return [...values].sort((a, b) => a.localeCompare(b));
+}
+function sortLanguageHistogram(entries) {
+  return [...entries].sort((a, b) => {
+    if (b.count !== a.count) return b.count - a.count;
+    return a.ext.localeCompare(b.ext);
+  });
+}
+function capToBytes(text, maxBytes) {
+  const byteLen = Buffer.byteLength(text, "utf-8");
+  if (byteLen <= maxBytes) {
+    return { text, truncated: false };
+  }
+  const marker = `
+
+_${ARCHITECTURE_CARD_TRUNCATION_MARKER}_`;
+  const markerBytes = Buffer.byteLength(marker, "utf-8");
+  const budget = maxBytes - markerBytes;
+  if (budget <= 0) {
+    return { text: marker.trimStart(), truncated: true };
+  }
+  let cut = 0;
+  let running = 0;
+  const chars = [...text];
+  for (let i = 0; i < chars.length; i++) {
+    const charBytes = Buffer.byteLength(chars[i], "utf-8");
+    if (running + charBytes > budget) break;
+    running += charBytes;
+    cut = i + 1;
+  }
+  return { text: chars.slice(0, cut).join("") + marker, truncated: true };
+}
+function clampSummaryToBytes(text, maxBytes) {
+  if (maxBytes <= 0) return "";
+  if (Buffer.byteLength(text, "utf-8") <= maxBytes) return text;
+  const ellipsis = " \u2026";
+  const budget = maxBytes - Buffer.byteLength(ellipsis, "utf-8");
+  if (budget <= 0) return "";
+  let cut = 0;
+  let running = 0;
+  const chars = [...text];
+  for (let i = 0; i < chars.length; i++) {
+    const charBytes = Buffer.byteLength(chars[i], "utf-8");
+    if (running + charBytes > budget) break;
+    running += charBytes;
+    cut = i + 1;
+  }
+  return chars.slice(0, cut).join("") + ellipsis;
+}
+
+// src/coding/architecture-surfaces.ts
+function isArchitectureCardSurfaceEnabled(config, codingContext) {
+  return config.enabled === true && config.architectureCard === true && codingContext !== null && codingContext !== void 0;
+}
+var ARCHITECTURE_CARD_TAG = "architecture-card";
+var ARCHITECTURE_CARD_KIND = "architecture";
+async function handleCodingArchitecture(request, ctx) {
+  const codingContext = request.sessionKey ? ctx.getCodingContext(request.sessionKey) : null;
+  if (codingContext === null || !isArchitectureCardSurfaceEnabled(ctx.codingKnowledge, codingContext)) {
+    ctx.throwInputError(
+      "coding_architecture requires codingKnowledge.enabled, codingKnowledge.architectureCard, and an attached coding context"
+    );
+  }
+  switch (request.subcommand) {
+    case "get":
+      return architectureGet(request, ctx);
+    case "refresh":
+      return architectureRefresh(request, ctx, codingContext);
+  }
+}
+async function architectureGet(request, ctx) {
+  const storage = await ctx.resolveStorage(request);
+  const existing = await findArchitectureCardMemory(storage);
+  if (!existing) {
+    return { subcommand: "get", found: false };
+  }
+  const content = stripAttributesSuffix(existing.content);
+  return {
+    subcommand: "get",
+    found: true,
+    card: {
+      content,
+      generatedAt: existing.frontmatter.updated ?? existing.frontmatter.created,
+      byteSize: Buffer.byteLength(content, "utf-8"),
+      // Derive truncation from the CONTENT marker, not a frontmatter tag —
+      // the refresh update path changes content without rewriting tags, so
+      // a tag-based check goes stale (cursor review: stale truncated tag).
+      truncated: content.includes(ARCHITECTURE_CARD_TRUNCATION_MARKER)
+    }
+  };
+}
+async function architectureRefresh(request, ctx, codingContext) {
+  const repoRoot = codingContext.rootPath ?? codingContext.projectId;
+  const storage = await ctx.resolveStorage(request);
+  const buildResult = await ctx.buildCard(repoRoot);
+  if (!buildResult.ok) {
+    log.warn(
+      `coding_architecture/refresh: card build failed (code=${buildResult.code}): ${buildResult.detail}`
+    );
+    ctx.throwInputError(
+      `coding_architecture refresh failed: card build returned ${buildResult.code}`
+    );
+  }
+  const cardContent = buildResult.card.content;
+  const tags = [ARCHITECTURE_CARD_TAG];
+  if (buildResult.card.truncated) tags.push("truncated");
+  const existing = await findArchitectureCardMemory(storage);
+  if (existing) {
+    await ctx.versioning.snapshotIfExists(existing);
+    const updated = await storage.updateMemory(existing.frontmatter.id, cardContent, {
+      actor: "coding-architecture-refresh"
+    });
+    if (!updated) {
+      log.warn(
+        `coding_architecture/refresh: updateMemory returned false for id=${existing.frontmatter.id} \u2014 falling back to writeMemory`
+      );
+      const memoryId2 = await storage.writeMemory("fact", cardContent, {
+        confidence: 1,
+        tags,
+        source: "coding-architecture",
+        structuredAttributes: { cardKind: ARCHITECTURE_CARD_KIND }
+      });
+      log.info(
+        `access-write op=coding_architecture/refresh memoryId=${memoryId2} (fallback write) byteSize=${buildResult.card.byteSize}`
+      );
+      return {
+        subcommand: "refresh",
+        refreshed: true,
+        memoryId: memoryId2,
+        byteSize: buildResult.card.byteSize,
+        truncated: buildResult.card.truncated
+      };
+    }
+    log.info(
+      `access-write op=coding_architecture/refresh memoryId=${existing.frontmatter.id} (updated) byteSize=${buildResult.card.byteSize}`
+    );
+    return {
+      subcommand: "refresh",
+      refreshed: true,
+      memoryId: existing.frontmatter.id,
+      byteSize: buildResult.card.byteSize,
+      truncated: buildResult.card.truncated
+    };
+  }
+  const memoryId = await storage.writeMemory("fact", cardContent, {
+    confidence: 1,
+    tags,
+    source: "coding-architecture",
+    structuredAttributes: { cardKind: ARCHITECTURE_CARD_KIND }
+  });
+  log.info(
+    `access-write op=coding_architecture/refresh memoryId=${memoryId} (new) byteSize=${buildResult.card.byteSize}`
+  );
+  return {
+    subcommand: "refresh",
+    refreshed: true,
+    memoryId,
+    byteSize: buildResult.card.byteSize,
+    truncated: buildResult.card.truncated
+  };
+}
+async function findArchitectureCardMemory(storage) {
+  const memories = await storage.readAllMemories();
+  const cards = memories.filter((m) => {
+    if (m.frontmatter.category !== "fact") return false;
+    const tags = m.frontmatter.tags ?? [];
+    if (!tags.includes(ARCHITECTURE_CARD_TAG)) return false;
+    if (m.frontmatter.structuredAttributes?.cardKind !== ARCHITECTURE_CARD_KIND) return false;
+    const outer = m.frontmatter.status;
+    if (outer !== void 0 && outer !== "active") return false;
+    if (m.frontmatter.archivedAt !== void 0 && m.frontmatter.archivedAt !== null) return false;
+    return true;
+  });
+  if (cards.length === 0) return null;
+  cards.sort((a, b) => {
+    const aUpdated = a.frontmatter.updated ?? a.frontmatter.created;
+    const bUpdated = b.frontmatter.updated ?? b.frontmatter.created;
+    if (aUpdated !== bUpdated) return bUpdated.localeCompare(aUpdated);
+    return b.frontmatter.id.localeCompare(a.frontmatter.id);
+  });
+  return cards[0] ?? null;
+}
+function createArchitectureVersioningHook(enabled, maxVersionsPerPage, sidecarDir, memoryDir, readFile3, writeVersion) {
+  return {
+    async snapshotIfExists(memory) {
+      if (!enabled) return;
+      try {
+        const fullContent = await readFile3(memory.path);
+        await writeVersion(
+          memory.path,
+          fullContent,
+          "manual",
+          { enabled: true, maxVersionsPerPage, sidecarDir },
+          void 0,
+          "architecture-card-refresh",
+          memoryDir
+        );
+      } catch {
+      }
+    }
+  };
+}
+
 // src/procedural/procedure-miner.ts
 import { createHash } from "crypto";
 import { mkdir, rm, stat } from "fs/promises";
-import path from "path";
+import path2 from "path";
 var PROCEDURE_CLUSTER_ATTR_MAX = 500;
 var PROCEDURE_CLUSTER_LOCK_STALE_MS = 12e4;
 var PROCEDURE_CLUSTER_LOCK_TIMEOUT_MS = 3e4;
@@ -632,8 +1181,8 @@ function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 async function acquireClusterWriteLock(memoryDir, clusterHash) {
-  const lockRoot = path.join(path.resolve(memoryDir), "state", "procedure-miner-locks");
-  const lockDir = path.join(lockRoot, `${clusterHash}.lock`);
+  const lockRoot = path2.join(path2.resolve(memoryDir), "state", "procedure-miner-locks");
+  const lockDir = path2.join(lockRoot, `${clusterHash}.lock`);
   await mkdir(lockRoot, { recursive: true });
   const startedAt = Date.now();
   let attempts = 0;
@@ -664,7 +1213,7 @@ async function acquireClusterWriteLock(memoryDir, clusterHash) {
   }
 }
 async function withClusterWriteLock(memoryDir, clusterHash, fn) {
-  const inProcessKey = `${path.resolve(memoryDir)}:${clusterHash}`;
+  const inProcessKey = `${path2.resolve(memoryDir)}:${clusterHash}`;
   const previous = inProcessClusterWriteLocks.get(inProcessKey) ?? Promise.resolve();
   let releaseInProcess;
   const current = previous.catch(() => void 0).then(
@@ -3255,6 +3804,51 @@ var EngramAccessService = class {
       }
     });
   }
+  /** Whether the coding_architecture tool should appear in tools/list (rule 39). */
+  get architectureCardSurfaceVisible() {
+    return this.orchestrator.config.codingKnowledge?.enabled === true && this.orchestrator.config.codingKnowledge?.architectureCard === true;
+  }
+  /**
+   * Thin delegate — handler logic in coding/architecture-surfaces.ts (#1548 PR3).
+   * All three surfaces (MCP/HTTP/CLI) arrive here via the boundary operation.
+   * Namespace resolution uses the SAME coding-scoped path as decision records.
+   */
+  async codingArchitecture(request, authenticatedPrincipal) {
+    const resolvedConfig = this.orchestrator.config;
+    return handleCodingArchitecture(request, {
+      codingKnowledge: this.orchestrator.config.codingKnowledge,
+      getCodingContext: (sk) => this.orchestrator.getCodingContextForSession(sk),
+      resolveStorage: async (req) => {
+        const isWrite = req.subcommand === "refresh";
+        const ns = isWrite ? await this.resolveCodingScopedWriteNamespace({
+          namespace: req.namespace,
+          sessionKey: req.sessionKey,
+          authenticatedPrincipal
+        }) : await this.resolveCodingScopedReadableNamespace({
+          namespace: req.namespace,
+          sessionKey: req.sessionKey,
+          authenticatedPrincipal
+        });
+        const storage = await this.orchestrator.getStorage(ns);
+        return Object.assign(storage, { namespace: ns });
+      },
+      buildCard: async (repoRoot) => buildArchitectureCard(repoRoot, {
+        llmSummary: this.orchestrator.config.codingKnowledge?.architectureCardLlmSummary === true,
+        summariser: createArchitectureCardSummariser(this.fallbackLlmRef ?? this.localLlmRef)
+      }),
+      versioning: createArchitectureVersioningHook(
+        resolvedConfig.versioningEnabled === true,
+        resolvedConfig.versioningMaxPerPage,
+        resolvedConfig.versioningSidecarDir,
+        resolvedConfig.memoryDir,
+        (p) => nodeFs.readFile(p, "utf-8"),
+        createVersion
+      ),
+      throwInputError: (msg) => {
+        throw new EngramAccessInputError(msg);
+      }
+    });
+  }
   async memoryBrowse(request = {}) {
     const resolvedNamespace = this.resolveReadableNamespace(
       request.namespace,
@@ -6066,4 +6660,4 @@ export {
   shapeMemorySummary,
   EngramAccessService
 };
-//# sourceMappingURL=chunk-XU7363OX.js.map
+//# sourceMappingURL=chunk-Z7KILAOU.js.map