@daniel156161/prism 0.2.92 → 0.2.97

package/node_modules/@earendil-works/pi-coding-agent/dist/core/resource-loader.js

@@ -104,6 +104,21 @@ export function loadProjectContextFiles(options) {
         currentDir = parentDir;
     }
     contextFiles.push(...ancestorContextFiles);
+    // prism: extra context files (e.g. .mex/AGENTS.md) load like AGENTS.md so they appear under "Context".
+    for (const extraContextEntry of (process.env.PRISM_EXTRA_CONTEXT_FILES ?? "").split("\n")) {
+        const extraContextPath = extraContextEntry.trim();
+        if (!extraContextPath || seenPaths.has(extraContextPath))
+            continue;
+        try {
+            if (!statSync(extraContextPath).isFile())
+                continue;
+            contextFiles.push({ path: extraContextPath, content: readFileSync(extraContextPath, "utf-8") });
+            seenPaths.add(extraContextPath);
+        }
+        catch {
+            // Unreadable extra context file: ignore, it is optional by design.
+        }
+    }
     return contextFiles;
 }
 export class DefaultResourceLoader {

package/node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/interactive-mode.js

@@ -484,8 +484,8 @@ export class InteractiveMode {
         }));
         // Convert extension commands to SlashCommand format
         const builtinCommandNames = new Set(slashCommands.map((c) => c.name));
-        const prismInternalCommandExtensions = new Set(["caveman-mode.ts", "clear-session.ts", "eval-command.ts", "git-commit.ts", "plan-command.ts", "prompt-review-command.ts", "self-improve-command.ts", "voice-command.ts", "vote-command.ts", "obsidian-memory.ts", "logseq-memory.ts", "honcho-memory.ts", "research-tools.ts", "ai-memory-system.ts", "rp-memory.ts", "manifest-provider.ts", "ollama-provider.ts", "toolbox.ts", "self-improvement-tools.ts", "context-usage.ts", "prism-status.ts", "toolbar.ts", "pi-mcp-adapter"]);
-        const prismInternalCommandNpmPackages = new Set(["pi-mcp-adapter"]);
+        const prismInternalCommandExtensions = new Set(["caveman-mode.ts", "clear-session.ts", "eval-command.ts", "git-commit.ts", "plan-command.ts", "prompt-review-command.ts", "self-improve-command.ts", "vote-command.ts", "obsidian-memory.ts", "logseq-memory.ts", "research-tools.ts", "ai-memory-system.ts", "rp-memory.ts", "mex-memory.ts", "manifest-provider.ts", "ollama-provider.ts", "toolbox.ts", "self-improvement-tools.ts", "context-usage.ts", "prism-status.ts", "toolbar.ts", "pi-mcp-adapter", "@juicesharp/rpiv-voice", "@juicesharp/rpiv-todo"]);
+        const prismInternalCommandNpmPackages = new Set(["pi-mcp-adapter", "@juicesharp/rpiv-voice", "@juicesharp/rpiv-todo"]);
         const isPrismInternalCommand = (cmd) => (() => { const prismExtensionPath = String(cmd.sourceInfo?.path || "").replaceAll("\\", "/"); const prismExtensionSource = String(cmd.sourceInfo?.source || ""); return prismInternalCommandExtensions.has(path.basename(prismExtensionPath)) || Array.from(prismInternalCommandNpmPackages).some((pkg) => prismExtensionSource === "npm:" + pkg || prismExtensionPath.includes("/node_modules/" + pkg + "/")); })();
         const extensionCommands = this.session.extensionRunner
             .getRegisteredCommands()
@@ -679,7 +679,7 @@ export class InteractiveMode {
         await this.themeController.applyFromSettings();
         // Add header with keybindings from config (unless silenced)
         if (this.options.verbose || !this.settingsManager.getQuietStartup()) {
-            const logo = "▲ \u001b[38;5;196mp\u001b[38;5;202mr\u001b[38;5;226mi\u001b[38;5;46ms\u001b[38;5;51mm\u001b[0m v0.2.92";
+            const logo = "▲ \u001b[38;5;196mp\u001b[38;5;202mr\u001b[38;5;226mi\u001b[38;5;46ms\u001b[38;5;51mm\u001b[0m v0.2.97";
             // Build startup instructions using keybinding hint helpers
             const hint = (keybinding, description) => keyHint(keybinding, description);
             const expandedInstructions = [
@@ -1348,8 +1348,8 @@ export class InteractiveMode {
                 const promptCompactList = formatCompactList(templates.map((template) => `/${template.name}`));
                 addLoadedSection("Prompts", promptCompactList, templateList);
             }
-            const prismInternalExtensions = new Set(["caveman-mode.ts", "clear-session.ts", "eval-command.ts", "git-commit.ts", "plan-command.ts", "prompt-review-command.ts", "self-improve-command.ts", "voice-command.ts", "vote-command.ts", "obsidian-memory.ts", "logseq-memory.ts", "honcho-memory.ts", "research-tools.ts", "ai-memory-system.ts", "rp-memory.ts", "manifest-provider.ts", "ollama-provider.ts", "toolbox.ts", "self-improvement-tools.ts", "context-usage.ts", "prism-status.ts", "toolbar.ts", "pi-mcp-adapter"]);
-            const prismInternalNpmPackages = new Set(["pi-mcp-adapter"]);
+            const prismInternalExtensions = new Set(["caveman-mode.ts", "clear-session.ts", "eval-command.ts", "git-commit.ts", "plan-command.ts", "prompt-review-command.ts", "self-improve-command.ts", "vote-command.ts", "obsidian-memory.ts", "logseq-memory.ts", "research-tools.ts", "ai-memory-system.ts", "rp-memory.ts", "mex-memory.ts", "manifest-provider.ts", "ollama-provider.ts", "toolbox.ts", "self-improvement-tools.ts", "context-usage.ts", "prism-status.ts", "toolbar.ts", "pi-mcp-adapter", "@juicesharp/rpiv-voice", "@juicesharp/rpiv-todo"]);
+            const prismInternalNpmPackages = new Set(["pi-mcp-adapter", "@juicesharp/rpiv-voice", "@juicesharp/rpiv-todo"]);
             extensions = extensions.filter((extension) => !(() => { const prismExtensionPath = String(extension.path || "").replaceAll("\\", "/"); const prismExtensionSource = String(extension.sourceInfo?.source || ""); return prismInternalExtensions.has(path.basename(prismExtensionPath)) || Array.from(prismInternalNpmPackages).some((pkg) => prismExtensionSource === "npm:" + pkg || prismExtensionPath.includes("/node_modules/" + pkg + "/")); })());
             if (extensions.length > 0) {
                 const groups = this.buildScopeGroups(extensions);
@@ -2932,7 +2932,7 @@ export class InteractiveMode {
         });
     }
     getPrismReadOnlyToolNames() {
-        const readOnly = new Set(["read", "grep", "find", "ls", "obsidian_memory_read", "obsidian_memory_search", "obsidian_memory_list", "web_search", "web_fetch"]);
+        const readOnly = new Set(["read", "grep", "find", "ls", "web_search", "web_fetch", "obsidian_memory_read", "obsidian_memory_search", "obsidian_memory_list", "logseq_read", "logseq_search", "logseq_list", "ai_memory_search", "ai_memory_read", "ai_memory_status", "ai_memory_vault_list", "mex_scope", "mex_get", "mex_query", "mex_impact", "rp_state", "rp_search", "toolbox_search", "self_improvement_list", "todo"]);
         return this.session.getActiveToolNames().filter((name) => readOnly.has(name));
     }
     setPrismPlanStatus(enabled) {

package/package.json

@@ -1,7 +1,17 @@
 {
   "name": "@daniel156161/prism",
-  "version": "0.2.92",
+  "version": "0.2.97",
   "description": "Prism-branded wrapper around pi that stores config in ~/.prism",
+  "license": "MIT",
+  "author": "Daniel Dolezal",
+  "keywords": [
+    "prism",
+    "pi",
+    "coding-agent",
+    "cli",
+    "ai",
+    "llm"
+  ],
   "type": "module",
   "engines": {
     "node": ">=25"
@@ -27,8 +37,10 @@
   "dependencies": {
     "@earendil-works/pi-ai": "^0.84.2",
     "@earendil-works/pi-coding-agent": "^0.84.2",
-    "pi-mcp-adapter": "^2.26.0",
-    "typebox": "^1.3.14"
+    "@juicesharp/rpiv-todo": "^2.6.2",
+    "@juicesharp/rpiv-voice": "^2.6.2",
+    "pi-mcp-adapter": "^2.26.1",
+    "typebox": "^1.3.15"
   },
   "bundledDependencies": [
     "@earendil-works/pi-coding-agent"
@@ -42,7 +54,8 @@
     "dist",
     "src/prism-extensions",
     "themes",
-    "README.md"
+    "README.md",
+    "LICENSE"
   ],
   "pi": {
     "extensions": [

package/src/prism-extensions/README.md

@@ -2,7 +2,7 @@
 Prism extension code is grouped by responsibility:
 - `commands/` — slash-command extensions (`/caveman`, `/plan`, `/git-commit`, `/self-improve`, `/eval`, `/vote`, `/prompt-review`, terminal clearing).
 - `core/` — shared config and utility primitives used by multiple extensions.
-- `integrations/` — external integrations and agent tools (Obsidian memory, AI Memory search/read, web research).
+- `integrations/` — external integrations and agent tools (Obsidian memory, AI Memory search/read, web research, mex code graph).
 - `providers/` — optional model/provider adapters (Ollama, Manifest).
 - `tools/` — toolbox registry, hidden built-in toolbox tools, and self-improvement persistence tools.
 - `ui/` — toolbar, status, context usage and tool-call rendering helpers.
@@ -17,3 +17,12 @@ Prism's self-improvement helpers are intentionally human-gated:
 - `/prompt-review <focus>` reviews prompts/behavior patterns and proposes safer candidates without auto-applying them.
 
 See `docs/safe-harness-improvement.md` for the full workflow and safety boundaries.
+
+## mex code graph
+`integrations/mex-memory.ts` only loads when the `mex` CLI (`npm install -g mex-agent`) is installed **and** the current repo has a `.mex/` scaffold (`npx mex-agent setup`). It then exposes `mex_scope`, `mex_get`, `mex_query`, `mex_impact`, `mex_log` plus the `/mex` command. Maintenance commands (`mex_graph_build`, `mex_check`, `mex_timeline`) live in the hidden toolbox.
+
+A missing `.mex/graph.db` is rebuilt automatically via `core/mex-graph-db.ts`: in the background on session start and lazily before the first graph-reading tool call. It requires an existing `.mex/` scaffold; without one nothing is built. Builds are deduplicated per scaffold and failures degrade to mex's own `GRAPH_UNAVAILABLE` handling.
+
+The `🕸 mex` toolbar segment only appears when mex actually works, i.e. scaffold **and** a non-empty `graph.db`. While a build runs it shows `🕸 mex ⟳`; disabled, scaffold-less or failed states show nothing.
+
+Env switches: `PRISM_DISABLE_MEX=1` (off), `PRISM_MEX_FORCE=1` (load without scaffold), `PRISM_MEX_BIN` (custom binary), `PRISM_MEX_TELEMETRY=1` (allow mex telemetry; off by default), `PRISM_DISABLE_MEX_AUTO_GRAPH=1` (never auto-build `graph.db`).

package/src/prism-extensions/core/mex-anchor.ts

@@ -0,0 +1,29 @@
+import * as fs from "node:fs"
+import * as path from "node:path"
+import { isMexAvailable, mexScaffoldDir } from "./mex-cli.js"
+
+/** Anchor file every mex scaffold exposes as its always-loaded entry point. */
+export const MEX_ANCHOR_FILE = "AGENTS.md"
+
+export function mexAnchorPath(cwd: string = process.cwd()): string {
+  return path.join(mexScaffoldDir(cwd), MEX_ANCHOR_FILE)
+}
+
+export function isMexAnchorEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
+  return env.PRISM_DISABLE_MEX_ANCHOR !== "1"
+}
+
+/**
+ * Absolute path of `.mex/AGENTS.md` when it should be loaded as a pi context file,
+ * i.e. the mex CLI plus scaffold are available and the anchor is not disabled.
+ */
+export function mexAnchorContextFile(cwd: string = process.cwd(), env: NodeJS.ProcessEnv = process.env): string | undefined {
+  if (!isMexAnchorEnabled(env)) return undefined
+  if (!isMexAvailable(env, cwd)) return undefined
+  const anchor = mexAnchorPath(cwd)
+  try {
+    return fs.statSync(anchor).isFile() ? anchor : undefined
+  } catch {
+    return undefined
+  }
+}

package/src/prism-extensions/core/mex-cli.ts

@@ -0,0 +1,217 @@
+import { execFile, spawnSync } from "node:child_process"
+import * as fs from "node:fs"
+import * as path from "node:path"
+import { promisify } from "node:util"
+
+const execFileAsync = promisify(execFile)
+
+export type MexExecRunner = typeof execFileAsync
+export type MexDetail = "minimal" | "standard" | "source"
+export type MexRelation = "who-calls" | "what-calls" | "where-defined"
+export type MexLogType = "decision" | "note" | "risk" | "todo"
+
+export const MEX_DETAIL_LEVELS: MexDetail[] = ["minimal", "standard", "source"]
+export const MEX_RELATIONS: MexRelation[] = ["who-calls", "what-calls", "where-defined"]
+export const MEX_LOG_TYPES: MexLogType[] = ["decision", "note", "risk", "todo"]
+
+export const MEX_SCAFFOLD_DIR = ".mex"
+export const DEFAULT_MEX_TIMEOUT_MS = 60_000
+
+function nonEmptyString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined
+}
+
+export function mexBinary(env: NodeJS.ProcessEnv = process.env): string {
+  return nonEmptyString(env.PRISM_MEX_BIN) ?? "mex"
+}
+
+/** mex telemetry is opt-out; Prism keeps it off unless explicitly enabled. */
+export function mexEnv(env: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv {
+  if (env.PRISM_MEX_TELEMETRY === "1") return { ...env }
+  return { ...env, DO_NOT_TRACK: "1", MEX_TELEMETRY: "0" }
+}
+
+export function isMexCliInstalled(env: NodeJS.ProcessEnv = process.env, runSync: typeof spawnSync = spawnSync): boolean {
+  if (env.PRISM_DISABLE_MEX === "1") return false
+  const result = runSync(mexBinary(env), ["--version"], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"], env: mexEnv(env), timeout: 5_000 })
+  return result.status === 0 && !!result.stdout?.trim()
+}
+
+export function mexScaffoldDir(cwd: string = process.cwd()): string {
+  return path.join(cwd, MEX_SCAFFOLD_DIR)
+}
+
+export function hasMexScaffold(cwd: string = process.cwd()): boolean {
+  // We treat a `.mex/` directory as a usable scaffold only when it contains
+  // the always-loaded anchor and router instruction files.
+  // This prevents accidentally counting a merely existing home/global `.mex/`
+  // directory that may not actually be a functional scaffold.
+  const dir = mexScaffoldDir(cwd)
+  const agentsFile = path.join(dir, "AGENTS.md")
+  const routerFile = path.join(dir, "ROUTER.md")
+  try {
+    return fs.statSync(dir).isDirectory() && fs.statSync(agentsFile).isFile() && fs.statSync(routerFile).isFile()
+  } catch {
+    return false
+  }
+}
+
+/** Tools only make sense when the CLI exists and the repo is scaffolded (or forced). */
+export function isMexAvailable(env: NodeJS.ProcessEnv = process.env, cwd: string = process.cwd(), runSync: typeof spawnSync = spawnSync): boolean {
+  if (env.PRISM_DISABLE_MEX === "1") return false
+  if (!hasMexScaffold(cwd) && env.PRISM_MEX_FORCE !== "1") return false
+  return isMexCliInstalled(env, runSync)
+}
+
+// --- argument builders (pure, easy to test) --------------------------------
+
+export type MexRetrievalOptions = {
+  detail?: unknown
+  maxNodes?: unknown
+  maxOutputTokens?: unknown
+  maxSourceLines?: unknown
+}
+
+function requiredText(value: unknown, name: string): string {
+  const text = String(value ?? "").trim()
+  if (!text) throw new Error(`${name} is required`)
+  return text
+}
+
+function positiveIntFlag(flag: string, value: unknown): string[] {
+  if (value === undefined || value === null || value === "") return []
+  const parsed = Math.trunc(Number(value))
+  if (!Number.isFinite(parsed) || parsed < 1) throw new Error(`${flag} must be a positive number`)
+  return [flag, String(parsed)]
+}
+
+export function mexDetail(value: unknown, fallback: MexDetail = "minimal"): MexDetail {
+  const detail = String(value ?? fallback).toLowerCase()
+  if (!MEX_DETAIL_LEVELS.includes(detail as MexDetail)) throw new Error(`detail must be one of ${MEX_DETAIL_LEVELS.join(", ")}`)
+  return detail as MexDetail
+}
+
+function retrievalFlags(options: MexRetrievalOptions, fallbackDetail: MexDetail): string[] {
+  return [
+    "--detail",
+    mexDetail(options.detail, fallbackDetail),
+    ...positiveIntFlag("--max-nodes", options.maxNodes),
+    ...positiveIntFlag("--max-output-tokens", options.maxOutputTokens),
+    ...positiveIntFlag("--max-source-lines", options.maxSourceLines),
+  ]
+}
+
+export function buildScopeArgs(task: unknown, options: MexRetrievalOptions & { fingerprint?: unknown } = {}): string[] {
+  return [
+    "graph",
+    "scope",
+    ...retrievalFlags(options, "minimal"),
+    ...(options.fingerprint ? ["--fingerprint"] : []),
+    "--",
+    requiredText(task, "task"),
+  ]
+}
+
+export function buildGetArgs(ids: unknown, options: Pick<MexRetrievalOptions, "maxOutputTokens" | "maxSourceLines"> = {}): string[] {
+  const list = (Array.isArray(ids) ? ids : [ids]).map((id) => String(id ?? "").trim()).filter(Boolean)
+  if (list.length === 0) throw new Error("ids is required")
+  return [
+    "graph",
+    "get",
+    ...positiveIntFlag("--max-source-lines", options.maxSourceLines),
+    ...positiveIntFlag("--max-output-tokens", options.maxOutputTokens),
+    "--",
+    ...list,
+  ]
+}
+
+export function buildQueryArgs(relation: unknown, target: unknown, options: MexRetrievalOptions = {}): string[] {
+  const value = String(relation ?? "").toLowerCase().trim()
+  if (!MEX_RELATIONS.includes(value as MexRelation)) throw new Error(`relation must be one of ${MEX_RELATIONS.join(", ")}`)
+  return ["graph", "query", ...retrievalFlags(options, "minimal"), "--", value, requiredText(target, "target")]
+}
+
+export function buildImpactArgs(target: unknown, options: MexRetrievalOptions & { depth?: unknown } = {}): string[] {
+  return [
+    "impact",
+    "--detail",
+    mexDetail(options.detail, "minimal"),
+    ...positiveIntFlag("--depth", options.depth),
+    ...positiveIntFlag("--max-nodes", options.maxNodes),
+    ...positiveIntFlag("--max-output-tokens", options.maxOutputTokens),
+    ...positiveIntFlag("--max-source-lines", options.maxSourceLines),
+    "--",
+    requiredText(target, "target"),
+  ]
+}
+
+export function buildGraphArgs(options: { json?: unknown; root?: unknown } = {}): string[] {
+  const root = nonEmptyString(options.root)
+  return ["graph", ...(options.json ? ["--json"] : []), ...(root ? ["--root", root] : [])]
+}
+
+export function buildCheckArgs(options: { json?: unknown; quiet?: unknown } = {}): string[] {
+  return ["check", ...(options.json ? ["--json"] : []), ...(options.quiet ? ["--quiet"] : [])]
+}
+
+export function buildTimelineArgs(options: { json?: unknown; since?: unknown; type?: unknown; limit?: unknown } = {}): string[] {
+  const since = nonEmptyString(options.since)
+  const type = nonEmptyString(options.type)?.toLowerCase()
+  if (type && !MEX_LOG_TYPES.includes(type as MexLogType)) throw new Error(`type must be one of ${MEX_LOG_TYPES.join(", ")}`)
+  return [
+    "timeline",
+    ...(options.json ? ["--json"] : []),
+    ...(since ? ["--since", since] : []),
+    ...(type ? ["--type", type] : []),
+    ...positiveIntFlag("--limit", options.limit),
+  ]
+}
+
+export function buildLogArgs(message: unknown, options: { type?: unknown; files?: unknown; source?: unknown; status?: unknown } = {}): string[] {
+  const type = String(options.type ?? "note").toLowerCase()
+  if (!MEX_LOG_TYPES.includes(type as MexLogType)) throw new Error(`type must be one of ${MEX_LOG_TYPES.join(", ")}`)
+  const files = (Array.isArray(options.files) ? options.files : options.files ? [options.files] : []).map((file) => String(file ?? "").trim()).filter(Boolean)
+  const source = nonEmptyString(options.source) ?? "prism-agent"
+  const status = nonEmptyString(options.status)
+  return [
+    "log",
+    "--type",
+    type,
+    ...files.flatMap((file) => ["--file", file]),
+    "--source",
+    source,
+    ...(status ? ["--status", status] : []),
+    "--",
+    requiredText(message, "message"),
+  ]
+}
+
+// --- execution -------------------------------------------------------------
+
+export type MexRunResult = { ok: boolean; exitCode: number; output: string }
+
+export type MexRunOptions = {
+  cwd?: string
+  env?: NodeJS.ProcessEnv
+  timeoutMs?: number
+  maxBuffer?: number
+  runner?: MexExecRunner
+}
+
+export async function runMex(args: string[], options: MexRunOptions = {}): Promise<MexRunResult> {
+  const env = options.env ?? process.env
+  const runner = options.runner ?? execFileAsync
+  try {
+    const { stdout, stderr } = await runner(mexBinary(env), args, {
+      cwd: options.cwd ?? process.cwd(),
+      env: mexEnv(env),
+      timeout: options.timeoutMs ?? DEFAULT_MEX_TIMEOUT_MS,
+      maxBuffer: options.maxBuffer ?? 32 * 1024 * 1024,
+    })
+    const output = [String(stdout ?? ""), String(stderr ?? "")].join("\n").trim()
+    return { ok: true, exitCode: 0, output }
+  } catch (error: any) {
+    const output = [String(error?.stdout ?? ""), String(error?.stderr ?? ""), error?.message ? `ERROR: ${error.message}` : ""].filter((part) => part.trim()).join("\n").trim()
+    return { ok: false, exitCode: Number.isFinite(error?.code) ? Number(error.code) : 1, output: output || `ERROR: mex ${args[0] ?? ""} failed` }
+  }
+}

package/src/prism-extensions/core/mex-graph-db.ts

@@ -0,0 +1,76 @@
+import * as fs from "node:fs"
+import * as path from "node:path"
+import { buildGraphArgs, hasMexScaffold, mexScaffoldDir, runMex, type MexRunOptions } from "./mex-cli.js"
+
+/** SQLite code graph mex builds into the scaffold. */
+export const MEX_GRAPH_DB_FILE = "graph.db"
+export const DEFAULT_MEX_GRAPH_BUILD_TIMEOUT_MS = 300_000
+
+/** Actions that read the code graph and therefore need `.mex/graph.db`. */
+export const MEX_GRAPH_ACTIONS = ["scope", "get", "query", "impact"] as const
+
+export type MexGraphEnsureStatus = "present" | "built" | "failed" | "disabled" | "no-scaffold"
+export type MexGraphEnsureResult = { status: MexGraphEnsureStatus; path: string; output?: string }
+export type MexGraphEnsureOptions = MexRunOptions & { force?: boolean }
+
+export function mexGraphDbPath(cwd: string = process.cwd()): string {
+  return path.join(mexScaffoldDir(cwd), MEX_GRAPH_DB_FILE)
+}
+
+export function hasMexGraphDb(cwd: string = process.cwd()): boolean {
+  try {
+    const stats = fs.statSync(mexGraphDbPath(cwd))
+    return stats.isFile() && stats.size > 0
+  } catch {
+    return false
+  }
+}
+
+export function isMexAutoGraphEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
+  return env.PRISM_DISABLE_MEX_AUTO_GRAPH !== "1"
+}
+
+export function needsMexGraphAction(action: string): boolean {
+  return (MEX_GRAPH_ACTIONS as readonly string[]).includes(action)
+}
+
+/** One build per scaffold at a time, so a session start and a tool call never race. */
+const inflightBuilds = new Map<string, Promise<MexGraphEnsureResult>>()
+
+/**
+ * Builds `.mex/graph.db` when it is missing (or when `force` is set).
+ * Never throws: mex degrades gracefully with GRAPH_UNAVAILABLE if the build fails.
+ */
+export async function ensureMexGraphDb(options: MexGraphEnsureOptions = {}): Promise<MexGraphEnsureResult> {
+  const cwd = options.cwd ?? process.cwd()
+  const env = options.env ?? process.env
+  const dbPath = mexGraphDbPath(cwd)
+  if (!isMexAutoGraphEnabled(env)) return { status: "disabled", path: dbPath }
+  if (!hasMexScaffold(cwd)) return { status: "no-scaffold", path: dbPath }
+  if (!options.force && hasMexGraphDb(cwd)) return { status: "present", path: dbPath }
+
+  const pending = inflightBuilds.get(dbPath)
+  if (pending) return pending
+  const build = buildMexGraphDb(cwd, dbPath, options).finally(() => inflightBuilds.delete(dbPath))
+  inflightBuilds.set(dbPath, build)
+  return build
+}
+
+async function buildMexGraphDb(cwd: string, dbPath: string, options: MexGraphEnsureOptions): Promise<MexGraphEnsureResult> {
+  const result = await runMex(buildGraphArgs({}), {
+    cwd,
+    env: options.env,
+    runner: options.runner,
+    maxBuffer: options.maxBuffer,
+    timeoutMs: options.timeoutMs ?? DEFAULT_MEX_GRAPH_BUILD_TIMEOUT_MS,
+  })
+  const built = result.ok && hasMexGraphDb(cwd)
+  return { status: built ? "built" : "failed", path: dbPath, output: result.output || undefined }
+}
+
+/** Short user-facing line for a build attempt, or undefined when nothing happened. */
+export function describeMexGraphEnsure(result: MexGraphEnsureResult): string | undefined {
+  if (result.status === "built") return `mex code graph built: ${result.path}`
+  if (result.status === "failed") return [`mex code graph build failed: ${result.path}`, result.output].filter(Boolean).join("\n")
+  return undefined
+}

package/src/prism-extensions/integrations/ai-memory-system.ts

@@ -276,8 +276,14 @@ export function formatAiMemoryToolCall(toolName: string, args: any, theme: Theme
  * ignores the per-turn query so a broken API does not warn on every prompt.
  */
 function reportBackgroundFailure(ctx: any, label: string, error: unknown): void {
-  const message = `AI Memory ${label} failed: ${error instanceof Error ? error.message : String(error)}`
-  const key = `${label}|${message.split(" | query=")[0]}`
+  const rawErrorMessage = error instanceof Error ? error.message : String(error)
+  // Background injection warnings should not be cluttered with the full
+  // query payload (often long JSON/string). Keep the code message still
+  // useful while making it readable.
+  const errorMessageForUser = rawErrorMessage.replace(/\s\|\squery=.*?(?=\s\|\sfilters=|$)/, "")
+
+  const message = `AI Memory ${label} failed: ${errorMessageForUser}`
+  const key = `${label}|${rawErrorMessage.split(" | query=")[0]}`
   if (reportedBackgroundFailures.has(key)) return
   reportedBackgroundFailures.add(key)
   ctx?.ui?.notify?.(message, "warning")
@@ -632,18 +638,33 @@ export default function aiMemorySystemExtension(pi: ExtensionAPI): void {
   pi.on?.("before_agent_start", async (event: any, ctx: any) => {
     const patch: { systemPrompt?: string; message?: any } = {}
 
+    // Background injection may fail when the local AI Memory HTTP daemon is
+    // down. We try every turn, but we only emit a single warning per turn to
+    // avoid spamming (and we also hide the full query payload).
+    let warnedThisTurn = false
+    const reportOnceThisTurn = (label: string, error: unknown) => {
+      if (warnedThisTurn) return
+      warnedThisTurn = true
+      reportBackgroundFailure(ctx, label, error)
+    }
+
     // Always-loaded durable context (mapped from 00 Kontext) is injected as a
     // system-prompt chunk so it remains in the cached prefix. It is opt-in so a
     // missing local AI Memory daemon does not produce startup/per-turn warnings.
     if (shouldInjectAiMemoryAlwaysContext()) {
       try {
-        const alwaysBlock = buildAlwaysContextMessage(await loadAlwaysContext())?.content?.trim()
+        // If the daemon is reachable again, allow warnings to re-appear on the
+        // next failure (clear the dedupe set on successful injection).
+        const alwaysContent = await loadAlwaysContext()
+        reportedBackgroundFailures.clear()
+
+        const alwaysBlock = buildAlwaysContextMessage(alwaysContent)?.content?.trim()
         if (alwaysBlock) {
           const prev = String(event?.systemPrompt ?? "")
           patch.systemPrompt = `${prev}${prev ? "\n\n" : ""}${alwaysBlock}`
         }
       } catch (error) {
-        reportBackgroundFailure(ctx, "always-context injection", error)
+        reportOnceThisTurn("always-context injection", error)
       }
     }
 
@@ -651,10 +672,13 @@ export default function aiMemorySystemExtension(pi: ExtensionAPI): void {
     const query = String(event?.prompt ?? "").trim()
     if (shouldInjectAiMemoryCandidates() && query) {
       try {
-        const message = buildAiMemoryContextMessage(await loadAiMemoryInjectResults(query))
+        const injectResults = await loadAiMemoryInjectResults(query)
+        reportedBackgroundFailures.clear()
+
+        const message = buildAiMemoryContextMessage(injectResults)
         if (message) patch.message = message
       } catch (error) {
-        reportBackgroundFailure(ctx, "candidate injection", error)
+        reportOnceThisTurn("candidate injection", error)
       }
     }