@gmickel/gno 2.5.1 → 2.6.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>,
@@ -216,6 +221,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 +234,7 @@ export function createToolContext(
           collections: config.collections,
           egress,
           requestIdentity: scope?.requestIdentity,
+          requestNamespace: scope?.requestNamespace,
         },
         operation
       );
@@ -241,6 +248,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/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,6 +42,7 @@ interface CaptureInput extends Omit<
   path?: string;
   collisionPolicy?: NoteCollisionPolicy;
   presetId?: NotePresetId;
+  requestId?: string;
 }
 
 type McpCaptureResult = CaptureReceipt & {
@@ -46,6 +50,7 @@ type McpCaptureResult = CaptureReceipt & {
   absPath: string;
   overwritten: boolean;
   serverInstanceId: string;
+  request?: RequestReceiptInfo;
 };
 
 const SENSITIVE_SUBPATHS = new Set([
@@ -86,6 +91,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 +118,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 +146,81 @@ 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 ?? "",
+        absPath: published.receipt.absPath ?? "",
+        overwritten: published.receipt.overwritten ?? false,
+        serverInstanceId: ctx.serverInstanceId,
+        ...(published.request ? { request: published.request } : {}),
+      } as McpCaptureResult;
     },
     formatCaptureResult
   );

package/src/mcp/tools/index.ts

@@ -101,6 +101,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 +114,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 +192,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 +385,7 @@ export const captureInputSchema = z.object({
     .describe(
       "Structured provenance metadata written under source frontmatter"
     ),
+  requestId: requestIdInputSchema.optional(),
 });
 
 const addCollectionInputSchema = z.object({
@@ -1141,6 +1161,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 +1532,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 +1566,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>;
@@ -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);
 }

package/src/mcp/tools/request-status.ts

@@ -0,0 +1,73 @@
+/**
+ * MCP request receipts: the caller's namespace, error rethrow, and the
+ * bounded `gno_request_status` lookup.
+ *
+ * @module src/mcp/tools/request-status
+ */
+
+import { z } from "zod";
+
+import type { ToolContext } from "../server";
+
+import {
+  formatRequestStatus,
+  LOCAL_OWNER_NAMESPACE,
+  readRequestStatus,
+  RequestReceiptError,
+  requestLedgerPath,
+} from "../../core/request-receipts";
+import { runTool, type ToolResult } from "./index";
+
+export const REQUEST_STATUS_MCP_ANNOTATIONS = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: false,
+} as const;
+
+export const requestIdInputSchema = z
+  .string()
+  .describe(
+    "Optional caller request ID (1-128 of A-Z a-z 0-9 . _ : -). Reuse the same ID when retrying the same write after a lost response; a new intent needs a new ID"
+  );
+
+export const requestStatusInputSchema = z.object({
+  requestId: z
+    .string()
+    .describe("Request ID previously sent with gno_capture or gno_remember"),
+});
+
+/** HTTP callers get their authorized identity's namespace; stdio is the local owner. */
+export function mcpRequestNamespace(ctx: ToolContext): string {
+  return ctx.getRequestNamespace?.() ?? LOCAL_OWNER_NAMESPACE;
+}
+
+/** Re-throw a request receipt error in the `CODE: message` shape runTool parses. */
+export function rethrowRequestError(error: unknown): never {
+  if (error instanceof RequestReceiptError) {
+    throw new Error(`${error.code}: ${error.message}`);
+  }
+  throw error;
+}
+
+export function handleRequestStatus(
+  args: z.infer<typeof requestStatusInputSchema>,
+  ctx: ToolContext
+): Promise<ToolResult> {
+  return runTool(
+    ctx,
+    "gno_request_status",
+    async () => {
+      try {
+        return await readRequestStatus({
+          ledgerPath: requestLedgerPath(ctx.store.getDbPath()),
+          namespace: mcpRequestNamespace(ctx),
+          requestId: args.requestId,
+        });
+      } catch (error) {
+        return rethrowRequestError(error);
+      }
+    },
+    formatRequestStatus
+  );
+}