memory-journal-mcp 8.0.1 → 9.1.0

package/dist/codemode/worker/mj-shim-proxy.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Worker `shimMj` Proxy — permissive top-level proxy that wraps `mjApi` to
+ * smooth out common agent hallucinations across repositories and SDK patterns.
+ */
+import { type SafeFsShim } from './node-shims.js';
+export interface CreateShimMjOptions {
+    mjApi: Record<string, unknown>;
+    safeFsShim: SafeFsShim;
+    executeCodeFnRef: {
+        current?: (arg: unknown) => Promise<unknown>;
+    };
+    getUpdateMemoryFn: () => (arg: unknown) => unknown;
+}
+/**
+ * Builds the `shimMj` permissive proxy wrapping `mjApi`.
+ */
+export declare function createShimMjProxy(options: CreateShimMjOptions): Record<string, unknown>;
+//# sourceMappingURL=mj-shim-proxy.d.ts.map

package/dist/codemode/worker/mj-shim-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mj-shim-proxy.d.ts","sourceRoot":"","sources":["../../../src/codemode/worker/mj-shim-proxy.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,KAAK,UAAU,EAAsD,MAAM,iBAAiB,CAAA;AA8ErG,MAAM,WAAW,mBAAmB;IAChC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,UAAU,EAAE,UAAU,CAAA;IACtB,gBAAgB,EAAE;QAAE,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,CAAA;IAClE,iBAAiB,EAAE,MAAM,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAA;CACrD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA0LvF"}

package/dist/codemode/worker/namespace-shims.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Worker Namespace Shims — helper factories for callable shims, schema shims,
+ * delegating tool wrappers, and `context` proxy fallbacks.
+ */
+export declare const DB_TO_JOURNAL: Record<string, [string, string]>;
+/**
+ * Creates a callable/constructable proxy that resolves all calls and property reads to `shimMj`.
+ */
+export declare function createCallableShim(shimMj: Record<string, unknown>, fnName?: string): object;
+/**
+ * Creates the `updateMemory` / `setMemory` / `updateJournal` smart router function.
+ */
+export declare function createUpdateMemoryFn(shimMj: Record<string, unknown>): (arg: unknown) => unknown;
+/**
+ * Wraps a top-level delegating function so `.schema()`, `.help()`, and `.describe()`
+ * forward to the underlying method on `shimMj`.
+ */
+export declare function wrapDelegatingTool(fn: (...args: unknown[]) => unknown, targetFnGetter: () => unknown): unknown;
+export declare const schemaHelpFn: () => Promise<unknown>;
+/**
+ * Creates the `schema` shim proxy for `shimMj`.
+ */
+export declare function createSchemaShim(shimMj: Record<string, unknown>): object;
+/**
+ * Creates an empty iterable/array-like/map-like fallback for missing collection properties on `context`.
+ */
+export declare function createEmptyFallback(_name: string): unknown;
+/**
+ * Builds the frozen `context` global proxy for the sandbox.
+ */
+export declare function createContextProxy(contextObj?: Record<string, unknown>): Record<string, unknown>;
+//# sourceMappingURL=namespace-shims.d.ts.map

package/dist/codemode/worker/namespace-shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespace-shims.d.ts","sourceRoot":"","sources":["../../../src/codemode/worker/namespace-shims.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAW1D,CAAA;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,SAAkB,GAAG,MAAM,CAqBpG;AAMD;;GAEG;AACH,wBAAgB,oBAAoB,CAChC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAgE3B;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAC9B,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,EACnC,cAAc,EAAE,MAAM,OAAO,GAC9B,OAAO,CAeT;AAaD,eAAO,MAAM,YAAY,QAAO,OAAO,CAAC,OAAO,CA0BzC,CAAA;AAEN;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CA4DxE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAyC1D;AAsCD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA4DhG"}

package/dist/codemode/worker/node-shims.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Worker Node.js Shims — safe sandbox shims for `fs`, `path`, `console`,
+ * and SQLite prepared statements (`db.prepare(...)`).
+ */
+export interface SafeFsShim {
+    existsSync: (filePath?: unknown) => boolean;
+    statSync: (_filePath?: unknown) => {
+        size: number;
+        isFile: () => boolean;
+        isDirectory: () => boolean;
+        mtime: Date;
+        birthtime: Date;
+    };
+    stat: (_filePath?: unknown, cb?: (err: Error | null, stats?: unknown) => void) => Promise<unknown>;
+    lstatSync: (_filePath?: unknown) => {
+        size: number;
+        isFile: () => boolean;
+        isDirectory: () => boolean;
+        mtime: Date;
+        birthtime: Date;
+    };
+    readFileSync: (_filePath?: unknown) => string;
+    readFile: (_filePath?: unknown, cb?: (err: Error | null, data?: string) => void) => Promise<string>;
+    writeFileSync: () => void;
+    writeFile: () => Promise<void>;
+    mkdirSync: () => void;
+    unlinkSync: () => void;
+    readdirSync: () => string[];
+    promises: {
+        stat: () => Promise<{
+            size: number;
+            isFile: () => boolean;
+            isDirectory: () => boolean;
+            mtime: Date;
+            birthtime: Date;
+        }>;
+        readFile: () => Promise<string>;
+        writeFile: () => Promise<void>;
+    };
+}
+export declare function createSafeFsShim(contextObj?: Record<string, unknown>): SafeFsShim;
+export declare const pathShim: {
+    join: (...parts: unknown[]) => string;
+    resolve: (...parts: unknown[]) => string;
+    basename: (p: unknown, ext?: string) => string;
+    dirname: (p: unknown) => string;
+    extname: (p: unknown) => string;
+    normalize: (p: unknown) => string;
+    isAbsolute: (p: unknown) => boolean;
+    sep: string;
+    delimiter: string;
+};
+export declare const consoleShim: Readonly<{
+    log: (...args: unknown[]) => unknown[];
+    warn: (...args: unknown[]) => unknown[];
+    error: (...args: unknown[]) => unknown[];
+    info: (...args: unknown[]) => unknown[];
+    debug: (...args: unknown[]) => unknown[];
+}>;
+/**
+ * Translates raw `db.prepare(sql).run(...)` / `.get(...)` / `.all(...)` hallucinations
+ * into high-level `mj.core` / `mj.admin` calls.
+ */
+export declare function createPreparedStatementShim(sql: string, shimMj: Record<string, unknown>): Record<string, unknown>;
+//# sourceMappingURL=node-shims.d.ts.map

package/dist/codemode/worker/node-shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-shims.d.ts","sourceRoot":"","sources":["../../../src/codemode/worker/node-shims.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH,MAAM,WAAW,UAAU;IACvB,UAAU,EAAE,CAAC,QAAQ,CAAC,EAAE,OAAO,KAAK,OAAO,CAAA;IAC3C,QAAQ,EAAE,CAAC,SAAS,CAAC,EAAE,OAAO,KAAK;QAC/B,IAAI,EAAE,MAAM,CAAA;QACZ,MAAM,EAAE,MAAM,OAAO,CAAA;QACrB,WAAW,EAAE,MAAM,OAAO,CAAA;QAC1B,KAAK,EAAE,IAAI,CAAA;QACX,SAAS,EAAE,IAAI,CAAA;KAClB,CAAA;IACD,IAAI,EAAE,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,EAAE,KAAK,CAAC,EAAE,OAAO,KAAK,IAAI,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAClG,SAAS,EAAE,CAAC,SAAS,CAAC,EAAE,OAAO,KAAK;QAChC,IAAI,EAAE,MAAM,CAAA;QACZ,MAAM,EAAE,MAAM,OAAO,CAAA;QACrB,WAAW,EAAE,MAAM,OAAO,CAAA;QAC1B,KAAK,EAAE,IAAI,CAAA;QACX,SAAS,EAAE,IAAI,CAAA;KAClB,CAAA;IACD,YAAY,EAAE,CAAC,SAAS,CAAC,EAAE,OAAO,KAAK,MAAM,CAAA;IAC7C,QAAQ,EAAE,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;IACnG,aAAa,EAAE,MAAM,IAAI,CAAA;IACzB,SAAS,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC9B,SAAS,EAAE,MAAM,IAAI,CAAA;IACrB,UAAU,EAAE,MAAM,IAAI,CAAA;IACtB,WAAW,EAAE,MAAM,MAAM,EAAE,CAAA;IAC3B,QAAQ,EAAE;QACN,IAAI,EAAE,MAAM,OAAO,CAAC;YAChB,IAAI,EAAE,MAAM,CAAA;YACZ,MAAM,EAAE,MAAM,OAAO,CAAA;YACrB,WAAW,EAAE,MAAM,OAAO,CAAA;YAC1B,KAAK,EAAE,IAAI,CAAA;YACX,SAAS,EAAE,IAAI,CAAA;SAClB,CAAC,CAAA;QACF,QAAQ,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAA;QAC/B,SAAS,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;KACjC,CAAA;CACJ;AAED,wBAAgB,gBAAgB,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,UAAU,CA+EjF;AAED,eAAO,MAAM,QAAQ;qBACA,OAAO,EAAE,KAAG,MAAM;wBAKf,OAAO,EAAE,KAAG,MAAM;kBAKxB,OAAO,QAAQ,MAAM,KAAG,MAAM;iBAI/B,OAAO,KAAG,MAAM;iBAKhB,OAAO,KAAG,MAAM;mBAKd,OAAO,KAAG,MAAM;oBACf,OAAO,KAAG,OAAO;;;CAGpC,CAAA;AAED,eAAO,MAAM,WAAW;mBACL,OAAO,EAAE;oBACR,OAAO,EAAE;qBACR,OAAO,EAAE;oBACV,OAAO,EAAE;qBACR,OAAO,EAAE;EAC5B,CAAA;AAyBF;;;GAGG;AACH,wBAAgB,2BAA2B,CACvC,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA8MzB"}

package/dist/codemode/worker/prototype-hardening.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Worker Prototype Hardening — outer-realm and inner-VM prototype freezing
+ * to prevent dynamic constructor chain escapes (`fn['con'+'structor']`).
+ */
+import * as vm from 'node:vm';
+/**
+ * Neuters `.constructor` on all outer function prototypes so untrusted scripts
+ * inside `vm` cannot traverse `fn['con'+'structor']` to reach the outer realm's
+ * Function/AsyncFunction/GeneratorFunction constructors.
+ */
+export declare function hardenOuterFunctionPrototypes(): void;
+/**
+ * Freezes built-in prototypes and neuters Function constructors inside the
+ * VM context to prevent dynamic constructor chain escapes like:
+ *   `const c = 'con'+'structor'; Error()[c][c]('return process')()`
+ */
+export declare function freezeInnerVmContext(context: vm.Context): void;
+//# sourceMappingURL=prototype-hardening.d.ts.map

package/dist/codemode/worker/prototype-hardening.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prototype-hardening.d.ts","sourceRoot":"","sources":["../../../src/codemode/worker/prototype-hardening.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,MAAM,SAAS,CAAA;AAE7B;;;;GAIG;AACH,wBAAgB,6BAA6B,IAAI,IAAI,CA6EpD;AA4CD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,GAAG,IAAI,CAE9D"}

package/dist/codemode/worker/result-compactor.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Worker Result Compactor — compacts oversized structured payloads and enforces
+ * the serialized egress byte boundary to prevent OOM and hard payload failures.
+ */
+import type { SandboxResult } from '../types.js';
+/**
+ * Automatically compacts oversized structured result payloads (objects and collections)
+ * so that queries returning large datasets (e.g. 50 entries with markdown content)
+ * do not fail outright when exceeding the egress limit.
+ *
+ * Primitive strings and numbers are deliberately left uncompacted so that raw
+ * string contract tests reject properly with structured aggregation guidance.
+ */
+export declare function compactOversizedResult(val: unknown, limitBytes: number, depth?: number, seen?: WeakSet<object>): unknown;
+/**
+ * Enforces the egress byte limit during JSON serialization and applies
+ * `compactOversizedResult` fallback when an object/array exceeds the boundary.
+ */
+export declare function serializeAndEnforceEgress(result: SandboxResult, maxResultSize?: number): void;
+//# sourceMappingURL=result-compactor.d.ts.map

package/dist/codemode/worker/result-compactor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-compactor.d.ts","sourceRoot":"","sources":["../../../src/codemode/worker/result-compactor.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAClC,GAAG,EAAE,OAAO,EACZ,UAAU,EAAE,MAAM,EAClB,KAAK,SAAI,EACT,IAAI,kBAAgB,GACrB,OAAO,CAiET;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CACrC,MAAM,EAAE,aAAa,EACrB,aAAa,CAAC,EAAE,MAAM,GACvB,IAAI,CA+EN"}

package/dist/codemode/worker/sandbox-globals.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Worker Sandbox Globals — builds the frozen `sandbox` object exposed to
+ * `vm.createContext` with all top-level aliases, delegating wrappers, and shims.
+ */
+import { type SafeFsShim } from './node-shims.js';
+export interface BuildSandboxGlobalsOptions {
+    mjApi: Record<string, unknown>;
+    shimMj: Record<string, unknown>;
+    safeFsShim: SafeFsShim;
+    frozenContext: Record<string, unknown>;
+    executeCodeFn: (arg: unknown) => Promise<unknown>;
+    updateMemoryFn: (arg: unknown) => unknown;
+    activeTimers?: Set<NodeJS.Timeout>;
+}
+/**
+ * Builds and freezes the sandbox global object for `vm.createContext`.
+ */
+export declare function buildSandboxGlobals(options: BuildSandboxGlobalsOptions): Record<string, unknown>;
+//# sourceMappingURL=sandbox-globals.d.ts.map

package/dist/codemode/worker/sandbox-globals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandbox-globals.d.ts","sourceRoot":"","sources":["../../../src/codemode/worker/sandbox-globals.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,KAAK,UAAU,EAAsD,MAAM,iBAAiB,CAAA;AAOrG,MAAM,WAAW,0BAA0B;IACvC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,UAAU,EAAE,UAAU,CAAA;IACtB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACtC,aAAa,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IACjD,cAAc,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAA;IACzC,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;CACrC;AAkJD;;GAEG;AACH,wBAAgB,mBAAmB,CAC/B,OAAO,EAAE,0BAA0B,GACpC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA4NzB"}

package/dist/codemode/worker-api-proxy.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Worker API Proxy Builder — constructs the `mj.*` proxy API for the sandbox.
+ *
+ * Each tool group becomes a namespace with methods that dispatch RPC calls
+ * to the main thread. Includes snake_case->camelCase fallback, readResource
+ * hallucination handling, and schema() introspection on every method.
+ */
+/**
+ * Build the mj.* API proxy from method and schema lists.
+ */
+export declare function buildApiProxy(rpcCall: (group: string, method: string, args: unknown[]) => Promise<unknown>, methods: Record<string, string[]>, schemas?: Record<string, Record<string, string>>, readonlyMode?: boolean, contextObj?: Record<string, unknown>): Record<string, unknown>;
+//# sourceMappingURL=worker-api-proxy.d.ts.map

package/dist/codemode/worker-api-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-api-proxy.d.ts","sourceRoot":"","sources":["../../src/codemode/worker-api-proxy.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA6CH;;GAEG;AACH,wBAAgB,aAAa,CACzB,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,EAC7E,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EACjC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAChD,YAAY,CAAC,EAAE,OAAO,EACtB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACrC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA2QzB"}

package/dist/codemode/worker-result-proxy.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Worker Result Proxy — wraps API call results with smart proxy behavior.
+ *
+ * - Failed results throw on property access with actionable error messages
+ * - Successful results auto-forward Array methods to nested array properties
+ * - Pagination cursor detection injects `hasMore` convenience boolean
+ */
+/**
+ * Wrap an API result with smart proxy behavior for improved DX.
+ */
+export declare function wrapResult(result: unknown): unknown;
+//# sourceMappingURL=worker-result-proxy.d.ts.map

package/dist/codemode/worker-result-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-result-proxy.d.ts","sourceRoot":"","sources":["../../src/codemode/worker-result-proxy.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAiFH;;GAEG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAoOnD"}

package/dist/codemode/worker-sandbox.d.ts

@@ -0,0 +1,58 @@
+/**
+ * memory-journal-mcp - Worker Sandbox (worker_threads)
+ *
+ * Production-grade sandboxed execution using `node:worker_threads`.
+ * Provides true V8 isolate boundary with resource limits,
+ * hard timeouts, and MessagePort RPC bridge.
+ */
+import { type SandboxOptions, type PoolOptions, type SandboxResult } from './types.js';
+/**
+ * Worker-thread sandbox for secure code execution.
+ * Maintains a persistent worker thread internally.
+ */
+export declare class WorkerSandbox {
+    private readonly options;
+    private worker;
+    isBusy: boolean;
+    readonly createdAt: number;
+    lastUsedAt: number;
+    private currentExecution;
+    private executionId;
+    get isDisposed(): boolean;
+    constructor(options?: SandboxOptions);
+    private initWorker;
+    private handleWorkerDeath;
+    dispose(): void;
+    /**
+     * Execute code in the worker thread with RPC bridge.
+     */
+    execute(code: string, apiBindings: Record<string, unknown>, schemas?: Record<string, Record<string, string>>, timeoutMs?: number, contextObj?: Record<string, unknown>, readonlyMode?: boolean, maxResultSizeOverride?: number): Promise<SandboxResult>;
+}
+/**
+ * Pool of persistent worker-thread sandboxes with pre-warming
+ * and lifecycle management (age recycling, idle eviction, re-warming).
+ */
+export declare class WorkerSandboxPool {
+    private readonly options;
+    private readonly sandboxOptions;
+    private pool;
+    private lifecycleTimer;
+    constructor(sandboxOptions?: SandboxOptions, poolOptions?: PoolOptions);
+    /**
+     * Eagerly create workers up to `minInstances`.
+     */
+    private warmPool;
+    /**
+     * Periodic lifecycle sweep:
+     * 1. Remove already-disposed workers
+     * 2. Recycle workers that exceed maxWorkerAgeMs
+     * 3. Evict idle workers (oldest first) above minInstances
+     * 4. Re-warm pool to minInstances
+     */
+    private lifecycleSweep;
+    execute(code: string, apiBindings: Record<string, unknown>, schemas?: Record<string, Record<string, string>>, timeoutMs?: number, contextObj?: Record<string, unknown>, readonlyMode?: boolean, maxResultSizeOverride?: number): Promise<SandboxResult>;
+    getActiveCount(): number;
+    dispose(): void;
+    readonly poolId: `${string}-${string}-${string}-${string}-${string}`;
+}
+//# sourceMappingURL=worker-sandbox.d.ts.map

package/dist/codemode/worker-sandbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-sandbox.d.ts","sourceRoot":"","sources":["../../src/codemode/worker-sandbox.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,OAAO,EAGH,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,aAAa,EAGrB,MAAM,YAAY,CAAA;AAuBnB;;;GAGG;AACH,qBAAa,aAAa;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0B;IAClD,OAAO,CAAC,MAAM,CAAsB;IAC7B,MAAM,UAAQ;IACrB,SAAgB,SAAS,EAAE,MAAM,CAAa;IACvC,UAAU,EAAE,MAAM,CAAa;IACtC,OAAO,CAAC,gBAAgB,CAMT;IACf,OAAO,CAAC,WAAW,CAAI;IAEvB,IAAW,UAAU,IAAI,OAAO,CAE/B;gBAEW,OAAO,CAAC,EAAE,cAAc;IAKpC,OAAO,CAAC,UAAU;IAiDlB,OAAO,CAAC,iBAAiB;IA4BzB,OAAO,IAAI,IAAI;IAaf;;OAEG;IACG,OAAO,CACT,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAChD,SAAS,CAAC,EAAE,MAAM,EAClB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,YAAY,CAAC,EAAE,OAAO,EACtB,qBAAqB,CAAC,EAAE,MAAM,GAC/B,OAAO,CAAC,aAAa,CAAC;CA6E5B;AAiED;;;GAGG;AACH,qBAAa,iBAAiB;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuB;IAC/C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAgB;IAC/C,OAAO,CAAC,IAAI,CAAsB;IAClC,OAAO,CAAC,cAAc,CAA8C;gBAExD,cAAc,CAAC,EAAE,cAAc,EAAE,WAAW,CAAC,EAAE,WAAW;IAWtE;;OAEG;IACH,OAAO,CAAC,QAAQ;IAMhB;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IAgChB,OAAO,CACT,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAChD,SAAS,CAAC,EAAE,MAAM,EAClB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,YAAY,CAAC,EAAE,OAAO,EACtB,qBAAqB,CAAC,EAAE,MAAM,GAC/B,OAAO,CAAC,aAAa,CAAC;IAqBzB,cAAc,IAAI,MAAM;IAIxB,OAAO,IAAI,IAAI;IAWf,QAAQ,CAAC,MAAM,sDAAsB;CACxC"}

package/dist/codemode/worker-script.d.ts

@@ -0,0 +1,9 @@
+/**
+ * memory-journal-mcp - Worker Script (Worker Thread Entry Point)
+ *
+ * Runs inside `node:worker_threads`. Receives serialized API bindings,
+ * builds an async Proxy API object (`mj.*`), and executes user code
+ * within a secondary `vm.createContext` boundary.
+ */
+export {};
+//# sourceMappingURL=worker-script.d.ts.map

package/dist/codemode/worker-script.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-script.d.ts","sourceRoot":"","sources":["../../src/codemode/worker-script.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/dist/constants/icons.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Memory Journal MCP Server - Icon Constants
+ *
+ * Centralized icon definitions using data URIs for self-contained distribution.
+ * Icons follow MCP 2025-11-25 specification.
+ *
+ * Using simple Lucide-style SVG icons encoded as data URIs.
+ */
+import type { McpIcon } from '../types/index.js';
+/** Journal/notebook icon for core operations */
+export declare const ICON_CORE: McpIcon;
+/** Magnifying glass for search operations */
+export declare const ICON_SEARCH: McpIcon;
+/** Chart/bar for analytics */
+export declare const ICON_ANALYTICS: McpIcon;
+/** Link for relationships */
+export declare const ICON_RELATIONSHIPS: McpIcon;
+/** Swap/IO icon for import and export operations */
+export declare const ICON_IO: McpIcon;
+/** Settings/cog for admin */
+export declare const ICON_ADMIN: McpIcon;
+/** GitHub logo for github tools */
+export declare const ICON_GITHUB: McpIcon;
+/** Git branch for git history operations */
+export declare const ICON_GIT: McpIcon;
+/** Archive/box for backup */
+export declare const ICON_BACKUP: McpIcon;
+/** Users group for team collaboration */
+export declare const ICON_TEAM: McpIcon;
+/** Document for briefing/instructions */
+export declare const ICON_BRIEFING: McpIcon;
+/** Network/share for graph resources */
+export declare const ICON_GRAPH: McpIcon;
+/** Clock for recent/timeline resources */
+export declare const ICON_CLOCK: McpIcon;
+/** Heartbeat for health status */
+export declare const ICON_HEALTH: McpIcon;
+/** Kanban board columns */
+export declare const ICON_KANBAN: McpIcon;
+/** Star for significant items */
+export declare const ICON_STAR: McpIcon;
+/** Tag for tags resource */
+export declare const ICON_TAG: McpIcon;
+/** Issue icon for GitHub issues */
+export declare const ICON_ISSUE: McpIcon;
+/** Git merge for PR resources */
+export declare const ICON_PR: McpIcon;
+/** Flag for milestone tracking */
+export declare const ICON_MILESTONE: McpIcon;
+/** Message bubble for prompts */
+export declare const ICON_PROMPT: McpIcon;
+/** Map tool group name to icon */
+export declare const TOOL_GROUP_ICONS: Record<string, McpIcon>;
+/**
+ * Get icons array for a tool based on its group
+ */
+export declare function getToolIcon(group: string): McpIcon[] | undefined;
+//# sourceMappingURL=icons.d.ts.map

package/dist/constants/icons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"icons.d.ts","sourceRoot":"","sources":["../../src/constants/icons.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAMhD,gDAAgD;AAChD,eAAO,MAAM,SAAS,EAAE,OAIvB,CAAA;AAED,6CAA6C;AAC7C,eAAO,MAAM,WAAW,EAAE,OAIzB,CAAA;AAED,8BAA8B;AAC9B,eAAO,MAAM,cAAc,EAAE,OAI5B,CAAA;AAED,6BAA6B;AAC7B,eAAO,MAAM,kBAAkB,EAAE,OAIhC,CAAA;AAED,oDAAoD;AACpD,eAAO,MAAM,OAAO,EAAE,OAIrB,CAAA;AAED,6BAA6B;AAC7B,eAAO,MAAM,UAAU,EAAE,OAIxB,CAAA;AAED,mCAAmC;AACnC,eAAO,MAAM,WAAW,EAAE,OAIzB,CAAA;AAED,4CAA4C;AAC5C,eAAO,MAAM,QAAQ,EAAE,OAItB,CAAA;AAED,6BAA6B;AAC7B,eAAO,MAAM,WAAW,EAAE,OAIzB,CAAA;AAED,yCAAyC;AACzC,eAAO,MAAM,SAAS,EAAE,OAIvB,CAAA;AAMD,yCAAyC;AACzC,eAAO,MAAM,aAAa,EAAE,OAI3B,CAAA;AAED,wCAAwC;AACxC,eAAO,MAAM,UAAU,EAAE,OAIxB,CAAA;AAED,0CAA0C;AAC1C,eAAO,MAAM,UAAU,EAAE,OAIxB,CAAA;AAED,kCAAkC;AAClC,eAAO,MAAM,WAAW,EAAE,OAIzB,CAAA;AAED,2BAA2B;AAC3B,eAAO,MAAM,WAAW,EAAE,OAIzB,CAAA;AAED,iCAAiC;AACjC,eAAO,MAAM,SAAS,EAAE,OAIvB,CAAA;AAED,4BAA4B;AAC5B,eAAO,MAAM,QAAQ,EAAE,OAItB,CAAA;AAED,mCAAmC;AACnC,eAAO,MAAM,UAAU,EAAE,OAIxB,CAAA;AAED,iCAAiC;AACjC,eAAO,MAAM,OAAO,EAAE,OAIrB,CAAA;AAED,kCAAkC;AAClC,eAAO,MAAM,cAAc,EAAE,OAI5B,CAAA;AAED,iCAAiC;AACjC,eAAO,MAAM,WAAW,EAAE,OAIzB,CAAA;AAOD,kCAAkC;AAClC,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAWpD,CAAA;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,EAAE,GAAG,SAAS,CAGhE"}

package/dist/constants/instructions/admin.d.ts

@@ -0,0 +1,2 @@
+export declare const ADMIN_HELP = "# Admin Operations\n- **Workspace Bounds**: Batch updates, deletions, and rebuilding vector indexes require `workspace_id` awareness. Ensure you are targeting the correct workspace to avoid unintended cross-tenant mutations.\n\n### Auto-Prune\n\nOn server startup, the auto-prune system automatically soft-deletes old entries with low significance scores.\n- **Configurable Thresholds**: Controlled via `--prune-older-than-days` (soft-delete) and `--prune-importance-threshold`.\n- **Exclusion Rules**: Specific tags can be exempted from auto-pruning using `--prune-exclude-tags <tags>` (e.g. `architecture`, `never-prune`).\n- **Dry Run**: Server administrators can preview what would be processed without mutating the database by using the `--prune-dry-run` flag.\n\n### Scheduled Reports\n\nWhen deployed in HTTP mode with `--report-interval <minutes>` and `--report-webhook-url <url>`, the server periodically generates digest reports and delivers them to the configured webhook. Reports include activity trends, significance highlights, stale project warnings, and top-importance entries.\n\n- **Formats**: `slack` (default, `{\"text\":\"<markdown>\"}`), `discord` (`{\"content\":\"<markdown>\"}`), or `json` (raw DigestSnapshot payload).\n- **Report history**: Read `memory://insights/reports` to view the last 5 generated reports and their delivery status.\n- **Independent from digest**: The `report` job is separate from the `digest` analytics job. You can run one without the other.\n\n### Real-Time Subscriptions\n\nThe server supports the standard MCP `resources/subscribe` capability. You can subscribe to resources (e.g., `memory://recent`, `memory://team/recent`, and `memory://briefing`) to receive real-time `notifications/resources/updated` notifications when other agents or team members mutate shared data. Note that subscriptions are scope-authorized; your session must possess the required scope (e.g., `team` or `admin`) for the target resource, or the subscription will be rejected with a `PermissionError`.\n\n## Available Tools\n\n- **Configuration**: `update_configuration`\n- **Project Lifecycle**: `register_project`, `update_project`, `delete_project`, `get_project`, `list_projects`\n- **Entry Mutations**: `update_entry`, `delete_entry`, `restore_entry`\n- **Batch Operations**: `batch_create_entries`, `batch_update_entries`, `batch_delete_entries`\n- **Vector Index**: `rebuild_vector_index`, `add_to_vector_index`\n- **Maintenance**: `merge_tags`, `run_auto_prune`\n- **Auditing**: `search_audit_log`\n\n";
+//# sourceMappingURL=admin.d.ts.map

package/dist/constants/instructions/admin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin.d.ts","sourceRoot":"","sources":["../../../src/constants/instructions/admin.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU,g/EAgCtB,CAAC"}

package/dist/constants/instructions/analytics.d.ts

@@ -0,0 +1,2 @@
+export declare const ANALYTICS_HELP = "# Analytics Operations\n- **Workspace Bounds**: Analytics operations inherently scope to the active `workspace_id`. Cross-project insights explicitly span workspaces to identify trends and duplicated efforts.\n\n## Available Tools\n\n- **Metrics**: `get_statistics`\n- **Insights**: `get_cross_project_insights`\n";
+//# sourceMappingURL=analytics.d.ts.map

package/dist/constants/instructions/analytics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analytics.d.ts","sourceRoot":"","sources":["../../../src/constants/instructions/analytics.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,8TAO1B,CAAC"}

package/dist/constants/instructions/backup.d.ts

@@ -0,0 +1,2 @@
+export declare const BACKUP_HELP = "# Backup Operations\n- **Snapshots**: Create on-demand snapshot backups of the database. Useful before performing destructive administrative operations like batch deletions.\n- **Restore**: Restore the entire database state from a specific backup snapshot.\n- **Cleanup**: Remove old or unnecessary backups to save disk space.\n\n## Available Tools\n\n- **Backup**: `backup_journal`, `list_backups`, `restore_backup`, `cleanup_backups`\n";
+//# sourceMappingURL=backup.d.ts.map

package/dist/constants/instructions/backup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backup.d.ts","sourceRoot":"","sources":["../../../src/constants/instructions/backup.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,0bAQvB,CAAC"}

package/dist/constants/instructions/base.d.ts

@@ -0,0 +1,3 @@
+export declare const CORE_INSTRUCTIONS = "# memory-journal-mcp\n\n## Quick Access\n\n| Purpose         | Action                      |\n| --------------- | --------------------------- |\n| Session context | `memory://briefing`         |\n| Recent entries  | `memory://recent`           |\n| Health/time     | `memory://health`           |\n| Metrics/Summary | `memory://metrics/summary`  |\n| Metrics/Latency | `memory://metrics/latency`  |\n| Resource reads  | `memory://metrics/resources`|\n| Project staleness| `memory://staleness`        |\n| Report history  | `memory://insights/reports` |\n| Agent context   | `memory://agent-context/{+repo}` |\n\n## Help Resources\n\n- **Agent Skill:** If available in your environment, load the `memory-journal-mcp` skill for high-level workflow guidelines.\n- **Dynamic Help:** Read `memory://help` for tool group index and available help resources.\n- **Gotchas:** Read `memory://help/gotchas` for critical usage patterns, heuristics, and session summary rules.\n- **Group Reference:** Read `memory://help/{group}` for per-group tool reference (parameters, annotations, examples).\n\nOnly help resources for your enabled tool groups are registered.\n\n## Essential Behaviors\n\n1. **Briefing:** You **MUST** read the `memory://briefing/{+repo}` at the start of each chat!\n2. **Session Identity:** You MUST pass your AntiGravity Conversation ID as the `--session-id` argument for all CLI journal mutation commands.\n3. **Workspace Isolation:** The `--project` argument is STRICTLY REQUIRED for mutations when the current working directory is not mapped in `PROJECT_REGISTRY` (otherwise it auto-resolves from CWD). Find it in the briefing's Config row. If you are mid-task and need this context, NEVER re-query the briefing; ALWAYS query `memory://agent-context/{+repo}`.\n4. **Anti-Hallucination:** If confused by an API, read `memory://help/{group}` or `memory://help/gotchas` BEFORE guessing. Use `mcp-heal` if a structural hallucination persists.\n5. **Orphan Prevention:** ALWAYS link entries to previous context via `--related-to` (comma-separated entry IDs).\n\n## Essential Operations\n\n- **Creating Entries:** Use the `memory-journal-mcp entry create` CLI command via your terminal (`run_command`). CLI commands are ALWAYS available globally on the system; do NOT attempt to run them via Code Mode. ALL entries MUST define `--impact-score`, `--trust-score`, and `--validation-status`. See `memory://help/core` for criteria.\n- **Session Summaries:** Use the `memory-journal-mcp entry create` CLI command with `--type retrospective` and `--tags session-summary`. You MUST provide the markdown content via `--content \"<string>\"` or `--file <path>` (or pipe to stdin). See `memory://help/templates` for the exact 4-section format required.\n- **Updating/Deleting:** Use `memory-journal-mcp entry update` (pass `--expected-version` to prevent concurrent overwrites) and use the `delete_entry` MCP tool for soft-deletes.\n- **Searching:** Use `search_entries` or `search_by_date_range`. Use `sort_by: \"importance\"` to surface structurally significant entries. Use phrase matching (e.g. `\"error handling\"`) for exact matches.\n- **Team DB:** Append the `--team` flag to your CLI commands for shared state. Use `team_*` MCP tools (or `mj.team.*` in Code Mode) for searches, deletes, relationships, analytics, and RBAC member/alias management. See `memory://help/team` for RBAC rules. Do NOT create bulk relationships between unrelated entries that happen to share tags.";
+export declare const CODE_MODE_INSTRUCTIONS = "\n## Code Mode\n\nAPI: `tool_name` \u2192 `mj.group.action()` (e.g., `search_entries` \u2192 `mj.search.searchEntries()`)\nGlobals: `createEntry()`, `find()`, `recent()`, `searchEntries()`, `deleteEntry()`, `help()` work without the `mj.` prefix.\nPositional: `createEntry(\"note\")`, `searchEntries(\"performance\")`\nAliases: Common parameter names are auto-corrected (`q`/`search`\u2192`query`, `path`/`filepath`\u2192`output_dir`, `keep`\u2192`keep_count`, `user`/`assignee`\u2192`target_user`, `team`/`project`\u2192`workspace_id`).\nDiscovery: `mj.help()` \u2192 `{groups, totalMethods}`. `mj.core.help()` for group-specific.\nAnti-Hallucination: Always provide a valid JavaScript string in the `code` parameter (e.g. `code: \"return await mj.searchEntries({ query: '...' })\"`). If `mj_execute_code` is called with an empty payload `{}` or missing `code`, Code Mode auto-heals by returning the active sandbox status and available namespaces. Structured dictionaries or JSON payloads passed in `code`, `payload`, or `entry` are automatically synthesized into journal entry operations.\nSandbox: No network access (`fetch()` is blocked and returns a 403 `VALIDATION_ERROR` response object). Node native modules (`fs`, `path`, `child_process`, `require()`) are disabled. Use the `context` parameter to pass file contents or external data into Code Mode. `setTimeout` and `sleep(ms)` are available for minor delays.\nReadonly: Pass `readonly: true` to `mj_execute_code` to restrict execution to read-only operations.\nRead `memory://help/codemode` for full namespace table, examples, and patterns.\n**Codemode-only**: When `mj_execute_code` is the only registered tool, all tool names referenced in these instructions (e.g., `create_entry`, `search_entries`) must be called via `mj_execute_code` using `mj.*` namespaces or bare globals. Do NOT call them as direct MCP tools. Note: This rule applies ONLY to MCP tools; CLI commands (like `memory-journal-mcp entry create`) should always be run natively in the terminal using `run_command`.";
+//# sourceMappingURL=base.d.ts.map

package/dist/constants/instructions/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/constants/instructions/base.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,45GAuCgU,CAAC;AAE/V,eAAO,MAAM,sBAAsB,8/DAYma,CAAC"}

package/dist/constants/instructions/codemode.d.ts

@@ -0,0 +1,2 @@
+export declare const CODEMODE_HELP = "# Code Mode API Reference\n\nIn Code Mode (`mj_execute_code`), you do NOT have native MCP tool schemas. You must orchestrate the server using the `mj.*` API inside the sandbox.\n\n## Sandbox Environment\n- **Network:** Disabled. `fetch()` is blocked and returns a 403 `VALIDATION_ERROR` response object. Node network modules are stripped.\n- **Native Modules:** `fs`, `path`, `child_process`, `require()`, `import` are disabled. To pass file contents or external payloads into Code Mode, use the `context` parameter (accessible inside JS code as `context`).\n- **Globals:** `createEntry()`, `find()`, `recent()`, `searchEntries()`, `deleteEntry()`, `help()` work without the `mj.` prefix.\n- **Positional Arguments:** `createEntry(\"note\")`, `searchEntries(\"performance\")`, `mj.backup.backupJournal(\"snapshot\")`.\n- **Healing Aliases:** The proxy auto-heals common hallucinations (e.g., `query` (search, q), `output_dir` (path, filepath), `keep_count` (keep), `target_user` (user, assignee), `workspace_id` (team, project)).\n- **Arrays & Methods:** Proxies seamlessly support native array properties/methods (e.g., `.length`, `[0]`, `.map()`, `.filter()`, `.includes()`, `.shift()`, `.concat()`). Calling an unsupported method returns an actionable `VALIDATION_ERROR` rather than crashing.\n- **Async/Await:** Do NOT access `Promise` objects synchronously. Always `await` async operations. Missing `await` statements will be intercepted and return an actionable `VALIDATION_ERROR`.\n- **SQL Translation & Auto-Healing:** Code Mode executes JavaScript code via `mj.*` API. If raw SQL statements are passed (e.g., `SELECT * FROM journal_entries LIMIT 10`), the server automatically translates them to type-safe `mj.core.getRecentEntries({ limit: 10 })` or `mj.search.searchEntries({ query: \"...\" })` calls.\n- **Direct SQLite & Prepared Statements:** Do NOT execute direct SQLite statements or driver preparations (e.g. `const db = mj.getDatabase(); db.prepare(...)`). Use high-level `mj.*` API calls instead: `mj.admin.updateEntry({ entry_id: ..., content: ... })` to update entries, and `mj.core.createEntry({ ... })` to insert entries. The sandbox automatically translates prepared statement updates and queries into safe `mj.*` method invocations.\n- **Template Literals & Backticks:** When passing multi-line strings or markdown with embedded backticks (e.g. inline code blocks like `` `.npmrc` ``), avoid raw unescaped backticks inside a template literal. Either escape them (`\\```) or pass the string safely via the `context` parameter and access it as `context.myContent`.\n- **Quotes & Escaping:** When passing strings with single quotes, double quotes, or backticks in Code Mode, avoid double-escaping backslashes (e.g. `\\\\'` or `\\\\\"`), which prematurely terminates string literals in JavaScript. Pass complex content safely via `context.content`.\n- **Payload Objects & Raw JSON:** When calling Code Mode, structured dictionary objects (via `payload`, `entry`, or as a raw JSON string in `code`) containing task summaries, notes, changes, status, or action directives (e.g., `{ action: \"create\", task: \"...\", changes: [...], notes: \"...\" }`) are automatically translated and synthesized into type-safe `mj.core.createEntry(...)` or `mj.admin.updateEntry(...)` calls.\n- **Result Size Cap & Auto-Compaction:** By default, Code Mode enforces a 100KB result serialization boundary to protect LLM context windows. For large datasets or multi-entry queries, pass `max_result_size: <bytes>` (e.g. `200 * 1024` or `500 * 1024`, up to 50MB) in `mj_execute_code` parameters or context. When structured results exceed the limit, the sandbox automatically compacts oversized markdown content and long arrays so execution succeeds seamlessly.\n\n## API Namespace Map\n\n### `mj.core`\n- `createEntry(params)`\n- `getEntryById(params)`\n- `getRecentEntries(params)`\n- `getEntryHistory(params)`\n- `testSimple(params)`\n- `testErrorHandling(params)`\n- `triggerProgress(params)`\n- `listTags(params)`\n- `markAnchorsStale(params)`\n\n### `mj.search`\n- `searchEntries(params)`\n- `searchByDateRange(params)`\n- `semanticSearch(params)`\n- `getVectorIndexStats(params)`\n- `listDeletedEntries(params)`\n- `crossTeamSearch(params)`\n\n### `mj.analytics`\n- `getStatistics(params)` (or `getStats()`)\n- `getCrossProjectInsights(params)` (or `getInsights()`)\n\n### `mj.relationships`\n- `linkEntries(params)`\n- `visualizeRelationships(params)`\n\n### `mj.io`\n- `exportEntries(params)`\n- `exportMarkdown(params)`\n- `importMarkdown(params)`\n- `importExternal(params)`\n\n### `mj.admin`\n- `updateConfiguration(params)`\n- `registerProject(params)`\n- `updateProject(params)`\n- `deleteProject(params)`\n- `getProject(params)`\n- `listProjects(params)`\n- `updateEntry(params)`\n- `deleteEntry(params)`\n- `restoreEntry(params)`\n- `rebuildVectorIndex(params)`\n- `addToVectorIndex(params)`\n- `mergeTags(params)`\n- `batchCreateEntries(params)`\n- `batchUpdateEntries(params)`\n- `batchDeleteEntries(params)`\n- `runAutoPrune(params)`\n- `searchAuditLog(params)`\n\n### `mj.github`\n- `getGithubIssues(params)`\n- `getGithubPrs(params)`\n- `getGithubIssue(params)`\n- `getGithubPr(params)`\n- `getGithubContext(params)`\n- `getKanbanBoard(params)`\n- `moveKanbanItem(params)`\n- `addKanbanItem(params)`\n- `deleteKanbanItem(params)`\n- `createGithubIssueWithEntry(params)`\n- `closeGithubIssueWithEntry(params)`\n- `getGithubMilestones(params)`\n- `getGithubMilestone(params)`\n- `createGithubMilestone(params)`\n- `updateGithubMilestone(params)`\n- `deleteGithubMilestone(params)`\n- `getRepoInsights(params)`\n- `getCopilotReviews(params)`\n\n### `mj.git`\n- `getCommitHistory(params)`\n- `searchCommits(params)`\n- `getReleaseInfo(params)`\n- `getUnreleasedCommits(params)`\n- `analyzeCommitPatterns(params)`\n- `checkEntryStaleness(params)`\n\n### `mj.backup`\n- `backupJournal(params)`\n- `listBackups(params)`\n- `restoreBackup(params)`\n- `cleanupBackups(params)`\n\n### `mj.team`\n- `teamCreateEntry(params)`, `teamGetEntryById(params)` (or `read()`), `teamGetRecent(params)`, `teamListTags(params)`\n- `teamSearch(params)`, `teamSearchByDateRange(params)`, `teamSemanticSearch(params)`\n- `teamUpdateEntry(params)`, `teamDeleteEntry(params)`, `teamRestoreEntry(params)`, `teamListDeletedEntries(params)` (or `trash()`)\n- `teamMergeTags(params)`, `teamLinkEntries(params)`, `teamVisualizeRelationships(params)`\n- `teamBatchCreateEntries(params)`, `teamBatchUpdateEntries(params)`, `teamBatchDeleteEntries(params)`\n- `teamGetStatistics(params)` (or `stats()`), `teamGetCrossProjectInsights(params)`, `teamGetCollaborationMatrix(params)`\n- `teamExportEntries(params)` (or `export()`), `teamExportMarkdown(params)`, `teamImportMarkdown(params)` (or `importMd()`), `teamImportExternal(params)`\n- `teamBackup(params)`, `teamListBackups(params)`\n- `teamGetVectorIndexStats(params)`, `teamRebuildVectorIndex(params)`, `teamAddToVectorIndex(params)`\n- `teamAddMember(params)`, `teamRemoveMember(params)`, `teamUpdateMemberRole(params)`, `teamListMembers(params)`, `teamGetMember(params)`\n- `teamAddAuthorAlias(params)`, `teamRemoveAuthorAlias(params)`, `teamListAuthorAliases(params)`, `teamResolveAuthor(params)`, `teamConsolidateAuthors(params)`\n\n**Rule:** When `mj_execute_code` is the only registered tool (e.g., Code Mode), all tool actions must be performed using the `mj.*` namespaces listed above inside the code sandbox. Do NOT attempt to call the original tool names as direct MCP operations. CLI commands are exempt from this and should be run in the terminal.";
+//# sourceMappingURL=codemode.d.ts.map

package/dist/constants/instructions/codemode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codemode.d.ts","sourceRoot":"","sources":["../../../src/constants/instructions/codemode.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,k7OAwH6S,CAAC"}

package/dist/constants/instructions/core.d.ts

@@ -0,0 +1,2 @@
+export declare const CORE_HELP = "# Core Operations\n- **Workspace Isolation**: When creating or reading entries, consider the `workspace_id` parameter. If a default workspace is active, entries are automatically scoped to it unless explicitly overridden.\n\n### Session Summaries\n\nUse the `memory-journal-mcp entry create` terminal command to record session summaries. You MUST provide the markdown content via `--content \"<string>\"` or `--file <path>` (or pipe to stdin). Required fields:\n\n- `--type retrospective`\n- `--tags session-summary` (plus relevant domain/activity tags, comma-separated)\n- `--project` from the briefing\n- `--impact-score`, `--trust-score`, and `--validation-status` MUST be evaluated and populated.\n- `--related-to` MUST be populated with IDs of related tasks, architectural plans, or preceding summaries.\n- `--auto-context` MUST be populated with a concise JSON payload representing the context (e.g. `{ \"commits\": [\"abc1234\", \"def5678\"] }`)\n\nDo NOT create session summaries for testing passes where everything passed and no code changes were made. Only summarize sessions with substantive work.\n\n### Entry Type Selection\n\nChoose the correct `entry_type` \u2014 do NOT default everything to `personal_reflection`:\n\n- `retrospective` \u2014 Session summaries, certification reports, any \"what was accomplished\" recap\n- `bug_fix` \u2014 Specific bug identification and/or resolution\n- `project_decision` \u2014 Architecture decisions, pattern adoptions, technology choices\n- `planning` \u2014 Roadmaps, sprint plans, project initialization\n- `code_review` \u2014 Security audits, code quality reviews, copilot findings\n- `technical_note` \u2014 Implementation notes, gotchas, reference documentation\n- `feature_implementation` \u2014 New feature completions\n- `research` \u2014 Investigation, benchmarking, evaluation of alternatives\n- `meeting_notes` \u2014 Meeting minutes, sync notes, discussion summaries\n- `learning` \u2014 Lessons learned, tutorials completed, skill acquisition\n- `standup` \u2014 Daily standup notes, status updates\n- `milestone` \u2014 Major project milestones, release checkpoints\n- `technical_achievement` \u2014 Significant technical accomplishments\n- `enhancement` \u2014 Incremental improvements, optimizations\n- `development_note` \u2014 Day-to-day development context and progress\n- `system_integration_test` \u2014 Full integration/e2e test results\n- `test_entry` \u2014 Automated or manual test results\n- `plan_draft` \u2014 Initial drafts of implementation plans\n- `adversarial_review` \u2014 Reviews and critiques from adversarial subagents\n- `plan_refinement` \u2014 Refinements to plans based on reviews\n- `plan_finalized` \u2014 Finalized implementation plans after review\n- `copilot_validation` \u2014 Validation of copilot suggestions\n- `maintenance` \u2014 Scheduled or manual database optimization, CMS consolidation, and infrastructure healing reports\n- `other` \u2014 Anything that doesn't fit the above categories\n- `personal_reflection` \u2014 Only for genuinely personal notes that don't fit above\n\n### Tag Taxonomy\n\nEvery entry MUST have at least one tag. Use kebab-case exclusively.\nTags are limited to a maximum of 100 characters. Journal entry content is limited to a maximum of 50,000 characters.\n\n- _Activity_: `session-summary`, `certification`, `stress-test`, `bug-fix`, `release`, `audit`, `remediation`, `refactor`\n- _Domain_: `security`, `performance`, `architecture`, `code-mode`, `documentation`, `ci-cd`, `github-integration`\n- _Tool group_: Name of the tool group being worked on (e.g., `core`, `search`, `github`, `admin`)\n- _Pattern_: `split-schema`, `zod`, `error-handling`, `dual-schema`\n\n### Heuristic Scoring Criteria\n\nALL entries MUST define heuristic scores. Use these explicit thresholds:\n\n- `validation_status`: \n  - `none`: Work completed but not yet explicitly tested/verified.\n  - `passed`: Work explicitly validated via tests, manual confirmation, or peer review.\n  - `failed`: Work that failed verification or was found to be hallucinatory.\n- `trust_score` (Confidence):\n  - `0.0 - 0.2`: Suspected hallucination or failed validation.\n  - `0.3 - 0.5`: Unverified work, draft plans, or assumptions (Baseline for unverified work).\n  - `0.6 - 0.8`: Partially verified or low-risk routine changes.\n  - `0.9 - 1.0`: Rigorously verified via automated tests, peer review, or explicitly confirmed by the user.\n  - *Note: `trust_score` acts as a multiplier on the entry's importance. Low trust entries will decay and be auto-pruned faster.*\n- `impact_score` (Blast Radius):\n  - `0.0 - 0.2`: Trivial changes, typos, minor doc updates.\n  - `0.3 - 0.5`: Standard feature work, isolated bug fixes.\n  - `0.6 - 0.8`: Major new features, cross-module changes.\n  - `0.9 - 1.0`: Core architectural shifts, destructive operations, critical security patches.\n\n### Significance Marking\n\nMark important entries with `significance_type`:\n\n- `release` \u2014 Version deployments\n- `milestone` \u2014 Major completions (full certification, security audit, feature launch)\n- `decision` \u2014 Technology or process decisions\n- `architecture` \u2014 Architecture decisions, pattern adoptions, structural changes\n- `blocker_resolved` \u2014 Critical blockers that were resolved\n- `lesson_learned` \u2014 Documented lessons from failures or unexpected outcomes\n- `breakthrough` \u2014 Significant technical or conceptual breakthroughs\n- `security` \u2014 Security audit completions, vulnerability remediations, hardening milestones\n\nDo NOT mark routine session summaries or pass-only testing results as significant.\n\n### Link Entries\n\nCreate relationships to build traversable context chains:\n\n- `implements` \u2014 implementation\u2192spec, remediation\u2192audit findings\n- `resolved` \u2014 bugfix\u2192issue that reported the bug\n- `evolves_from` \u2014 v2\u2192v1, new iteration\u2192prior version\n- `references` \u2014 cross-project parity work, related entries\n- `clarifies` \u2014 documentation\u2192implementation it explains\n- `response_to` \u2014 reply to a question or issue raised in another entry\n- `blocked_by` \u2014 entry was blocked by another (blocker\u2192resolution)\n- `caused` \u2014 entry caused or led to another outcome\n\nOnly link truly related entries. Do NOT create bulk relationships between unrelated entries that happen to share tags.\n- **Opportunistic Superseding (Awake Contradiction Resolution)**: When creating a `project_decision`, `bug_fix`, or `technical_note` that invalidates or replaces an earlier entry surfaced in your briefing or search results, immediately link the new entry to the superseded entry via `evolves_from` or `resolved` so the knowledge graph reflects the superseding chain in real time.\n\n### Git Commit Standards\n\nWhen committing changes to a repository:\n\n- **Commit Journaling**: Record a corresponding `commit-narrative` journal entry containing `auto_context: { \"commits\": [\"<sha>\"] }` along with accurate heuristic scores (`impact_score`, `trust_score`, `validation_status`). If your workspace provides a `commit.ts` wrapper (e.g. `.agents/scripts/commit.ts`), append `--journal` to automate this step; otherwise use standard `git commit` and log the entry via `mj_execute_code`, `create_entry`, or `memory-journal-mcp entry create`.\n- **Scoring**: Provide accurate scores (`0.1-1.0`) for blast radius (`impact_score`) and verification level (`trust_score`). **NEVER \"rubber stamp\" 1.0** without rigorous validation; accurately reflect verification.\n- **Validation**: Provide `validation_status` (`passed`, `failed`, or `none`).\n\n## Available Tools\n\n- **Entry Lifecycle**: `create_entry`, `get_entry_by_id`, `get_recent_entries`, `get_entry_history`\n- **Taxonomy & Graph**: `list_tags`, `mark_anchors_stale`\n- **Testing Tools**: `test_simple`, `test_error_handling`, `trigger_progress`\n\n";
+//# sourceMappingURL=core.d.ts.map

package/dist/constants/instructions/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../src/constants/instructions/core.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,wvPAyHrB,CAAC"}

package/dist/constants/instructions/git.d.ts

@@ -0,0 +1,2 @@
+export declare const GIT_HELP = "# Git History Mining\n\n- **Commit Discovery**: Use `get_commit_history` to fetch sequential logs and `search_commits` to find specific changes by message or author.\n- **Release Tracking**: Use `get_release_info` to retrieve tag details and `get_unreleased_commits` to track work pending release.\n- **Analytics**: Use `analyze_commit_patterns` to identify file hotspots and active contributors within a timeframe.\n- **Performance**: Deep searches can take time. Cap your search ranges when possible.\n- **Code Mode**: These tools are exposed under the `mj.git.*` namespace (e.g., `mj.git.getCommitHistory()`).\n\n## Available Tools\n\n- **History**: `get_commit_history`, `search_commits`\n- **Releases**: `get_release_info`, `get_unreleased_commits`\n- **Analytics**: `analyze_commit_patterns`, `check_entry_staleness`\n\n";
+//# sourceMappingURL=git.d.ts.map

package/dist/constants/instructions/git.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../../../src/constants/instructions/git.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ,+zBAcpB,CAAC"}

package/dist/constants/instructions/github.d.ts

@@ -0,0 +1,2 @@
+export declare const GITHUB_HELP = "# GitHub Integration\n\n- Include `issue_number`/`pr_number` and `--project` in your `memory-journal-mcp entry create` CLI command to auto-link\n- After closing issue/merging PR \u2192 create summary entry with learnings\n- CI failures \u2192 `actions-failure-digest` prompt or `memory://actions/recent`\n- Kanban: `get_kanban_board` \u2192 `add_kanban_item` / `move_kanban_item` / `delete_kanban_item` \u2192 document completion (project_number auto-resolves if repo is registered). **\u26A0\uFE0F Eventual Consistency:** GitHub Projects V2 read index is heavily eventually consistent. Do NOT rely on `get_kanban_board` to immediately reflect items that were just added or moved.\n- Milestones: `get_github_milestones` \u2192 track project progress, `memory://github/milestones`\n- Commits: `memory://commits/{project_number}/by-issue` and `memory://commits/{project_number}/by-pr` group commits by referenced issues/PRs.\n- Rate Limits & Status: Before expensive API operations, check `memory://github/status` (or `memory://github/status/{+repo}`) to inspect repository connectivity and status.\n- **Project Initialization**: To register a new project workspace, use the `register_project` (or `update_project`) MCP tool (`mj.admin.registerProject` / `mj.admin.updateProject` in Code Mode) or the `memory-journal-mcp project create <name> --path <path> --number <N>` CLI command.\n- **Multi-Project Routing**: If `memory://briefing` shows \"Registered Workspaces\":\n  - **Tools**: The `repo` parameter automatically resolves from `project_number`. If you omit both, they default to the primary project.\n  - **Resources**: Resource URIs like `memory://github/status` will fallback to the default project. To explicitly target another project, use the `{repo}` variant (e.g., `memory://github/status/{repo}`).\n  - **Dynamic Briefings**: You can explicitly request the briefing for a specific project by reading `memory://briefing/{repo}` instead of the global `memory://briefing` resource.\n\n## Copilot Review Patterns\n\nWhen the user has GitHub Copilot code review enabled:\n\n**Learn from reviews** \u2014 After a PR is merged or reviewed, use `get_copilot_reviews({ pr_number, owner, repo })` to read Copilot's findings (leave `owner` and `repo` empty to auto-detect from git). If patterns emerge (e.g., repeated null check warnings, missing error handling), suggest adding a rule or updating existing rules. Create journal entries tagged `copilot-finding` and link to the PR via `pr_number`.\n\n**Pre-emptive checking** \u2014 Before creating or modifying code, search journal entries with tag `copilot-finding` for patterns relevant to the current work. Apply those patterns proactively to reduce review cycles.\n\n## Available Tools\n\n- **Issues**: `get_github_issues`, `get_github_issue`, `create_github_issue_with_entry`, `close_github_issue_with_entry`\n- **Pull Requests**: `get_github_prs`, `get_github_pr`, `get_copilot_reviews`\n- **Context & Insights**: `get_github_context`, `get_repo_insights`\n- **Kanban**: `get_kanban_board`, `add_kanban_item`, `move_kanban_item`, `delete_kanban_item`\n- **Milestones**: `get_github_milestones`, `get_github_milestone`, `create_github_milestone`, `update_github_milestone`, `delete_github_milestone`\n\n";
+//# sourceMappingURL=github.d.ts.map

package/dist/constants/instructions/github.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github.d.ts","sourceRoot":"","sources":["../../../src/constants/instructions/github.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,msGA+BvB,CAAC"}

package/dist/constants/instructions/gotchas.d.ts

@@ -0,0 +1,2 @@
+export declare const GOTCHAS_HELP = "# Field Notes & Gotchas\n\n## Tool Usage Pitfalls\n\n1. **Result Limits**: The `MAX_QUERY_LIMIT` is strictly 500 for most search tools. Use the optional `cursor` parameter and `next_cursor` output for O(1) keyset pagination on large datasets. Batch operations are strictly limited to `MAX_BATCH_SIZE` (50) per transaction.\n2. **Code Mode Restrictions**: The `mj_execute_code` sandbox cannot make network requests (calling `fetch()` returns a 403 `VALIDATION_ERROR` response object and Node network modules are stripped). Use it strictly for orchestrating `mj.*` API calls. If you need to hit external/HTTP endpoints or execute shell commands, you must use native OS tools outside of Code Mode. Note: `setTimeout` and `sleep(ms)` are available for minor delays, but avoid long-running operations.\n3. **Tool & Parameter Hallucinations**: Do NOT attempt to use tools that are not listed in the `memory://help` resource. If you guess incorrect parameter names, array methods, or access `Promise` objects synchronously in Code Mode, the proxy layer will intercept the mistake and return a structured `[VALIDATION_ERROR]` payload with `{ success: false }`. Read the feedback and adjust your payload rather than expecting a raw V8 crash. (Note: In-process MCP tool and argument healing is enabled by default and can be disabled globally via `--no-agent-healing` or `MCP_AGENT_HEALING=false`.)\n   - **Batch Operations:** Tools like `batch_create_entries`, `batch_update_entries`, and `batch_delete_entries` strictly require an object wrapper (e.g., `{ entries: [...] }`, `{ updates: [...] }`, `{ entry_ids: [...] }`). **NEVER** pass an array directly as the main argument.\n   - **Entry Creation Fields:** Entry creation tools require `content` for the primary markdown text. Hallucinated parameter names such as `entry`, `text`, `message`, `description`, `notes`, or `details` (as well as nested `{ entry: { ... } }` objects) are automatically healed and normalized to `content`.\n   - **Parameterless Tools & Prompts:** Tools like `rebuild_vector_index` take an empty object `{}`. Similarly, for MCP Prompts, note that some arguments are explicitly required (e.g., `project_number` in `project-status-summary` and `project-milestone-tracker`, or `pr_number` in `pr-summary`, `code-review-prep`, and `pr-retrospective`).\n   - **Diagnostic & Adapter Tools:** Ecosystem diagnostic methods like `server_info`, `server_health`, and `list_adapters` are automatically healed when called as MCP tools or via Code Mode (`mj.system.listAdapters()`, `mj.adapters()`).\n   - **Native Tool & Codebase Search Fallbacks:** Agent-native inspection tools like `grep_search`, `file_search`, `view_file`, and `list_dir` are automatically healed when autonomous healing is enabled. When invoked against the MCP server, local filesystem queries are bounded by `--allowed-io-roots` (`ALLOWED_IO_ROOTS`) and returned safely, and journal queries are seamlessly mapped to `search_entries` or resources.\n4. **Phrase Matching**: The `query` parameter in search tools supports true phrase matching. Wrap exact strings in double quotes (e.g., `\"error handling\"`) when word order and adjacency are critical.\n5. **Typo Tolerance**: FTS5 search operations automatically fall back to Levenshtein distance matching on tags and entry types if no results are found. To disable this when strict exact matching is needed, explicitly set `fuzzy_match: false`.\n6. **Team RBAC**: If the team database has at least one member registered, RBAC is active. Unregistered authors fall back to the `TEAM_DEFAULT_ROLE` (which denies access by default). Non-admin members can only modify or delete entries they originally authored.\n7. **Concurrent Edits**: When updating or deleting an entry (`update_entry`, `team_update_entry`, `delete_entry`, `team_delete_entry`), always pass `expected_version` if you know the current version to prevent silently overwriting concurrent changes. If you get a `VERSION_CONFLICT` error, re-read the latest entry state returned in the error payload, merge your changes, and retry.\n8. **Cross-Team Search**: The `cross_team_search` tool searches across multiple team databases configured via `ADDITIONAL_TEAM_DBS`. Results include a `team_db` label identifying the source database. This tool is read-only and uses FTS5 only (no semantic/vector search across DBs). Individual DB failures are non-fatal \u2014 the response includes `degraded: true` and per-DB error details.\n9. **Observability & Persistence**: If the server runs via HTTP with `--metrics-export prometheus` (or `METRICS_EXPORT`), a standard `/metrics` endpoint is exposed for external scrapers. Code Mode cannot natively fetch this endpoint; instead, use the `memory://metrics/summary`, `memory://metrics/latency`, and `memory://metrics/resources` resources to retrieve telemetry. **Metrics reset on restart** unless the `--persist-metrics` flag (or `PERSIST_METRICS` env var) is provided, which enables periodic JSON state snapshots for long-term trend analysis.\n10. **Multi-step Operations & Error Aggregation**: Tools performing batch actions (e.g., `import_markdown`, `batch_create_entries`, `batch_update_entries`, `batch_delete_entries`, `rebuild_vector_index`) will return a single `ErrorResponse` on partial failure (with `success: false`). This response contains an `aggregated_errors` array of objects (e.g. `[{ \"message\": \"Item at index 0 failed: UNIQUE constraint failed\" }]`) detailing individual item failures, while the top-level error message summarizes total success/failure counts.\n11. **Configuration Precedence & Debugging**: Server settings are resolved using strict precedence: CLI flags override Environment Variables, which override the Config File (`memory-journal.config.yaml` / `.yml` / `.json`), which overrides Defaults. If you encounter unexpected settings, you can run the server with the `--dump-config` flag. This command aggregates any startup configuration validation errors (printing them all at once rather than failing on the first one) or, if valid, prints the fully resolved configuration tree (with secrets automatically redacted as `[REDACTED]`) and exits cleanly. This is the primary method for diagnosing overriding issues.\n12. **Runtime Configuration Hot-Reloading**: Use `update_configuration` to dynamically change the `tool_filter` or briefing variables without a server restart. Both `update_configuration` and `mj_execute_code` are **always available** regardless of the active filter \u2014 you can never lock yourself out.\n\n   **Granular Tool Switching**: You can enable/disable individual tools at runtime:\n   - Add a tool: `update_configuration({ tool_filter: \"starter,+get_github_issues\" })`\n   - Remove a tool: `update_configuration({ tool_filter: \"full,-backup_journal,-restore_backup\" })`\n   - Exact whitelist: `update_configuration({ tool_filter: \"create_entry,search_entries\" })`\n   - Read `memory://tools/available` to discover all tools and their groups before enabling them.\n   \n   After calling `update_configuration`, the server emits `notifications/tools/list_changed` so MCP clients that support it automatically refresh the available tool list.\n13. **Database Encryption**: If the database requires SQLCipher encryption at rest, you must set the `DB_ENCRYPTION_KEY` environment variable when starting the server. If this key is missing or incorrect for an encrypted database, any operations will fail with a \"not a database\" error.\n14. **Scheduled Reports**: The `--report-interval` scheduler job is HTTP-only and requires `--report-webhook-url` to actually deliver reports. Without a webhook URL, the job still generates and persists report snapshots (viewable via `memory://insights/reports`) but skips delivery. Report delivery failures are logged but never crash the server.\n15. **Token Estimation & Content-Type Heuristics**: To assist you in optimizing your context window consumption, every tool execution result includes a `_meta.tokenEstimate` field. This value uses dynamic, content-type-aware heuristics to closely estimate real token costs (Prose defaults to 4.0 bytes/token; JSON payloads to 2.8 bytes/token; Code blocks to 3.2 bytes/token). Leverage this telemetry to govern your batch sizes or fallback to paginated/throttled endpoints if usage spikes.\n16. **Schema Hallucinations in Custom Scripts**: When writing standalone scripts or Code Mode execution payloads, do **NOT** write raw SQL queries against `better-sqlite3` guessing the database schema based on TypeScript interfaces. For example, the primary table is named `memory_journal` (NOT `entries`), and it **DOES NOT** have columns for `importance` or `created_by_agent`. Always rely on the built-in MCP API tools (e.g., `search_entries`, `get_recent_entries`) or Code Mode `mj` globals rather than crafting raw `SELECT` or `DELETE` statements to avoid `SqliteError: no such table` or `no such column` crashes.\n17. **Template Literals & Backticks in Code Mode**: When generating JavaScript code inside `mj_execute_code`, avoid unescaped nested backticks (`` ` ``) inside template literals (e.g., `` content: `... `.npmrc` ...` ``). Unescaped backticks prematurely terminate the template string and trigger syntax errors or tagged template TypeErrors (e.g., `TypeError: \"...\".npmrc is not a function`). Instead, pass large markdown payloads via the `context` parameter (e.g., `context: { content: \"...\" }`) and reference them as `context.content`, or escape all nested backticks with `\\`.\n18. **Result Size Cap & Auto-Compaction in Code Mode**: The Code Mode sandbox enforces a default 100KB result serialization cap to protect context windows and prevent out-of-memory crashes. If your script returns large payloads (such as querying 50+ entries with complete markdown content), pass `max_result_size: <bytes>` (e.g. `200 * 1024` or `500 * 1024`, up to 50MB) in `mj_execute_code` parameters or context, set the `CODE_MODE_MAX_RESULT_SIZE` environment variable, or select specific fields before returning. When returning oversized collections, the sandbox automatically compacts large markdown strings to preserve execution success.\n\n## GitHub & Kanban Sync\n\n- **Eventual Consistency**: GitHub Projects V2 read indexes are eventually consistent. If you `add_kanban_item` or `move_kanban_item`, a subsequent `get_kanban_board` might take up to 10 seconds to reflect the change.\n- **Multi-Project Routing**: Always pass the `repo` parameter to GitHub tools if your `memory://briefing` indicates you are in a multi-project environment.\n\n## Structural Integrity\n\n- **Session Summaries**: Always use `entry_type: \"retrospective\"` and tag with `session-summary`.\n- **References**: Never guess `entry_id`, `issue_number`, or `pr_number`. Always query them first to avoid broken links.\n- **Significance**: Only mark entries with `significance_type` if they are genuinely major milestones, decisions, or breakthroughs. Overusing this degrades the signal-to-noise ratio of the journal.";
+//# sourceMappingURL=gotchas.d.ts.map

package/dist/constants/instructions/gotchas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gotchas.d.ts","sourceRoot":"","sources":["../../../src/constants/instructions/gotchas.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,gxVA6C+K,CAAC"}

package/dist/constants/instructions/io.d.ts

@@ -0,0 +1,2 @@
+export declare const IO_HELP = "# IO Operations\n- **Exporting**: Supports exporting entries to JSON or Markdown format. Native Markdown exports (`export_markdown`) include JSON-formatted frontmatter inside `---` delimiters for lossless metadata round-tripping.\n- **Importing**: Supports importing entries from native Markdown files with JSON frontmatter (`import_markdown`) or external Markdown vaults with standard YAML frontmatter such as Obsidian, Notion, and Logseq (`import_external`).\n\n## Available Tools\n\n- **Export**: `export_entries`, `export_markdown`\n- **Import**: `import_markdown`, `import_external`\n";
+//# sourceMappingURL=io.d.ts.map

package/dist/constants/instructions/io.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"io.d.ts","sourceRoot":"","sources":["../../../src/constants/instructions/io.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,klBAQnB,CAAC"}

package/dist/constants/instructions/relationships.d.ts

@@ -0,0 +1,2 @@
+export declare const RELATIONSHIPS_HELP = "# Relationships Operations\n- **Linking**: Entries can be connected to form a traversable graph. Use explicit relation types like `implements`, `resolved`, `evolves_from`, `references`, `clarifies`, `response_to`, `blocked_by`, or `caused`.\n- **Visualization**: Generates a Mermaid.js graph or standard JSON representation of the relationship network between entries.\n\n## Available Tools\n\n- **Linking**: `link_entries`\n- **Visualization**: `visualize_relationships`\n";
+//# sourceMappingURL=relationships.d.ts.map

package/dist/constants/instructions/relationships.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relationships.d.ts","sourceRoot":"","sources":["../../../src/constants/instructions/relationships.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,8dAQ9B,CAAC"}

package/dist/constants/instructions/search.d.ts

@@ -0,0 +1,2 @@
+export declare const SEARCH_HELP = "# Search Operations\n- **Workspace Filtering**: All search and listing operations filter by `workspace_id` if configured. You can query across workspaces by explicitly omitting the workspace or passing an asterisk/wildcard if supported.\n- **CLI Commands**: You can search natively via the CLI by using `memory-journal-mcp search <query>`, or explicitly with the `--query`, `--term`, or `--keyword` flags.\n\n## Available Tools\n\n- **Core Search**: `search_entries`, `search_by_date_range`, `cross_team_search`\n- **Vector/Semantic**: `semantic_search`, `get_vector_index_stats`\n- **Recycle Bin**: `list_deleted_entries`\n\n";
+//# sourceMappingURL=search.d.ts.map

package/dist/constants/instructions/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../src/constants/instructions/search.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,unBAUvB,CAAC"}

package/dist/constants/instructions/team.d.ts

@@ -0,0 +1,2 @@
+export declare const TEAM_HELP = "# Team Collaboration\n\n### Team RBAC & Access Control\n\nThe team database features a Role-Based Access Control (RBAC) system for team members:\n- **Roles**: \n  - `viewer`: Read-only access to all team data.\n  - `member`: Read all, Create/Edit/Delete *own* entries.\n  - `admin`: Read/Write/Delete *all* entries, manage team members, rebuild vector indexes, backup data.\n- **Bootstrap Workflow**: The RBAC system is inactive until the first member is added. The first time `team_add_member` is called, the caller is automatically registered as an `admin`. Alternatively, the server can be bootstrapped via the `TEAM_ADMIN` environment variable or `--team-admin` CLI flag. Unregistered authors fall back to the configured `TEAM_DEFAULT_ROLE`.\n- **Managing Members**: Admins can manage members using `team_add_member`, `team_remove_member`, `team_update_member_role`, `team_list_members`, and `team_get_member`. \n- **Author Aliases**: Admins can manage author aliases to consolidate attribution for team analytics when one person uses multiple usernames using `team_add_author_alias`, `team_list_author_aliases`, `team_resolve_author`, `team_remove_author_alias`, and `team_consolidate_authors`.\n- **OAuth Scopes**: OAuth scopes (read/write/admin) govern broad HTTP endpoint access. RBAC roles govern fine-grained internal tool capabilities. Both must be satisfied when OAuth is active.\n\n## Available Tools\n\n- **Core**: `team_create_entry`, `team_get_entry_by_id`, `team_get_recent`, `team_list_tags`\n- **Search**: `team_search`, `team_search_by_date_range`, `team_list_deleted_entries`\n- **Admin**: `team_update_entry`, `team_delete_entry`, `team_restore_entry`, `team_merge_tags`, `team_batch_create_entries`, `team_batch_update_entries`, `team_batch_delete_entries`\n- **Analytics**: `team_get_statistics`, `team_get_cross_project_insights`, `team_get_collaboration_matrix`\n- **Relationships**: `team_link_entries`, `team_visualize_relationships`\n- **IO**: `team_export_entries`, `team_export_markdown`, `team_import_markdown`, `team_import_external`\n- **Backup**: `team_backup`, `team_list_backups`\n- **Vector**: `team_semantic_search`, `team_get_vector_index_stats`, `team_rebuild_vector_index`, `team_add_to_vector_index`\n- **Members**: `team_add_member`, `team_remove_member`, `team_update_member_role`, `team_list_members`, `team_get_member`\n- **Aliases**: `team_add_author_alias`, `team_remove_author_alias`, `team_list_author_aliases`, `team_resolve_author`, `team_consolidate_authors`\n\n";
+//# sourceMappingURL=team.d.ts.map

package/dist/constants/instructions/team.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"team.d.ts","sourceRoot":"","sources":["../../../src/constants/instructions/team.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,y9EA2BrB,CAAC"}

package/dist/constants/instructions/templates.d.ts

@@ -0,0 +1,2 @@
+export declare const TEMPLATES_HELP = "# Content Templates\n\nThese templates define the REQUIRED structure for journal entry content by type. Do NOT invent additional top-level sections. Do NOT omit required sections.\n\n## Session Summary (entry\\_type: \"retrospective\", tag: \"session-summary\")\n\n```\n## Accomplished\n- [Concrete item: what was done, key files/PRs/entry IDs]\n- [Another concrete item]\n\n## Unfinished / Blocked\n- [Item: why it's blocked or what remains \u2014 or \"None\" if complete]\n\n## Context for Next Session\n- [Key context the next agent/session needs: branch names, PR numbers, entry IDs, pending decisions]\n\n## Commits\n- `<sha>` \u2014 [Brief commit summary or \"None\"]\n```\n\nDo NOT add extra top-level sections (no \"## Summary\", \"## Overview\", \"## Notes\").\nDo NOT omit any of the four required sections.\nAlways remember to populate the `auto_context` payload parameter with the session's commit SHAs.\n\n## Feature Implementation (entry\\_type: \"feature\\_implementation\")\n\n```\n## Summary\n[1-2 sentence description of the feature]\n\n## Changes\n- [File/module]: [what changed]\n\n## Testing\n- [How it was tested, results]\n\n## Notes\n- [Any gotchas, follow-ups, or related entries]\n```\n\n## Bug Fix (entry\\_type: \"bug\\_fix\")\n\n```\n## Problem\n[What was broken and how it manifested]\n\n## Root Cause\n[Why it happened]\n\n## Fix\n- [What was changed to fix it]\n\n## Verification\n- [How the fix was verified]\n```\n\n## Planning (entry\\_type: \"planning\")\n\n```\n## Goal\n[What this plan aims to achieve]\n\n## Approach\n- [Step or phase]: [description]\n\n## Open Questions\n- [Unresolved decisions or dependencies]\n```\n\n## Technical Note (entry\\_type: \"technical\\_note\")\n\n```\n## Topic\n[What this note documents]\n\n## Details\n[Technical explanation, code patterns, configuration]\n\n## References\n- [Related entries, docs, or external links]\n```\n\n## General Rule\n\nFor any entry type not listed above, structure content with:\n1. A clear `##` heading describing the main topic\n2. Bullet points for discrete items\n3. No invented sections beyond what the content actually covers";
+//# sourceMappingURL=templates.d.ts.map

package/dist/constants/instructions/templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../../../src/constants/instructions/templates.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,0lEAwFqC,CAAC"}