memory-journal-mcp 8.0.1 → 9.1.0

package/dist/worker-script.js

@@ -1,415 +1,3010 @@
+import { METHOD_ALIASES, VERSION, applyArgInterceptions } from './chunk-SGJU2DHU.js';
+import { SIGNIFICANCE_TYPES, ENTRY_TYPES } from './chunk-D2FY6XS5.js';
 import { parentPort } from 'worker_threads';
-import * as vm from 'vm';
-
-// src/codemode/worker-script.ts
+import * as vm2 from 'vm';
 
 // src/codemode/auto-return.ts
 var NON_RETURNABLE = /^\s*(return|throw|const |let |var |if\b|else\b|for\b|while\b|do\b|switch\b|try\b|catch\b|finally\b|class |function |\/\/|\/\*|\{|\})/;
 function transformAutoReturn(code) {
-  const trimmed = code.trimEnd();
+  let trimmed = code.trimEnd();
   if (!trimmed) return code;
+  while (trimmed.endsWith(";")) {
+    trimmed = trimmed.slice(0, -1).trimEnd();
+  }
+  let inString = null;
+  let isEscaped = false;
+  let lastBoundary = -1;
   let depth = 0;
-  let splitIndex = -1;
-  for (let i = trimmed.length - 1; i >= 0; i--) {
-    const ch = trimmed.charAt(i);
-    if (ch === "}" || ch === "]" || ch === ")") depth++;
-    else if (ch === "{" || ch === "[" || ch === "(") depth--;
-    if (depth === 0 && (ch === ";" || ch === "\n")) {
-      splitIndex = i;
-      break;
+  for (let i = 0; i < trimmed.length; i++) {
+    const ch = trimmed[i];
+    if (inString) {
+      if (ch === "\\") {
+        isEscaped = !isEscaped;
+      } else {
+        if (ch === inString && !isEscaped) {
+          inString = null;
+        }
+        isEscaped = false;
+      }
+    } else {
+      if (ch === "'" || ch === '"' || ch === "`") {
+        inString = ch;
+      } else if (ch === "{" || ch === "[" || ch === "(") {
+        depth++;
+      } else if (ch === "}" || ch === "]" || ch === ")") {
+        depth--;
+      } else if (depth === 0 && (ch === ";" || ch === "\n")) {
+        lastBoundary = i;
+      }
     }
   }
-  const lastStmt = (splitIndex >= 0 ? trimmed.slice(splitIndex + 1) : trimmed).trim();
+  const lastStmt = (lastBoundary >= 0 ? trimmed.slice(lastBoundary + 1) : trimmed).trim();
   if (!lastStmt) return code;
   if (NON_RETURNABLE.test(lastStmt)) return code;
-  if (splitIndex >= 0) {
-    const before = trimmed.slice(0, splitIndex + 1);
+  if (lastBoundary >= 0) {
+    const before = trimmed.slice(0, lastBoundary + 1);
     return `${before}
 return ${lastStmt}`;
   }
   return `return ${trimmed}`;
 }
 
-// src/codemode/worker-script.ts
-var rpcPort = null;
-var rpcIdCounter = 0;
-var pendingRpcRequests = /* @__PURE__ */ new Map();
-function rpcCall(group, method, args) {
-  return new Promise((resolve, reject) => {
-    if (!rpcPort) {
-      reject(new Error("RPC port not initialized"));
-      return;
-    }
-    const id = ++rpcIdCounter;
-    pendingRpcRequests.set(id, { resolve, reject });
-    const request = { id, group, method, args };
-    rpcPort.postMessage(request);
-  });
+// src/codemode/worker-result-proxy.ts
+var RESULT_COLLECTION_KEYS = [
+  "entries",
+  "results",
+  "projects",
+  "items",
+  "rows",
+  "tables",
+  "flags",
+  "groups",
+  "users",
+  "capabilities",
+  "metrics",
+  "events",
+  "records",
+  "logs",
+  "aliases",
+  "tags",
+  "issues",
+  "pullRequests",
+  "milestones",
+  "columns",
+  "comments",
+  "files",
+  "errors",
+  "backups",
+  "deleted",
+  "updated",
+  "notFound",
+  "history",
+  "relationships",
+  "members",
+  "data"
+];
+var ITERATOR_COLLECTION_KEYS = [
+  "entries",
+  "results",
+  "projects",
+  "items",
+  "issues",
+  "pullRequests",
+  "milestones",
+  "columns",
+  "comments",
+  "files",
+  "errors",
+  "backups",
+  "deleted",
+  "updated",
+  "notFound",
+  "history",
+  "relationships",
+  "members"
+];
+var FAILED_ARRAY_METHODS = [
+  "find",
+  "map",
+  "filter",
+  "reduce",
+  "reduceRight",
+  "forEach",
+  "some",
+  "every",
+  "flatMap",
+  "includes",
+  "indexOf",
+  "findIndex",
+  "findLast",
+  "findLastIndex",
+  "join",
+  "at",
+  "concat",
+  "flat",
+  "with",
+  "slice"
+];
+var SUCCESS_ARRAY_METHODS = [
+  ...FAILED_ARRAY_METHODS,
+  "keys",
+  "values",
+  "entries"
+];
+var MUTATOR_ARRAY_METHODS = [
+  "push",
+  "pop",
+  "shift",
+  "unshift",
+  "splice",
+  "sort",
+  "reverse",
+  "copyWithin",
+  "fill"
+];
+var ARRAY_SELF_ALIASES = [
+  "projects",
+  "entries",
+  "results",
+  "items",
+  "data",
+  "rows",
+  "relationships",
+  "members",
+  "tags",
+  "history",
+  "records"
+];
+var RESULT_LIST_ALIASES = [
+  "data",
+  "items",
+  "entries",
+  "results",
+  "rows",
+  "dataArray",
+  "projects",
+  "list",
+  "records"
+];
+var isObject = (val) => typeof val === "object" && val !== null && !Array.isArray(val);
+var hasNumberId = (val) => isObject(val) && typeof val["id"] === "number";
+var isDictLike = (obj) => {
+  const keys = Object.keys(obj).filter((k) => typeof k === "string" && !k.startsWith("_"));
+  return keys.length > 0 && !keys.includes("error") && !keys.includes("success");
+};
+var dictToItems = (obj) => Object.entries(obj).filter(([k]) => typeof k === "string" && !k.startsWith("_")).map(([key, item]) => {
+  if (isObject(item)) {
+    const name = typeof item["name"] === "string" && item["name"].length > 0 ? item["name"] : key;
+    const desc = typeof item["description"] === "string" ? item["description"] : "";
+    const projNum = item["project_number"] ?? item["id"] ?? item["projectNumber"];
+    return { ...item, name, description: desc, project_number: projNum, projectNumber: projNum };
+  }
+  return { name: key, description: "", value: item };
+});
+function findPrimaryArrayKey(targetRecord, keysToCheck = RESULT_COLLECTION_KEYS) {
+  const arrayKeys = Object.keys(targetRecord).filter((k) => Array.isArray(targetRecord[k]));
+  const matched = arrayKeys.find((k) => keysToCheck.includes(k));
+  if (matched !== void 0) return matched;
+  return arrayKeys.length === 1 ? arrayKeys[0] : void 0;
+}
+function bindArrayMethod(arr, prop) {
+  const method = Reflect.get(arr, prop);
+  if (typeof method === "function") {
+    return (...args) => method.apply(arr, args);
+  }
+  return void 0;
 }
 function wrapResult(result) {
-  if (result !== null && result !== void 0 && typeof result === "object" && "success" in result && result["success"] === false) {
-    const failedResult = result;
-    return new Proxy(failedResult, {
+  if (result === null || result === void 0 || typeof result !== "object") {
+    return result;
+  }
+  if ("success" in result && Reflect.get(result, "success") === false) {
+    return new Proxy(result, {
+      ownKeys: (target) => Reflect.ownKeys(target),
+      getOwnPropertyDescriptor: (target, prop) => Reflect.getOwnPropertyDescriptor(target, prop),
       get(target, prop) {
-        if (prop in target) return target[prop];
-        if (typeof prop === "string" && prop !== "then" && prop !== "catch" && prop !== "finally" && prop !== "constructor" && prop !== "prototype" && prop !== "toJSON") {
-          const errVal = target["error"];
-          const errorMsg = typeof errVal === "string" ? errVal : "Unknown error";
-          throw new Error(
-            `Attempted to access missing property '${prop}' on a failed operation. API Error: ${errorMsg}`
-          );
+        const errVal = Reflect.get(target, "error");
+        const codeVal = Reflect.get(target, "code");
+        if (prop === "error" && typeof errVal === "string" && typeof codeVal === "string") {
+          return `[${codeVal}] ${errVal}`;
+        }
+        if (prop in target) return Reflect.get(target, prop);
+        if (prop === "length") return 0;
+        if (typeof prop === "string" && /^\d+$/.test(prop)) return void 0;
+        if (prop === Symbol.iterator) return function* () {
+          yield* [];
+        };
+        if (typeof prop === "string" && RESULT_COLLECTION_KEYS.includes(prop)) return [];
+        if (typeof prop === "string" && FAILED_ARRAY_METHODS.includes(prop)) return () => [];
+        return void 0;
+      }
+    });
+  }
+  if (Array.isArray(result)) {
+    const arr = result;
+    return new Proxy(arr, {
+      ownKeys: (target) => Reflect.ownKeys(target),
+      getOwnPropertyDescriptor: (target, prop) => Reflect.getOwnPropertyDescriptor(target, prop),
+      get(target, prop, receiver) {
+        if (prop in target) {
+          const val = Reflect.get(target, prop, receiver);
+          return typeof val === "function" ? val.bind(target) : val;
         }
+        if (prop === "success") return true;
+        if (typeof prop === "string" && ARRAY_SELF_ALIASES.includes(prop)) return receiver;
         return void 0;
       }
     });
   }
-  return result;
+  return new Proxy(result, {
+    ownKeys: (target) => Reflect.ownKeys(target),
+    getOwnPropertyDescriptor: (target, prop) => Reflect.getOwnPropertyDescriptor(target, prop),
+    get(target, prop, receiver) {
+      if (prop in target) {
+        const val = Reflect.get(target, prop);
+        return val !== null && typeof val === "object" && !Array.isArray(val) ? wrapResult(val) : val;
+      }
+      if (!isObject(target)) return void 0;
+      const targetRecord = target;
+      if (prop === "hasMore") {
+        if ("next_cursor" in targetRecord && targetRecord["next_cursor"] !== null && targetRecord["next_cursor"] !== void 0 && targetRecord["next_cursor"] !== "") {
+          return true;
+        }
+        if ("entries" in targetRecord || "results" in targetRecord || "items" in targetRecord) {
+          return false;
+        }
+      }
+      if ((prop === "statistics" || prop === "stats") && !("statistics" in targetRecord) && !("stats" in targetRecord) && ("totalEntries" in targetRecord || "entriesByType" in targetRecord)) {
+        return receiver;
+      }
+      if (prop === "total" || prop === "totalCount" || prop === "total_entries" || prop === "totalEntries") {
+        if ("count" in targetRecord && typeof targetRecord["count"] === "number") return targetRecord["count"];
+        if ("totalEntries" in targetRecord && typeof targetRecord["totalEntries"] === "number") {
+          return targetRecord["totalEntries"];
+        }
+        if ("total" in targetRecord && typeof targetRecord["total"] === "number") return targetRecord["total"];
+        const targetKey = findPrimaryArrayKey(targetRecord, [
+          "entries",
+          "results",
+          "projects",
+          "items",
+          "rows",
+          "records"
+        ]);
+        if (targetKey !== void 0 && Array.isArray(targetRecord[targetKey])) {
+          return targetRecord[targetKey].length;
+        }
+      }
+      const entryObj = targetRecord["entry"];
+      if ((prop === "id" || prop === "entryId") && isObject(entryObj) && "id" in entryObj) {
+        return entryObj["id"];
+      }
+      const projObj = targetRecord["project"];
+      if (isObject(projObj)) {
+        if (prop === "project_number" && ("project_number" in projObj || "id" in projObj)) {
+          return projObj["project_number"] ?? projObj["id"];
+        }
+        if ((prop === "name" || prop === "project_name") && "name" in projObj) return projObj["name"];
+        if (typeof prop === "string" && prop in projObj) return projObj[prop];
+      }
+      if (prop === "entryIds" && "entries" in targetRecord && Array.isArray(targetRecord["entries"])) {
+        return targetRecord["entries"].filter(hasNumberId).map((e) => e.id);
+      }
+      if (prop === "entryIds" && "updated" in targetRecord && Array.isArray(targetRecord["updated"])) {
+        return targetRecord["updated"].filter(hasNumberId).map((e) => e.id);
+      }
+      if (prop === "deletedIds" && "deleted" in targetRecord && Array.isArray(targetRecord["deleted"])) {
+        return targetRecord["deleted"];
+      }
+      if (prop === "deletedCount" && "count" in targetRecord && typeof targetRecord["count"] === "number") {
+        return targetRecord["count"];
+      }
+      if (prop === "revisions" && "history" in targetRecord && Array.isArray(targetRecord["history"])) {
+        return targetRecord["history"].filter(isObject).map(
+          (h) => new Proxy(h, {
+            get(t, p) {
+              if (p === "revisionNumber") return t["revisionId"];
+              if (p === "contentSnapshot") return t["content"];
+              return typeof p === "string" ? t[p] : void 0;
+            }
+          })
+        );
+      }
+      if (prop === Symbol.iterator) {
+        const targetKey = findPrimaryArrayKey(targetRecord, ITERATOR_COLLECTION_KEYS);
+        if (targetKey !== void 0 && Array.isArray(targetRecord[targetKey])) {
+          const arrToYield = targetRecord[targetKey];
+          return function* () {
+            yield* arrToYield;
+          };
+        }
+        if ("project" in targetRecord && isObject(targetRecord["project"])) {
+          const proj = targetRecord["project"];
+          return function* () {
+            yield proj;
+          };
+        }
+        if ("projects" in targetRecord && isObject(targetRecord["projects"])) {
+          const items = dictToItems(targetRecord["projects"]);
+          return function* () {
+            yield* items;
+          };
+        }
+        if (isDictLike(targetRecord)) {
+          const items = dictToItems(targetRecord);
+          return function* () {
+            yield* items;
+          };
+        }
+      }
+      if (typeof prop === "string" && RESULT_LIST_ALIASES.includes(prop)) {
+        const targetKey = findPrimaryArrayKey(targetRecord);
+        if (targetKey !== void 0) return targetRecord[targetKey];
+        if ("projects" in targetRecord && isObject(targetRecord["projects"])) {
+          return wrapResult(dictToItems(targetRecord["projects"]));
+        }
+        if (isDictLike(targetRecord)) return wrapResult(dictToItems(targetRecord));
+        if ("project" in targetRecord && isObject(targetRecord["project"])) {
+          return wrapResult([targetRecord["project"]]);
+        }
+        if ("entry" in targetRecord && isObject(targetRecord["entry"])) {
+          return wrapResult([targetRecord["entry"]]);
+        }
+      }
+      if (prop === "result") return receiver;
+      if (prop === "length") {
+        const targetKey = findPrimaryArrayKey(targetRecord);
+        if (targetKey !== void 0 && Array.isArray(targetRecord[targetKey])) {
+          return targetRecord[targetKey].length;
+        }
+        if ("project" in targetRecord && isObject(targetRecord["project"])) return 1;
+        if ("projects" in targetRecord && isObject(targetRecord["projects"])) {
+          return Object.keys(targetRecord["projects"]).length;
+        }
+        if (isDictLike(targetRecord)) return Object.keys(targetRecord).length;
+      }
+      if (typeof prop === "string" && /^\d+$/.test(prop)) {
+        const idx = parseInt(prop, 10);
+        if ("project" in targetRecord && isObject(targetRecord["project"]) && idx === 0) {
+          return targetRecord["project"];
+        }
+        const targetKey = findPrimaryArrayKey(targetRecord);
+        if (targetKey !== void 0 && Array.isArray(targetRecord[targetKey])) {
+          return targetRecord[targetKey][idx];
+        }
+        if ("projects" in targetRecord && isObject(targetRecord["projects"])) {
+          return dictToItems(targetRecord["projects"])[idx];
+        }
+        if (isDictLike(targetRecord)) return dictToItems(targetRecord)[idx];
+      }
+      if (typeof prop === "string" && SUCCESS_ARRAY_METHODS.includes(prop)) {
+        const targetKey = findPrimaryArrayKey(targetRecord);
+        if (targetKey !== void 0 && Array.isArray(targetRecord[targetKey])) {
+          const bound = bindArrayMethod(targetRecord[targetKey], prop);
+          if (bound !== void 0) return bound;
+        }
+        if ("project" in targetRecord && isObject(targetRecord["project"])) {
+          const bound = bindArrayMethod([targetRecord["project"]], prop);
+          if (bound !== void 0) return bound;
+        }
+        if ("projects" in targetRecord && isObject(targetRecord["projects"])) {
+          const bound = bindArrayMethod(dictToItems(targetRecord["projects"]), prop);
+          if (bound !== void 0) return bound;
+        }
+        if (isDictLike(targetRecord)) {
+          const bound = bindArrayMethod(dictToItems(targetRecord), prop);
+          if (bound !== void 0) return bound;
+        }
+        const keys = Object.keys(target).join(", ") || "none";
+        throw new TypeError(
+          `\u{1F6E0}\uFE0F AUTONOMOUS HEALING: CodeMode Non-Array Proxy Error: Attempted to call Array method '${prop}' on an Object. The returned result is not an Array, and no array properties could be automatically resolved. Check the available keys and access the correct array property. Keys available: ${keys}`
+        );
+      }
+      if (typeof prop === "string" && MUTATOR_ARRAY_METHODS.includes(prop)) {
+        throw new Error(
+          `\u{1F6E0}\uFE0F AUTONOMOUS HEALING: [VALIDATION_ERROR] CodeMode Proxy Error: Array mutator method '${prop}' is not allowed on API results. Modifying local arrays does not update the server state. You MUST use the appropriate API tool (e.g., mj.core.updateEntry, mj.admin.batchUpdateEntries) to persist changes.`
+        );
+      }
+      return void 0;
+    }
+  });
+}
+
+// src/codemode/proxy-helpers.ts
+function wrapPromise(promise, methodName) {
+  return new Proxy(promise, {
+    get(target, prop) {
+      if (prop === "then") return target.then.bind(target);
+      if (prop === "catch") return target.catch.bind(target);
+      if (prop === "finally") return target.finally.bind(target);
+      if (typeof prop === "string" && !["constructor", "toString", "valueOf", "toJSON"].includes(prop)) {
+        if (["prepare", "exec", "query", "run"].includes(prop)) {
+          throw new Error(
+            `\u{1F6E0}\uFE0F AUTONOMOUS HEALING: Attempted to call database method '${prop}' on an unresolved Promise. In Code Mode, avoid direct database driver methods and use high-level mj.* API methods (e.g. mj.admin.updateEntry, mj.core.createEntry), or await the tool call.`
+          );
+        }
+        throw new Error(
+          `\u{1F6E0}\uFE0F AUTONOMOUS HEALING: Attempted to access property '${prop}' on a Promise object. Did you forget to 'await' the tool call? (e.g. const result = await mj.group.${methodName}(...))`
+        );
+      }
+      if (prop === Symbol.iterator) {
+        throw new Error(
+          `\u{1F6E0}\uFE0F AUTONOMOUS HEALING: Attempted to iterate over a Promise object. Did you forget to 'await' the tool call? (e.g. const [item] = await mj.group.${methodName}(...))`
+        );
+      }
+      return Reflect.get(target, prop);
+    }
+  });
+}
+function attachMethodIntrospection(targetFn, group, methodName, getSchema, customDescription) {
+  const description = customDescription ?? `Code Mode tool mj.${group}.${methodName}. Use mj.${group}.${methodName}.schema() to view parameter schema.`;
+  const getInfo = () => Promise.resolve({ name: methodName, group, schema: getSchema(), description });
+  Object.assign(targetFn, {
+    schema: () => Promise.resolve(getSchema()),
+    help: getInfo,
+    describe: getInfo
+  });
+}
+function createGetConfigInterceptor() {
+  return () => wrapPromise(
+    Promise.resolve(
+      wrapResult({
+        success: false,
+        error: "Code Mode cannot directly read configuration via getConfig(). Use mj.core.listProjects() to discover active projects, or updateConfiguration() to change settings.",
+        code: "VALIDATION_ERROR",
+        category: "validation",
+        recoverable: true
+      })
+    ),
+    "getConfig"
+  );
+}
+function createGetBriefingInterceptor() {
+  return () => wrapPromise(
+    Promise.resolve(
+      wrapResult({
+        success: false,
+        error: "Code Mode cannot directly read the briefing resource via getBriefing(). Use mj.core.getRecentEntries() instead, or read the memory://briefing resource via standard MCP client requests outside of Code Mode.",
+        code: "VALIDATION_ERROR",
+        category: "validation",
+        recoverable: true
+      })
+    ),
+    "getBriefing"
+  );
+}
+var RESOURCE_SUGGESTIONS = {
+  "memory://recent": "mj.core.getRecentEntries()",
+  "memory://statistics": "mj.analytics.getStatistics()",
+  "memory://tags": "mj.core.listTags()",
+  "memory://flags": 'mj.team.teamListFlags({ status: "active" })',
+  "memory://significant": 'mj.search.searchEntries({ sort_by: "importance" })',
+  "memory://insights": "mj.analytics.getCrossProjectInsights()"
+};
+function createReadResourceInterceptor() {
+  return (uri) => {
+    let hint = "";
+    if (typeof uri === "string") {
+      const match = Object.entries(RESOURCE_SUGGESTIONS).find(([k]) => uri.startsWith(k));
+      if (match !== void 0) hint = ` Try: ${match[1]}`;
+    }
+    return wrapPromise(
+      Promise.resolve(
+        wrapResult({
+          success: false,
+          error: `Code Mode cannot directly read MCP resources (e.g., memory://briefing) using readResource().${hint} Use the appropriate mj.* tools to query data, or read the resource via standard MCP client requests outside of Code Mode.`,
+          code: "VALIDATION_ERROR",
+          category: "validation",
+          recoverable: true
+        })
+      ),
+      "readResource"
+    );
+  };
+}
+function createFactoryFnProxy(api) {
+  const factoryFn = function(..._args) {
+    return api;
+  };
+  return new Proxy(factoryFn, {
+    apply: () => api,
+    construct: () => api,
+    get(_t, p) {
+      if (p === "then") return void 0;
+      if (p === "name") return "factoryFn";
+      if (p === "length") return 0;
+      if (p === "bind" || p === "call" || p === "apply" || p === "toString") {
+        return Function.prototype[p].bind(factoryFn);
+      }
+      return typeof p === "string" ? api[p] : void 0;
+    }
+  });
+}
+function createUnknownGroupRejectionProxy(prop, reason) {
+  return new Proxy(() => void 0, {
+    apply() {
+      return wrapPromise(
+        Promise.resolve(
+          wrapResult({
+            success: false,
+            error: reason,
+            code: "VALIDATION_ERROR",
+            category: "validation",
+            recoverable: true
+          })
+        ),
+        prop
+      );
+    },
+    get(_t, subProp) {
+      if (typeof subProp === "symbol" || subProp === "then") return void 0;
+      return (..._args) => wrapPromise(
+        Promise.resolve(
+          wrapResult({
+            success: false,
+            error: `${reason} (Attempted to access 'mj.${prop}.${subProp}')`,
+            code: "VALIDATION_ERROR",
+            category: "validation",
+            recoverable: true
+          })
+        ),
+        `${prop}.${subProp}`
+      );
+    }
+  });
+}
+
+// src/codemode/proxy-namespaces.ts
+var TABLES = [
+  "memory_journal",
+  "tags",
+  "entry_tags",
+  "relationships",
+  "entry_anchors",
+  "entry_revisions",
+  "vec_embeddings",
+  "team_flags"
+];
+function createSchemaProxy(safeRpcCall) {
+  const schemaHelp = () => Promise.resolve({
+    group: "schema",
+    description: "Memory Journal Schema: Embedded SQLite database storing journal entries, tags, relationships, code anchors, revisions, vector embeddings, and team flags.",
+    tables: TABLES,
+    entrySchema: {
+      id: "number (auto-increment primary key)",
+      content: "string (required, markdown body)",
+      entry_type: ENTRY_TYPES.map((t) => `'${t}'`).join(" | "),
+      timestamp: "string (ISO 8601 timestamp)",
+      is_personal: "boolean (default: true)",
+      significance_type: `optional (${SIGNIFICANCE_TYPES.map((t) => `'${t}'`).join(" | ")})`,
+      tags: "string[] (optional array of kebab-case tags)",
+      workspace_id: "string (required repository/workspace identifier)",
+      project_number: "number (optional GitHub project number)",
+      impact_score: "number (0.0-1.0 blast radius score)",
+      trust_score: "number (0.0-1.0 confidence score)",
+      validation_status: "'passed' | 'none' | 'failed'",
+      auto_context: 'string (optional JSON metadata string, e.g. { "commits": ["<sha>"] })',
+      session_id: "string (optional session tracking id)",
+      relationships: "Array<{ targetId: number, relationType?: string }> (optional entry links)",
+      anchors: "Array<{ anchor_path: string, anchor_type: string, status?: string }> (optional code anchors)"
+    },
+    methods: ["help", "describe", "listTables", "describeTable", "getSchema"],
+    usage: "Use mj.core.createEntry.schema() for entry parameter details, or mj.analytics.getStatistics() for database statistics."
+  });
+  const schemaCallable = (..._args) => safeRpcCall("analytics", "get_statistics", []).then(wrapResult);
+  return new Proxy(schemaCallable, {
+    apply: (_t, _thisArg, args) => safeRpcCall("analytics", "get_statistics", args).then(wrapResult),
+    get(_t, p) {
+      if (typeof p === "symbol" || p === "then") return void 0;
+      if (p === "help" || p === "describe" || p === "describeTable" || p === "getSchema") return schemaHelp;
+      if (p === "listTables") return () => Promise.resolve({ success: true, tables: TABLES });
+      if (p === "tables") return TABLES;
+      if (p in Function.prototype) return Reflect.get(Function.prototype, p);
+      return void 0;
+    }
+  });
+}
+function createProjectsProxy(methods, invokeRpc) {
+  const adminListProjects = methods["admin"]?.includes("list_projects") ? (...args) => invokeRpc("admin", "list_projects", args) : methods["analytics"]?.includes("get_cross_project_insights") ? (...args) => invokeRpc("analytics", "get_cross_project_insights", args) : () => wrapPromise(Promise.resolve(wrapResult({ success: true, projects: {}, items: [], data: [] })), "list_projects");
+  const adminGetProject = methods["admin"]?.includes("get_project") ? (nameOrParams) => {
+    const params = typeof nameOrParams === "string" || typeof nameOrParams === "number" ? [{ name: String(nameOrParams) }] : [nameOrParams ?? {}];
+    return invokeRpc("admin", "get_project", params);
+  } : () => wrapPromise(Promise.resolve(wrapResult({ success: true })), "get_project");
+  const adminRegisterProject = methods["admin"]?.includes("register_project") ? (...args) => invokeRpc("admin", "register_project", args) : () => wrapPromise(Promise.resolve(wrapResult({ success: true })), "register_project");
+  const adminUpdateProject = methods["admin"]?.includes("update_project") ? (...args) => invokeRpc("admin", "update_project", args) : () => wrapPromise(Promise.resolve(wrapResult({ success: true })), "update_project");
+  const adminDeleteProject = methods["admin"]?.includes("delete_project") ? (...args) => invokeRpc("admin", "delete_project", args) : () => wrapPromise(Promise.resolve(wrapResult({ success: true })), "delete_project");
+  const projectsCallable = (...args) => adminListProjects(...args);
+  Object.assign(projectsCallable, {
+    list: adminListProjects,
+    listProjects: adminListProjects,
+    list_projects: adminListProjects,
+    getProjects: adminListProjects,
+    get_projects: adminListProjects,
+    getAll: adminListProjects,
+    all: adminListProjects,
+    get: adminGetProject,
+    getProject: adminGetProject,
+    get_project: adminGetProject,
+    find: adminGetProject,
+    findProject: adminGetProject,
+    find_project: adminGetProject,
+    register: adminRegisterProject,
+    registerProject: adminRegisterProject,
+    register_project: adminRegisterProject,
+    create: adminRegisterProject,
+    createProject: adminRegisterProject,
+    update: adminUpdateProject,
+    updateProject: adminUpdateProject,
+    update_project: adminUpdateProject,
+    delete: adminDeleteProject,
+    deleteProject: adminDeleteProject,
+    delete_project: adminDeleteProject,
+    remove: adminDeleteProject,
+    removeProject: adminDeleteProject
+  });
+  return new Proxy(projectsCallable, {
+    apply: (_t, _thisArg, args) => adminListProjects(...args),
+    get(t, p) {
+      if (typeof p === "symbol" || p === "then") return void 0;
+      if (p in t) return Reflect.get(t, p);
+      if (typeof p === "string") {
+        const low = p.toLowerCase();
+        if (low.includes("list") || low.includes("all") || low.includes("get") && low.endsWith("s")) {
+          return adminListProjects;
+        }
+        if (low.includes("get") || low.includes("find")) return adminGetProject;
+        if (low.includes("create") || low.includes("register") || low.includes("add")) return adminRegisterProject;
+        if (low.includes("update") || low.includes("edit")) return adminUpdateProject;
+        if (low.includes("delete") || low.includes("remove")) return adminDeleteProject;
+      }
+      return adminListProjects;
+    }
+  });
+}
+function createTagsProxy(methods, invokeRpc) {
+  const coreListTags = methods["core"]?.includes("list_tags") ? (...args) => invokeRpc("core", "list_tags", args) : () => wrapPromise(Promise.resolve(wrapResult({ success: true, tags: [], count: 0 })), "list_tags");
+  const adminMergeTags = methods["admin"]?.includes("merge_tags") ? (...args) => invokeRpc("admin", "merge_tags", args) : () => wrapPromise(Promise.resolve(wrapResult({ success: true })), "merge_tags");
+  const tagsCallable = (...args) => coreListTags(...args);
+  Object.assign(tagsCallable, {
+    list: coreListTags,
+    listTags: coreListTags,
+    list_tags: coreListTags,
+    get: coreListTags,
+    getTags: coreListTags,
+    get_tags: coreListTags,
+    getAll: coreListTags,
+    all: coreListTags,
+    merge: adminMergeTags,
+    mergeTags: adminMergeTags,
+    merge_tags: adminMergeTags
+  });
+  return new Proxy(tagsCallable, {
+    apply: (_t, _thisArg, args) => coreListTags(...args),
+    get(t, p) {
+      if (typeof p === "symbol" || p === "then") return void 0;
+      if (p in t) return Reflect.get(t, p);
+      if (typeof p === "string" && p.toLowerCase().includes("merge")) return adminMergeTags;
+      return coreListTags;
+    }
+  });
+}
+function createSystemProxy(methods, invokeRpc) {
+  const getStats = methods["analytics"]?.includes("get_statistics") ? (...args) => invokeRpc("analytics", "get_statistics", args) : () => wrapPromise(Promise.resolve(wrapResult({ success: true })), "get_statistics");
+  const systemCallable = (...args) => getStats(...args);
+  const statsKeys = [
+    "getStatistics",
+    "getStats",
+    "stats",
+    "serverInfo",
+    "server_info",
+    "serverHealth",
+    "server_health",
+    "serverStatus",
+    "server_status",
+    "healthCheck",
+    "health_check",
+    "diagnostics",
+    "getDiagnostics",
+    "systemInfo",
+    "system_info",
+    "info",
+    "getInfo",
+    "health",
+    "getHealth",
+    "status",
+    "getStatus",
+    "adapters",
+    "listAdapters",
+    "list_adapters",
+    "getAdapters",
+    "get_adapters"
+  ];
+  const systemObj = {
+    ping: () => wrapPromise(Promise.resolve(wrapResult({ success: true, status: "pong" })), "ping"),
+    version: () => wrapPromise(Promise.resolve(wrapResult({ success: true, version: VERSION, name: "memory-journal-mcp" })), "version")
+  };
+  for (const k of statsKeys) systemObj[k] = getStats;
+  Object.assign(systemCallable, systemObj);
+  return new Proxy(systemCallable, {
+    apply: (_t, _thisArg, args) => getStats(...args),
+    get(t, p) {
+      if (typeof p === "symbol" || p === "then") return void 0;
+      if (p in t) return Reflect.get(t, p);
+      return getStats;
+    }
+  });
+}
+function createContextNamespaceProxy(contextObj) {
+  const projNum = contextObj?.["project_number"] ?? contextObj?.["projectNumber"] ?? 1;
+  const sessId = contextObj?.["session_id"] ?? contextObj?.["sessionId"] ?? "session-default";
+  const wsId = contextObj?.["workspace_id"] ?? contextObj?.["workspaceId"] ?? "default";
+  const projId = contextObj?.["project_id"] ?? contextObj?.["projectId"] ?? projNum;
+  const contextData = {
+    success: true,
+    project_number: projNum,
+    projectNumber: projNum,
+    session_id: sessId,
+    sessionId: sessId,
+    workspace_id: wsId,
+    workspaceId: wsId,
+    project_id: projId,
+    projectId: projId,
+    ...contextObj ?? {}
+  };
+  const getContextRpc = (keyOrObj) => {
+    if (typeof keyOrObj === "string" && keyOrObj in contextData) {
+      return wrapPromise(Promise.resolve(wrapResult(contextData[keyOrObj])), "get_context");
+    }
+    return wrapPromise(Promise.resolve(wrapResult(contextData)), "get_context");
+  };
+  const contextCallable = (...args) => getContextRpc(args[0]);
+  Object.assign(contextCallable, {
+    get: getContextRpc,
+    getContext: getContextRpc,
+    get_context: getContextRpc,
+    find: getContextRpc,
+    list: getContextRpc,
+    ...contextData
+  });
+  const contextProxy = new Proxy(contextCallable, {
+    apply: (_t, _thisArg, args) => getContextRpc(args[0]),
+    get(t, p) {
+      if (typeof p === "symbol" || p === "then") return void 0;
+      if (p in t) return Reflect.get(t, p);
+      if (typeof p === "string") {
+        if (["get", "getContext", "get_context", "find", "list"].includes(p)) return getContextRpc;
+        if (p in contextData) return contextData[p];
+      }
+      return Reflect.get(t, p);
+    }
+  });
+  return { contextProxy, getContextRpc };
+}
+
+// src/codemode/worker-api-proxy.ts
+var FACTORY_METHOD_NAMES = /* @__PURE__ */ new Set([
+  "getInstance",
+  "get_instance",
+  "createInstance",
+  "create_instance",
+  "getClient",
+  "get_client",
+  "createClient",
+  "create_client",
+  "initClient",
+  "init_client",
+  "initInstance",
+  "init_instance",
+  "getJournal",
+  "get_journal",
+  "loadJournal",
+  "load_journal",
+  "loadMemory",
+  "load_memory",
+  "getDatabase",
+  "get_database",
+  "getDb",
+  "get_db",
+  "connectToDatabase",
+  "connect_to_database",
+  "openDatabase",
+  "open_database",
+  "init",
+  "initialize",
+  "connect",
+  "open",
+  "default"
+]);
+var KNOWN_PROMPTS = [
+  "session-summary",
+  "plan-draft",
+  "adversarial-review",
+  "copilot-validation",
+  "plan-refinement",
+  "team-session-summary"
+];
+function getPropOrSnake(obj, snake, camel) {
+  if (typeof obj === "object" && obj !== null || typeof obj === "function") {
+    return Reflect.get(obj, snake) ?? Reflect.get(obj, camel);
+  }
+  return void 0;
 }
-function buildApiProxy(methods, schemas, readonlyMode) {
+function buildApiProxy(rpcCall2, methods, schemas, readonlyMode, contextObj) {
   const api = {};
+  const safeRpcCall = (group, method, args) => rpcCall2(group, method, args).catch((err) => ({
+    success: false,
+    error: err instanceof Error ? err.message : String(err),
+    code: "EXECUTION_ERROR",
+    category: "execution",
+    recoverable: true
+  }));
+  const invokeRpc = (g, m, args) => {
+    const intercept = applyArgInterceptions(m, args);
+    if ("error" in intercept) {
+      return wrapPromise(Promise.resolve(wrapResult(intercept.error)), m);
+    }
+    return wrapPromise(safeRpcCall(g, m, intercept.args).then(wrapResult), m);
+  };
+  const createMethodProxyFn = (groupName, methodName, schemaFallbackKey) => {
+    const fn = (...args) => invokeRpc(groupName, methodName, args);
+    attachMethodIntrospection(
+      fn,
+      groupName,
+      methodName,
+      () => schemas?.[groupName]?.[methodName] ?? (schemaFallbackKey !== void 0 ? schemas?.[groupName]?.[schemaFallbackKey] : void 0) ?? "unknown"
+    );
+    return fn;
+  };
   for (const [group, methodNames] of Object.entries(methods)) {
+    if (!Array.isArray(methodNames)) continue;
     if (group === "_topLevel") {
       for (const methodName of methodNames) {
-        const proxyFn = async (...args) => {
-          const result = await rpcCall("_topLevel", methodName, args);
-          return wrapResult(result);
-        };
-        Object.assign(proxyFn, {
-          schema: () => Promise.resolve(schemas?.["_topLevel"]?.[methodName] ?? "any")
-        });
-        api[methodName] = proxyFn;
+        api[methodName] = createMethodProxyFn("_topLevel", methodName);
       }
       continue;
     }
     const groupProxy = {};
     for (const methodName of methodNames) {
-      const proxyFn = async (...args) => {
-        const result = await rpcCall(group, methodName, args);
-        return wrapResult(result);
-      };
-      Object.assign(proxyFn, {
-        schema: () => Promise.resolve(schemas?.[group]?.[methodName] ?? "any")
-      });
-      groupProxy[methodName] = proxyFn;
+      groupProxy[methodName] = createMethodProxyFn(group, methodName);
     }
-    groupProxy["help"] = () => Promise.resolve({
-      group,
-      methods: methodNames
-    });
-    const groupProxyWrapped = new Proxy(groupProxy, {
+    groupProxy["help"] = () => Promise.resolve({ group, methods: methodNames });
+    groupProxy["describe"] = groupProxy["help"];
+    const groupCallable = function() {
+    };
+    Object.assign(groupCallable, groupProxy);
+    api[group] = new Proxy(groupCallable, {
+      apply(_target, _thisArg, args) {
+        const primaryMethod = methodNames.find((m) => !m.endsWith("_help") && m !== "help");
+        const fn = primaryMethod !== void 0 ? groupProxy[primaryMethod] : void 0;
+        if (fn !== void 0) return fn(...args);
+        return wrapPromise(
+          Promise.resolve(
+            wrapResult({
+              success: false,
+              error: `Group '${group}' is a tool namespace, not a function. Available methods in '${group}': ${methodNames.join(", ")}.`,
+              code: "VALIDATION_ERROR",
+              category: "validation",
+              recoverable: true
+            })
+          ),
+          group
+        );
+      },
       get(target, prop) {
         if (typeof prop === "symbol") return void 0;
         const key = prop;
-        if (key in target) return target[key];
-        if (key === "then") return void 0;
+        if (key in target) return Reflect.get(target, key);
+        if (/[A-Z]/.test(key)) {
+          const snakeKey = key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+          if (snakeKey in target) return Reflect.get(target, snakeKey);
+        }
+        const aliases = METHOD_ALIASES[group];
+        let resolvedKey = key;
+        if (aliases?.[key] !== void 0) {
+          const canonicalCamel = aliases[key];
+          const canonicalSnake = canonicalCamel.replace(/[A-Z]/g, (l) => `_${l.toLowerCase()}`);
+          if (canonicalSnake in target) return Reflect.get(target, canonicalSnake);
+          if (canonicalCamel in target) return Reflect.get(target, canonicalCamel);
+          resolvedKey = canonicalCamel;
+        }
+        if (group === "core") {
+          if (resolvedKey === "projects" || resolvedKey === "project" || key === "projects" || key === "project") {
+            return api["projects"];
+          }
+          if (resolvedKey === "semanticSearch" || key === "semantic_search") {
+            return getPropOrSnake(api["semantic"], "semantic_search", "semanticSearch");
+          }
+          if (resolvedKey === "vectorStats" || key === "vector_stats") {
+            return getPropOrSnake(api["semantic"], "vector_stats", "vectorStats");
+          }
+          if (resolvedKey === "searchAuditLog" || key === "search_audit_log") {
+            return getPropOrSnake(api["admin"], "search_audit_log", "searchAuditLog");
+          }
+          if (resolvedKey === "listDeletedEntries" || key === "list_deleted_entries") {
+            return getPropOrSnake(api["admin"], "list_deleted_entries", "listDeletedEntries");
+          }
+        }
+        if (resolvedKey === "getConfig") return createGetConfigInterceptor();
+        if (resolvedKey === "getBriefing") return createGetBriefingInterceptor();
+        if (resolvedKey === "readResource") return createReadResourceInterceptor();
+        if (resolvedKey === "then") return void 0;
+        if (typeof resolvedKey === "string") {
+          const snakeKey = /[A-Z]/.test(resolvedKey) ? resolvedKey.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`) : resolvedKey;
+          const teamSnakeKey = `team_${snakeKey}`;
+          const teamGroup = Object.keys(methods).find((g) => methods[g]?.includes(teamSnakeKey));
+          if (teamGroup !== void 0 && !Object.keys(methods).some((g) => methods[g]?.includes(snakeKey))) {
+            return createMethodProxyFn(teamGroup, teamSnakeKey);
+          }
+          const foundGroup = Object.keys(methods).find((g) => methods[g]?.includes(snakeKey));
+          if (foundGroup !== void 0) {
+            return createMethodProxyFn(foundGroup, snakeKey, resolvedKey);
+          }
+        }
         const available = methodNames.join(", ") || "none";
-        const reason = readonlyMode ? `Operation '${key}' is blocked in readonly mode. Read operations only.` : methodNames.length === 0 ? `Operation '${key}' is not available \u2014 this group has no methods (read-only mode?). Available: ${available}.` : `Operation '${key}' is not found in group. Available: ${available}.`;
-        return (..._args) => {
-          throw new Error(reason);
-        };
-      }
+        const reason = readonlyMode === true ? `\u{1F6E0}\uFE0F AUTONOMOUS HEALING: Operation '${key}' is blocked in readonly mode. Read operations only.` : methodNames.length === 0 ? `\u{1F6E0}\uFE0F AUTONOMOUS HEALING: Operation '${key}' is not available \u2014 this group has no methods (read-only mode?). Available: ${available}.` : `\u{1F6E0}\uFE0F AUTONOMOUS HEALING: Operation '${key}' is not found in group '${group}'. Available: ${available}.`;
+        const fallbackFn = (..._args) => wrapPromise(
+          Promise.resolve(
+            wrapResult({
+              success: false,
+              error: reason,
+              code: "VALIDATION_ERROR",
+              category: "validation",
+              recoverable: true
+            })
+          ),
+          key
+        );
+        attachMethodIntrospection(fallbackFn, group, key, () => "unknown", reason);
+        return fallbackFn;
+      },
+      set: () => false,
+      defineProperty: () => false,
+      deleteProperty: () => false,
+      setPrototypeOf: () => false
     });
-    api[group] = groupProxyWrapped;
   }
+  api["schema"] = createSchemaProxy(safeRpcCall);
   api["help"] = () => {
-    const groups = Object.keys(methods).filter(
-      (g) => g !== "_topLevel" && g !== "memory" && g !== "entries"
-    );
+    const groups = Object.keys(methods).filter((g) => g !== "_topLevel" && g !== "memory" && g !== "entries");
     let totalMethods = 0;
-    for (const group of groups) {
-      totalMethods += methods[group]?.length ?? 0;
-    }
+    for (const group of groups) totalMethods += methods[group]?.length ?? 0;
     return Promise.resolve({
       groups,
       totalMethods,
       usage: "Use mj.<group>.help() for group details. Use mj.<group>.<method>.schema() for parameter details."
     });
   };
+  api["describe"] = api["help"];
+  const projectsProxy = createProjectsProxy(methods, invokeRpc);
+  api["projects"] = projectsProxy;
+  api["project"] = projectsProxy;
+  const tagsProxy = createTagsProxy(methods, invokeRpc);
+  api["tags"] = tagsProxy;
+  api["tag"] = tagsProxy;
+  const systemProxy = createSystemProxy(methods, invokeRpc);
+  api["system"] = systemProxy;
+  api["adapters"] = systemProxy;
+  const { contextProxy, getContextRpc } = createContextNamespaceProxy(contextObj);
+  api["context"] = contextProxy;
+  api["getContext"] = getContextRpc;
+  api["get_context"] = getContextRpc;
+  api["getDatabase"] = () => api;
+  api["get_database"] = () => api;
+  api["getDb"] = () => api;
+  api["get_db"] = () => api;
+  api["connectToDatabase"] = () => api;
+  api["openDatabase"] = () => api;
   return new Proxy(api, {
     get(target, prop) {
       if (typeof prop === "symbol") return void 0;
       if (prop in target) return target[prop];
+      if (prop === "gitApi") return target["git"];
+      if (prop === "journal" || prop === "memory" || prop === "entries" || prop === "entry")
+        return target["core"] ?? target;
+      if (prop === "schema") return target["schema"];
+      if (prop === "projects" || prop === "project") return target["projects"];
+      if (prop === "tags" || prop === "tag") return target["tags"];
+      if (prop === "system") return target["system"];
+      if (prop === "context") return target["context"];
+      if (prop === "getContext" || prop === "get_context") return target["getContext"];
+      if (prop === "sqlite" || prop === "sqlite3" || prop === "db") return target;
       if (prop === "then") return void 0;
-      const available = Object.keys(methods).filter((k) => k !== "_topLevel").join(", ");
-      const reason = `Group or property '${prop}' is not found on 'mj'. Available groups: ${available}. Use mj.help() for more info.`;
-      return new Proxy(
-        () => {
-        },
-        {
-          apply() {
-            throw new Error(reason);
-          },
-          get(_t, subProp) {
-            if (typeof subProp === "symbol") return void 0;
-            if (subProp === "then") return void 0;
-            return (..._args) => {
-              throw new Error(
-                `${reason} (Attempted to access 'mj.${prop}.${subProp}')`
-              );
-            };
-          }
-        }
-      );
-    }
-  });
-}
-async function executeCode(code, methodList, schemaList, timeoutMs, contextObj, readonlyMode) {
-  const startCpu = process.cpuUsage();
-  const startTime = performance.now();
-  try {
-    const mjApi = buildApiProxy(methodList, schemaList, readonlyMode);
-    const shimMj = new Proxy(mjApi, {
-      get(target, prop) {
-        if (prop === "mj" || prop === "journal" || prop === "memory") return shimMj;
-        if (prop === "executeCode") {
-          if ("codemode" in target) {
-            const codemodeGroup = target["codemode"];
-            return codemodeGroup["mjExecuteCode"] ?? codemodeGroup["executeCode"];
+      if (FACTORY_METHOD_NAMES.has(prop)) return createFactoryFnProxy(api);
+      if (typeof prop === "string") {
+        const snakeKey = /[A-Z]/.test(prop) ? prop.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`) : prop;
+        for (const [g, groupAliases] of Object.entries(METHOD_ALIASES)) {
+          if (groupAliases?.[prop] !== void 0) {
+            const canonicalCamel = groupAliases[prop];
+            const canonicalSnake = canonicalCamel.replace(/[A-Z]/g, (l) => `_${l.toLowerCase()}`);
+            if (methods[g]?.includes(canonicalSnake)) {
+              return createMethodProxyFn(g, canonicalSnake);
+            }
           }
-          return () => Promise.reject(
-            new Error(
-              "You are already inside Code Mode execution. You do not need to call executeCode again. Just write your logic directly (e.g., return await mj.core.createEntry(...))."
-            )
-          );
         }
-        if (prop === "readResource") {
-          return () => Promise.reject(
-            new Error(
-              "Code Mode cannot directly read MCP resources using mj.readResource(). Please use the appropriate mj.* tools (e.g., mj.team.teamListFlags) to query data, or read the resource via standard MCP resource requests outside of Code Mode."
-            )
-          );
+        const teamSnakeKey = `team_${snakeKey}`;
+        const teamGroup = Object.keys(methods).find((g) => methods[g]?.includes(teamSnakeKey));
+        if (teamGroup !== void 0 && !Object.keys(methods).some((g) => methods[g]?.includes(snakeKey))) {
+          return createMethodProxyFn(teamGroup, teamSnakeKey);
         }
-        if (prop === "addEntry" && "core" in target) {
-          const coreGroup = target["core"];
-          return coreGroup["createEntry"];
-        }
-        if (prop === "append" && "core" in target) {
-          const coreGroup = target["core"];
-          const createEntry = coreGroup["createEntry"];
-          return (arg1, arg2, arg3) => {
-            const tags = Array.isArray(arg1) ? arg1 : [typeof arg1 === "string" ? arg1 : "test"];
-            const content = typeof arg2 === "string" ? arg2 : arg2 != null ? JSON.stringify(arg2) : "";
-            const metadata = typeof arg3 === "object" && arg3 !== null ? { ...arg3 } : void 0;
-            const typeVal = metadata?.["type"];
-            const type = typeof typeVal === "string" && typeVal !== "" ? typeVal : "test_entry";
-            if (metadata && "type" in metadata) delete metadata["type"];
-            return createEntry({ type, tags, content, metadata });
-          };
+        const foundGroup = Object.keys(methods).find((g) => methods[g]?.includes(snakeKey));
+        if (foundGroup !== void 0) {
+          return createMethodProxyFn(foundGroup, snakeKey);
         }
-        if (typeof prop === "string") {
-          const DB_TO_JOURNAL = {
-            listTables: ["analytics", "getStatistics"],
-            describeTable: ["analytics", "getStatistics"],
-            count: ["analytics", "getStatistics"],
-            analyze: ["analytics", "getStatistics"],
-            vacuum: ["analytics", "getStatistics"],
-            integrityCheck: ["analytics", "getStatistics"],
-            exists: ["core", "getEntryById"],
-            upsert: ["core", "createEntry"],
-            batchInsert: ["core", "createEntry"],
-            readQuery: ["search", "searchEntries"]
-          };
-          const mapping = DB_TO_JOURNAL[prop];
-          if (mapping !== void 0) {
-            const [group, method] = mapping;
-            if (group in target) {
-              return target[group][method];
-            }
-          }
+      }
+      const available = Object.keys(methods).filter((k) => k !== "_topLevel").join(", ");
+      let reason = `Group or property '${prop}' is not found on 'mj'. Available groups: ${available}. Use mj.help() for more info.`;
+      if (typeof prop === "string") {
+        const normalized = prop.replace(/^mj_/, "").replace(/_/g, "-");
+        const isPrompt = KNOWN_PROMPTS.includes(normalized) || KNOWN_PROMPTS.includes(prop) || KNOWN_PROMPTS.includes(prop.replace(/^mj_/, ""));
+        if (isPrompt) {
+          reason = `'${prop}' is an MCP Prompt, not an MCP Tool. Code Mode cannot invoke MCP Prompts directly. Please use the 'get_prompt' tool (or your native MCP Prompts integration) outside of Code Mode to evaluate it, then use 'mj.core.createEntry' to save the result.`;
+        } else if (prop.startsWith("mj_")) {
+          reason = `'${prop}' is not a valid root tool in Code Mode. Code Mode uses namespaced groups (e.g., 'mj.core.searchEntries'). Use 'mj.help()' to see available namespaces.`;
         }
-        return Reflect.get(target, prop);
       }
-    });
-    const sandbox = {
-      mj: shimMj,
-      journal: shimMj,
-      sqlite: shimMj,
-      postgres: shimMj,
-      mysql: shimMj,
-      db: shimMj,
-      memory: shimMj,
-      // Unified with shimMj to catch memory.append and memory.journal
-      sqlite_journal_add_entry: shimMj["core"]?.["createEntry"],
-      context: contextObj ?? {},
-      console: {
-        log: (...args) => args,
-        warn: (...args) => args,
-        error: (...args) => args,
-        info: (...args) => args,
-        debug: (...args) => args
-      },
-      setTimeout: void 0,
-      setInterval: void 0,
-      setImmediate: void 0,
-      process: void 0,
-      require: void 0,
-      __dirname: void 0,
-      __filename: void 0,
-      global: void 0,
-      globalThis: void 0,
-      Proxy: void 0
-    };
-    for (const key of Object.keys(mjApi)) {
-      if (key in sandbox) continue;
-      const val = shimMj[key];
-      if (typeof val === "function") {
-        sandbox[key] = val;
+      return createUnknownGroupRejectionProxy(prop, reason);
+    }
+  });
+}
+function hardenOuterFunctionPrototypes() {
+  const noopConstructor = Object.freeze(function ForbiddenConstructor() {
+    throw new Error("Dynamic code generation is disabled in sandbox");
+  });
+  const AsyncFnProto = Object.getPrototypeOf(async function() {
+  });
+  const GenFnProto = Object.getPrototypeOf(function* () {
+  });
+  const AsyncGenFnProto = Object.getPrototypeOf(async function* () {
+  });
+  for (const proto of [Object.prototype, Function.prototype, AsyncFnProto, GenFnProto, AsyncGenFnProto]) {
+    if (proto !== null && proto !== void 0) {
+      try {
+        Object.defineProperty(proto, "constructor", {
+          value: noopConstructor,
+          writable: false,
+          configurable: false
+        });
+      } catch {
       }
     }
-    const context = vm.createContext(sandbox, {
-      name: "codemode-worker-sandbox",
-      codeGeneration: {
-        strings: false,
-        wasm: false
+  }
+  const outerBuiltins = [
+    Object,
+    Function,
+    Array,
+    String,
+    Number,
+    Boolean,
+    RegExp,
+    Error,
+    TypeError,
+    RangeError,
+    ReferenceError,
+    SyntaxError,
+    URIError,
+    EvalError,
+    Map,
+    Set,
+    WeakMap,
+    WeakSet,
+    Promise,
+    Date,
+    ArrayBuffer,
+    DataView,
+    JSON,
+    Math
+  ];
+  for (const B of outerBuiltins) {
+    if (typeof B === "function" && B.prototype !== void 0 && B.prototype !== null) {
+      try {
+        Object.freeze(B.prototype);
+      } catch {
       }
-    });
-    vm.runInContext(
-      `(function() {
-                "use strict";
-                const builtins = [
-                    Object, Function, Array, String, Number, Boolean, RegExp,
-                    Error, TypeError, RangeError, ReferenceError, SyntaxError,
-                    URIError, EvalError, Map, Set, WeakMap, WeakSet,
-                    Promise, Date, ArrayBuffer, DataView,
-                    Int8Array, Uint8Array, Uint8ClampedArray,
-                    Int16Array, Uint16Array, Int32Array, Uint32Array,
-                    Float32Array, Float64Array, BigInt64Array, BigUint64Array,
-                    JSON, Math,
-                ];
-                for (const B of builtins) {
-                    if (B && typeof B === "function" && B.prototype) {
-                        try { Object.freeze(B.prototype); } catch(e) {}
-                    }
-                    try { Object.freeze(B); } catch(e) {}
-                }
-                try { Object.freeze(Object.prototype); } catch(e) {}
-                try { Object.freeze(Function.prototype); } catch(e) {}
-            })()`,
-      context
-    );
-    const wrappedCode = `(async () => { ${transformAutoReturn(code)} })()`;
-    const script = new vm.Script(wrappedCode, {
-      filename: "codemode-execution.js"
-    });
-    const resultPromise = script.runInContext(context, {
-      timeout: timeoutMs
-    });
-    const result = await resultPromise;
-    const endTime = performance.now();
-    const endCpu = process.cpuUsage(startCpu);
-    const metrics = {
-      wallTimeMs: Math.round(endTime - startTime),
-      cpuTimeMs: Math.round((endCpu.user + endCpu.system) / 1e3),
-      memoryUsedMb: 0
-    };
-    return { success: true, result, metrics };
-  } catch (err) {
-    const endTime = performance.now();
-    const endCpu = process.cpuUsage(startCpu);
-    const error = err instanceof Error ? err : new Error(String(err));
-    if (error instanceof SyntaxError && error.message.includes("missing ) after argument list")) {
-      error.message += "\n\n\u{1F4A1} Tip: When passing long multi-line strings or markdown with embedded quotes, use template literals (backticks `) instead of single/double quotes to avoid escaping SyntaxErrors.";
     }
-    return {
-      success: false,
-      error: error.message,
-      stack: error.stack,
-      metrics: {
-        wallTimeMs: Math.round(endTime - startTime),
-        cpuTimeMs: Math.round((endCpu.user + endCpu.system) / 1e3),
-        memoryUsedMb: 0
+    try {
+      Object.freeze(B);
+    } catch {
+    }
+  }
+  for (const proto of [Object.prototype, Function.prototype, AsyncFnProto, GenFnProto, AsyncGenFnProto]) {
+    if (proto !== null && proto !== void 0) {
+      try {
+        Object.freeze(proto);
+      } catch {
       }
-    };
+    }
   }
 }
-parentPort?.on("message", (msg) => {
-  void (async () => {
-    if (msg !== null && msg !== void 0 && typeof msg === "object" && "type" in msg && msg.type === "EXECUTE") {
-      const executeMsg = msg;
-      const {
-        id,
-        code,
-        methodList,
-        schemaList,
-        timeoutMs,
-        maxResultSize,
-        rpcPort: newRpcPort,
-        contextObj,
-        readonlyMode
-      } = executeMsg;
-      rpcPort = newRpcPort;
-      rpcIdCounter = 0;
-      pendingRpcRequests.clear();
-      rpcPort?.on("message", (response) => {
-        const pending = pendingRpcRequests.get(response.id);
-        if (pending) {
-          pendingRpcRequests.delete(response.id);
-          if (response.error) {
-            pending.reject(new Error(response.error));
-          } else {
-            pending.resolve(response.result);
-          }
+var FREEZE_INNER_CONTEXT_SCRIPT = new vm2.Script(`(function() {
+    "use strict";
+    const noopCtor = Object.freeze(function ForbiddenConstructor() {
+        throw new Error("Dynamic code generation is disabled in sandbox");
+    });
+    const AsyncFnProto = Object.getPrototypeOf(async function() {});
+    const GenFnProto = Object.getPrototypeOf(function*() {});
+    const AsyncGenFnProto = Object.getPrototypeOf(async function*() {});
+    for (const proto of [Function.prototype, AsyncFnProto, GenFnProto, AsyncGenFnProto]) {
+        if (proto) {
+            try {
+                Object.defineProperty(proto, "constructor", {
+                    value: noopCtor,
+                    writable: false,
+                    configurable: false,
+                });
+            } catch(e) {}
         }
-      });
-      const result = await executeCode(
-        code,
-        methodList,
-        schemaList,
-        timeoutMs ?? 3e4,
-        contextObj,
-        readonlyMode
-      );
-      if (result.success) {
-        try {
-          const egressLimit = maxResultSize ?? 100 * 1024;
-          let bytes = 0;
-          const cache = /* @__PURE__ */ new Set();
-          const resultJson = JSON.stringify(
-            result.result,
-            (_key, value) => {
-              if (typeof value === "object" && value !== null) {
-                if (cache.has(value)) return "[Circular]";
-                cache.add(value);
-              }
-              if (typeof value === "string") {
-                bytes += Buffer.byteLength(value, "utf8") + 2;
-              } else if (typeof value === "number" || typeof value === "boolean") {
-                bytes += Buffer.byteLength(String(value), "utf8");
-              } else {
-                bytes += 5;
-              }
-              if (bytes > egressLimit) {
-                throw new Error(`EgressLimitExceeded:${bytes}`);
-              }
-              return value;
-            }
-          );
-          if (resultJson !== void 0) {
-            const byteLength = Buffer.byteLength(resultJson, "utf8");
-            if (byteLength > egressLimit) {
-              throw new Error(`EgressLimitExceeded:${byteLength}`);
-            }
-            result.result = JSON.parse(resultJson);
-          } else {
-            result.result = void 0;
-          }
-        } catch (err) {
-          result.success = false;
-          const egressLimit = maxResultSize ?? 100 * 1024;
-          if (err instanceof Error && err.message.startsWith("EgressLimitExceeded:")) {
-            const actualBytesStr = err.message.split(":")[1];
-            const actualBytes = actualBytesStr !== void 0 ? Number(actualBytesStr) : egressLimit + 1;
-            const actualKb = (actualBytes / 1024).toFixed(1);
-            result.error = `Output limit exceeded: Result serialization exceeded the ${Math.round(egressLimit / 1024)}KB boundary (Actual size: >${actualKb}KB). Please aggregate or filter your results to reduce the payload size.`;
-          } else {
-            result.error = `Result could not be serialized or exceeded memory limits: ${err instanceof Error ? err.message : String(err)}`;
-          }
-          result.result = void 0;
+    }
+    const builtins = [
+        Object, Function, Array, String, Number, Boolean, RegExp,
+        Error, TypeError, RangeError, ReferenceError, SyntaxError,
+        URIError, EvalError, Map, Set, WeakMap, WeakSet,
+        Promise, Date, ArrayBuffer, DataView,
+        Int8Array, Uint8Array, Uint8ClampedArray,
+        Int16Array, Uint16Array, Int32Array, Uint32Array,
+        Float32Array, Float64Array, BigInt64Array, BigUint64Array,
+        JSON, Math,
+    ];
+    for (const B of builtins) {
+        if (B && typeof B === "function" && B.prototype) {
+            try { Object.freeze(B.prototype); } catch(e) {}
         }
-      }
-      rpcPort?.close();
-      rpcPort = null;
-      parentPort?.postMessage({ type: "RESULT", id, result });
+        try { Object.freeze(B); } catch(e) {}
     }
+    for (const proto of [Object.prototype, Function.prototype, AsyncFnProto, GenFnProto, AsyncGenFnProto]) {
+        if (proto) {
+            try { Object.freeze(proto); } catch(e) {}
+        }
+    }
+})()`);
+function freezeInnerVmContext(context) {
+  FREEZE_INNER_CONTEXT_SCRIPT.runInContext(context);
+}
+
+// src/codemode/worker/node-shims.ts
+var toStr = (val) => {
+  if (typeof val === "string") return val;
+  if (typeof val === "number" || typeof val === "boolean") return `${val}`;
+  return "";
+};
+function createSafeFsShim(contextObj) {
+  const readContent = () => contextObj !== void 0 && typeof contextObj["content"] === "string" ? contextObj["content"] : "";
+  return {
+    existsSync: (filePath) => {
+      if (filePath === void 0 || filePath === null) return false;
+      const p = toStr(filePath).toLowerCase();
+      return p.includes(".db") || p.includes("memory") || p.includes("journal") || p.includes("sqlite") || p.length > 0;
+    },
+    statSync: (_filePath) => ({
+      size: 1048576,
+      isFile: () => true,
+      isDirectory: () => false,
+      mtime: /* @__PURE__ */ new Date(),
+      birthtime: /* @__PURE__ */ new Date()
+    }),
+    stat: (_filePath, cb) => {
+      const s = {
+        size: 1048576,
+        isFile: () => true,
+        isDirectory: () => false,
+        mtime: /* @__PURE__ */ new Date(),
+        birthtime: /* @__PURE__ */ new Date()
+      };
+      if (typeof cb === "function") cb(null, s);
+      return Promise.resolve(s);
+    },
+    lstatSync: (_filePath) => ({
+      size: 1048576,
+      isFile: () => true,
+      isDirectory: () => false,
+      mtime: /* @__PURE__ */ new Date(),
+      birthtime: /* @__PURE__ */ new Date()
+    }),
+    readFileSync: (_filePath) => readContent(),
+    readFile: (_filePath, cb) => {
+      const data = readContent();
+      if (typeof cb === "function") cb(null, data);
+      return Promise.resolve(data);
+    },
+    writeFileSync: () => void 0,
+    writeFile: () => Promise.resolve(void 0),
+    mkdirSync: () => void 0,
+    unlinkSync: () => void 0,
+    readdirSync: () => [],
+    promises: {
+      stat: () => Promise.resolve({
+        size: 1048576,
+        isFile: () => true,
+        isDirectory: () => false,
+        mtime: /* @__PURE__ */ new Date(),
+        birthtime: /* @__PURE__ */ new Date()
+      }),
+      readFile: () => Promise.resolve(readContent()),
+      writeFile: () => Promise.resolve(void 0)
+    }
+  };
+}
+var pathShim = {
+  join: (...parts) => parts.filter((p) => typeof p === "string" && p.length > 0).join("/").replace(/\/+/g, "/"),
+  resolve: (...parts) => parts.filter((p) => typeof p === "string" && p.length > 0).join("/").replace(/\/+/g, "/"),
+  basename: (p, ext) => {
+    const b = toStr(p).split(/[/\\]/).pop() ?? "";
+    return ext !== void 0 && b.endsWith(ext) ? b.slice(0, -ext.length) : b;
+  },
+  dirname: (p) => {
+    const parts = toStr(p).split(/[/\\]/);
+    parts.pop();
+    return parts.join("/") || ".";
+  },
+  extname: (p) => {
+    const b = toStr(p).split(/[/\\]/).pop() ?? "";
+    const dot = b.lastIndexOf(".");
+    return dot > 0 ? b.slice(dot) : "";
+  },
+  normalize: (p) => toStr(p).replace(/\\/g, "/"),
+  isAbsolute: (p) => /^[a-zA-Z]:[/\\]|^\//.test(toStr(p)),
+  sep: "/",
+  delimiter: ":"
+};
+var consoleShim = Object.freeze({
+  log: (...args) => args,
+  warn: (...args) => args,
+  error: (...args) => args,
+  info: (...args) => args,
+  debug: (...args) => args
+});
+function isPlainRecord(val) {
+  return typeof val === "object" && val !== null && !Array.isArray(val);
+}
+function invokeGroupMethod(shimMj, group, camelName, snakeName, params) {
+  const groupObj = shimMj[group];
+  if (typeof groupObj === "object" && groupObj !== null || typeof groupObj === "function") {
+    const fn = Reflect.get(groupObj, camelName) ?? Reflect.get(groupObj, snakeName);
+    if (typeof fn === "function") {
+      return fn(params);
+    }
+  }
+  return void 0;
+}
+function createPreparedStatementShim(sql, shimMj) {
+  const parseSqlParams = (args) => {
+    const cleanSql = sql.trim().replace(/^--[^\n]*\n/gm, "").trim();
+    const isUpdate = /^UPDATE\b/i.test(cleanSql);
+    const isInsert = /^INSERT\b/i.test(cleanSql);
+    const isDelete = /^DELETE\b/i.test(cleanSql);
+    const isSelect = /^SELECT\b/i.test(cleanSql);
+    if (isUpdate) {
+      const idMatch = /\bWHERE\s+[`"']?(?:id|entry_id)[`"']?\s*=\s*(?:\?|(\d+))/i.exec(
+        cleanSql
+      );
+      let entryId;
+      if (idMatch?.[1] !== void 0) {
+        entryId = parseInt(idMatch[1], 10);
+      }
+      let content;
+      let tags;
+      let title;
+      for (const arg of args) {
+        if (typeof arg === "number" && entryId === void 0) {
+          entryId = arg;
+        } else if (typeof arg === "string") {
+          if (arg.trim().startsWith("[") && arg.trim().endsWith("]")) {
+            try {
+              const parsed = JSON.parse(arg);
+              if (Array.isArray(parsed)) {
+                tags = parsed.map(String);
+                continue;
+              }
+            } catch {
+            }
+          }
+          if (content === void 0) {
+            content = arg;
+          } else {
+            title ??= arg;
+          }
+        } else if (Array.isArray(arg)) {
+          tags = arg.map(String);
+        } else if (isPlainRecord(arg)) {
+          if (typeof arg["entry_id"] === "number") entryId = arg["entry_id"];
+          if (typeof arg["id"] === "number") entryId = arg["id"];
+          if (typeof arg["content"] === "string") content = arg["content"];
+          if (Array.isArray(arg["tags"])) tags = arg["tags"].map(String);
+        }
+      }
+      if (content === void 0) {
+        const setContentMatch = /\bSET\s+[\s\S]*?\bcontent\s*=\s*['"]([\s\S]*?)['"]/i.exec(cleanSql);
+        if (setContentMatch?.[1] !== void 0) {
+          content = setContentMatch[1];
+        }
+      }
+      const updatePayload = {};
+      if (entryId !== void 0) updatePayload["entry_id"] = entryId;
+      if (content !== void 0) updatePayload["content"] = content;
+      if (tags !== void 0) updatePayload["tags"] = tags;
+      if (title !== void 0) updatePayload["title"] = title;
+      return { action: "update", params: updatePayload };
+    }
+    if (isInsert) {
+      let content = "";
+      let title = "Journal Entry";
+      let tags = [];
+      let entryType = "technical_decision";
+      for (const arg of args) {
+        if (typeof arg === "string") {
+          if (arg.trim().startsWith("[") && arg.trim().endsWith("]")) {
+            try {
+              const parsed = JSON.parse(arg);
+              if (Array.isArray(parsed)) {
+                tags = parsed.map(String);
+                continue;
+              }
+            } catch {
+            }
+          }
+          if (content === "") {
+            content = arg;
+          } else if (title === "Journal Entry") {
+            title = arg;
+          }
+        } else if (Array.isArray(arg)) {
+          tags = arg.map(String);
+        } else if (isPlainRecord(arg)) {
+          if (typeof arg["content"] === "string") content = arg["content"];
+          if (typeof arg["title"] === "string") title = arg["title"];
+          if (Array.isArray(arg["tags"])) tags = arg["tags"].map(String);
+          if (typeof arg["entry_type"] === "string") entryType = arg["entry_type"];
+        }
+      }
+      return { action: "create", params: { content, title, tags, entry_type: entryType } };
+    }
+    if (isDelete) {
+      let entryId;
+      const idMatch = /\bWHERE\s+[`"']?(?:id|entry_id)[`"']?\s*=\s*(?:\?|(\d+))/i.exec(
+        cleanSql
+      );
+      if (idMatch?.[1] !== void 0) entryId = parseInt(idMatch[1], 10);
+      for (const arg of args) {
+        if (typeof arg === "number") entryId = arg;
+      }
+      return { action: "delete", params: { entry_id: entryId ?? 0 } };
+    }
+    if (isSelect) {
+      let entryId;
+      const idMatch = /\bWHERE\s+[`"']?(?:id|entry_id)[`"']?\s*=\s*(?:\?|(\d+))/i.exec(
+        cleanSql
+      );
+      if (idMatch?.[1] !== void 0) entryId = parseInt(idMatch[1], 10);
+      for (const arg of args) {
+        if (typeof arg === "number") entryId = arg;
+      }
+      if (entryId !== void 0) {
+        return { action: "get_by_id", params: { entry_id: entryId } };
+      }
+      return { action: "list", params: { limit: 50 } };
+    }
+    return { action: "other", params: {} };
+  };
+  const executeOperation = (args) => {
+    const { action, params } = parseSqlParams(args);
+    if (action === "update") {
+      return invokeGroupMethod(shimMj, "admin", "updateEntry", "update_entry", params) ?? invokeGroupMethod(shimMj, "core", "updateEntry", "update_entry", params) ?? Promise.resolve({ success: true, changes: 1 });
+    }
+    if (action === "create") {
+      return invokeGroupMethod(shimMj, "core", "createEntry", "create_entry", params) ?? Promise.resolve({ success: true, changes: 1 });
+    }
+    if (action === "delete") {
+      return invokeGroupMethod(shimMj, "admin", "deleteEntry", "delete_entry", params) ?? invokeGroupMethod(shimMj, "core", "deleteEntry", "delete_entry", params) ?? Promise.resolve({ success: true, changes: 1 });
+    }
+    if (action === "get_by_id") {
+      return invokeGroupMethod(shimMj, "core", "getEntryById", "get_entry_by_id", params) ?? Promise.resolve({ success: true, changes: 1 });
+    }
+    if (action === "list") {
+      return invokeGroupMethod(
+        shimMj,
+        "core",
+        "getRecentEntries",
+        "get_recent_entries",
+        params
+      ) ?? Promise.resolve({ success: true, changes: 1 });
+    }
+    return Promise.resolve({ success: true, changes: 1 });
+  };
+  const stmtObj = {
+    run: (...args) => {
+      const res = executeOperation(args);
+      return {
+        changes: 1,
+        lastInsertRowid: typeof args[2] === "number" ? args[2] : typeof args[0] === "number" ? args[0] : 1,
+        success: true,
+        then: (resolve) => Promise.resolve(res).then(resolve)
+      };
+    },
+    get: (...args) => executeOperation(args),
+    all: (...args) => executeOperation(args),
+    iterate: (...args) => executeOperation(args),
+    bind: () => stmtObj,
+    columns: () => [],
+    raw: () => stmtObj,
+    pluck: () => stmtObj,
+    expand: () => stmtObj,
+    safeIntegers: () => stmtObj
+  };
+  return stmtObj;
+}
+
+// src/codemode/worker/namespace-shims.ts
+var DB_TO_JOURNAL = {
+  listTables: ["analytics", "getStatistics"],
+  describeTable: ["analytics", "getStatistics"],
+  count: ["analytics", "getStatistics"],
+  analyze: ["analytics", "getStatistics"],
+  vacuum: ["analytics", "getStatistics"],
+  integrityCheck: ["analytics", "getStatistics"],
+  exists: ["core", "getEntryById"],
+  upsert: ["core", "createEntry"],
+  batchInsert: ["core", "createEntry"],
+  readQuery: ["core", "readQuery"]
+};
+function createCallableShim(shimMj, fnName = "MemoryJournal") {
+  const callableFn = function(..._args) {
+    return shimMj;
+  };
+  return new Proxy(callableFn, {
+    apply(_t, _thisArg, _args) {
+      return shimMj;
+    },
+    construct(_t, _args) {
+      return shimMj;
+    },
+    get(_t, p) {
+      if (p === "then") return void 0;
+      if (p === "name") return fnName;
+      if (p === "length") return 0;
+      if (p === "bind" || p === "call" || p === "apply" || p === "toString") {
+        return Function.prototype[p].bind(callableFn);
+      }
+      return typeof p === "string" ? shimMj[p] : void 0;
+    }
+  });
+}
+function isTargetLike(val) {
+  return typeof val === "object" && val !== null || typeof val === "function";
+}
+function createUpdateMemoryFn(shimMj) {
+  const updateMemoryFn = (arg) => {
+    if (typeof arg === "object" && arg !== null && !Array.isArray(arg)) {
+      const entryId = Reflect.get(arg, "entry_id") ?? Reflect.get(arg, "id") ?? Reflect.get(arg, "entryId");
+      if (entryId !== void 0 && entryId !== null) {
+        const adminGroup = shimMj["admin"];
+        const coreGroup2 = shimMj["core"];
+        const fn = (isTargetLike(adminGroup) ? Reflect.get(adminGroup, "updateEntry") ?? Reflect.get(adminGroup, "update_entry") : void 0) ?? (isTargetLike(coreGroup2) ? Reflect.get(coreGroup2, "updateEntry") : void 0);
+        if (typeof fn === "function") {
+          return fn(arg);
+        }
+      }
+    }
+    const coreGroup = shimMj["core"];
+    if (isTargetLike(coreGroup)) {
+      const createFn = Reflect.get(coreGroup, "createEntry");
+      if (typeof createFn === "function") {
+        return createFn(arg);
+      }
+    }
+    return void 0;
+  };
+  Object.assign(updateMemoryFn, {
+    help: () => Promise.resolve({
+      name: "updateMemory",
+      group: "core",
+      description: "Record or update an entry in the memory journal. Pass { title, content, tags, ... } to create an entry, or include entry_id to update an existing entry."
+    }),
+    describe: () => Promise.resolve({
+      name: "updateMemory",
+      group: "core",
+      description: "Record or update an entry in the memory journal. Pass { title, content, tags, ... } to create an entry, or include entry_id to update an existing entry."
+    }),
+    schema: () => {
+      const coreGroup = shimMj["core"];
+      if (isTargetLike(coreGroup)) {
+        const createEntry = Reflect.get(coreGroup, "createEntry");
+        if (isTargetLike(createEntry) && "schema" in createEntry) {
+          const schemaFn = Reflect.get(createEntry, "schema");
+          if (typeof schemaFn === "function") {
+            return schemaFn();
+          }
+        }
+      }
+      return Promise.resolve("unknown");
+    }
+  });
+  return updateMemoryFn;
+}
+function wrapDelegatingTool(fn, targetFnGetter) {
+  return new Proxy(fn, {
+    get(target, prop, receiver) {
+      const real = targetFnGetter();
+      if (typeof real === "object" && real !== null || typeof real === "function") {
+        if (prop in real) {
+          return Reflect.get(real, prop);
+        }
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+var SHIM_TABLES = [
+  "memory_journal",
+  "tags",
+  "entry_tags",
+  "relationships",
+  "entry_anchors",
+  "entry_revisions",
+  "vec_embeddings",
+  "team_flags"
+];
+var schemaHelpFn = () => Promise.resolve({
+  group: "schema",
+  description: "Memory Journal Schema: Embedded SQLite database storing journal entries, tags, relationships, code anchors, revisions, vector embeddings, and team flags.",
+  tables: SHIM_TABLES,
+  entrySchema: {
+    id: "number (auto-increment primary key)",
+    content: "string (required, markdown body)",
+    entry_type: ENTRY_TYPES.map((t) => `'${t}'`).join(" | "),
+    timestamp: "string (ISO 8601 timestamp)",
+    is_personal: "boolean (default: true)",
+    significance_type: `optional (${SIGNIFICANCE_TYPES.map((t) => `'${t}'`).join(" | ")})`,
+    tags: "string[] (optional array of kebab-case tags)",
+    workspace_id: "string (required repository/workspace identifier)",
+    project_number: "number (optional GitHub project number)",
+    impact_score: "number (0.0-1.0 blast radius score)",
+    trust_score: "number (0.0-1.0 confidence score)",
+    validation_status: "'passed' | 'none' | 'failed'",
+    auto_context: 'string (optional JSON metadata string, e.g. { "commits": ["<sha>"] })',
+    session_id: "string (optional session tracking id)",
+    relationships: "Array<{ targetId: number, relationType?: string }> (optional entry links)",
+    anchors: "Array<{ anchor_path: string, anchor_type: string, status?: string }> (optional code anchors)"
+  },
+  methods: ["help", "describe", "listTables", "describeTable", "getSchema"],
+  usage: "Call mj.core.createEntry.schema() for entry parameter details, or mj.analytics.getStatistics() for database statistics."
+});
+function createSchemaShim(shimMj) {
+  const getStatsFn = () => {
+    const analyticsGroup = shimMj["analytics"];
+    if (isTargetLike(analyticsGroup)) {
+      const fn = Reflect.get(analyticsGroup, "getStatistics");
+      if (typeof fn === "function") {
+        return fn;
+      }
+    }
+    return void 0;
+  };
+  const schemaCallable = function(...args) {
+    const fn = getStatsFn();
+    if (fn !== void 0) {
+      return fn(...args);
+    }
+    return schemaHelpFn();
+  };
+  return new Proxy(schemaCallable, {
+    apply(_t, _thisArg, args) {
+      const fn = getStatsFn();
+      if (fn !== void 0) {
+        return Reflect.apply(fn, void 0, args);
+      }
+      return schemaHelpFn();
+    },
+    get(_t, p) {
+      if (p === "then") return void 0;
+      if (p === "help" || p === "describe") return schemaHelpFn;
+      if (p === "listTables") {
+        return () => Promise.resolve({
+          success: true,
+          tables: SHIM_TABLES
+        });
+      }
+      if (p === "describeTable" || p === "getSchema") return schemaHelpFn;
+      if (p === "schema") return createSchemaShim(shimMj);
+      if (p === "tables")
+        return SHIM_TABLES;
+      if (p === "memory_journal" || p === "entries" || p === "journal" || p === "memory") {
+        const coreGroup = shimMj["core"];
+        if (isTargetLike(coreGroup)) {
+          const createEntry = Reflect.get(coreGroup, "createEntry");
+          if (isTargetLike(createEntry) && "schema" in createEntry) {
+            const schemaFn = Reflect.get(createEntry, "schema");
+            if (typeof schemaFn === "function") {
+              return schemaFn();
+            }
+          }
+        }
+        return schemaHelpFn();
+      }
+      if (typeof p === "string" && p in Function.prototype) {
+        return Reflect.get(Function.prototype, p);
+      }
+      return Reflect.get(shimMj, p);
+    }
+  });
+}
+function createEmptyFallback(_name) {
+  const emptyIter = function* () {
+  };
+  const fallback = {
+    values: () => emptyIter(),
+    keys: () => emptyIter(),
+    entries: () => emptyIter(),
+    forEach: () => void 0,
+    get: () => void 0,
+    has: () => false,
+    set: () => fallback,
+    delete: () => false,
+    clear: () => void 0,
+    size: 0,
+    length: 0,
+    [Symbol.iterator]: emptyIter,
+    map: () => [],
+    filter: () => [],
+    reduce: (_fn, init) => init ?? [],
+    reduceRight: (_fn, init) => init ?? [],
+    slice: () => [],
+    find: () => void 0,
+    findIndex: () => -1,
+    some: () => false,
+    every: () => true,
+    includes: () => false,
+    indexOf: () => -1,
+    join: () => "",
+    concat: () => [],
+    at: () => void 0,
+    flat: () => [],
+    flatMap: () => []
+  };
+  return new Proxy(fallback, {
+    get(t, p) {
+      if (p in t) return t[p];
+      if (typeof p === "symbol") return void 0;
+      return void 0;
+    }
+  });
+}
+var CONTEXT_COLLECTION_NAMES = [
+  "entries",
+  "results",
+  "projects",
+  "items",
+  "rows",
+  "tables",
+  "flags",
+  "groups",
+  "users",
+  "capabilities",
+  "metrics",
+  "events",
+  "records",
+  "logs",
+  "aliases",
+  "tags",
+  "issues",
+  "pullRequests",
+  "milestones",
+  "columns",
+  "comments",
+  "files",
+  "errors",
+  "backups",
+  "deleted",
+  "updated",
+  "notFound",
+  "history",
+  "relationships",
+  "members",
+  "data",
+  "map",
+  "list"
+];
+function createContextProxy(contextObj) {
+  const contextProxy = new Proxy(contextObj ?? {}, {
+    get(target, prop) {
+      if (typeof prop === "symbol") {
+        if (prop === Symbol.toPrimitive) {
+          return (hint) => {
+            if (hint === "number") return NaN;
+            try {
+              return JSON.stringify(target);
+            } catch {
+              return "[object Object]";
+            }
+          };
+        }
+        return void 0;
+      }
+      if (prop === "toString") {
+        return () => {
+          try {
+            return JSON.stringify(target);
+          } catch {
+            return "[object Object]";
+          }
+        };
+      }
+      if (prop === "toJSON") {
+        return () => target;
+      }
+      if (prop === "get" || prop === "getContext" || prop === "get_context") {
+        return (key) => Promise.resolve(
+          wrapResult(
+            typeof key === "string" && key in target ? target[key] : { success: true, ...target }
+          )
+        );
+      }
+      if (prop in target) return target[prop];
+      if (prop === "executeSystemPrompt" || prop === "getPrompt" || prop === "executePrompt") {
+        return (_promptName) => Promise.resolve({
+          success: false,
+          error: `Code Mode cannot execute MCP Prompts via context.${prop}(). Code Mode is for running JavaScript with mj.* tools. Use mj.core.createEntry to save entries.`,
+          code: "VALIDATION_ERROR",
+          category: "validation",
+          recoverable: true
+        });
+      }
+      if (typeof prop === "string" && CONTEXT_COLLECTION_NAMES.includes(prop)) {
+        return createEmptyFallback();
+      }
+      return target[prop];
+    }
+  });
+  return Object.freeze(contextProxy);
+}
+
+// src/codemode/worker/mj-shim-domains.ts
+function getGroupProp(target, group, prop) {
+  const g = target[group];
+  return typeof g === "object" && g !== null || typeof g === "function" ? Reflect.get(g, prop) : void 0;
+}
+var ADAPTER_ITEMS = [
+  { name: "sqlite", type: "database", driver: "better-sqlite3", status: "connected", primary: true, description: "Primary SQLite storage engine for journal entries, tags, and relationships" },
+  { name: "sqlite-vec", type: "vector", driver: "sqlite-vec", status: "connected", description: "Native vector embeddings and semantic search engine" },
+  { name: "team", type: "database", driver: "better-sqlite3", status: "connected", description: "Collaborative team journal database adapter" },
+  { name: "github", type: "integration", driver: "octokit / gh", status: "connected", description: "GitHub synchronization and issue tracking adapter" }
+];
+function createAdaptersShim(prop) {
+  const returnAdapters = () => Promise.resolve({
+    success: true,
+    adapters: ADAPTER_ITEMS,
+    default_adapter: "sqlite",
+    _healing_note: `\u{1F6E0}\uFE0F AUTONOMOUS HEALING: '${prop}' was called. Returned registered database and service adapters successfully.`
+  });
+  const callable = () => returnAdapters();
+  Object.assign(callable, {
+    list: returnAdapters,
+    listAdapters: returnAdapters,
+    list_adapters: returnAdapters,
+    get: returnAdapters
+  });
+  return new Proxy(callable, {
+    apply: () => returnAdapters(),
+    get(t, p) {
+      if (typeof p === "symbol" || p === "then") return void 0;
+      if (p in t) return Reflect.get(t, p);
+      return returnAdapters;
+    }
+  });
+}
+var RESOURCE_SUGGESTIONS2 = {
+  "memory://agent-id": "mj.core.getStatistics() or mj.core.listProjects()",
+  "memory://recent": "mj.core.getRecentEntries()",
+  "memory://statistics": "mj.analytics.getStatistics()",
+  "memory://tags": "mj.core.listTags()",
+  "memory://flags": 'mj.team.teamListFlags({ status: "active" })',
+  "memory://significant": 'mj.search.searchEntries({ sort_by: "importance" })',
+  "memory://insights": "mj.analytics.getCrossProjectInsights()"
+};
+function createShimReadResourceHandler() {
+  return (uri) => {
+    let hint = "";
+    if (typeof uri === "string") {
+      const match = Object.entries(RESOURCE_SUGGESTIONS2).find(([k]) => uri.startsWith(k));
+      if (match !== void 0) hint = ` Try: ${match[1]}`;
+    }
+    return Promise.resolve({
+      success: false,
+      error: `Code Mode cannot directly read MCP resources (e.g., memory://briefing) using readResource().${hint} Use the appropriate mj.* tools to query data, or read the resource via standard MCP client requests outside of Code Mode.`,
+      code: "VALIDATION_ERROR",
+      category: "validation",
+      recoverable: true
+    });
+  };
+}
+function createEntriesDomainProxy(target) {
+  const listFunc = getGroupProp(target, "core", "get_recent_entries") ?? getGroupProp(target, "core", "getRecentEntries");
+  if (typeof listFunc !== "function") return void 0;
+  const callableEntries = function(...args) {
+    return listFunc.apply(this, args);
+  };
+  const createFn = getGroupProp(target, "core", "create_entry") ?? getGroupProp(target, "core", "createEntry");
+  const getFn = getGroupProp(target, "core", "get_entry_by_id") ?? getGroupProp(target, "core", "getEntryById");
+  const updateFn = getGroupProp(target, "admin", "update_entry") ?? getGroupProp(target, "admin", "updateEntry") ?? getGroupProp(target, "core", "update_entry") ?? getGroupProp(target, "core", "updateEntry");
+  const deleteFn = getGroupProp(target, "admin", "delete_entry") ?? getGroupProp(target, "admin", "deleteEntry") ?? getGroupProp(target, "core", "delete_entry") ?? getGroupProp(target, "core", "deleteEntry");
+  const searchFn = getGroupProp(target, "search", "search_entries") ?? getGroupProp(target, "search", "searchEntries") ?? getGroupProp(target, "core", "search_entries") ?? getGroupProp(target, "core", "searchEntries");
+  Object.assign(callableEntries, {
+    create: createFn,
+    createEntry: createFn,
+    create_entry: createFn,
+    add: createFn,
+    push: createFn,
+    get: getFn,
+    getEntryById: getFn,
+    get_entry_by_id: getFn,
+    update: updateFn,
+    updateEntry: updateFn,
+    update_entry: updateFn,
+    delete: deleteFn,
+    deleteEntry: deleteFn,
+    delete_entry: deleteFn,
+    search: searchFn,
+    searchEntries: searchFn,
+    search_entries: searchFn,
+    list: listFunc,
+    listEntries: listFunc,
+    list_entries: listFunc,
+    getRecent: listFunc,
+    getRecentEntries: listFunc,
+    get_recent_entries: listFunc
+  });
+  return new Proxy(callableEntries, {
+    get(targetFn, p, receiver) {
+      if (p in targetFn) return Reflect.get(targetFn, p, receiver);
+      if (typeof p === "string") {
+        const pLower = p.toLowerCase().replace(/_/g, "");
+        if ((pLower.includes("search") || pLower.includes("query") || pLower.includes("find")) && typeof searchFn === "function") return searchFn;
+        if ((pLower.includes("create") || pLower.includes("add") || pLower.includes("insert") || pLower.includes("append")) && typeof createFn === "function") return createFn;
+        if ((pLower.includes("get") || pLower.includes("fetch") || pLower.includes("read") || pLower.includes("byid")) && typeof getFn === "function") return getFn;
+        if ((pLower.includes("update") || pLower.includes("edit") || pLower.includes("patch")) && typeof updateFn === "function") return updateFn;
+        if ((pLower.includes("delete") || pLower.includes("remove")) && typeof deleteFn === "function") return deleteFn;
+        if (pLower.includes("recent") || pLower.includes("list") || pLower.includes("all")) return listFunc;
+        const methodOnCore = getGroupProp(target, "core", p) ?? getGroupProp(target, "search", p) ?? getGroupProp(target, "admin", p);
+        if (typeof methodOnCore === "function") return methodOnCore;
+      }
+      return Reflect.get(targetFn, p, receiver);
+    }
+  });
+}
+function createGetReadFindInterceptor(target, shimMj) {
+  const getFn = getGroupProp(target, "core", "get_entry_by_id") ?? getGroupProp(target, "core", "getEntryById");
+  const searchFn = getGroupProp(target, "search", "search_entries") ?? getGroupProp(target, "search", "searchEntries");
+  return (arg) => {
+    if (arg === void 0) return Promise.resolve(shimMj);
+    if (typeof arg === "number" || typeof arg === "string") {
+      const parsedId = Number(arg);
+      if (!Number.isNaN(parsedId)) {
+        return typeof getFn === "function" ? getFn({ entry_id: parsedId }) : void 0;
+      }
+      if (typeof arg === "string") return Promise.resolve(shimMj);
+    }
+    if (arg !== null && typeof arg === "object") {
+      if ("entry_id" in arg || "id" in arg) {
+        return typeof getFn === "function" ? getFn(arg) : void 0;
+      }
+      if ("query" in arg || "tags" in arg || "search" in arg || "text" in arg || "q" in arg) {
+        return typeof searchFn === "function" ? searchFn(arg) : void 0;
+      }
+    }
+    return typeof getFn === "function" ? getFn(arg) : void 0;
+  };
+}
+function createShimProjectsDomain(target, shimMj) {
+  const baseProjectsProxy = target["projects"];
+  const createFn = getGroupProp(target, "core", "create_entry") ?? getGroupProp(target, "core", "createEntry");
+  const insightsFn = getGroupProp(target, "analytics", "get_cross_project_insights") ?? getGroupProp(target, "analytics", "getCrossProjectInsights");
+  const projectsFn = function(...args) {
+    if (typeof baseProjectsProxy === "function") {
+      return baseProjectsProxy.apply(this, args);
+    }
+    return Promise.resolve({ success: true, projects: {}, items: [], data: [] });
+  };
+  return new Proxy(projectsFn, {
+    apply(_t, thisArg, args) {
+      if (typeof baseProjectsProxy === "function") {
+        return baseProjectsProxy.apply(thisArg, args);
+      }
+      return Promise.resolve({ success: true, projects: [] });
+    },
+    get(_t, p) {
+      if (typeof p === "symbol" || p === "then") return void 0;
+      if (p === "entries") return { create: createFn, add: createFn };
+      if (p === "insights" && typeof insightsFn === "function") {
+        return (...args) => insightsFn(...args);
+      }
+      if (typeof baseProjectsProxy === "function" || typeof baseProjectsProxy === "object" && baseProjectsProxy !== null) {
+        return Reflect.get(baseProjectsProxy, p);
+      }
+      return createCallableShim(shimMj);
+    }
+  });
+}
+var STATS_METHOD_KEYS = /* @__PURE__ */ new Set([
+  "getStatistics",
+  "getStats",
+  "stats",
+  "info",
+  "getInfo",
+  "getDatabaseInfo",
+  "databaseInfo",
+  "getHealth",
+  "health",
+  "status",
+  "getStatus",
+  "serverInfo",
+  "server_info",
+  "serverHealth",
+  "server_health",
+  "serverStatus",
+  "server_status",
+  "healthCheck",
+  "health_check",
+  "diagnostics",
+  "getDiagnostics",
+  "systemInfo",
+  "system_info",
+  "adapters",
+  "listAdapters",
+  "list_adapters",
+  "getAdapters",
+  "get_adapters"
+]);
+function createDbDomainProxy(target, shimMj) {
+  const getStatsFn = getGroupProp(target, "analytics", "getStatistics") ?? getGroupProp(target, "analytics", "get_statistics");
+  return new Proxy({}, {
+    get(_t, dbProp) {
+      if (typeof dbProp === "symbol" || dbProp === "then") return void 0;
+      if (dbProp === "schema") return createSchemaShim(shimMj);
+      if (dbProp === "help" || dbProp === "describe") {
+        const helpFn = target["help"];
+        return () => typeof helpFn === "function" ? helpFn() : void 0;
+      }
+      if (dbProp === "prepare" || dbProp === "stmt" || dbProp === "statement") {
+        return (sql) => createPreparedStatementShim(typeof sql === "string" ? sql : "", shimMj);
+      }
+      if (dbProp === "exec") {
+        return (sql) => {
+          const stmt = createPreparedStatementShim(typeof sql === "string" ? sql : "", shimMj);
+          const runFn = stmt["run"];
+          return typeof runFn === "function" ? runFn() : void 0;
+        };
+      }
+      if (dbProp === "query" || dbProp === "raw") {
+        return (sql) => {
+          const stmt = createPreparedStatementShim(typeof sql === "string" ? sql : "", shimMj);
+          const allFn = stmt["all"];
+          return typeof allFn === "function" ? allFn() : void 0;
+        };
+      }
+      if (dbProp === "close" || dbProp === "dispose" || dbProp === "disconnect") {
+        return () => ({ success: true });
+      }
+      if (dbProp === "getDatabase" || dbProp === "getDb" || dbProp === "get_database" || dbProp === "get_db") {
+        return () => shimMj;
+      }
+      if (dbProp === "ping") return () => Promise.resolve({ success: true, status: "pong" });
+      if (dbProp === "version") {
+        return () => Promise.resolve({ success: true, version: VERSION, name: "memory-journal-mcp" });
+      }
+      if (STATS_METHOD_KEYS.has(dbProp) && typeof getStatsFn === "function") return getStatsFn;
+      return (..._args) => Promise.resolve({
+        success: false,
+        error: `Direct SQLite database access 'mj.db.${dbProp}()' is not available in Code Mode sandbox. Use high-level API methods instead: mj.core.createEntry({ ... }), mj.core.getRecentEntries({ ... }), or mj.search.searchEntries({ ... }).`,
+        code: "VALIDATION_ERROR",
+        category: "validation",
+        suggestion: "Use mj.core or mj.search methods.",
+        recoverable: true
+      });
+    }
+  });
+}
+function createSystemDatabaseDomainProxy(target, shimMj) {
+  if (typeof target["system"] === "function" || typeof target["system"] === "object" && target["system"] !== null) {
+    return target["system"];
+  }
+  const getStatsFn = getGroupProp(target, "analytics", "getStatistics") ?? getGroupProp(target, "analytics", "get_statistics");
+  const dbShim = {
+    ping: () => Promise.resolve({ success: true, status: "pong" }),
+    version: () => Promise.resolve({ success: true, version: VERSION, name: "memory-journal-mcp" })
+  };
+  for (const k of STATS_METHOD_KEYS) dbShim[k] = getStatsFn;
+  return new Proxy(dbShim, {
+    get(t, p) {
+      if (typeof p === "symbol" || p === "then") return void 0;
+      if (typeof p === "string" && p in t) return t[p];
+      if (typeof getStatsFn === "function") return getStatsFn;
+      return createCallableShim(shimMj);
+    }
+  });
+}
+function createSearchDomainProxy(target) {
+  const searchGroup = target["search"];
+  if ((typeof searchGroup !== "object" || searchGroup === null) && typeof searchGroup !== "function") {
+    return void 0;
+  }
+  const searchFunc = Reflect.get(searchGroup, "search_entries") ?? Reflect.get(searchGroup, "searchEntries");
+  if (typeof searchFunc === "function") {
+    const callableSearch = function(...args) {
+      return searchFunc.apply(this, args);
+    };
+    Object.assign(callableSearch, searchGroup, {
+      search: searchFunc,
+      query: searchFunc,
+      queryEntries: searchFunc,
+      query_entries: searchFunc,
+      searchEntries: searchFunc,
+      search_entries: searchFunc,
+      find: searchFunc,
+      findEntries: searchFunc,
+      find_entries: searchFunc
+    });
+    return new Proxy(callableSearch, {
+      get(targetFn, p, receiver) {
+        if (p in targetFn) return Reflect.get(targetFn, p, receiver);
+        return Reflect.get(searchGroup, p, receiver);
+      }
+    });
+  }
+  return searchGroup;
+}
+function createAppendInterceptor(target) {
+  const createEntry = getGroupProp(target, "core", "createEntry");
+  if (typeof createEntry !== "function") return void 0;
+  return (arg1, arg2, arg3) => {
+    const tags = Array.isArray(arg1) ? arg1 : [typeof arg1 === "string" ? arg1 : "test"];
+    const content = typeof arg2 === "string" ? arg2 : arg2 !== null && arg2 !== void 0 ? JSON.stringify(arg2) : "";
+    const metadata = typeof arg3 === "object" && arg3 !== null && !Array.isArray(arg3) ? { ...arg3 } : void 0;
+    const typeVal = metadata?.["type"];
+    const type = typeof typeVal === "string" && typeVal !== "" ? typeVal : "test_entry";
+    if (metadata !== void 0 && "type" in metadata) delete metadata["type"];
+    return createEntry({ type, tags, content, metadata });
+  };
+}
+
+// src/codemode/worker/mj-shim-proxy.ts
+var SELF_REFERENTIAL_PROPS = /* @__PURE__ */ new Set([
+  "mj",
+  "journal",
+  "journals",
+  "journal_entries",
+  "journalEntries",
+  "memory",
+  "memory_journal",
+  "memory_journal_mcp",
+  "sqlite",
+  "sqlite3",
+  "m",
+  "env",
+  "agent",
+  "mcp",
+  "mcpx",
+  "mc",
+  "memoryJournal",
+  "MemoryJournal",
+  "mjJournal",
+  "mjClient",
+  "mj_client",
+  "app",
+  "tools",
+  "tool",
+  "api",
+  "client",
+  "sdk",
+  "service",
+  "services",
+  "kernel",
+  "node",
+  "default"
+]);
+var EXECUTE_CODE_PROPS = /* @__PURE__ */ new Set([
+  "execute",
+  "executeCode",
+  "execute_code",
+  "mj_execute_code",
+  "mjExecuteCode"
+]);
+var ADAPTER_PROPS = /* @__PURE__ */ new Set([
+  "adapters",
+  "list_adapters",
+  "listAdapters",
+  "get_adapters",
+  "getAdapters"
+]);
+var READ_RESOURCE_PROPS = /* @__PURE__ */ new Set([
+  "readResource",
+  "read_resource",
+  "memory_read_resource",
+  "memoryReadResource",
+  "getResource",
+  "get_resource"
+]);
+var BRIEFING_PROPS = /* @__PURE__ */ new Set([
+  "loadBriefing",
+  "load_briefing",
+  "getBriefing",
+  "get_briefing"
+]);
+var CREATE_ENTRY_HALLUCINATION_PROPS = /* @__PURE__ */ new Set([
+  "addEntry",
+  "create_entry",
+  "createEntry",
+  "create",
+  "add",
+  "log",
+  "insertEntry",
+  "insert_entry",
+  "insert",
+  "add_entry",
+  "newEntry",
+  "new_entry",
+  "logEntry",
+  "log_entry",
+  "saveEntry",
+  "save_entry",
+  "writeEntry",
+  "write_entry",
+  "appendEntry",
+  "append_entry",
+  "createMemory",
+  "create_memory",
+  "addMemory",
+  "add_memory",
+  "recordMemory",
+  "record_memory"
+]);
+var UPDATE_MEMORY_PROPS = /* @__PURE__ */ new Set([
+  "updateMemory",
+  "update_memory",
+  "setMemory",
+  "set_memory",
+  "updateJournal",
+  "update_journal"
+]);
+var FACTORY_SHIM_PROPS = /* @__PURE__ */ new Set([
+  "load",
+  "loadJournal",
+  "loadMemory",
+  "load_memory",
+  "init",
+  "initialize",
+  "connect",
+  "getJournal",
+  "get_journal",
+  "load_journal",
+  "getInstance",
+  "get_instance",
+  "createInstance",
+  "create_instance",
+  "initInstance",
+  "init_instance",
+  "getClient",
+  "get_client",
+  "createClient",
+  "create_client",
+  "initClient",
+  "init_client",
+  "getService",
+  "get_service",
+  "createService",
+  "create_service",
+  "createJournal",
+  "create_journal",
+  "open",
+  "start",
+  "getDatabase",
+  "get_database",
+  "getDb",
+  "get_db",
+  "connectToDatabase",
+  "connect_to_database",
+  "openDatabase",
+  "open_database",
+  "create"
+]);
+var LIFECYCLE_PROPS = /* @__PURE__ */ new Set([
+  "close",
+  "dispose",
+  "disconnect",
+  "end",
+  "destroy",
+  "quit",
+  "exit",
+  "terminate",
+  "clear",
+  "reset"
+]);
+var DB_CONSTRUCTOR_PROPS = /* @__PURE__ */ new Set([
+  "Database",
+  "Sqlite3",
+  "BetterSqlite3",
+  "better_sqlite3",
+  "betterSqlite3"
+]);
+function getGroupProp2(target, group, prop) {
+  const g = target[group];
+  return typeof g === "object" && g !== null || typeof g === "function" ? Reflect.get(g, prop) : void 0;
+}
+function createShimMjProxy(options) {
+  const { mjApi, safeFsShim, executeCodeFnRef, getUpdateMemoryFn } = options;
+  const shimMj = new Proxy({}, {
+    get(_fakeTarget, prop) {
+      const target = mjApi;
+      if (typeof prop === "string" && SELF_REFERENTIAL_PROPS.has(prop)) return shimMj;
+      if (prop === "context") return mjApi["context"];
+      if (prop === "getContext" || prop === "get_context") return mjApi["getContext"];
+      if (prop === "schema") return createSchemaShim(shimMj);
+      if (typeof prop === "string" && EXECUTE_CODE_PROPS.has(prop)) {
+        return (arg) => {
+          if (executeCodeFnRef.current !== void 0) return executeCodeFnRef.current(arg);
+          if ("codemode" in target) {
+            const fn = getGroupProp2(target, "codemode", "mjExecuteCode") ?? getGroupProp2(target, "codemode", "executeCode");
+            if (typeof fn === "function") return fn(arg);
+          }
+          return Promise.resolve({ success: true });
+        };
+      }
+      if (typeof prop === "string" && ADAPTER_PROPS.has(prop)) return createAdaptersShim(prop);
+      if (typeof prop === "string" && READ_RESOURCE_PROPS.has(prop)) return createShimReadResourceHandler();
+      if (prop === "logger") return consoleShim;
+      if (typeof prop === "string" && BRIEFING_PROPS.has(prop) && "core" in target) {
+        const fn = getGroupProp2(target, "core", "getRecentEntries") ?? getGroupProp2(target, "core", "get_recent_entries");
+        if (typeof fn === "function") {
+          return (args) => fn({ limit: 10, sort_by: "importance", ...args });
+        }
+      }
+      if ((prop === "entries" || prop === "entry") && "core" in target) {
+        const entriesProxy = createEntriesDomainProxy(target);
+        if (entriesProxy !== void 0) return entriesProxy;
+      }
+      if (typeof prop === "string" && CREATE_ENTRY_HALLUCINATION_PROPS.has(prop) && "core" in target) {
+        return getGroupProp2(target, "core", "create_entry") ?? getGroupProp2(target, "core", "createEntry");
+      }
+      if (typeof prop === "string" && UPDATE_MEMORY_PROPS.has(prop)) return getUpdateMemoryFn();
+      if (prop === "saveMemory" || prop === "save_memory") {
+        return (arg) => arg !== void 0 && arg !== null ? getUpdateMemoryFn()(arg) : Promise.resolve({ success: true });
+      }
+      if ((prop === "get" || prop === "read" || prop === "find" || prop === "fetch") && "core" in target && "search" in target) {
+        return createGetReadFindInterceptor(target, shimMj);
+      }
+      if ((prop === "update" || prop === "edit") && "core" in target) {
+        return getGroupProp2(target, "core", "update_entry") ?? getGroupProp2(target, "core", "updateEntry");
+      }
+      if ((prop === "delete" || prop === "remove") && "core" in target) {
+        return getGroupProp2(target, "core", "delete_entry") ?? getGroupProp2(target, "core", "deleteEntry");
+      }
+      if (typeof prop === "string" && FACTORY_SHIM_PROPS.has(prop)) {
+        return createCallableShim(shimMj, "factoryFn");
+      }
+      if (prop === "projects" || prop === "project") return createShimProjectsDomain(target, shimMj);
+      if (prop === "db") {
+        return "core" in target ? createDbDomainProxy(target, shimMj) : createSystemDatabaseDomainProxy(target, shimMj);
+      }
+      if (prop === "prepare" || prop === "stmt" || prop === "statement") {
+        return (sql) => createPreparedStatementShim(typeof sql === "string" ? sql : "", shimMj);
+      }
+      if (prop === "query" || prop === "raw") {
+        return (sql) => {
+          const stmt = createPreparedStatementShim(typeof sql === "string" ? sql : "", shimMj);
+          const allFn = stmt["all"];
+          return typeof allFn === "function" ? allFn() : void 0;
+        };
+      }
+      if (prop === "exec") {
+        return (sql) => {
+          const stmt = createPreparedStatementShim(typeof sql === "string" ? sql : "", shimMj);
+          const runFn = stmt["run"];
+          return typeof runFn === "function" ? runFn() : void 0;
+        };
+      }
+      if (typeof prop === "string" && LIFECYCLE_PROPS.has(prop)) return () => ({ success: true });
+      if (prop === "execSync" || prop === "spawnSync" || prop === "execFileSync") return () => "";
+      if (prop === "spawn" || prop === "fork" || prop === "execFile") {
+        return (_cmd, cbOrOptions, maybeCb) => {
+          const cb = typeof cbOrOptions === "function" ? cbOrOptions : typeof maybeCb === "function" ? maybeCb : void 0;
+          if (cb !== void 0) {
+            try {
+              cb(null, "", "");
+            } catch {
+            }
+          }
+          const noop = () => {
+          };
+          return { on: noop, stdout: { on: noop }, stderr: { on: noop }, kill: () => true, status: 0, output: ["", "", ""] };
+        };
+      }
+      if (prop === "fs" || prop === "__safeFs" || prop === "safeFs") return safeFsShim;
+      if (prop === "path" || prop === "__path") return pathShim;
+      if (prop === "existsSync") return safeFsShim.existsSync;
+      if (prop === "readFileSync" || prop === "readFile") return safeFsShim.readFileSync;
+      if (prop === "writeFileSync" || prop === "writeFile" || prop === "mkdirSync" || prop === "appendFileSync" || prop === "unlinkSync") {
+        return () => void 0;
+      }
+      if (prop === "statSync") return safeFsShim.statSync;
+      if (prop === "stat") return safeFsShim.stat;
+      if (prop === "readdirSync") return () => [];
+      if (prop === "join" || prop === "resolve" || prop === "basename" || prop === "dirname" || prop === "extname") {
+        return (...parts) => parts.filter((p) => typeof p === "string").join("/");
+      }
+      if (prop === "promisify") return (fn) => fn;
+      if (prop === "format" || prop === "inspect") return (...args) => args.map(String).join(" ");
+      if (typeof prop === "string" && DB_CONSTRUCTOR_PROPS.has(prop)) return createCallableShim(shimMj);
+      if (prop === "database" || prop === "system") return createSystemDatabaseDomainProxy(target, shimMj);
+      if (prop === "tags" || prop === "tag") return target["tags"];
+      if ((prop === "getProjects" || prop === "listProjects" || prop === "searchProjects") && "analytics" in target) {
+        return getGroupProp2(target, "analytics", "get_cross_project_insights") ?? getGroupProp2(target, "analytics", "getCrossProjectInsights");
+      }
+      if (prop === "search" && "search" in target) {
+        const searchDomain = createSearchDomainProxy(target);
+        if (searchDomain !== void 0) return searchDomain;
+      }
+      if (prop === "append" && "core" in target) {
+        const appendFn = createAppendInterceptor(target);
+        if (appendFn !== void 0) return appendFn;
+      }
+      if (typeof prop === "string" && prop.includes("_")) {
+        const camelProp = prop.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+        if (camelProp !== prop) {
+          const mapping = DB_TO_JOURNAL[camelProp];
+          if (mapping !== void 0) {
+            const [group, method] = mapping;
+            if (group in target) return getGroupProp2(target, group, method);
+          }
+          if (camelProp in target) return target[camelProp];
+        }
+      }
+      if (typeof prop === "string") {
+        const mapping = DB_TO_JOURNAL[prop];
+        if (mapping !== void 0) {
+          const [group, method] = mapping;
+          if (group in target) return getGroupProp2(target, group, method);
+        }
+      }
+      return typeof prop === "string" ? target[prop] : void 0;
+    },
+    has: (_fakeTarget, prop) => prop in mjApi,
+    ownKeys: () => Reflect.ownKeys(mjApi),
+    getOwnPropertyDescriptor(_fakeTarget, prop) {
+      const desc = Reflect.getOwnPropertyDescriptor(mjApi, prop);
+      return desc ? { ...desc, configurable: true } : void 0;
+    },
+    set: () => false,
+    defineProperty: () => false,
+    deleteProperty: () => false,
+    setPrototypeOf: () => false,
+    isExtensible: () => true,
+    preventExtensions: () => false
+  });
+  return shimMj;
+}
+
+// src/codemode/worker/sandbox-globals.ts
+function getGroupMethod(shimMj, group, method) {
+  const g = shimMj[group];
+  if (typeof g === "object" && g !== null || typeof g === "function") {
+    const fn = Reflect.get(g, method);
+    if (typeof fn === "function") {
+      return fn;
+    }
+  }
+  return void 0;
+}
+function makeDelegatingTool(shimMj, group, method) {
+  return wrapDelegatingTool(
+    (arg) => getGroupMethod(shimMj, group, method)?.(arg),
+    () => getGroupMethod(shimMj, group, method)
+  );
+}
+function createProcessOperationFn(shimMj) {
+  return (arg) => {
+    if (typeof arg === "object" && arg !== null && !Array.isArray(arg)) {
+      const op = Reflect.get(arg, "operation") ?? Reflect.get(arg, "op") ?? Reflect.get(arg, "action") ?? Reflect.get(arg, "type");
+      if (op === "add_entry" || op === "create_entry" || op === "create" || op === "add" || op === "insert") {
+        return getGroupMethod(shimMj, "core", "createEntry")?.(arg);
+      }
+      if (op === "update_entry" || op === "update" || op === "edit") {
+        return getGroupMethod(shimMj, "admin", "updateEntry")?.(arg);
+      }
+      if (op === "delete_entry" || op === "delete" || op === "remove") {
+        return getGroupMethod(shimMj, "admin", "deleteEntry")?.(arg);
+      }
+      if (op === "search_entries" || op === "search" || op === "find") {
+        return getGroupMethod(shimMj, "search", "searchEntries")?.(arg);
+      }
+    }
+    return getGroupMethod(shimMj, "core", "createEntry")?.(arg);
+  };
+}
+var DELEGATING_TOOL_MAPPINGS = [
+  [
+    [
+      "search_entries",
+      "searchEntries",
+      "query_entries",
+      "queryEntries",
+      "mj_search_entries",
+      "mjSearchEntries"
+    ],
+    "search",
+    "searchEntries"
+  ],
+  [
+    ["get_recent_entries", "getRecentEntries", "mj_get_recent_entries", "mjGetRecentEntries"],
+    "core",
+    "getRecentEntries"
+  ],
+  [
+    ["get_entry_by_id", "getEntryById", "mj_get_entry_by_id", "mjGetEntryById"],
+    "core",
+    "getEntryById"
+  ],
+  [
+    ["list_projects", "listProjects", "mj_list_projects", "mjListProjects"],
+    "admin",
+    "listProjects"
+  ],
+  [["get_project", "getProject", "mj_get_project", "mjGetProject"], "admin", "getProject"],
+  [["list_tags", "listTags", "mj_list_tags", "mjListTags"], "core", "listTags"],
+  [
+    [
+      "sqlite_journal_add_entry",
+      "mj_create_entry",
+      "mjCreateEntry",
+      "create_entry",
+      "createEntry",
+      "insert_entry",
+      "insertEntry",
+      "add_entry",
+      "addEntry",
+      "new_entry",
+      "newEntry",
+      "log_entry",
+      "logEntry",
+      "save_entry",
+      "saveEntry",
+      "write_entry",
+      "writeEntry"
+    ],
+    "core",
+    "createEntry"
+  ],
+  [
+    ["mj_update_entry", "mjUpdateEntry", "update_entry", "updateEntry"],
+    "admin",
+    "updateEntry"
+  ],
+  [
+    ["mj_delete_entry", "mjDeleteEntry", "delete_entry", "deleteEntry"],
+    "admin",
+    "deleteEntry"
+  ]
+];
+var DIRECT_CREATE_ENTRY_SHIMS = [
+  "append",
+  "append_entry",
+  "appendEntry",
+  "logJournal",
+  "log_journal",
+  "insertJournal",
+  "insert_journal",
+  "addJournal",
+  "add_journal",
+  "recordJournal",
+  "record_journal",
+  "appendJournal",
+  "append_journal",
+  "saveJournalEntry",
+  "save_journal_entry",
+  "addJournalEntry",
+  "add_journal_entry",
+  "createJournalEntry",
+  "writeJournal"
+];
+function buildSandboxGlobals(options) {
+  const { mjApi, shimMj, safeFsShim, frozenContext, executeCodeFn, updateMemoryFn, activeTimers } = options;
+  const registerTimer = (handle) => {
+    activeTimers?.add(handle);
+    return handle;
+  };
+  const servicesProxy = new Proxy({}, { get: () => shimMj });
+  const kernelProxy = new Proxy({}, { get: () => shimMj });
+  const callableShim = () => createCallableShim(shimMj);
+  const schemaShim = createSchemaShim(shimMj);
+  const getSchemaShim = () => createSchemaShim(shimMj);
+  const processOpFn = createProcessOperationFn(shimMj);
+  const directCreateFn = (arg) => getGroupMethod(shimMj, "core", "createEntry")?.(arg);
+  const updateConfigFn = (arg) => (getGroupMethod(shimMj, "admin", "update_configuration") ?? getGroupMethod(shimMj, "admin", "updateConfiguration"))?.(arg);
+  const saveMemoryFn = (arg) => arg !== void 0 && arg !== null ? updateMemoryFn(arg) : Promise.resolve({ success: true });
+  const sandbox = {
+    mj: shimMj,
+    mcp: shimMj,
+    __mcp: shimMj,
+    __mcp_server: shimMj,
+    __mcp_client: shimMj,
+    execute: executeCodeFn,
+    mj_execute_code: executeCodeFn,
+    execute_code: executeCodeFn,
+    executeCode: executeCodeFn,
+    mjExecuteCode: executeCodeFn,
+    core: shimMj,
+    journal: shimMj,
+    _journal: shimMj,
+    MJ: callableShim(),
+    M: callableShim(),
+    adapter: callableShim(),
+    Entry: callableShim(),
+    getJournal: () => Promise.resolve(shimMj),
+    services: servicesProxy,
+    kernel: kernelProxy,
+    sqlite: shimMj,
+    sqlite3: callableShim(),
+    Database: callableShim(),
+    better_sqlite3: callableShim(),
+    betterSqlite3: callableShim(),
+    BetterSqlite3: callableShim(),
+    Sqlite3: callableShim(),
+    cp: shimMj,
+    child_process: shimMj,
+    fs: safeFsShim,
+    __safeFs: safeFsShim,
+    safeFs: safeFsShim,
+    path: pathShim,
+    __path: pathShim,
+    os: shimMj,
+    util: shimMj,
+    crypto: shimMj,
+    buffer: shimMj,
+    execSync: (..._args) => "",
+    spawnSync: () => ({ status: 0, stdout: "", stderr: "", output: ["", "", ""] }),
+    exec: (_cmd, cb) => {
+      if (typeof cb === "function") {
+        try {
+          ;
+          cb(null, "", "");
+        } catch {
+        }
+      }
+    },
+    spawn: () => {
+      const noop = () => {
+      };
+      return { on: noop, stdout: { on: noop }, stderr: { on: noop } };
+    },
+    postgres: shimMj,
+    mysql: shimMj,
+    db: shimMj,
+    api: shimMj,
+    memory: shimMj,
+    mcpx: shimMj,
+    memoryJournal: callableShim(),
+    MemoryJournal: callableShim(),
+    memory_journal: callableShim(),
+    memory_journal_mcp: callableShim(),
+    m: shimMj,
+    env: shimMj,
+    agent: shimMj,
+    tools: shimMj,
+    sdk: shimMj,
+    client: shimMj,
+    system: shimMj,
+    projects: shimMj["projects"],
+    tags: shimMj["tags"],
+    utils: shimMj,
+    sql: shimMj,
+    schema: schemaShim,
+    Schema: callableShim(),
+    getSchema: getSchemaShim,
+    get_schema: getSchemaShim,
+    tables: schemaShim,
+    Tables: callableShim(),
+    getTables: getSchemaShim,
+    get_tables: getSchemaShim,
+    getInstance: () => shimMj,
+    get_instance: () => shimMj,
+    getClient: () => shimMj,
+    get_client: () => shimMj,
+    createClient: () => shimMj,
+    create_client: () => shimMj,
+    createInstance: () => shimMj,
+    create_instance: () => shimMj,
+    initClient: () => shimMj,
+    init_client: () => shimMj,
+    getDb: () => shimMj,
+    get_db: () => shimMj,
+    getDatabase: () => shimMj,
+    get_database: () => shimMj,
+    connectToDatabase: () => shimMj,
+    openDatabase: () => shimMj,
+    open_database: () => shimMj,
+    prepare: (sql) => createPreparedStatementShim(typeof sql === "string" ? sql : "", shimMj),
+    process_operation: processOpFn,
+    processOperation: processOpFn,
+    updateMemory: updateMemoryFn,
+    update_memory: updateMemoryFn,
+    setMemory: updateMemoryFn,
+    set_memory: updateMemoryFn,
+    updateJournal: updateMemoryFn,
+    update_journal: updateMemoryFn,
+    addMemory: updateMemoryFn,
+    add_memory: updateMemoryFn,
+    recordMemory: updateMemoryFn,
+    record_memory: updateMemoryFn,
+    createMemory: updateMemoryFn,
+    create_memory: updateMemoryFn,
+    loadJournal: () => Promise.resolve(shimMj),
+    saveJournal: () => Promise.resolve({ success: true }),
+    readJournal: () => getGroupMethod(shimMj, "core", "getRecentEntries")?.({ limit: 50 }),
+    loadMemory: () => Promise.resolve(shimMj),
+    saveMemory: saveMemoryFn,
+    save_memory: saveMemoryFn,
+    update_configuration: updateConfigFn,
+    updateConfiguration: updateConfigFn,
+    context: frozenContext,
+    console: consoleShim,
+    fetch: (..._args) => {
+      const errObj = {
+        success: false,
+        error: `\u{1F6E0}\uFE0F AUTONOMOUS HEALING: Direct HTTP 'fetch()' is disabled in sandboxed Code Mode. To query metrics or system state, use mj.analytics.* or mj.admin.* tools (e.g. mj.analytics.getStatistics()).`,
+        code: "VALIDATION_ERROR",
+        category: "validation",
+        recoverable: true
+      };
+      return Promise.resolve({
+        ...errObj,
+        json: () => Promise.resolve(errObj),
+        text: () => Promise.resolve(JSON.stringify(errObj)),
+        ok: false,
+        status: 403
+      });
+    },
+    sleep: (ms) => new Promise((resolve) => {
+      registerTimer(setTimeout(resolve, Math.min(Math.max(0, ms), 3e4)));
+    }),
+    setTimeout: (cb, ms, ...args) => registerTimer(setTimeout(cb, Math.min(Math.max(0, ms), 3e4), ...args)),
+    setInterval: void 0,
+    setImmediate: void 0,
+    getConfig: () => Promise.resolve({ dbPath: "memory-journal.db" }),
+    process: Object.freeze({
+      exit: (code) => ({
+        success: (code ?? 0) === 0,
+        exited: true,
+        exitCode: code ?? 0
+      }),
+      env: Object.freeze({})
+    }),
+    require: void 0,
+    __dirname: void 0,
+    __filename: void 0,
+    global: void 0,
+    globalThis: shimMj,
+    Proxy: void 0
+  };
+  for (const [aliases, group, method] of DELEGATING_TOOL_MAPPINGS) {
+    const delegated = makeDelegatingTool(shimMj, group, method);
+    for (const alias of aliases) {
+      sandbox[alias] = delegated;
+    }
+  }
+  for (const name of DIRECT_CREATE_ENTRY_SHIMS) {
+    sandbox[name] = directCreateFn;
+  }
+  for (const key of Object.keys(mjApi)) {
+    const val = mjApi[key];
+    if (val !== null && typeof val === "object" || typeof val === "function") {
+      for (const groupMethod of Object.keys(val)) {
+        if (groupMethod in sandbox) continue;
+        const fn = Reflect.get(val, groupMethod);
+        if (typeof fn === "function") {
+          sandbox[groupMethod] = fn;
+        }
+      }
+      if (typeof val === "function" && !(key in sandbox)) {
+        sandbox[key] = val;
+      }
+    }
+  }
+  return Object.freeze(sandbox);
+}
+
+// src/codemode/worker/result-compactor.ts
+function compactOversizedResult(val, limitBytes, depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
+  if (val === null || val === void 0 || typeof val !== "object") {
+    return val;
+  }
+  if (depth > 6) {
+    return "[MaxDepthExceeded]";
+  }
+  if (seen.has(val)) {
+    return "[Circular]";
+  }
+  seen.add(val);
+  if (Array.isArray(val)) {
+    const arr = val;
+    const maxItems = arr.length > 25 ? 20 : arr.length;
+    const compactedArr = [];
+    for (let i = 0; i < maxItems; i++) {
+      const item = arr[i];
+      if (typeof item === "string" && item.length > 400) {
+        compactedArr.push(
+          `${item.slice(0, 300)}... [truncated by Code Mode result size guardrail]`
+        );
+      } else {
+        compactedArr.push(compactOversizedResult(item, limitBytes, depth + 1, seen));
+      }
+    }
+    if (arr.length > maxItems) {
+      compactedArr.push({
+        _truncated: true,
+        omitted_items_count: arr.length - maxItems,
+        message: `\u26A0\uFE0F Array truncated from ${arr.length} to ${maxItems} items to fit within ${Math.round(limitBytes / 1024)}KB egress boundary. Pass 'max_result_size' parameter in mj_execute_code to retrieve full data.`
+      });
+    }
+    return compactedArr;
+  }
+  const compactedObj = {};
+  const entries = Object.entries(val);
+  const maxKeys = entries.length > 100 ? 100 : entries.length;
+  for (let i = 0; i < maxKeys; i++) {
+    const entry = entries[i];
+    if (!entry) continue;
+    const [k, v] = entry;
+    if (typeof v === "string") {
+      if (v.length > 400) {
+        compactedObj[k] = `${v.slice(0, 300)}... [truncated by Code Mode result size guardrail]`;
+      } else {
+        compactedObj[k] = v;
+      }
+    } else if (typeof v === "object" && v !== null) {
+      compactedObj[k] = compactOversizedResult(v, limitBytes, depth + 1, seen);
+    } else {
+      compactedObj[k] = v;
+    }
+  }
+  if (entries.length > maxKeys) {
+    compactedObj["_omitted_keys_count"] = entries.length - maxKeys;
+  }
+  if (depth === 0) {
+    compactedObj["_compaction_notice"] = `\u26A0\uFE0F Result payload was automatically compacted because serialized payload exceeded the ${Math.round(limitBytes / 1024)}KB boundary. Pass 'max_result_size' in mj_execute_code (e.g. max_result_size: ${limitBytes * 2}) to retrieve full contents without truncation.`;
+  }
+  return compactedObj;
+}
+function serializeAndEnforceEgress(result, maxResultSize) {
+  if (!result.success) return;
+  const egressLimit = maxResultSize ?? 100 * 1024;
+  try {
+    let bytes = 0;
+    const cache = /* @__PURE__ */ new Set();
+    const resultJson = JSON.stringify(result.result, (_key, value) => {
+      if (typeof value === "object" && value !== null) {
+        if (cache.has(value)) return "[Circular]";
+        cache.add(value);
+        bytes += 5;
+      } else if (typeof value === "string") {
+        bytes += value.length + 2;
+      } else if (typeof value === "number" || typeof value === "boolean") {
+        bytes += 8;
+      } else if (typeof value === "bigint") {
+        const str = value.toString();
+        bytes += str.length + 2;
+        return str;
+      } else {
+        bytes += 5;
+      }
+      if (bytes > egressLimit) {
+        throw new Error(`EgressLimitExceeded:${bytes}`);
+      }
+      return value;
+    });
+    if (resultJson !== void 0) {
+      const byteLength = Buffer.byteLength(resultJson, "utf8");
+      if (byteLength > egressLimit) {
+        throw new Error(`EgressLimitExceeded:${byteLength}`);
+      }
+      result.result = JSON.parse(resultJson);
+    } else {
+      result.result = void 0;
+    }
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith("EgressLimitExceeded:")) {
+      const actualBytesStr = err.message.split(":")[1];
+      const actualBytes = actualBytesStr !== void 0 ? Number(actualBytesStr) : egressLimit + 1;
+      const actualKb = (actualBytes / 1024).toFixed(1);
+      let compactedSuccessfully = false;
+      if (result.result !== null && typeof result.result === "object") {
+        try {
+          const compacted = compactOversizedResult(result.result, egressLimit);
+          if (compacted !== void 0) {
+            const compactedJson = JSON.stringify(compacted);
+            const compactedBytes = Buffer.byteLength(compactedJson, "utf8");
+            if (compactedBytes <= egressLimit) {
+              result.result = JSON.parse(compactedJson);
+              result.success = true;
+              delete result.error;
+              compactedSuccessfully = true;
+            }
+          }
+        } catch {
+          compactedSuccessfully = false;
+        }
+      }
+      if (!compactedSuccessfully) {
+        result.success = false;
+        result.error = `\u{1F6E0}\uFE0F AUTONOMOUS HEALING: Output limit exceeded: Result serialization exceeded the ${Math.round(egressLimit / 1024)}KB boundary (Actual size: >${actualKb}KB). Please aggregate or filter your results to reduce the payload size, or pass 'max_result_size' parameter (in bytes) to accommodate larger payloads.`;
+        result.result = void 0;
+      }
+    } else {
+      result.success = false;
+      result.error = `Result could not be serialized or exceeded memory limits: ${err instanceof Error ? err.message : String(err)}`;
+      result.result = void 0;
+    }
+  }
+}
+
+// src/codemode/worker-script.ts
+hardenOuterFunctionPrototypes();
+process.on("unhandledRejection", () => {
+});
+process.on("uncaughtException", () => {
+});
+var rpcPort = null;
+var rpcIdCounter = 0;
+var pendingRpcRequests = /* @__PURE__ */ new Map();
+function rpcCall(group, method, args) {
+  return new Promise((resolve, reject) => {
+    if (!rpcPort) {
+      reject(new Error("RPC port not initialized"));
+      return;
+    }
+    const id = ++rpcIdCounter;
+    pendingRpcRequests.set(id, { resolve, reject });
+    const request = { id, group, method, args };
+    rpcPort.postMessage(request);
+  });
+}
+async function executeCode(code, methodList, schemaList, timeoutMs, contextObj, readonlyMode) {
+  const startCpu = process.cpuUsage();
+  const startTime = performance.now();
+  const activeTimers = /* @__PURE__ */ new Set();
+  try {
+    const mjApi = buildApiProxy(rpcCall, methodList, schemaList, readonlyMode, contextObj);
+    for (const key of Object.keys(mjApi)) {
+      const val = mjApi[key];
+      if (typeof val === "object" && val !== null) Object.freeze(val);
+    }
+    Object.freeze(mjApi);
+    const safeFsShim = createSafeFsShim(contextObj);
+    const executeCodeFnRef = {};
+    const updateMemoryFnHolder = {};
+    const shimMj = createShimMjProxy({
+      mjApi,
+      safeFsShim,
+      executeCodeFnRef,
+      getUpdateMemoryFn: () => updateMemoryFnHolder.current ?? (() => void 0)
+    });
+    const updateMemoryFn = createUpdateMemoryFn(shimMj);
+    updateMemoryFnHolder.current = updateMemoryFn;
+    const frozenContext = createContextProxy(contextObj);
+    const vmContextRef = {};
+    const invokeCreateEntry = (payload) => {
+      const coreGroup = shimMj["core"];
+      if (typeof coreGroup === "object" && coreGroup !== null || typeof coreGroup === "function") {
+        const fn = Reflect.get(coreGroup, "createEntry");
+        if (typeof fn === "function") return fn(payload);
+      }
+      return void 0;
+    };
+    const executeCodeFn = async (arg) => {
+      let codeToExec = "";
+      if (typeof arg === "string") {
+        codeToExec = arg;
+      } else if (typeof arg === "object" && arg !== null && !Array.isArray(arg)) {
+        const codeProp = Reflect.get(arg, "code");
+        const scriptProp = Reflect.get(arg, "script");
+        codeToExec = typeof codeProp === "string" ? codeProp : typeof scriptProp === "string" ? scriptProp : "";
+        if (codeToExec === "" && (typeof Reflect.get(arg, "content") === "string" || typeof Reflect.get(arg, "text") === "string" || typeof Reflect.get(arg, "description") === "string" || typeof Reflect.get(arg, "title") === "string")) {
+          return invokeCreateEntry(arg);
+        }
+      }
+      if (codeToExec !== "") {
+        const trimmed = codeToExec.trim();
+        const isNaturalPrompt = /^(?:write|document|create|include|record|summary|log|add|added|note|task|fix|implement)\b/i.test(trimmed) && !/\b(const|let|var|function|return|await|import|export)\b/.test(trimmed);
+        if (isNaturalPrompt || /^(?:create|add|new|record|log)?\s*entry\b/i.test(trimmed)) {
+          const firstLine = (trimmed.split("\n")[0] ?? "").replace(/^(?:create|add|new|record|log|insert)?\s*entry\s*(?:for|:)?\s*/i, "").replace(/[:.]+$/, "").trim();
+          const title = firstLine.length > 0 && firstLine.length < 80 ? firstLine : "Journal Entry";
+          return invokeCreateEntry({ title, content: trimmed, entry_type: "technical_decision" });
+        }
+        if (vmContextRef.current !== void 0) {
+          const transformed2 = transformAutoReturn(codeToExec);
+          const wrapped = `(async () => {
+${transformed2}
+})()`;
+          return await vm2.runInContext(wrapped, vmContextRef.current, { timeout: timeoutMs });
+        }
+      }
+      return { success: true };
+    };
+    executeCodeFnRef.current = executeCodeFn;
+    const sandbox = buildSandboxGlobals({
+      mjApi,
+      shimMj,
+      safeFsShim,
+      frozenContext,
+      executeCodeFn,
+      updateMemoryFn,
+      activeTimers
+    });
+    const context = vm2.createContext(sandbox, {
+      name: "codemode-worker-sandbox",
+      codeGeneration: { strings: false, wasm: false }
+    });
+    vmContextRef.current = context;
+    freezeInnerVmContext(context);
+    const transformed = transformAutoReturn(code);
+    const script = new vm2.Script(`(async () => {
+${transformed}
+})()`, {
+      filename: "codemode-execution.js"
+    });
+    const resultPromise = script.runInContext(context, { timeout: timeoutMs });
+    const result = await resultPromise;
+    const endTime = performance.now();
+    const endCpu = process.cpuUsage(startCpu);
+    const metrics = {
+      wallTimeMs: Math.round(endTime - startTime),
+      cpuTimeMs: Math.round((endCpu.user + endCpu.system) / 1e3),
+      memoryUsedMb: 0
+    };
+    return { success: true, result, metrics };
+  } catch (err) {
+    const endTime = performance.now();
+    const endCpu = process.cpuUsage(startCpu);
+    const error = err instanceof Error ? err : new Error(String(err));
+    const errString = String(err);
+    if (errString.includes("missing ) after argument list") || errString.includes("is not a function") || errString.includes("Invalid or unexpected token") || errString.includes("Unexpected token") || errString.includes("Unexpected identifier") || errString.includes("Cannot use import statement")) {
+      error.message = `\u{1F6E0}\uFE0F AUTONOMOUS HEALING: Syntax error in Code Mode execution (${error.message}). Code Mode requires valid JavaScript code (e.g., 'return await mj.core.getRecentEntries({ limit: 10 })' or 'return await mj.core.createEntry(...)'), not raw SQL statements or unquoted text.
+
+\u{1F4A1} Tip: When querying the journal, use Code Mode methods like 'return await mj.core.getRecentEntries({ limit: 10 })' or 'return await mj.search.searchEntries({ query: "..." })'. When passing long multi-line strings or markdown with embedded quotes/backticks, pass them safely via the \`context\` parameter and reference them as \`context.myParam\`.`;
+    }
+    return {
+      success: false,
+      error: error.message,
+      metrics: {
+        wallTimeMs: Math.round(endTime - startTime),
+        cpuTimeMs: Math.round((endCpu.user + endCpu.system) / 1e3),
+        memoryUsedMb: 0
+      }
+    };
+  } finally {
+    for (const handle of activeTimers) {
+      clearTimeout(handle);
+    }
+    activeTimers.clear();
+  }
+}
+function isExecuteMessage(msg) {
+  return msg !== null && msg !== void 0 && typeof msg === "object" && "type" in msg && Reflect.get(msg, "type") === "EXECUTE";
+}
+parentPort?.on("message", (msg) => {
+  void (async () => {
+    if (!isExecuteMessage(msg)) return;
+    const { id, code, methodList, schemaList, timeoutMs, maxResultSize, rpcPort: newRpcPort, contextObj, readonlyMode } = msg;
+    rpcPort = newRpcPort;
+    rpcIdCounter = 0;
+    pendingRpcRequests.clear();
+    rpcPort?.on("message", (response) => {
+      const pending = pendingRpcRequests.get(response.id);
+      if (pending !== void 0) {
+        pendingRpcRequests.delete(response.id);
+        if (response.error !== void 0) pending.reject(new Error(response.error));
+        else pending.resolve(response.result);
+      }
+    });
+    const result = await executeCode(code, methodList, schemaList, timeoutMs ?? 3e4, contextObj, readonlyMode);
+    serializeAndEnforceEgress(result, maxResultSize);
+    rpcPort?.close();
+    rpcPort = null;
+    parentPort?.postMessage({ type: "RESULT", id, result });
   })();
 });