@gmickel/gno 2.5.1 → 2.7.0

package/src/mcp/context.ts

@@ -66,11 +66,14 @@ export interface ToolContextSnapshot {
    * session id, so this is what keeps two modern callers apart.
    */
   requestIdentity?: string;
+  /** Stable request-receipt namespace of the authorized HTTP identity. */
+  requestNamespace?: string;
 }
 
 export interface RequestScope {
   egress: NonNullable<ToolContextSnapshot["egress"]>;
   requestIdentity?: string;
+  requestNamespace?: string;
 }
 
 export interface ToolContext {
@@ -107,6 +110,8 @@ export interface ToolContext {
   getEgressContext?: () => ToolContextSnapshot["egress"];
   /** Per-caller identity of the current request; absent on stdio. */
   getRequestIdentity?: () => string | undefined;
+  /** Request-receipt namespace of the current HTTP caller; absent on stdio. */
+  getRequestNamespace?: () => string | undefined;
   runWithEgressContext?<T>(
     egress: NonNullable<ToolContextSnapshot["egress"]>,
     operation: () => Promise<T>,
@@ -115,6 +120,15 @@ export interface ToolContext {
   runWithSnapshot?<T>(operation: () => Promise<T>): Promise<T>;
 }
 
+/**
+ * Host absolute paths reach only stdio callers, which run on the owner's
+ * machine. Every Streamable HTTP request runs inside an egress context,
+ * whatever its peer, so HTTP callers get URIs and relative paths only.
+ */
+export const exposesHostPaths = (
+  ctx: Pick<ToolContext, "getEgressContext">
+): boolean => ctx.getEgressContext?.() === undefined;
+
 export interface CreateToolContextOptions {
   store: SqliteAdapter;
   getConfig: () => Config;
@@ -216,6 +230,7 @@ export function createToolContext(
       requestSnapshot.getStore()?.egress?.authorizationEpoch?.value,
     getEgressContext: () => requestSnapshot.getStore()?.egress,
     getRequestIdentity: () => requestSnapshot.getStore()?.requestIdentity,
+    getRequestNamespace: () => requestSnapshot.getStore()?.requestNamespace,
     runWithEgressContext<T>(
       egress: NonNullable<ToolContextSnapshot["egress"]>,
       operation: () => Promise<T>,
@@ -228,6 +243,7 @@ export function createToolContext(
           collections: config.collections,
           egress,
           requestIdentity: scope?.requestIdentity,
+          requestNamespace: scope?.requestNamespace,
         },
         operation
       );
@@ -241,6 +257,7 @@ export function createToolContext(
           collections: config.collections,
           egress: current?.egress,
           requestIdentity: current?.requestIdentity,
+          requestNamespace: current?.requestNamespace,
         },
         operation
       );

package/src/mcp/http-egress.ts

@@ -57,8 +57,12 @@ export const MCP_HTTP_EGRESS_TOOLS = {
   gno_remember: "source",
   gno_remove_collection: "metadata",
   gno_rename_note: "metadata",
+  gno_request_status: "metadata",
   gno_search: "snippet",
   gno_section: "metadata",
+  gno_sessions_automation_run: "metadata",
+  gno_sessions_import: "metadata",
+  gno_sessions_status: "metadata",
   gno_similar: "snippet",
   gno_peek: "metadata",
   gno_status: "metadata",

package/src/mcp/http-transport.ts

@@ -15,6 +15,7 @@ import type {
 
 import { MCP_SERVER_NAME, VERSION } from "../app/constants";
 import { EgressDeniedError } from "../core/egress-enforcement";
+import { httpMcpRequestNamespace } from "../core/request-receipts";
 import { withInferenceScope } from "../llm/inference-scope";
 import { createMcpServerSurface, type ToolContext } from "./context";
 import {
@@ -445,6 +446,7 @@ export class HttpMcpTransport {
                 this.#runtime.mcpContext.serverInstanceId,
                 context.identity
               ),
+              requestNamespace: httpMcpRequestNamespace(context.identity),
             }
           )
         : await handle();

package/src/mcp/resources/index.ts

@@ -21,6 +21,7 @@ import { resolveEffectiveIndex } from "../../core/indexed-reference";
 import { normalizeTag, validateTag } from "../../core/tags";
 import { normalizeCollectionName } from "../../core/validation";
 import { openScopedIndexStore } from "../../store/sqlite/scoped-index";
+import { exposesHostPaths } from "../context";
 
 // Tags resource URI prefix
 const TAGS_URI = `${URI_PREFIX}tags`;
@@ -53,15 +54,15 @@ function formatResourceContent(
   ctx: ToolContext,
   indexName = ctx.indexName
 ): string {
-  // Find collection for absPath
+  // Host path for stdio callers; HTTP callers see the relative path.
   const uriParsed = parseUri(doc.uri);
-  let absPath = doc.relPath;
-  if (uriParsed) {
+  let source = doc.relPath;
+  if (uriParsed && exposesHostPaths(ctx)) {
     const collection = ctx.collections.find(
       (c) => c.name === uriParsed.collection
     );
     if (collection) {
-      absPath = pathJoin(collection.path, doc.relPath);
+      source = pathJoin(collection.path, doc.relPath);
     }
   }
 
@@ -72,7 +73,7 @@ function formatResourceContent(
   const displayUri = decorateUriForIndex(doc.uri, indexName);
   const header = `<!-- ${displayUri}
      docid: ${doc.docid}
-     source: ${absPath}
+     source: ${source}
      mime: ${doc.sourceMime}${langLine}
 -->
 

package/src/mcp/tool-descriptions-core.ts

@@ -32,7 +32,7 @@ export const MCP_CORE_TOOL_DESCRIPTIONS: Readonly<Record<string, string>> = {
   gno_recall:
     "Call before answering about the user's preferences, decisions, people, or prior work, and before gno_remember to find the predecessor of a changed fact. Retrieves current facts from a memory-managed collection for the explicit scopes you pass; superseded facts are excluded. Returns at most 8 facts within 512 tokens by default, each with text, scopes, provenance, gno:// cite, and content hash, plus a content-free receipt. Pass that receipt to gno_remember when a stored fact derives from this recall. An empty result names the command that stores the first fact.",
   gno_capture:
-    "Call to create a new note from text the user wants kept: pass collection and content (or a presetId scaffold), optionally title, path or folderPath, tags, and source provenance. Writes the file to disk with source: frontmatter, syncs it for keyword search, and returns a receipt with uri, docid, relPath, absPath, contentHash, collisionPolicyResult, and sync and embed status. Embedding is a separate step (embed.status stays short of completed until gno_index or gno_embed runs), so vector search sees the note later. An existing target follows collisionPolicy: error, open_existing, or create_with_suffix.",
+    "Call to create a new note from text the user wants kept: pass collection and content (or a presetId scaffold), optionally title, path or folderPath, tags, and source provenance. Writes the file to disk with source: frontmatter, syncs it for keyword search, and returns a receipt with uri, docid, relPath, absPath (stdio only), contentHash, collisionPolicyResult, and sync and embed status. Embedding is a separate step (embed.status stays short of completed until gno_index or gno_embed runs), so vector search sees the note later. An existing target follows collisionPolicy: error, open_existing, or create_with_suffix.",
   gno_remember:
     "Call when the user states a durable preference, decision, or fact worth recalling later; documents go through gno_capture and existing notes through file edits. Stores one fact in a memory-managed collection under the explicit scopes you pass. Without decision it returns likely matches and writes nothing; decision=add writes a new fact; decision=supersede replaces predecessorUri after a hash check, one successor per fact. Returns outcome (candidates, existing, added, or superseded) with the stored record; an exact duplicate returns the existing record. Text that replays a recall receipt span or declares a gno:// origin is rejected. The fact is lexically searchable when the call returns.",
 };

package/src/mcp/tools/capture.ts

@@ -4,33 +4,36 @@
  * @module src/mcp/tools/capture
  */
 
-// node:fs/promises for mkdir (no Bun equivalent for structure ops)
-import { mkdir } from "node:fs/promises";
 // node:path for path utils (no Bun path utils)
-import { dirname, extname, join } from "node:path";
+import { extname } from "node:path";
 
 import type { NoteCollisionPolicy } from "../../core/note-creation";
 import type { NotePresetId } from "../../core/note-presets";
 import type { ToolContext } from "../server";
 
 import {
-  buildCaptureReceipt,
   CaptureSyncError,
-  ensureCapturedFileIndexed,
   listCaptureDiskRelPaths,
   planCapture,
-  syncCapturedFile,
   type CaptureInput as SharedCaptureInput,
+  type CapturePlan,
   type CaptureReceipt,
-  type SyncCapturedFileResult,
 } from "../../core/capture";
-import { writeCapturePlanFile } from "../../core/capture-write";
+import {
+  publishCapture,
+  type PublishedCapture,
+} from "../../core/capture-publish";
 import { MCP_ERRORS } from "../../core/errors";
-import { withWriteLock } from "../../core/file-lock";
 import { recordContentMutation } from "../../core/mutation-generations";
+import {
+  formatRequestReceiptLine,
+  type RequestReceiptInfo,
+  requestLedgerPath,
+} from "../../core/request-receipts";
 import { normalizeCollectionName } from "../../core/validation";
 import { DEFAULT_LOCK_WAIT_MS } from "../../core/write-lease";
 import { runTool, type ToolResult } from "./index";
+import { mcpRequestNamespace, rethrowRequestError } from "./request-status";
 
 interface CaptureInput extends Omit<
   SharedCaptureInput,
@@ -39,13 +42,14 @@ interface CaptureInput extends Omit<
   path?: string;
   collisionPolicy?: NoteCollisionPolicy;
   presetId?: NotePresetId;
+  requestId?: string;
 }
 
 type McpCaptureResult = CaptureReceipt & {
   docid: string;
-  absPath: string;
   overwritten: boolean;
   serverInstanceId: string;
+  request?: RequestReceiptInfo;
 };
 
 const SENSITIVE_SUBPATHS = new Set([
@@ -75,7 +79,7 @@ function formatCaptureResult(result: McpCaptureResult): string {
   const lines: string[] = [];
   lines.push(`Doc: ${result.docid}`);
   lines.push(`URI: ${result.uri}`);
-  lines.push(`Path: ${result.absPath}`);
+  if (result.absPath) lines.push(`Path: ${result.absPath}`);
   lines.push(`Created: ${result.created ? "yes" : "no"}`);
   lines.push(`Opened existing: ${result.openedExisting ? "yes" : "no"}`);
   lines.push(`Overwritten: ${result.overwritten ? "yes" : "no"}`);
@@ -86,6 +90,7 @@ function formatCaptureResult(result: McpCaptureResult): string {
   if (result.tags.length > 0) {
     lines.push(`Tags: ${result.tags.join(", ")}`);
   }
+  if (result.request) lines.push(formatRequestReceiptLine(result.request));
   return lines.join("\n");
 }
 
@@ -112,7 +117,7 @@ function rethrowCaptureError(error: unknown): never {
   if (error instanceof CaptureSyncError) {
     throw new Error(`${error.code}: ${error.message}`);
   }
-  throw error;
+  return rethrowRequestError(error);
 }
 
 export function handleCapture(
@@ -140,83 +145,80 @@ export function handleCapture(
       // Write + lexical sync complete under the shared write lease: the tool
       // succeeds only once the capture is retrievable (v1.38 contention
       // contract: wait for the lease, LOCKED when it stays busy).
-      return await withWriteLock(
-        ctx.writeLockPath,
-        async () => {
-          const existingDocs = await ctx.store.listDocuments(collectionName);
-          if (!existingDocs.ok) {
-            throw new Error(existingDocs.error.message);
-          }
-
-          let plan;
-          try {
-            plan = planCapture({
-              input: buildSharedInput(args, collection.name),
-              existingRelPaths: existingDocs.value.map((doc) => doc.relPath),
-              diskRelPaths: await listCaptureDiskRelPaths(collection.path),
-            });
-          } catch (error) {
-            const message =
-              error instanceof Error ? error.message : String(error);
-            throw new Error(`${MCP_ERRORS.INVALID_INPUT.code}: ${message}`);
-          }
-
-          assertNotSensitive(plan.relPath);
-
-          const absPath = join(collection.path, plan.relPath);
-          const syncInput = {
-            collection,
-            store: ctx.store,
-            relPath: plan.relPath,
-            absPath,
-            config: ctx.config,
-          };
-
-          let synced: SyncCapturedFileResult;
-          let overwritten = false;
-          try {
-            if (plan.openedExisting) {
-              synced = await ensureCapturedFileIndexed(syncInput);
-            } else {
-              overwritten =
-                (await Bun.file(absPath).exists()) && args.overwrite === true;
-              await mkdir(dirname(absPath), { recursive: true });
-              await writeCapturePlanFile(plan, absPath);
-              synced = await syncCapturedFile(syncInput);
+      const input = buildSharedInput(args, collection.name);
+      let published: PublishedCapture;
+      try {
+        published = await publishCapture({
+          collection,
+          store: ctx.store,
+          lockPath: ctx.writeLockPath,
+          lockWaitMs: DEFAULT_LOCK_WAIT_MS,
+          config: ctx.config,
+          plan: async () => {
+            const existingDocs = await ctx.store.listDocuments(collectionName);
+            if (!existingDocs.ok) {
+              throw new Error(existingDocs.error.message);
             }
-          } catch (error) {
-            rethrowCaptureError(error);
-          }
-          if (synced.result) {
-            recordContentMutation(synced.result, ctx.markContentMutation);
-          }
-
-          const isMarkdown =
-            plan.relPath.endsWith(".md") || plan.relPath.endsWith(".markdown");
-          if (!isMarkdown && !plan.openedExisting && plan.tags.length > 0) {
-            const tagResult = await ctx.store.setDocTags(
-              synced.documentId,
-              plan.tags,
-              "user"
-            );
-            if (!tagResult.ok) {
-              console.error(
-                `[MCP] Warning: Document created but tags not stored: ${tagResult.error.message}`
+            let plan: CapturePlan;
+            try {
+              plan = planCapture({
+                input,
+                existingRelPaths: existingDocs.value.map((doc) => doc.relPath),
+                diskRelPaths: await listCaptureDiskRelPaths(collection.path),
+              });
+            } catch (error) {
+              const message =
+                error instanceof Error ? error.message : String(error);
+              throw new Error(`${MCP_ERRORS.INVALID_INPUT.code}: ${message}`);
+            }
+            assertNotSensitive(plan.relPath);
+            return plan;
+          },
+          afterSync: async (synced, receipt) => {
+            if (synced.result) {
+              recordContentMutation(synced.result, ctx.markContentMutation);
+            }
+            const isMarkdown =
+              receipt.relPath.endsWith(".md") ||
+              receipt.relPath.endsWith(".markdown");
+            if (
+              !isMarkdown &&
+              !receipt.openedExisting &&
+              receipt.tags.length > 0
+            ) {
+              const tagResult = await ctx.store.setDocTags(
+                synced.documentId,
+                receipt.tags,
+                "user"
               );
+              if (!tagResult.ok) {
+                console.error(
+                  `[MCP] Warning: Document created but tags not stored: ${tagResult.error.message}`
+                );
+              }
             }
-          }
+          },
+          request:
+            args.requestId === undefined
+              ? undefined
+              : {
+                  ledgerPath: requestLedgerPath(ctx.store.getDbPath()),
+                  namespace: mcpRequestNamespace(ctx),
+                  requestId: args.requestId,
+                  input,
+                },
+        });
+      } catch (error) {
+        rethrowCaptureError(error);
+      }
 
-          return buildCaptureReceipt({
-            plan,
-            absPath,
-            docid: synced.docid,
-            sync: synced.sync,
-            overwritten,
-            serverInstanceId: ctx.serverInstanceId,
-          }) as McpCaptureResult;
-        },
-        DEFAULT_LOCK_WAIT_MS
-      );
+      return {
+        ...published.receipt,
+        docid: published.receipt.docid ?? "",
+        overwritten: published.receipt.overwritten ?? false,
+        serverInstanceId: ctx.serverInstanceId,
+        ...(published.request ? { request: published.request } : {}),
+      } as McpCaptureResult;
     },
     formatCaptureResult
   );

package/src/mcp/tools/index.ts

@@ -20,6 +20,7 @@ import {
   compiledContextPreviewSchema,
   compiledContextCheckSchema,
 } from "../../core/compiled-context";
+import { withoutHostPaths } from "../../core/host-paths";
 import { NOTE_PRESETS, type NotePresetId } from "../../core/note-presets";
 import { RETRIEVAL_TRACE_METADATA } from "../../core/retrieval-trace-session";
 import { normalizeTag } from "../../core/tags";
@@ -31,6 +32,7 @@ import {
   assertInferenceActive,
   acquireInferencePermit,
 } from "../../llm/inference-scope";
+import { exposesHostPaths } from "../context";
 import { profileToolDescription } from "../tool-descriptions-core";
 import {
   createProfileToolRegistrar,
@@ -101,6 +103,12 @@ import { handleMultiGet } from "./multi-get";
 import { handlePeek, PEEK_MCP_ANNOTATIONS } from "./peek";
 import { handleQuery, handleQueryDiagnose } from "./query";
 import { handleRemoveCollection } from "./remove-collection";
+import {
+  handleRequestStatus,
+  REQUEST_STATUS_MCP_ANNOTATIONS,
+  requestIdInputSchema,
+  requestStatusInputSchema,
+} from "./request-status";
 import { handleSearch } from "./search";
 import {
   handleSection,
@@ -108,6 +116,17 @@ import {
   sectionInputSchema,
   sectionOutputSchema,
 } from "./sections";
+import {
+  handleSessionsAutomationRun,
+  handleSessionsImport,
+  handleSessionsStatus,
+  SESSIONS_AUTOMATION_RUN_MCP_ANNOTATIONS,
+  SESSIONS_IMPORT_MCP_ANNOTATIONS,
+  SESSIONS_STATUS_MCP_ANNOTATIONS,
+  sessionsAutomationRunInputSchema,
+  sessionsImportInputSchema,
+  sessionsStatusInputSchema,
+} from "./sessions";
 import { handleStatus } from "./status";
 import { handleSync } from "./sync";
 import {
@@ -175,6 +194,8 @@ export const MCP_TOOL_DESCRIPTIONS = {
   ask: "Generate one answer from a deterministic Context Capsule, verify every substantive claim against exact retained spans, and abstain unless support coverage is complete. Read-only; returns the Capsule, freshness receipt, claim verdicts, gaps, and evidence IDs.",
   recall:
     "Recall current facts from a memory-managed collection for explicit scopes. Call before answering about the user's preferences, decisions, people, or prior work, and before gno_remember to find the predecessor of a changed fact. Returns at most 8 facts within 512 tokens by default, each with text, scopes, provenance, gno:// cite, and content hash, plus a content-free receipt; superseded facts are excluded. Pass the receipt to gno_remember when a stored fact derives from this recall. An empty result names the command that stores the first fact.",
+  requestStatus:
+    "Look up a write request ID sent with gno_capture or gno_remember before retrying it. Returns pending, committed (with the result uri and hashes), expired, or not_found within this caller's own namespace; never returns note or fact content. Committed: do not resend. Pending: retry the same request ID later. not_found: nothing was accepted under that ID.",
   remember:
     "Store one fact in a memory-managed collection under explicit scopes. Call when the user states a durable preference, decision, or fact worth recalling later; use gno_capture for documents and file edits for existing notes. Without decision it returns likely matches and writes nothing; decision=add writes a new fact; decision=supersede replaces predecessorUri after a hash check, one successor per fact. Exact duplicates return the existing record. Text that replays a recall receipt span or declares a gno:// origin is rejected. The fact is lexically searchable when the call returns.",
 } as const;
@@ -366,6 +387,7 @@ export const captureInputSchema = z.object({
     .describe(
       "Structured provenance metadata written under source frontmatter"
     ),
+  requestId: requestIdInputSchema.optional(),
 });
 
 const addCollectionInputSchema = z.object({
@@ -952,6 +974,10 @@ export interface ToolResult {
 // DRY Helper: Exception Firewall + Mutex + Response Shaping
 // ─────────────────────────────────────────────────────────────────────────────
 
+/** Tool data as the current caller may see it (no host paths over HTTP). */
+const forCaller = <T>(ctx: ToolContext, data: T): T =>
+  exposesHostPaths(ctx) ? data : withoutHostPaths(data);
+
 export async function runTool<T>(
   ctx: ToolContext,
   name: string,
@@ -970,12 +996,13 @@ export async function runTool<T>(
   const release = await acquireInferencePermit(() => ctx.toolMutex.acquire());
   try {
     assertInferenceActive();
-    const data = await (ctx.runWithSnapshot?.(fn) ?? fn());
+    const raw = await (ctx.runWithSnapshot?.(fn) ?? fn());
     assertInferenceActive();
     const traceMetadata =
-      data !== null && typeof data === "object"
-        ? (data as Record<PropertyKey, unknown>)[RETRIEVAL_TRACE_METADATA]
+      raw !== null && typeof raw === "object"
+        ? (raw as Record<PropertyKey, unknown>)[RETRIEVAL_TRACE_METADATA]
         : undefined;
+    const data = forCaller(ctx, raw);
     return {
       content: [{ type: "text", text: formatText(data) }],
       structuredContent: data as { [x: string]: unknown },
@@ -1019,7 +1046,7 @@ export async function runToolNoMutex<T>(
 
   try {
     assertInferenceActive();
-    const data = await (ctx.runWithSnapshot?.(fn) ?? fn());
+    const data = forCaller(ctx, await (ctx.runWithSnapshot?.(fn) ?? fn()));
     assertInferenceActive();
     return {
       content: [{ type: "text", text: formatText(data) }],
@@ -1141,6 +1168,17 @@ export function registerTools(server: McpServer, ctx: ToolContext): void {
       })
   );
 
+  registerTool(
+    "gno_sessions_status",
+    {
+      description:
+        "Status of this session-archive instance: archive collections, owner-registered session sources (by ID, no host paths), pending/incomplete/failed units, last import, and opt-in automation profiles (enabled hook/schedule, daemon availability, pending/running/partial/failed, last success, next due, recovery action). Only available when the server runs on a dedicated session-archive config/index pair; nothing is imported unless the owner enabled it.",
+      inputSchema: sessionsStatusInputSchema,
+      annotations: SESSIONS_STATUS_MCP_ANNOTATIONS,
+    },
+    () => handleSessionsStatus(ctx)
+  );
+
   registerTool(
     "gno_search",
     {
@@ -1501,6 +1539,28 @@ export function registerTools(server: McpServer, ctx: ToolContext): void {
         })
     );
 
+    registerTool(
+      "gno_sessions_import",
+      {
+        description:
+          "Manually import one owner-registered session source into the session archive and sync it for search. Takes a source ID only (never a host path); dryRun=true reports without writing. Returns a receipt with imported/updated/unchanged/skipped/incomplete/failed counts, lexical readiness and embedding backlog; partial imports stay visible and are retried by the next call.",
+        inputSchema: sessionsImportInputSchema,
+        annotations: SESSIONS_IMPORT_MCP_ANNOTATIONS,
+      },
+      (args) => handleSessionsImport(args, ctx)
+    );
+
+    registerTool(
+      "gno_sessions_automation_run",
+      {
+        description:
+          "Run one owner-configured session automation profile now: imports its registered sources through the manual importer and records the outcome in automation status. Takes a profile ID only; it cannot enable hooks or schedules, add sources or change destinations. Returns the run outcome (complete, up_to_date, partial, failed, or not_started with a reason such as busy) and one import receipt per source.",
+        inputSchema: sessionsAutomationRunInputSchema,
+        annotations: SESSIONS_AUTOMATION_RUN_MCP_ANNOTATIONS,
+      },
+      (args) => handleSessionsAutomationRun(args, ctx)
+    );
+
     registerTool(
       "gno_capture",
       {
@@ -1513,6 +1573,19 @@ export function registerTools(server: McpServer, ctx: ToolContext): void {
       (args) => handleCapture(args, ctx)
     );
 
+    registerTool(
+      "gno_request_status",
+      {
+        description: describe(
+          "gno_request_status",
+          MCP_TOOL_DESCRIPTIONS.requestStatus
+        ),
+        inputSchema: requestStatusInputSchema,
+        annotations: REQUEST_STATUS_MCP_ANNOTATIONS,
+      },
+      (args) => handleRequestStatus(args, ctx)
+    );
+
     registerTool(
       "gno_add_collection",
       {

package/src/mcp/tools/memory-remember.ts

@@ -14,6 +14,7 @@ import type { ToolContext } from "../server";
 
 import { type RememberResult } from "../../core/memory";
 import { MEMORY_MAX_FACT_BYTES } from "../../core/memory-record";
+import { formatRequestReceiptLine } from "../../core/request-receipts";
 import { runTool, type ToolResult } from "./index";
 import {
   createMcpMemoryService,
@@ -22,6 +23,7 @@ import {
   resolveMcpMemoryIdentity,
   rethrowMemoryError,
 } from "./memory-shared";
+import { requestIdInputSchema } from "./request-status";
 
 export const REMEMBER_MCP_ANNOTATIONS = {
   readOnlyHint: false,
@@ -92,6 +94,7 @@ export const rememberInputSchema = z.object({
     .min(1)
     .optional()
     .describe("Free-text evidence for the fact (where it came from)"),
+  requestId: requestIdInputSchema.optional(),
 });
 
 export type RememberToolInput = z.infer<typeof rememberInputSchema>;
@@ -124,7 +127,7 @@ export function formatRememberResult(result: RememberResult): string {
       lines.push(`Outcome: ${result.outcome}`);
       lines.push(`URI: ${result.record.uri}`);
       lines.push(`Hash: ${result.record.contentHash}`);
-      lines.push(`Path: ${result.absPath}`);
+      if (result.absPath) lines.push(`Path: ${result.absPath}`);
       lines.push(`Sync: ${result.sync.status}`);
       if (result.record.supersedes.length > 0) {
         lines.push(`Supersedes: ${result.record.supersedes.join(", ")}`);
@@ -132,6 +135,9 @@ export function formatRememberResult(result: RememberResult): string {
       break;
   }
   lines.push(matching);
+  if ("request" in result && result.request) {
+    lines.push(formatRequestReceiptLine(result.request));
+  }
   return lines.join("\n");
 }
 
@@ -163,6 +169,7 @@ export function handleRemember(
           receipt: args.receipt,
           derivedFrom: args.derivedFrom,
           source: args.source,
+          requestId: args.requestId,
         });
       } catch (error) {
         return rethrowMemoryError(error);

package/src/mcp/tools/memory-shared.ts

@@ -19,6 +19,8 @@ import {
   MemoryService,
 } from "../../core/memory";
 import { MEMORY_MAX_SCOPES } from "../../core/memory-record";
+import { requestLedgerPath } from "../../core/request-receipts";
+import { mcpRequestNamespace, rethrowRequestError } from "./request-status";
 
 /** Caller name when the MCP client sent no implementation name. */
 const DEFAULT_MCP_CALLER = "mcp";
@@ -74,6 +76,10 @@ export function createMcpMemoryService(ctx: ToolContext): MemoryService {
     config: ctx.config,
     collections: ctx.collections,
     lockPath: ctx.writeLockPath,
+    requests: {
+      ledgerPath: requestLedgerPath(ctx.store.getDbPath()),
+      namespace: mcpRequestNamespace(ctx),
+    },
   });
 }
 
@@ -82,5 +88,5 @@ export function rethrowMemoryError(error: unknown): never {
   if (error instanceof MemoryError) {
     throw new Error(`${error.code}: ${error.message}`);
   }
-  throw error;
+  return rethrowRequestError(error);
 }