supipowers 2.0.2 → 2.1.0

package/src/mempalace/python/mempalace_bridge.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """One-shot JSON bridge for the native supipowers MemPalace tool.
 
-Action mapping (auditable API surface) — wired against MemPalace 3.3.4:
+Action mapping (auditable API surface):
 - version: stdlib importlib.metadata only; does not import MemPalace runtime modules.
 - 29 MCP-equivalent actions dispatch to ``mempalace.mcp_server.tool_<action>``
   (with the ``traverse → tool_traverse_graph`` rename). The mcp_server
@@ -129,6 +129,8 @@ def _handle_version(params: Dict[str, Any], options: Dict[str, Any]) -> Dict[str
 
 def _apply_palace_path(options: Dict[str, Any]) -> None:
     """Set MEMPALACE_PALACE_PATH so MemPalace's MempalaceConfig picks it up."""
+    # NOTE: mutates os.environ — safe only because we run in a fresh process per
+    # call. Any future daemon/persistent-process refactor MUST re-evaluate this.
     palace = options.get("palacePath") or options.get("palace")
     if palace and isinstance(palace, str) and palace:
         os.environ["MEMPALACE_PALACE_PATH"] = os.path.expanduser(palace)
@@ -203,6 +205,42 @@ def _rename(mapping: Dict[str, str]) -> Callable[[Dict[str, Any]], Dict[str, Any
     return extract
 
 
+
+# ── diary_write: source_file embedding ───────────────────────────────────
+#
+# tool_diary_write(agent_name, entry, topic, wing) does not accept source_file.
+# When a source_file is provided, embed it as a deterministic first-line prefix
+# "[source: <source_file>]" in the entry text so that diary_read content
+# carries the linkage. This is the Option-2 convention documented in
+# session-summary.ts: the caller supplies source_file in params; the bridge
+# embeds it; the round-trip proves it via content inspection.
+DIARY_SOURCE_PREFIX = "[source: "
+
+# Upstream sanitize_content default in mempalace.config (3.3.5). Mirrored in
+# src/mempalace/upstream-limits.ts (MEMPALACE_MAX_CONTENT_LENGTH). Bump both
+# when upgrading.
+_MAX_CONTENT_LENGTH = 100_000
+
+
+def _diary_write_extractor(params: Dict[str, Any]) -> Dict[str, Any]:
+    kwargs = _select("agent_name", "topic", "wing")(params)
+    entry: str = params.get("entry") or ""
+    source_file = params.get("source_file")
+    if source_file and isinstance(source_file, str):
+        # MemPalace's tool_diary_write calls sanitize_content(entry), which
+        # raises ValueError if len(entry) > MAX_CONTENT_LENGTH. Adding the
+        # deterministic `[source: ...]\n` prefix can push a TS-valid entry
+        # past that limit and turn a previously-valid request into a domain
+        # failure. Reserve the prefix budget here by clipping the entry tail
+        # so the prefixed payload always fits.
+        prefix = f"{DIARY_SOURCE_PREFIX}{source_file}]\n"
+        budget = max(0, _MAX_CONTENT_LENGTH - len(prefix))
+        if len(entry) > budget:
+            entry = entry[:budget]
+        entry = f"{prefix}{entry}"
+    kwargs["entry"] = entry
+    return kwargs
+
 # ── MCP-equivalent action dispatch ───────────────────────────────────────
 #
 # Each entry maps our action -> (function name in mempalace.mcp_server,
@@ -224,7 +262,7 @@ MCP_TOOL_DISPATCH: Dict[str, "tuple[str, Callable[[Dict[str, Any]], Dict[str, An
     "delete_drawer": ("tool_delete_drawer", _select("drawer_id")),
     # Knowledge graph: MemPalace uses `entity` for the subject in queries.
     "kg_query": ("tool_kg_query", _rename({"subject": "entity", "as_of": "as_of", "direction": "direction"})),
-    "kg_add": ("tool_kg_add", _select("subject", "predicate", "object", "valid_from", "source_closet")),
+    "kg_add": ("tool_kg_add", _select("subject", "predicate", "object", "valid_from", "valid_to", "source_file", "source_drawer_id")),
     "kg_invalidate": ("tool_kg_invalidate", _select("subject", "predicate", "object", "ended")),
     "kg_timeline": ("tool_kg_timeline", _rename({"subject": "entity"})),
     "kg_stats": ("tool_kg_stats", lambda p: {}),
@@ -239,7 +277,9 @@ MCP_TOOL_DISPATCH: Dict[str, "tuple[str, Callable[[Dict[str, Any]], Dict[str, An
     "delete_tunnel": ("tool_delete_tunnel", _select("tunnel_id")),
     # follow_tunnels: MemPalace uses wing/room (not source_wing/source_room).
     "follow_tunnels": ("tool_follow_tunnels", _rename({"source_wing": "wing", "source_room": "room"})),
-    "diary_write": ("tool_diary_write", _select("agent_name", "entry", "topic", "wing")),
+    # diary_write: source_file is embedded as a prefix in the entry text by
+    # _diary_write_extractor — tool_diary_write does not accept source_file natively.
+    "diary_write": ("tool_diary_write", _diary_write_extractor),
     "diary_read": ("tool_diary_read", _select("agent_name", "wing")),
     "hook_settings": ("tool_hook_settings", lambda p: {}),
     "memories_filed_away": ("tool_memories_filed_away", lambda p: {}),
@@ -287,6 +327,84 @@ def _handle_wake_up(params: Dict[str, Any], options: Dict[str, Any]) -> Dict[str
     return _ok({"text": text}, options)
 
 
+
+# ── wake_up_and_search: composite action (saves one python process spawn) ─
+
+
+def _handle_wake_up_and_search(params: Dict[str, Any], options: Dict[str, Any]) -> Dict[str, Any]:
+    """Batch wake_up + optional search into a single python process.
+
+    Returns {"wake": {"text": ...}, "search": <tool_search payload or null>}.
+    Either half may fail independently; the other half is still returned.
+    """
+    _apply_palace_path(options)
+    palace = options.get("palacePath")
+
+    # ── Wake half ─────────────────────────────────────────────────────────────
+    wake_result: Any = None
+    wake_error: "str | None" = None
+    try:
+        layers = _import_or_raise("mempalace.layers")
+        stack = layers.MemoryStack(palace_path=palace) if palace else layers.MemoryStack()
+        wake_kwargs: Dict[str, Any] = {}
+        if params.get("wing"):
+            wake_kwargs["wing"] = params["wing"]
+        text = _wrap_runtime_errors("MemoryStack.wake_up", lambda: stack.wake_up(**wake_kwargs))
+        wake_result = {"text": text}
+    except BridgeDomainError as exc:
+        wake_error = f"{exc.code}: {exc.message}"
+    except Exception as exc:  # pragma: no cover — defensive isolation
+        wake_error = str(exc)
+
+    # ── Search half (skipped when query is absent or empty) ───────────────────
+    search_result: Any = None
+    search_error: "str | None" = None
+    query = params.get("query")
+    if query and isinstance(query, str) and query.strip():
+        try:
+            module = _import_or_raise("mempalace.mcp_server")
+            tool_search = getattr(module, "tool_search", None)
+            if not callable(tool_search):
+                raise BridgeDomainError(
+                    "mempalace_missing",
+                    "mempalace.mcp_server.tool_search is not callable.",
+                    "Upgrade the managed MemPalace runtime via `/supi:memory setup`.",
+                )
+            search_kwargs: Dict[str, Any] = {"query": query}
+            if params.get("wing"):
+                search_kwargs["wing"] = params["wing"]
+            if params.get("room"):
+                search_kwargs["room"] = params["room"]
+            if isinstance(params.get("limit"), int):
+                search_kwargs["limit"] = params["limit"]
+            raw = _wrap_runtime_errors(
+                "mempalace.mcp_server.tool_search",
+                lambda: tool_search(**search_kwargs),
+            )
+            normalized = _to_jsonable(raw)
+            if isinstance(normalized, dict) and normalized.get("ok") is False and isinstance(normalized.get("error"), dict):
+                err = normalized["error"]
+                code = err.get("code") if isinstance(err.get("code"), str) else "mempalace_runtime_error"
+                message = err.get("message") if isinstance(err.get("message"), str) else json.dumps(err, sort_keys=True)
+                search_error = f"{code}: {message}"
+            else:
+                search_result = normalized
+        except BridgeDomainError as exc:
+            # Surface as partial error so the caller can distinguish a real
+            # search failure from "no query / no hits". Mirrors the wake half.
+            search_error = f"{exc.code}: {exc.message}"
+        except Exception as exc:  # pragma: no cover — defensive isolation
+            # Same contract: never let one half kill the other, but the caller
+            # gets a string they can render or log.
+            search_error = str(exc)
+
+    payload: Dict[str, Any] = {"wake": wake_result, "search": search_result}
+    if wake_error is not None:
+        payload["wake_error"] = wake_error
+    if search_error is not None:
+        payload["search_error"] = search_error
+    return _ok(payload, options)
+
 # ── Native CLI args builders ──────────────────────────────────────────────
 
 
@@ -307,6 +425,8 @@ def _make_cli_args_mine(params: Dict[str, Any]) -> "list[str]":
         args.append("--include-ignored")
     if params.get("no_gitignore"):
         args.append("--no-gitignore")
+    if params.get("dry_run"):
+        args.append("--dry-run")
     if params.get("extract"):
         args.append("--extract")
     return args
@@ -331,6 +451,10 @@ def _make_cli_args_repair(params: Dict[str, Any]) -> "list[str]":
         args.append("--yes")
     if params.get("mode"):
         args.extend(["--mode", str(params["mode"])])
+    if params.get("source"):
+        args.extend(["--source", str(params["source"])])
+    if params.get("archive_existing"):
+        args.append("--archive-existing")
     if params.get("dry_run"):
         args.append("--dry-run")
     return args
@@ -396,6 +520,7 @@ def _make_cli_handler(action: str) -> Callable[[Dict[str, Any], Dict[str, Any]],
 DISPATCH: Dict[str, Callable[[Dict[str, Any], Dict[str, Any]], Dict[str, Any]]] = {
     "version": _handle_version,
     "wake_up": _handle_wake_up,
+    "wake_up_and_search": _handle_wake_up_and_search,
 }
 for _action in MCP_TOOL_DISPATCH:
     DISPATCH[_action] = _make_mcp_handler(_action)

package/src/mempalace/runtime.ts

@@ -19,6 +19,15 @@ export type BridgePathResult =
 
 export interface BridgePathOptions {
   moduleUrl?: string;
+  /**
+   * Installed extension package roots. Used when OMP executes temp-copied TS
+   * modules that do not preserve adjacent non-TypeScript assets.
+   */
+  extensionRoots?: string[];
+}
+
+export interface BridgePathPlatformPaths {
+  agent(...segments: string[]): string;
 }
 
 export interface ProcessRunResult {
@@ -74,6 +83,7 @@ export type RunBridgeRequestResult =
       stdoutPreview: string;
       stderrTail: string;
       durationMs: number;
+      completion?: Promise<void>;
     };
 
 export interface RunBridgeRequestOptions {
@@ -132,21 +142,39 @@ export interface SetupMempalaceRuntimeOptions {
 export function resolveBridgeScriptPath(options: BridgePathOptions = {}): BridgePathResult {
   const moduleUrl = options.moduleUrl ?? import.meta.url;
   const runtimePath = fileURLToPath(moduleUrl);
-  const bridgePath = path.join(path.dirname(runtimePath), "python", "mempalace_bridge.py");
+  const moduleBridgePath = path.join(path.dirname(runtimePath), "python", "mempalace_bridge.py");
+  if (fs.existsSync(moduleBridgePath)) {
+    return { ok: true, path: moduleBridgePath };
+  }
 
-  if (!fs.existsSync(bridgePath)) {
-    return {
-      ok: false,
-      path: bridgePath,
-      error: {
-        code: "bridge_not_found",
-        message: `Bundled MemPalace bridge not found at ${bridgePath}`,
-        remediation: "Reinstall supipowers or verify the package includes src/mempalace/python/mempalace_bridge.py.",
-      },
-    };
+  let missingBridgePath = moduleBridgePath;
+  for (const extensionRoot of options.extensionRoots ?? []) {
+    const extensionBridgePath = path.join(extensionRoot, "src", "mempalace", "python", "mempalace_bridge.py");
+    missingBridgePath = extensionBridgePath;
+    if (fs.existsSync(extensionBridgePath)) {
+      return { ok: true, path: extensionBridgePath };
+    }
   }
 
-  return { ok: true, path: bridgePath };
+  return {
+    ok: false,
+    path: missingBridgePath,
+    error: {
+      code: "bridge_not_found",
+      message: `Bundled MemPalace bridge not found at ${missingBridgePath}`,
+      remediation: "Reinstall supipowers or verify the package includes src/mempalace/python/mempalace_bridge.py.",
+    },
+  };
+}
+
+export function resolveInstalledBridgeScriptPath(
+  paths: BridgePathPlatformPaths,
+  options: BridgePathOptions = {},
+): BridgePathResult {
+  return resolveBridgeScriptPath({
+    ...options,
+    extensionRoots: [paths.agent("extensions", "supipowers"), ...(options.extensionRoots ?? [])],
+  });
 }
 
 export function resolveManagedVenvPaths(
@@ -296,8 +324,14 @@ export async function runBridgeRequest(options: RunBridgeRequestOptions): Promis
   const input = JSON.stringify(options.request);
   const runner = options.runner ?? defaultProcessRunner;
 
+  const runnerPromise = Promise.resolve().then(() =>
+    runner(options.pythonPath, [options.bridgeScriptPath], { input, timeoutMs: options.timeoutMs }),
+  );
+  const completion = runnerPromise.then(() => {}, () => {});
+
+  let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
   const timeout = new Promise<ProcessRunResult>((resolve) => {
-    setTimeout(() => resolve({
+    timeoutHandle = setTimeout(() => resolve({
       code: -1,
       stdout: "",
       stderr: "",
@@ -307,9 +341,9 @@ export async function runBridgeRequest(options: RunBridgeRequestOptions): Promis
   let runResult: ProcessRunResult;
   try {
     runResult = await Promise.race([
-      runner(options.pythonPath, [options.bridgeScriptPath], { input, timeoutMs: options.timeoutMs }),
+      runnerPromise,
       timeout,
-    ]);
+    ]).finally(() => clearTimeout(timeoutHandle));
   } catch (error) {
     return {
       ok: false,
@@ -336,6 +370,7 @@ export async function runBridgeRequest(options: RunBridgeRequestOptions): Promis
       stdoutPreview: "",
       stderrTail: "",
       durationMs,
+      completion,
     };
   }
 
@@ -550,13 +585,15 @@ export function buildMempalaceCliArgs(
   const args: string[] = [action];
   if (action === "split") {
     if (params.source_file) args.push(params.source_file);
-  } else if (params.dir) {
+  } else if (action !== "repair" && params.dir) {
     args.push(params.dir);
   }
 
   if (typeof params.limit === "number") args.push("--limit", String(params.limit));
   if (params.mode) args.push("--mode", params.mode);
+  if (action === "repair" && params.source) args.push("--source", params.source);
   if (params.extract) args.push("--extract");
+  if (action === "repair" && params.archive_existing) args.push("--archive-existing");
   if (params.dry_run) args.push("--dry-run");
   if (params.include_ignored) args.push("--include-ignored");
   if (params.no_gitignore) args.push("--no-gitignore");

package/src/mempalace/schema.ts

@@ -1,3 +1,11 @@
+import {
+  MEMPALACE_MAX_CONTENT_LENGTH,
+  MEMPALACE_MAX_HOPS,
+  MEMPALACE_MAX_NAME_LENGTH,
+  MEMPALACE_MAX_QUERY_LENGTH,
+  MEMPALACE_MAX_RESULTS,
+} from "./upstream-limits.js";
+
 export const MEMPALACE_ACTIONS = [
   "status",
   "list_wings",
@@ -35,6 +43,7 @@ export const MEMPALACE_ACTIONS = [
   "split",
   "repair",
   "wake_up",
+  "wake_up_and_search",
 ] as const;
 
 export type MempalaceAction = typeof MEMPALACE_ACTIONS[number];
@@ -50,13 +59,14 @@ export interface MempalaceParams {
   drawer_id?: string;
   content?: string;
   source_file?: string;
+  source_drawer_id?: string;
   added_by?: string;
   subject?: string;
   predicate?: string;
   object?: string;
   valid_from?: string;
   valid_to?: string;
-  ended?: boolean;
+  ended?: string;
   as_of?: string;
   direction?: string;
   start_room?: string;
@@ -72,8 +82,10 @@ export interface MempalaceParams {
   topic?: string;
   dir?: string;
   mode?: string;
+  source?: string;
   extract?: boolean;
   dry_run?: boolean;
+  archive_existing?: boolean;
   include_ignored?: boolean;
   no_gitignore?: boolean;
   yes?: boolean;
@@ -94,12 +106,14 @@ const STRING_FIELDS = [
   "drawer_id",
   "content",
   "source_file",
+  "source_drawer_id",
   "added_by",
   "subject",
   "predicate",
   "object",
   "valid_from",
   "valid_to",
+  "ended",
   "as_of",
   "direction",
   "start_room",
@@ -114,34 +128,65 @@ const STRING_FIELDS = [
   "topic",
   "dir",
   "mode",
+  "source",
 ] as const;
 
 const POSITIVE_INTEGER_FIELDS = ["limit", "max_hops", "timeout"] as const;
+const MAX_INTEGER_FIELDS: ReadonlyArray<readonly [keyof MempalaceParams, number]> = [
+  ["limit", MEMPALACE_MAX_RESULTS],
+  ["max_hops", MEMPALACE_MAX_HOPS],
+];
 const NON_NEGATIVE_INTEGER_FIELDS = ["offset"] as const;
-const BOOLEAN_FIELDS = ["ended", "extract", "dry_run", "include_ignored", "no_gitignore", "yes"] as const;
+const BOOLEAN_FIELDS = ["extract", "dry_run", "archive_existing", "include_ignored", "no_gitignore", "yes"] as const;
+
+// Per-field maximum string lengths. Each entry mirrors the JSON schema
+// `maxLength` and corresponds to an upstream MemPalace sanitizer bound:
+//   - sanitize_query (tool_search) silently truncates anything beyond
+//     MAX_QUERY_LENGTH, so callers can't tell their long query was clipped.
+//   - sanitize_name / sanitize_kg_value / sanitize_content all raise
+//     ValueError beyond their limits, which surfaces as a domain error
+//     from the python bridge instead of at the TS boundary.
+// Enforcing here gives every overlong field the same `field exceeds <N>
+// characters` error path before the python child is spawned.
+const MAX_LENGTH_FIELDS: ReadonlyArray<readonly [keyof MempalaceParams, number]> = [
+  ["query", MEMPALACE_MAX_QUERY_LENGTH],
+  ["content", MEMPALACE_MAX_CONTENT_LENGTH],
+  ["entry", MEMPALACE_MAX_CONTENT_LENGTH],
+  ["wing", MEMPALACE_MAX_NAME_LENGTH],
+  ["room", MEMPALACE_MAX_NAME_LENGTH],
+  ["subject", MEMPALACE_MAX_NAME_LENGTH],
+  ["predicate", MEMPALACE_MAX_NAME_LENGTH],
+  ["object", MEMPALACE_MAX_NAME_LENGTH],
+  ["start_room", MEMPALACE_MAX_NAME_LENGTH],
+  ["source_wing", MEMPALACE_MAX_NAME_LENGTH],
+  ["source_room", MEMPALACE_MAX_NAME_LENGTH],
+  ["target_wing", MEMPALACE_MAX_NAME_LENGTH],
+  ["target_room", MEMPALACE_MAX_NAME_LENGTH],
+  ["agent_name", MEMPALACE_MAX_NAME_LENGTH],
+  ["topic", MEMPALACE_MAX_NAME_LENGTH],
+] as const;
 
-const REQUIRED_FIELDS: Partial<Record<MempalaceAction, readonly (keyof MempalaceParams)[]>> = {
+export const REQUIRED_FIELDS: Partial<Record<MempalaceAction, readonly (keyof MempalaceParams)[]>> = {
   search: ["query"],
   check_duplicate: ["content"],
   get_drawer: ["drawer_id"],
   list_drawers: ["wing"],
-  add_drawer: ["content"],
+  add_drawer: ["wing", "room", "content"],
   update_drawer: ["drawer_id", "content"],
   delete_drawer: ["drawer_id"],
   kg_query: ["subject"],
   kg_add: ["subject", "predicate", "object"],
-  kg_invalidate: ["subject", "predicate"],
+  kg_invalidate: ["subject", "predicate", "object"],
   kg_timeline: ["subject"],
   traverse: ["start_room"],
-  find_tunnels: ["source_wing", "source_room"],
   create_tunnel: ["source_wing", "source_room", "target_wing", "target_room", "label"],
   delete_tunnel: ["tunnel_id"],
   follow_tunnels: ["source_wing", "source_room"],
-  diary_write: ["entry"],
+  diary_write: ["entry", "agent_name"],
+  diary_read: ["agent_name"],
   init: ["dir"],
   mine: ["dir"],
   split: ["source_file"],
-  repair: ["dir"],
 };
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -156,6 +201,44 @@ function isNonEmptyString(value: unknown): value is string {
   return typeof value === "string" && value.trim().length > 0;
 }
 
+const ISO_DATE_PART_PATTERN = "\\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\\d|3[01])";
+const ISO_UTC_DATETIME_PATTERN = `${ISO_DATE_PART_PATTERN}T(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:Z|\\+00:00)`;
+const ISO_TEMPORAL_PATTERN = `^(?:${ISO_DATE_PART_PATTERN}|${ISO_UTC_DATETIME_PATTERN})$`;
+const ISO_TEMPORAL_DESCRIPTION =
+  "ISO temporal string accepted by MemPalace: YYYY-MM-DD, YYYY-MM-DDTHH:MM:SSZ, or YYYY-MM-DDTHH:MM:SS+00:00.";
+const ISO_TEMPORAL_SCHEMA = {
+  type: "string",
+  pattern: ISO_TEMPORAL_PATTERN,
+  description: ISO_TEMPORAL_DESCRIPTION,
+} as const;
+const ISO_TEMPORAL_REGEX = new RegExp(ISO_TEMPORAL_PATTERN);
+const ISO_TEMPORAL_FIELDS = ["as_of", "valid_from", "valid_to", "ended"] as const;
+const DAYS_IN_MONTH = [31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] as const;
+
+function fixedInt(value: string, start: number, end: number): number {
+  let out = 0;
+  for (let i = start; i < end; i += 1) {
+    out = out * 10 + value.charCodeAt(i) - 48;
+  }
+  return out;
+}
+
+function isLeapYear(year: number): boolean {
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+
+function isValidIsoTemporal(value: string): boolean {
+  if (!ISO_TEMPORAL_REGEX.test(value)) return false;
+
+  const year = fixedInt(value, 0, 4);
+  const month = fixedInt(value, 5, 7);
+  const day = fixedInt(value, 8, 10);
+  if (year < 1) return false;
+
+  const daysInMonth = month === 2 ? (isLeapYear(year) ? 29 : 28) : DAYS_IN_MONTH[month - 1];
+  return day <= daysInMonth;
+}
+
 export const mempalaceToolParameters = {
   type: "object",
   additionalProperties: false,
@@ -166,38 +249,45 @@ export const mempalaceToolParameters = {
       description: "Action to dispatch.",
     },
     palace: { type: "string" },
-    wing: { type: "string" },
-    room: { type: "string" },
-    query: { type: "string" },
-    limit: { type: "integer", minimum: 1 },
-    offset: { type: "integer", minimum: 0 },
+    wing: {
+      type: "string",
+      maxLength: MEMPALACE_MAX_NAME_LENGTH,
+      description: "Wing name. Required for list_drawers to scope the query and avoid an accidental full-palace dump.",
+    },
+    room: { type: "string", maxLength: MEMPALACE_MAX_NAME_LENGTH },
+    query: { type: "string", maxLength: MEMPALACE_MAX_QUERY_LENGTH },
+    limit: { type: "integer", minimum: 1, maximum: MEMPALACE_MAX_RESULTS },
+    offset: { type: "integer", minimum: 0, description: "Zero-based pagination offset (use with limit for list_drawers and similar listing actions)." },
     drawer_id: { type: "string" },
-    content: { type: "string" },
+    content: { type: "string", maxLength: MEMPALACE_MAX_CONTENT_LENGTH },
     source_file: { type: "string" },
+    source_drawer_id: { type: "string" },
     added_by: { type: "string" },
-    subject: { type: "string" },
-    predicate: { type: "string" },
-    object: { type: "string" },
-    valid_from: { type: "string" },
-    valid_to: { type: "string" },
-    ended: { type: "boolean" },
-    as_of: { type: "string" },
+    subject: { type: "string", maxLength: MEMPALACE_MAX_NAME_LENGTH },
+    predicate: { type: "string", maxLength: MEMPALACE_MAX_NAME_LENGTH },
+    object: { type: "string", maxLength: MEMPALACE_MAX_NAME_LENGTH },
+    valid_from: ISO_TEMPORAL_SCHEMA,
+    valid_to: ISO_TEMPORAL_SCHEMA,
+    ended: ISO_TEMPORAL_SCHEMA,
+    as_of: ISO_TEMPORAL_SCHEMA,
     direction: { type: "string" },
-    start_room: { type: "string" },
-    max_hops: { type: "integer", minimum: 1 },
-    source_wing: { type: "string" },
-    source_room: { type: "string" },
-    target_wing: { type: "string" },
-    target_room: { type: "string" },
+    start_room: { type: "string", maxLength: MEMPALACE_MAX_NAME_LENGTH },
+    max_hops: { type: "integer", minimum: 1, maximum: MEMPALACE_MAX_HOPS },
+    source_wing: { type: "string", maxLength: MEMPALACE_MAX_NAME_LENGTH },
+    source_room: { type: "string", maxLength: MEMPALACE_MAX_NAME_LENGTH },
+    target_wing: { type: "string", maxLength: MEMPALACE_MAX_NAME_LENGTH },
+    target_room: { type: "string", maxLength: MEMPALACE_MAX_NAME_LENGTH },
     label: { type: "string" },
     tunnel_id: { type: "string" },
-    agent_name: { type: "string" },
-    entry: { type: "string" },
-    topic: { type: "string" },
+    agent_name: { type: "string", maxLength: MEMPALACE_MAX_NAME_LENGTH },
+    entry: { type: "string", maxLength: MEMPALACE_MAX_CONTENT_LENGTH },
+    topic: { type: "string", maxLength: MEMPALACE_MAX_NAME_LENGTH },
     dir: { type: "string" },
     mode: { type: "string" },
+    source: { type: "string" },
     extract: { type: "boolean" },
     dry_run: { type: "boolean" },
+    archive_existing: { type: "boolean" },
     include_ignored: { type: "boolean" },
     no_gitignore: { type: "boolean" },
     yes: { type: "boolean" },
@@ -254,6 +344,37 @@ export function validateMempalaceParams(params: unknown): MempalaceValidationRes
     }
   }
 
+  for (const [field, max] of MAX_INTEGER_FIELDS) {
+    const value = params[field];
+    if (typeof value === "number" && Number.isInteger(value) && value > max) {
+      errors.push(`${field} exceeds maximum of ${max}`);
+    }
+  }
+
+  for (const [field, max] of MAX_LENGTH_FIELDS) {
+    const value = params[field];
+    if (typeof value === "string" && value.length > max) {
+      errors.push(`${field} exceeds maximum length of ${max} characters`);
+    }
+  }
+
+  // ISO temporal fields: callers commonly pass `" 2026-05-13 "` from logs or
+  // env vars — strip surrounding whitespace before validating so we accept
+  // the same shape MemPalace's downstream sqlite comparison would. Empty
+  // strings are still rejected (semantically not a date, and would be stored
+  // as garbage in the kg.triples valid_from/valid_to columns).
+  for (const field of ISO_TEMPORAL_FIELDS) {
+    const value = params[field];
+    if (typeof value !== "string") continue;
+    const trimmed = value.trim();
+    if (trimmed !== value) {
+      (params as Record<string, unknown>)[field] = trimmed;
+    }
+    if (!isValidIsoTemporal(trimmed)) {
+      errors.push(`${field} must be an ISO temporal string accepted by MemPalace`);
+    }
+  }
+
   for (const field of REQUIRED_FIELDS[action] ?? []) {
     if (!isNonEmptyString(params[field])) {
       errors.push(`${field} is required for action ${action}`);

package/src/mempalace/session-summary.ts

@@ -185,6 +185,11 @@ export function buildCompactionCheckpoint(options: SessionSummaryOptions): Compa
 
 export function buildShutdownDiary(options: SessionSummaryOptions): ShutdownDiary {
   const { body, now } = buildBody("MemPalace shutdown diary", "shutdown", options);
+  // source_file convention: the bridge's Python layer (mempalace_bridge.py) embeds
+  // the source_file value as a deterministic first-line prefix in the entry text:
+  //   "[source: <source_file>]\n<entry>"
+  // tool_diary_write does not accept source_file natively; the prefix is how the
+  // round-trip proves the linkage (diary_read returns the full document text).
   return {
     entry: body,
     metadata: {

package/src/mempalace/tool.ts

@@ -5,7 +5,7 @@ import { resolveMempalaceConfig, type ResolvedMempalaceConfig } from "./config.j
 import { formatMempalaceError, formatMempalaceResult } from "./format.js";
 import { mempalaceToolParameters, validateMempalaceParams, type MempalaceParams } from "./schema.js";
 import {
-  resolveBridgeScriptPath,
+  resolveInstalledBridgeScriptPath,
   setupMempalaceRuntime,
   type BridgePathResult,
   type SetupMempalaceRuntimeOptions,
@@ -55,10 +55,11 @@ async function executeSetup(
   resolved: ResolvedMempalaceConfig,
   cwd: string,
   managedBinDir: string,
+  defaultResolveBridgeScriptPath: () => BridgePathResult,
   deps: MempalaceToolDeps,
   onUpdate: unknown,
 ): Promise<{ content: Array<{ type: "text"; text: string }>; details: Record<string, unknown> }> {
-  const bridgePath = (deps.resolveBridgeScriptPath ?? resolveBridgeScriptPath)();
+  const bridgePath = (deps.resolveBridgeScriptPath ?? defaultResolveBridgeScriptPath)();
   if (!bridgePath.ok) {
     const formatted = formatMempalaceError(bridgePath.error, {
       ok: false,
@@ -121,6 +122,10 @@ export function registerMempalaceTool(
     return;
   }
   if (!snapshot.ready) return;
+  const bridgeRuntime = {
+    resolveBridgeScriptPath: () => resolveInstalledBridgeScriptPath(platform.paths),
+  };
+
 
   platform.registerTool({
     name: "mempalace",
@@ -143,12 +148,20 @@ export function registerMempalaceTool(
         const params = validation.params;
 
         if (params.action === "setup") {
-          return await executeSetup(params, resolved, cwd, platform.paths.global("bin"), deps, onUpdate);
+          return await executeSetup(
+            params,
+            resolved,
+            cwd,
+            platform.paths.global("bin"),
+            bridgeRuntime.resolveBridgeScriptPath,
+            deps,
+            onUpdate,
+          );
         }
 
         const bridge = deps.createBridge
           ? deps.createBridge(resolved, cwd)
-          : createMempalaceBridge({ cwd, config: resolved });
+          : createMempalaceBridge({ cwd, config: resolved, runtime: bridgeRuntime });
         const result = await bridge.execute(params);
 
         if (!result.ok) {