@remnic/core 10.0.85 → 10.0.87

package/src/access-http.ts

@@ -417,6 +417,11 @@ export class EngramAccessHttpServer extends ReviewDeckAccessHttpBase {
   private readonly resourceMetadataUrl?: string;
   private readonly externalRequestHandler?: SupportPassportExternalRequestHandler;
   private readonly writeLimiter: WriteRateLimiter;
+  // Reservations taken by ensureWriteRateLimitAvailable and not yet committed
+  // by recordWriteRateLimitHit, keyed by request. The per-request release in
+  // the connection callback covers every early return and error path, so a
+  // failed or exempt write never leaks its slot (issue #3225 C4).
+  private readonly pendingWriteQuotas = new WeakMap<IncomingMessage, WriteRateLimitReservation>();
   private readonly mcpServer: EngramMcpServer;
   private server: Server | null = null;
   private boundPort = 0;
@@ -544,6 +549,13 @@ export class EngramAccessHttpServer extends ReviewDeckAccessHttpBase {
             });
             return;
           }
+          if (err.name === "ReplayAdmissionRefusedError") {
+            // Durable-capture backpressure (#3251/#1908): the request was
+            // never accepted — the buffer is at entry capacity. Retryable,
+            // not a server fault (503, not 500).
+            this.respondJson(res, 503, { error: err.message, code: "buffer_admission_refused" });
+            return;
+          }
           if (res.headersSent) {
             res.destroy(err as Error);
             return;
@@ -556,6 +568,9 @@ export class EngramAccessHttpServer extends ReviewDeckAccessHttpBase {
         }).finally(() => {
           req.off("aborted", abortDisconnectedRequest);
           res.off("close", abortDisconnectedRequest);
+          // A counted write that failed or was exempt (dry run, replay) must
+          // not hold its reserved slot past the request (issue #3225 C4).
+          this.releasePendingWriteQuota(req);
         });
       });
     });
@@ -2739,26 +2754,38 @@ export class EngramAccessHttpServer extends ReviewDeckAccessHttpBase {
     //   DELETE /engram/v1/peers/:id?forget=true — destructive full purge (issue #679 completion)
     //   GET    /engram/v1/peers/:id/profile  — get peer profile
     if (req.method === "GET" && pathname === "/engram/v1/peers") {
-      this.enforceTokenOp("peer_list"); // boundary dispatch (issue #1525)
-      const result = await this.service.peerList();
-      this.respondJson(res, 200, result);
+      const op = getOperation("peer_list"); // boundary dispatch (issue #1525)
+      if (!op) throw new EngramAccessInputError("access-boundary: operation not registered: peer_list");
+      // SAFETY: the registered peer_list handler returns { result } from the service.
+      const output = (await op.run({}, {
+        service: this.service,
+        authenticatedPrincipal: this.resolveRequestPrincipal(req),
+        sourceConnector: this.resolveConnector(req),
+      })) as { result: unknown };
+      this.respondJson(res, 200, output.result);
       return;
     }
 
     const peerProfileMatch = /^\/engram\/v1\/peers\/([^/]+)\/profile$/.exec(pathname);
     if (peerProfileMatch) {
-      this.enforceTokenOp("peer_profile_get"); // boundary dispatch (issue #1525)
       if (req.method !== "GET") {
         this.respondJson(res, 405, { error: "method_not_allowed", code: "method_not_allowed" });
         return;
       }
+      const op = getOperation("peer_profile_get"); // boundary dispatch (issue #1525)
+      if (!op) throw new EngramAccessInputError("access-boundary: operation not registered: peer_profile_get");
       const peerId = decodePeerIdSegment(peerProfileMatch[1] ?? "");
-      const result = await this.service.peerProfileGet(peerId);
-      if (!result.found) {
+      // SAFETY: the registered peer_profile_get handler returns { result } from the service.
+      const output = (await op.run({ id: peerId }, {
+        service: this.service,
+        authenticatedPrincipal: this.resolveRequestPrincipal(req),
+        sourceConnector: this.resolveConnector(req),
+      })) as { result: { found: boolean } };
+      if (!output.result.found) {
         this.respondJson(res, 404, { error: "peer_profile_not_found", code: "peer_profile_not_found" });
         return;
       }
-      this.respondJson(res, 200, result);
+      this.respondJson(res, 200, output.result);
       return;
     }
 
@@ -2767,47 +2794,49 @@ export class EngramAccessHttpServer extends ReviewDeckAccessHttpBase {
       const peerId = decodePeerIdSegment(peerIdMatch[1] ?? "");
 
       if (req.method === "GET") {
-        this.enforceTokenOp("peer_get"); // boundary dispatch (issue #1525)
-        const result = await this.service.peerGet(peerId);
-        if (!result.found) {
+        const op = getOperation("peer_get"); // boundary dispatch (issue #1525)
+        if (!op) throw new EngramAccessInputError("access-boundary: operation not registered: peer_get");
+        // SAFETY: the registered peer_get handler returns { result } with a found flag.
+        const output = (await op.run({ id: peerId }, {
+          service: this.service,
+          authenticatedPrincipal: this.resolveRequestPrincipal(req),
+          sourceConnector: this.resolveConnector(req),
+        })) as { result: { found: boolean } };
+        if (!output.result.found) {
           this.respondJson(res, 404, { error: "peer_not_found", code: "peer_not_found" });
           return;
         }
-        this.respondJson(res, 200, result);
+        this.respondJson(res, 200, output.result);
         return;
       }
 
       if (req.method === "PUT") {
-        this.enforceTokenOp("peer_set"); // boundary dispatch (issue #1525)
         const body = await this.readJsonBody(req) as Record<string, unknown>;
-        // Reject malformed types up front rather than silently dropping them
-        // to undefined and letting peerSet fall back to defaults
-        // (CLAUDE.md rule 51: no silent defaults on bad input).
-        if ("kind" in body && body.kind !== undefined && typeof body.kind !== "string") {
-          throw new EngramAccessInputError("kind must be a string when provided");
-        }
-        if (
-          "displayName" in body &&
-          body.displayName !== undefined &&
-          typeof body.displayName !== "string"
-        ) {
-          throw new EngramAccessInputError("displayName must be a string when provided");
-        }
-        if ("notes" in body && body.notes !== undefined && typeof body.notes !== "string") {
-          throw new EngramAccessInputError("notes must be a string when provided");
+        const op = getOperation("peer_set"); // boundary dispatch (issue #1525)
+        if (!op) throw new EngramAccessInputError("access-boundary: operation not registered: peer_set");
+        // The operation schema strips nulls as "absent", so an explicit null
+        // must fail here or the peer would register with default fields.
+        for (const field of ["kind", "displayName", "notes"]) {
+          if (body[field] === null) throw new EngramAccessInputError(`${field} must be a string when provided`);
         }
-        const result = await this.service.peerSet({
+        // Raw body fields: the operation schema rejects malformed types with an
+        // input error instead of silently defaulting them (rule 51).
+        // SAFETY: the registered peer_set handler returns { result } with the upsert outcome.
+        const output = (await op.run({
           id: peerId,
-          kind: typeof body.kind === "string" ? body.kind : undefined,
-          displayName: typeof body.displayName === "string" ? body.displayName : undefined,
-          notes: typeof body.notes === "string" ? body.notes : undefined,
-        });
-        this.respondJson(res, result.created ? 201 : 200, result);
+          kind: body.kind,
+          displayName: body.displayName,
+          notes: body.notes,
+        }, {
+          service: this.service,
+          authenticatedPrincipal: this.resolveRequestPrincipal(req),
+          sourceConnector: this.resolveConnector(req),
+        })) as { result: { created: boolean } };
+        this.respondJson(res, output.result.created ? 201 : 200, output.result);
         return;
       }
 
       if (req.method === "DELETE") {
-        this.enforceTokenOp("peer_delete"); // boundary dispatch (issue #1525)
         // `?forget=true` triggers the destructive full-purge path (issue #679
         // completion). The caller must also pass `confirm=yes` in the request
         // body; absent confirmation yields 400. Plain DELETE (no ?forget) keeps
@@ -2824,12 +2853,26 @@ export class EngramAccessHttpServer extends ReviewDeckAccessHttpBase {
             });
             return;
           }
-          const result = await this.service.peerForget(peerId, { confirm: "yes" });
-          this.respondJson(res, 200, result);
+          const op = getOperation("peer_forget"); // boundary dispatch (issue #1525)
+          if (!op) throw new EngramAccessInputError("access-boundary: operation not registered: peer_forget");
+          // SAFETY: the registered peer_forget handler returns { result } with the purge outcome.
+          const output = (await op.run({ id: peerId, confirm: "yes" }, {
+            service: this.service,
+            authenticatedPrincipal: this.resolveRequestPrincipal(req),
+            sourceConnector: this.resolveConnector(req),
+          })) as { result: unknown };
+          this.respondJson(res, 200, output.result);
           return;
         }
-        const result = await this.service.peerDelete(peerId);
-        this.respondJson(res, 200, result);
+        const op = getOperation("peer_delete"); // boundary dispatch (issue #1525)
+        if (!op) throw new EngramAccessInputError("access-boundary: operation not registered: peer_delete");
+        // SAFETY: the registered peer_delete handler returns { result } with the delete outcome.
+        const output = (await op.run({ id: peerId }, {
+          service: this.service,
+          authenticatedPrincipal: this.resolveRequestPrincipal(req),
+          sourceConnector: this.resolveConnector(req),
+        })) as { result: unknown };
+        this.respondJson(res, 200, output.result);
         return;
       }
 
@@ -3931,16 +3974,48 @@ export class EngramAccessHttpServer extends ReviewDeckAccessHttpBase {
     return 200;
   }
 
+  /**
+   * Admit a quota-counted write by RESERVING a limiter slot for the request
+   * (issue #3225 C4). A bare hasCapacity check admits N concurrent requests
+   * against the same committed count; the reservation holds in-flight
+   * capacity until the write commits at recordWriteRateLimitHit or the
+   * request ends. Idempotent per request, so a quota hook that fires after
+   * an earlier reservation is a no-op.
+   */
   protected ensureWriteRateLimitAvailable(req?: IncomingMessage): void {
-    if (!this.writeLimiter.hasCapacity(this.principalForRateLimit(req))) {
+    if (!req) {
+      if (!this.writeLimiter.hasCapacity()) {
+        throw new HttpError(429, "write_rate_limited", "write_rate_limited");
+      }
+      return;
+    }
+    if (this.pendingWriteQuotas.has(req)) return;
+    const reservation = this.writeLimiter.reserve(this.principalForRateLimit(req));
+    if (!reservation) {
       throw new HttpError(429, "write_rate_limited", "write_rate_limited");
     }
+    this.pendingWriteQuotas.set(req, reservation);
   }
 
+  /** Commit a counted write at the durable boundary; consumes the request's reservation. */
   protected recordWriteRateLimitHit(req?: IncomingMessage): void {
+    const pending = req ? this.pendingWriteQuotas.get(req) : undefined;
+    if (pending && req) {
+      this.pendingWriteQuotas.delete(req);
+      pending.commit();
+      return;
+    }
     this.writeLimiter.record(this.principalForRateLimit(req));
   }
 
+  /** Release an uncommitted reservation after a rejection, failure, or exempt outcome. */
+  private releasePendingWriteQuota(req: IncomingMessage): void {
+    const pending = this.pendingWriteQuotas.get(req);
+    if (!pending) return;
+    this.pendingWriteQuotas.delete(req);
+    pending.release();
+  }
+
   protected reserveWriteRateLimitSlot(req?: IncomingMessage): WriteRateLimitReservation {
     const reservation = this.writeLimiter.reserve(this.principalForRateLimit(req));
     if (!reservation) {

package/src/access-mcp.test.ts

@@ -109,6 +109,46 @@ function makeToolRequest(name: string, args: Record<string, unknown> = {}): Reco
     },
   };
 }
+test("MCP reports buffer admission refusal as retryable and does not return success", async () => {
+  let attempts = 0;
+  const refusal = new Error("buffer at session-entry cap");
+  refusal.name = "ReplayAdmissionRefusedError";
+  // SAFETY: the mock overrides only observe; every other MCP dispatch path is unreachable in this test.
+  const service = Object.assign({} as EngramAccessService, {
+    observe: async () => {
+      attempts += 1;
+      if (attempts === 1) throw refusal;
+      return { ok: true };
+    },
+  });
+  const server = new EngramMcpServer(service);
+  const request = makeToolRequest("engram.observe", {
+    sessionKey: "capacity-test-session",
+    messages: [{ role: "user", content: "retry me" }],
+  });
+
+  const refused = await server.handleRequest(request);
+  // SAFETY: a tools/call request always resolves to a JSON-RPC result envelope; only isError and structuredContent are asserted.
+  const refusedResult = refused as {
+    result?: {
+      isError?: boolean;
+      structuredContent?: { code?: string; retryable?: boolean };
+    };
+  };
+  assert.equal(refusedResult.result?.isError, true, "refused admission must not be acknowledged as success");
+  // SAFETY: same tools/call result envelope as the assertion above.
+  assert.deepEqual(refusedResult.result?.structuredContent, {
+    code: "buffer_admission_refused",
+    retryable: true,
+  }, JSON.stringify(refused));
+
+  const retried = await server.handleRequest(request);
+  // SAFETY: same tools/call result envelope as refusedResult above.
+  const retriedResult = retried as typeof refusedResult;
+  assert.equal(retriedResult.result?.isError, false);
+  assert.equal(attempts, 2, "the same request can be retried after capacity is available");
+});
+
 
 // ──────────────────────────────────────────────────────────────────────────
 // Finding 2 (#396 new): invalid MCP briefing format values must be rejected
@@ -1295,6 +1335,17 @@ const FLEET_WIDE_MAINTENANCE_TOOLS = [
   "compounding_promote_candidate",
   "compression_guidelines_optimize",
   "compression_guidelines_activate",
+  // Issue #3225 B3: work and peer ops run against GLOBAL stores, so a
+  // namespace argument cannot isolate them — same fleet-wide rule.
+  "work_task",
+  "work_project",
+  "work_board",
+  "peer_list",
+  "peer_get",
+  "peer_set",
+  "peer_delete",
+  "peer_profile_get",
+  "peer_forget",
 ] as const;
 
 test("MCP fleet-wide maintenance ops: namespace-scoped token denied for every op, no side effect (issue #1850 round 10)", async () => {
@@ -1319,6 +1370,19 @@ test("MCP fleet-wide maintenance ops: namespace-scoped token denied for every op
     compressionGuidelinesOptimize: track,
     compressionGuidelinesActivate: track,
   } as unknown as EngramAccessService;
+  // Issue #3225 B3: track the global-store methods the fleet-wide guard must
+  // block; the dispatch reads them off this same object at call time.
+  Object.assign(service, {
+    workTask: track,
+    workProject: track,
+    workBoard: track,
+    peerList: track,
+    peerGet: track,
+    peerSet: track,
+    peerDelete: track,
+    peerProfileGet: track,
+    peerForget: track,
+  });
   const server = new EngramMcpServer(service, { principal: "ops" });
   try {
     for (const tool of FLEET_WIDE_MAINTENANCE_TOOLS) {

package/src/access-mcp.ts

@@ -84,6 +84,13 @@ type JsonRpcRequest = {
   params?: Record<string, unknown>;
 };
 
+/** tools/call failure envelope; admission backpressure adds a retryable code. */
+type McpToolErrorResult = {
+  content: Array<{ type: string; text: string }>;
+  isError: boolean;
+  structuredContent?: { code: string; retryable: boolean };
+};
+
 function throwMcpAbort(signal: AbortSignal | undefined, message: string): void {
   if (!signal?.aborted) return;
   if (isAbortError(signal.reason)) throw signal.reason;
@@ -2418,14 +2425,17 @@ export class EngramMcpServer {
         // Preserve the original AbortError so HTTP can silently end a dead socket.
         if (isAbortError(err)) throw err;
         const message = mcpToolErrorMessage(err instanceof Error ? err : new Error(String(err)));
-        return {
-          jsonrpc: "2.0",
-          id,
-          result: {
-            content: [{ type: "text", text: message }],
-            isError: true,
-          },
+        const admissionBackpressure =
+          err instanceof Error &&
+          (err.name === "ReplayAdmissionRefusedError" || err.name === "BufferAdmissionRefusedError");
+        const result: McpToolErrorResult = {
+          content: [{ type: "text", text: message }],
+          isError: true,
         };
+        if (admissionBackpressure) {
+          result.structuredContent = { code: "buffer_admission_refused", retryable: true };
+        }
+        return { jsonrpc: "2.0", id, result };
       }
     }
 

package/src/access-observe-replay-durability.test.ts

@@ -32,7 +32,7 @@ import { EngramAccessService } from "./access-service.js";
 import { SmartBuffer } from "./buffer.js";
 import { ExtractionDeadlineError } from "./orchestration/extraction-run.js";
 import { runExtractionDeferRetention } from "./orchestration/extraction-run-helpers.js";
-import { TurnIngestionCoordinator, type TurnIngestionDeps } from "./orchestration/turn-ingestion.js";
+import { ReplayAdmissionRefusedError, TurnIngestionCoordinator, type TurnIngestionDeps } from "./orchestration/turn-ingestion.js";
 import { resolveScopeProfilePlan } from "./namespaces/scope-profiles.js";
 import { resolveCodingNamespaceOverlay } from "./coding/coding-namespace.js";
 import type { ResolvedScopeProfilePlan } from "./namespaces/scope-profiles.js";
@@ -378,6 +378,40 @@ test("#3251 buffered observe append is durable before accept: a failed save reje
     await cleanupDir(memoryDir);
   }
 });
+test("#3251 multi-session refusal is atomic: earlier sessions are not partially accepted", async () => {
+  const config = parseConfig({
+    bufferMaxSessions: 3,
+    bufferMaxTurns: 100,
+    triggerMode: "every_n",
+    extractionMinChars: 1_000_000,
+    extractionMinUserTurns: 1000,
+  });
+  // SAFETY: SeedStorage implements the loadBuffer/saveBuffer surface this fixture drives.
+  const buffer = new SmartBuffer(config, new SeedStorage() as StorageManager);
+  const occupied = makeReplayTurn("occupied", "existing backlog");
+  await buffer.addTurn("occupied", {
+    role: occupied.role,
+    content: occupied.content,
+    timestamp: occupied.timestamp,
+    sessionKey: occupied.sessionKey,
+  });
+  const coordinator = makeTurnIngestionDouble(config, buffer, []);
+
+  await assert.rejects(
+    coordinator.ingestReplayBatch(
+      [
+        makeReplayTurn("fresh-a", "first in batch"),
+        makeReplayTurn("fresh-b", "second in batch"),
+      ],
+      bufferedObserveOptions({ writeNamespaceOverride: "default", sessionOwnerPrincipal: "alice" }),
+    ),
+    ReplayAdmissionRefusedError,
+  );
+
+  assert.equal(buffer.getTurns("fresh-a").length, 0, "refused batch must not durably accept its first session");
+  assert.equal(buffer.getTurns("fresh-b").length, 0, "refused batch must not durably accept its second session");
+  assert.equal(buffer.getTurns("occupied").length, 1, "pre-existing backlog remains intact");
+});
 
 test("#3251 durable observe admission is bounded: at the entry cap a new session is refused, not evicted", async () => {
   // Real SmartBuffer + real coordinator, NO Orchestrator background actors —
@@ -413,8 +447,10 @@ test("#3251 durable observe admission is bounded: at the entry cap a new session
     // (buffer.ts), each holding an accepted, durably pending capture. The
     // seed turns are PINNED accepted captures — cap pressure must refuse new
     // captures, never evict these (#3251 eviction guard; the pre-existing
-    // `default` mirror entry also occupies the entries map).
-    for (let index = 0; index < 200; index += 1) {
+    // `default` mirror entry also occupies the entries map). 199 seeds +
+    // `default` = 200 entries: the reachable cap boundary (durable ingress
+    // refuses a 200th seed once pinned entries fill the cap).
+    for (let index = 0; index < 199; index += 1) {
       const key = `seed-${index}`;
       await buffer.addTurn(key, {
         role: "user",
@@ -452,7 +488,7 @@ test("#3251 durable observe admission is bounded: at the entry cap a new session
     assert.equal(queued.length, 0, "refused capture must not queue extraction");
 
     const snapshot = await buffer.getBufferSnapshot();
-    assert.equal(snapshot.bufferedSessionCount, 200, "refusal must not evict accepted captures");
+    assert.equal(snapshot.bufferedSessionCount, 199, "refusal must not evict accepted captures");
     assert.ok(
       buffer.getTurns("seed-0").some((turn) => turn.content.includes("accepted seed capture 0")),
     );

package/src/access-operations-batch.ts

@@ -14,7 +14,7 @@ import { z } from "zod";
 import type { DreamsPhase, RecallDisclosure, RecallPlanMode } from "./types.js";
 import type { RemnicChatGptMemoryInspectorInput } from "./mcp-memory-inspector-app.js";
 import { defineOperation } from "./access-boundary.js";
-import { EngramAccessForbiddenError } from "./access-errors.js";
+import { EngramAccessForbiddenError, rejectReservedArgumentKey } from "./access-errors.js";
 import {
   type ObserveRequest,
   observeRequestSchema,
@@ -55,11 +55,15 @@ import { normalizeDreamsStatusWindowHours } from "./maintenance/dreams-ledger.js
 // Shared helpers
 // ---------------------------------------------------------------------------
 
+// Object.create(null): a plain {} lets a copied own `__proto__` member invoke
+// the prototype setter, so an inherited field could reach the zod parse
+// (issue #3225 B1).
 function stripNulls(data: unknown): unknown {
   if (data !== null && typeof data === "object" && !Array.isArray(data)) {
     const obj = data as Record<string, unknown>;
-    const cleaned: Record<string, unknown> = {};
+    const cleaned = Object.create(null);
     for (const [key, value] of Object.entries(obj)) {
+      rejectReservedArgumentKey(key);
       if (value !== null) cleaned[key] = value;
     }
     return cleaned;
@@ -79,8 +83,9 @@ function strictSchema<T extends z.ZodRawShape>(shape: T): z.ZodType<Record<strin
  */
 function stripNullsExcept(data: unknown, preserve: readonly string[]): unknown {
   if (data !== null && typeof data === "object" && !Array.isArray(data)) {
-    const cleaned: Record<string, unknown> = {};
+    const cleaned = Object.create(null);
     for (const [key, value] of Object.entries(data as Record<string, unknown>)) {
+      rejectReservedArgumentKey(key);
       if (value !== null || preserve.includes(key)) cleaned[key] = value;
     }
     return cleaned;
@@ -328,9 +333,15 @@ defineOperation({ name: "identity_anchor_update", description: "Update identity
 defineOperation({ name: "memory_identity", description: "Memory identity.", schema: strictSchema({ namespace: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.memoryIdentity({ namespace: optStr(input.namespace), principal: ctx.authenticatedPrincipal }) }) });
 
 // === WORK/SHARED ===
-defineOperation({ name: "work_task", description: "Manage work task.", schema: strictSchema({ action: S.str, id: S.str, title: S.str, description: S.str, status: S.str, priority: S.str, owner: S.str, assignee: S.str, projectId: S.str, tags: S.strArr, dueAt: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.workTask({ action: (optStr(input.action) as "update" | "list" | "get" | "create" | "delete" | "transition") ?? "list", id: optStr(input.id), title: optStr(input.title), description: optStr(input.description), status: optStr(input.status), priority: optStr(input.priority), owner: optStr(input.owner), assignee: optStr(input.assignee), projectId: optStr(input.projectId), tags: optStrArr(input.tags), dueAt: optStr(input.dueAt) }) }) });
-defineOperation({ name: "work_project", description: "Manage work project.", schema: strictSchema({ action: S.str, id: S.str, name: S.str, description: S.str, status: S.str, owner: S.str, tags: S.strArr, taskId: S.str, projectId: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.workProject({ action: (optStr(input.action) as "update" | "list" | "get" | "create" | "delete" | "link_task") ?? "list", id: optStr(input.id), name: optStr(input.name), description: optStr(input.description), status: optStr(input.status), owner: optStr(input.owner), tags: optStrArr(input.tags), taskId: optStr(input.taskId), projectId: optStr(input.projectId) }) }) });
-defineOperation({ name: "work_board", description: "Manage work board.", schema: strictSchema({ action: S.str, projectId: S.str, snapshotJson: S.str, linkToMemory: S.bool }), handler: async (input, ctx) => ({ result: await ctx.service.workBoard({ action: (optStr(input.action) as "export_markdown" | "export_snapshot" | "import_snapshot") ?? "export_markdown", projectId: optStr(input.projectId) ?? "", snapshotJson: optStr(input.snapshotJson) ?? "", linkToMemory: input.linkToMemory === true }) }) });
+// SAFETY: optStr yields undefined or a string; workTask rejects any action
+// string outside its union with an input error before touching a store.
+defineOperation({ name: "work_task", description: "Manage work task.", fleetWide: true, schema: strictSchema({ action: S.str, id: S.str, title: S.str, description: S.str, status: S.str, priority: S.str, owner: S.str, assignee: S.str, projectId: S.str, tags: S.strArr, dueAt: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.workTask({ action: (optStr(input.action) as "update" | "list" | "get" | "create" | "delete" | "transition") ?? "list", id: optStr(input.id), title: optStr(input.title), description: optStr(input.description), status: optStr(input.status), priority: optStr(input.priority), owner: optStr(input.owner), assignee: optStr(input.assignee), projectId: optStr(input.projectId), tags: optStrArr(input.tags), dueAt: optStr(input.dueAt) }) }) });
+// SAFETY: optStr yields undefined or a string; workProject rejects any action
+// string outside its union with an input error before touching a store.
+defineOperation({ name: "work_project", description: "Manage work project.", fleetWide: true, schema: strictSchema({ action: S.str, id: S.str, name: S.str, description: S.str, status: S.str, owner: S.str, tags: S.strArr, taskId: S.str, projectId: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.workProject({ action: (optStr(input.action) as "update" | "list" | "get" | "create" | "delete" | "link_task") ?? "list", id: optStr(input.id), name: optStr(input.name), description: optStr(input.description), status: optStr(input.status), owner: optStr(input.owner), tags: optStrArr(input.tags), taskId: optStr(input.taskId), projectId: optStr(input.projectId) }) }) });
+// SAFETY: optStr yields undefined or a string; workBoard rejects any action
+// string outside its union with an input error before touching a store.
+defineOperation({ name: "work_board", description: "Manage work board.", fleetWide: true, schema: strictSchema({ action: S.str, projectId: S.str, snapshotJson: S.str, linkToMemory: S.bool }), handler: async (input, ctx) => ({ result: await ctx.service.workBoard({ action: (optStr(input.action) as "export_markdown" | "export_snapshot" | "import_snapshot") ?? "export_markdown", projectId: optStr(input.projectId) ?? "", snapshotJson: optStr(input.snapshotJson) ?? "", linkToMemory: input.linkToMemory === true }) }) });
 // Issue #2920: the envelope controls (authority/expiresAt/supersedes) are
 // parsed by the ONE canonical surface module shared with the OpenClaw tool
 // (write-output-controls.ts); semantics stay in composeWriteEnvelope. A
@@ -451,12 +462,12 @@ defineOperation({ name: "memory_summarize_hourly", description: "Hourly summariz
 defineOperation({ name: "conversation_index_update", description: "Update conv index.", fleetWide: true, schema: strictSchema({ sessionKey: S.str, hours: S.num, embed: S.bool }), handler: async (input, ctx) => { if (input.sessionKey !== undefined && typeof input.sessionKey !== "string") throw new EngramAccessInputError("sessionKey must be a string when provided"); return { result: await ctx.service.conversationIndexUpdate({ sessionKey: optStr(input.sessionKey), hours: optNum(input.hours), embed: optBool(input.embed) }) }; } });
 defineOperation({ name: "profiling_report", description: "Profiling report.", schema: strictSchema({ format: S.str, limit: S.num }), handler: async (input, ctx) => { if (input.format !== undefined && typeof input.format !== "string") throw new EngramAccessInputError("format must be a string when provided"); if (input.limit !== undefined && typeof input.limit !== "number") throw new EngramAccessInputError("limit must be a number when provided"); return { result: await ctx.service.profilingReport({ format: optStr(input.format), limit: optNum(input.limit) }) }; } });
 defineOperation({ name: "live_connectors_run", description: "Run connectors.", fleetWide: true, schema: strictSchema({ force: S.bool }), handler: async (input, ctx) => ({ result: await ctx.service.liveConnectorsRun({ authenticatedPrincipal: ctx.authenticatedPrincipal, force: input.force === true }, ctx.authenticatedPrincipal) }) });
-defineOperation({ name: "peer_list", description: "List peers.", schema: strictSchema({}), handler: async (_i, ctx) => ({ result: await ctx.service.peerList() }) });
-defineOperation({ name: "peer_get", description: "Get peer.", schema: strictSchema({ id: S.str }), handler: async (input, ctx) => { const id = defStr(input.id, ""); if (!id) throw new EngramAccessInputError("peer_get: id is required"); return { result: await ctx.service.peerGet(id) }; } });
-defineOperation({ name: "peer_set", description: "Set peer.", schema: strictSchema({ id: S.str, kind: S.str, displayName: S.str, notes: S.str }), handler: async (input, ctx) => { const id = defStr(input.id, ""); if (!id) throw new EngramAccessInputError("peer_set: id is required"); if (input.kind !== undefined && typeof input.kind !== "string") throw new EngramAccessInputError("peer_set: kind must be a string when provided"); if (input.displayName !== undefined && typeof input.displayName !== "string") throw new EngramAccessInputError("peer_set: displayName must be a string when provided"); if (input.notes !== undefined && typeof input.notes !== "string") throw new EngramAccessInputError("peer_set: notes must be a string when provided"); return { result: await ctx.service.peerSet({ id, kind: optStr(input.kind), displayName: optStr(input.displayName), notes: optStr(input.notes) }) }; } });
-defineOperation({ name: "peer_delete", description: "Delete peer.", schema: strictSchema({ id: S.str }), handler: async (input, ctx) => { const id = defStr(input.id, ""); if (!id) throw new EngramAccessInputError("peer_delete: id is required"); return { result: await ctx.service.peerDelete(id) }; } });
-defineOperation({ name: "peer_profile_get", description: "Get peer profile.", schema: strictSchema({ id: S.str }), handler: async (input, ctx) => { const id = defStr(input.id, ""); if (!id) throw new EngramAccessInputError("peer_profile_get: id is required"); return { result: await ctx.service.peerProfileGet(id) }; } });
-defineOperation({ name: "peer_forget", description: "Forget peer.", schema: strictSchema({ id: S.str, confirm: S.str }), handler: async (input, ctx) => { const id = defStr(input.id, ""); if (!id) throw new EngramAccessInputError("peer_forget: id is required"); const c = optStr(input.confirm) ?? ""; if (c !== "yes") throw new EngramAccessInputError("peer_forget: confirm must be 'yes' to prevent accidental data loss"); return { result: await ctx.service.peerForget(id, { confirm: "yes" }) }; } });
+defineOperation({ name: "peer_list", description: "List peers.", fleetWide: true, schema: strictSchema({}), handler: async (_i, ctx) => ({ result: await ctx.service.peerList() }) });
+defineOperation({ name: "peer_get", description: "Get peer.", fleetWide: true, schema: strictSchema({ id: S.str }), handler: async (input, ctx) => { const id = defStr(input.id, ""); if (!id) throw new EngramAccessInputError("peer_get: id is required"); return { result: await ctx.service.peerGet(id) }; } });
+defineOperation({ name: "peer_set", description: "Set peer.", fleetWide: true, schema: strictSchema({ id: S.str, kind: S.str, displayName: S.str, notes: S.str }), handler: async (input, ctx) => { const id = defStr(input.id, ""); if (!id) throw new EngramAccessInputError("peer_set: id is required"); return { result: await ctx.service.peerSet({ id, kind: optStr(input.kind), displayName: optStr(input.displayName), notes: optStr(input.notes) }) }; } });
+defineOperation({ name: "peer_delete", description: "Delete peer.", fleetWide: true, schema: strictSchema({ id: S.str }), handler: async (input, ctx) => { const id = defStr(input.id, ""); if (!id) throw new EngramAccessInputError("peer_delete: id is required"); return { result: await ctx.service.peerDelete(id) }; } });
+defineOperation({ name: "peer_profile_get", description: "Get peer profile.", fleetWide: true, schema: strictSchema({ id: S.str }), handler: async (input, ctx) => { const id = defStr(input.id, ""); if (!id) throw new EngramAccessInputError("peer_profile_get: id is required"); return { result: await ctx.service.peerProfileGet(id) }; } });
+defineOperation({ name: "peer_forget", description: "Forget peer.", fleetWide: true, schema: strictSchema({ id: S.str, confirm: S.str }), handler: async (input, ctx) => { const id = defStr(input.id, ""); if (!id) throw new EngramAccessInputError("peer_forget: id is required"); const c = optStr(input.confirm) ?? ""; if (c !== "yes") throw new EngramAccessInputError("peer_forget: confirm must be 'yes' to prevent accidental data loss"); return { result: await ctx.service.peerForget(id, { confirm: "yes" }) }; } });
 defineOperation({ name: "console_state", description: "Console state.", schema: strictSchema({ namespace: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.consoleState(optStr(input.namespace), ctx.authenticatedPrincipal) }) });
 defineOperation({ name: "dreams_status", description: "Dreams status.", schema: strictSchema({ windowHours: S.num, namespace: S.str }), handler: async (input, ctx) => { let wh = 24; try { wh = normalizeDreamsStatusWindowHours(input.windowHours); } catch { throw new EngramAccessInputError("dreams_status: windowHours must be a positive integer. Got: " + String(input.windowHours)); } return { result: await ctx.service.dreamsStatus({ windowHours: wh, namespace: optStr(input.namespace), principal: ctx.authenticatedPrincipal }) }; } });
 defineOperation({ name: "dreams_run", description: "Run dreams.", schema: strictSchema({ phase: S.str, dryRun: S.bool, namespace: S.str }), handler: async (input, ctx) => { const VP = ["lightSleep", "rem", "deepSleep"]; const ph = optStr(input.phase) ?? ""; if (!ph || !VP.includes(ph)) throw new EngramAccessInputError("dreams_run: phase must be one of: " + VP.join(", ")); if (input.dryRun !== undefined && typeof input.dryRun !== "boolean") throw new EngramAccessInputError("dreams_run: dryRun must be boolean"); return { result: await ctx.service.dreamsRun({ phase: ph as DreamsPhase, dryRun: input.dryRun === true, namespace: optStr(input.namespace), authenticatedPrincipal: ctx.authenticatedPrincipal }) }; } });