@stigmer/server 3.40.1 → 3.41.0

package/src/domain/mcpserver/start-connect.ts

@@ -20,6 +20,11 @@
  * run) is not reconciled in place — the fresh start below overwrites it,
  * which is both the repair and the caller's intent.
  *
+ * With a sandbox lane composed the run is served by a connect sandbox
+ * provisioned for this connect (connect-sandbox.ts): the settle task
+ * releases it with the ExecutionContext, and every arm that never hands a
+ * run to the settler (a start failure, an attach) releases it at once.
+ *
  * Proven by mcpserver-connect.conformance.test.ts
  * (CONFORMANCE_TARGET=local-execution), __tests__/connect.test.ts and
  * __tests__/store-faults.test.ts.
@@ -48,11 +53,13 @@ import {
 import {
   ASYNC_CONNECT_TIMEOUT,
   BEST_EFFORT_CONNECT_GET_BUFFER_MS,
+  acquireConnectRouteFor,
   deleteConnectExecutionContext,
   mapConnectFailure,
   prepareConnect,
 } from "./connect.js";
 import type { McpServerConnectDeps } from "./connect.js";
+import type { ConnectRoute } from "./connect-sandbox.js";
 import type { ConnectRun, McpServerConnectEngine } from "./engine.js";
 
 /**
@@ -124,11 +131,34 @@ export async function startConnect(
 
   const prepared = await prepareConnect(deps, mcpServer, input, identity);
 
+  let route: ConnectRoute;
+  try {
+    route = await acquireConnectRouteFor(deps, mcpServerId, {
+      connectExecutionId: prepared.executionId,
+      org: input.org,
+      caller: identity,
+    });
+  } catch (error) {
+    if (prepared.ecResourceId !== "") {
+      await deleteConnectExecutionContext(
+        deps,
+        prepared.ecResourceId,
+        prepared.executionId,
+      );
+    }
+    throw error;
+  }
+
   // Taken before the start so the advisory describes the queue the run is
   // about to join. Warn-only by design: a worker may be booting (the
   // pre-flight has a startup false-negative race), so the operation
-  // proceeds either way and the poller renders the warning as context.
-  const warning = await runnerQueueWarning(engineState.engine);
+  // proceeds either way and the poller renders the warning as context. A
+  // connect sandbox's queue is never probed: it was created a moment ago
+  // and has no poller yet by construction.
+  const warning =
+    route.taskQueue.kind === "runner"
+      ? await runnerQueueWarning(engineState.engine)
+      : "";
 
   let run: ConnectRun;
   try {
@@ -136,8 +166,10 @@ export async function startConnect(
       mcpServerId,
       prepared.workflowInput,
       ASYNC_CONNECT_TIMEOUT.ms,
+      route.taskQueue,
     );
   } catch (error) {
+    await route.release();
     if (prepared.ecResourceId !== "") {
       await deleteConnectExecutionContext(
         deps,
@@ -153,8 +185,10 @@ export async function startConnect(
   }
 
   if (run.attached) {
-    // Lost the residual race to another lane: its run and CONNECTING
-    // record stand, and the ExecutionContext prepared here is unused.
+    // Lost the residual race to another lane: its run, its sandbox and
+    // its CONNECTING record stand, and the route and ExecutionContext
+    // prepared here are unused.
+    await route.release();
     if (prepared.ecResourceId !== "") {
       await deleteConnectExecutionContext(
         deps,
@@ -188,11 +222,11 @@ export async function startConnect(
     // The workflow is already running; hand it to the background settler
     // (which copes with a deleted resource) but fail the RPC honestly —
     // a caller that cannot observe CONNECTING cannot poll.
-    detachSettle(deps, mcpServer, run, prepared);
+    detachSettle(deps, mcpServer, run, route, prepared);
     throw internalError(error, "failed to record connect operation");
   }
 
-  detachSettle(deps, mcpServer, run, prepared);
+  detachSettle(deps, mcpServer, run, route, prepared);
 
   return persisted;
 }
@@ -206,12 +240,14 @@ function detachSettle(
   deps: McpServerConnectDeps,
   mcpServer: McpServer,
   run: ConnectRun,
+  route: ConnectRoute,
   prepared: { readonly ecResourceId: string; readonly executionId: string },
 ): void {
   void settleConnectAsync(
     deps,
     mcpServer,
     run,
+    route,
     prepared.ecResourceId,
     prepared.executionId,
   ).catch((error: unknown) => {
@@ -232,13 +268,15 @@ function detachSettle(
  * first; the slightly longer backstop only guarantees the settle task can
  * never hang if Temporal becomes unreachable. If this process dies before
  * settling, the CONNECTING record goes stale; the next startConnect
- * overwrites it (the orphan contract on ConnectStatus). Never throws —
+ * overwrites it (the orphan contract on ConnectStatus), and a connect
+ * sandbox it held is left to the edition's orphan sweep. Never throws —
  * every failure lands on connect_status or the log.
  */
 async function settleConnectAsync(
   deps: McpServerConnectDeps,
   mcpServer: McpServer,
   run: ConnectRun,
+  route: ConnectRoute,
   ecResourceId: string,
   executionId: string,
 ): Promise<void> {
@@ -298,6 +336,7 @@ async function settleConnectAsync(
       tool_approvals: toolApprovalCount,
     });
   } finally {
+    await route.release();
     if (ecResourceId !== "") {
       await deleteConnectExecutionContext(deps, ecResourceId, executionId);
     }
@@ -306,9 +345,9 @@ async function settleConnectAsync(
 
 /**
  * The dead-runner advisory for connect_status, or "" when a worker is
- * polling the runner task queue — or when the question cannot be answered
- * (an unreachable Temporal should not cry wolf on an operation that is
- * about to fail loudly anyway; Go runnerQueueWarning).
+ * polling the shared runner task queue — or when the question cannot be
+ * answered (an unreachable Temporal should not cry wolf on an operation
+ * that is about to fail loudly anyway; Go runnerQueueWarning).
  */
 async function runnerQueueWarning(
   engine: McpServerConnectEngine,

package/src/domain/memory/__tests__/memory.test.ts

@@ -8,12 +8,16 @@
  *     state_changed_at set; the subject is forced to the OSS single-user
  *     sentinel "" (DD-005 D2); provenance is stored as supplied with
  *     tool_call_id force-cleared (the Stage 3 contract); an unnamed
- *     create defaults its name from the minted mem_ id; a missing org is
- *     the exact InvalidArgument copy;
+ *     create defaults its name from the minted mem_ id, and an id the
+ *     request carried is replaced by that mint (stigmer#1266); a missing
+ *     org is the exact InvalidArgument copy;
  *   - enablement fails CLOSED: org switch off is the exact formatted
  *     FailedPrecondition copy, an unknown org is NotFound;
  *   - the 100-per-subject-per-org ceiling refuses the 101st record with
- *     the exact copy and never blocks another org;
+ *     the exact copy and never blocks another org or counts another
+ *     person's rows;
+ *   - list answers one org's rows newest created first, the list index's
+ *     order (stigmer#1405);
  *   - confirm/reject are one contract with opposite verdicts: idempotent
  *     re-decisions write NOTHING (no audit bump), cross-decisions are
  *     refused with the pinned copy;
@@ -29,6 +33,7 @@ import path from "node:path";
 
 import { create } from "@bufbuild/protobuf";
 import type { MessageInitShape } from "@bufbuild/protobuf";
+import { timestampFromDate } from "@bufbuild/protobuf/wkt";
 import { Code, ConnectError, createClient } from "@connectrpc/connect";
 import type { Client, Transport } from "@connectrpc/connect";
 import { createGrpcTransport } from "@connectrpc/connect-node";
@@ -205,6 +210,19 @@ describe("memory create", () => {
     expect(created.metadata?.name).toBe(created.metadata?.id);
   });
 
+  it("replaces a client-supplied id with its own mint, which the name then follows", async () => {
+    const org = await createOrg(true);
+    const created = await command.create({
+      apiVersion: MEMORY_API_VERSION,
+      kind: MEMORY_KIND,
+      metadata: { org, id: "mem_chosen" },
+      spec: { content: "A fact whose id the caller tried to choose." },
+    });
+    expect(created.metadata?.id).toMatch(/^mem_[0-9a-hjkmnp-tv-z]{26}$/);
+    expect(created.metadata?.id).not.toBe("mem_chosen");
+    expect(created.metadata?.name).toBe(created.metadata?.id);
+  });
+
   it("requires metadata.org with the exact InvalidArgument copy", async () => {
     const error = await grpcError(() =>
       command.create({
@@ -234,30 +252,36 @@ describe("memory enablement (fail-closed)", () => {
   });
 });
 
+/**
+ * Seeds a full ceiling for `subject` in `org` directly through the store
+ * (the RPC path would be needlessly slow at 100 creates).
+ */
+async function seedCeiling(org: string, subject: string): Promise<void> {
+  for (let i = 0; i < MAX_MEMORIES_PER_SUBJECT; i++) {
+    const id = generateId("mem");
+    const seeded = create(MemorySchema, {
+      apiVersion: MEMORY_API_VERSION,
+      kind: MEMORY_KIND,
+      metadata: { id, name: id, slug: id, org },
+      spec: { content: `Seeded fact ${i}.`, subjectIdentityAccountId: subject },
+    });
+    await server.store.saveResource(
+      ApiResourceKind.memory,
+      id,
+      MemorySchema,
+      seeded,
+    );
+  }
+}
+
 describe("memory cap", () => {
   it("refuses the record past the per-subject ceiling, visibly, without blocking other orgs", async () => {
     const org = await createOrg(true);
     const otherOrg = await createOrg(true);
 
-    // Seed the ceiling directly through the store (the RPC path would be
-    // needlessly slow at 100 creates); the refused create goes through
-    // the RPC. Seeded rows carry the sentinel subject "" the create path
-    // would derive.
-    for (let i = 0; i < MAX_MEMORIES_PER_SUBJECT; i++) {
-      const id = generateId("mem");
-      const seeded = create(MemorySchema, {
-        apiVersion: MEMORY_API_VERSION,
-        kind: MEMORY_KIND,
-        metadata: { id, name: id, slug: id, org },
-        spec: { content: `Seeded fact ${i}.`, subjectIdentityAccountId: "" },
-      });
-      await server.store.saveResource(
-        ApiResourceKind.memory,
-        id,
-        MemorySchema,
-        seeded,
-      );
-    }
+    // The refused create goes through the RPC. Seeded rows carry the
+    // sentinel subject "" the create path would derive.
+    await seedCeiling(org, "");
 
     const error = await grpcError(() => createMemory(org, "One too many."));
     expect(error.code).toBe(Code.FailedPrecondition);
@@ -270,6 +294,14 @@ describe("memory cap", () => {
     );
     expect(unblocked.metadata?.id).toMatch(/^mem_/);
   });
+
+  it("counts only the subject's own rows: another person's full ceiling in the org does not block", async () => {
+    const org = await createOrg(true);
+    await seedCeiling(org, "ida_someone_else");
+
+    const created = await createMemory(org, "Plenty of room for me.");
+    expect(created.metadata?.id).toMatch(/^mem_/);
+  });
 });
 
 describe("memory confirm/reject", () => {
@@ -480,4 +512,42 @@ describe("memory list", () => {
       expect(item.metadata?.org).toBe(org);
     }
   });
+
+  it("answers newest created first, whatever the write order", async () => {
+    const org = await createOrg(true);
+    // Seeded through the store so each row carries a chosen creation
+    // instant; written oldest-last to prove the order is not the write's.
+    const seeded = [
+      { id: generateId("mem"), day: 3 },
+      { id: generateId("mem"), day: 1 },
+      { id: generateId("mem"), day: 2 },
+    ];
+    for (const { id, day } of seeded) {
+      await server.store.saveResource(
+        ApiResourceKind.memory,
+        id,
+        MemorySchema,
+        create(MemorySchema, {
+          apiVersion: MEMORY_API_VERSION,
+          kind: MEMORY_KIND,
+          metadata: { id, name: id, slug: id, org },
+          spec: { content: `Fact of day ${day}.` },
+          status: {
+            audit: {
+              specAudit: {
+                createdAt: timestampFromDate(new Date(Date.UTC(2026, 8, day))),
+              },
+            },
+          },
+        }),
+      );
+    }
+
+    const listed = await query.list({ org });
+    expect(listed.items.map((m) => m.spec?.content)).toEqual([
+      "Fact of day 3.",
+      "Fact of day 2.",
+      "Fact of day 1.",
+    ]);
+  });
 });

package/src/domain/memory/__tests__/queries.test.ts

@@ -0,0 +1,173 @@
+/**
+ * Pins the memory kind's indexed reads (../queries.ts) over a real sqlite
+ * store opened with the server's list indexes (stigmer#1405): a subject's
+ * read answers that subject's rows in the one organization, in every
+ * lifecycle state, newest first; the "" sentinel reads by organization
+ * and stays exact against a named subject's rows; the organization read
+ * answers every subject's rows there and none elsewhere; and rows a
+ * binary that does not know the index wrote (a second handle opened with
+ * no declarations, the overlap of a roll) answer the same.
+ */
+import { DatabaseSync } from "node:sqlite";
+
+import { create } from "@bufbuild/protobuf";
+import { timestampFromDate } from "@bufbuild/protobuf/wkt";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { MemorySchema } from "@stigmer/protos/ai/stigmer/agentic/memory/v1/api_pb";
+import type { Memory } from "@stigmer/protos/ai/stigmer/agentic/memory/v1/api_pb";
+import { MemoryLifecycleState } from "@stigmer/protos/ai/stigmer/agentic/memory/v1/enum_pb";
+import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
+
+import type { Store } from "../../../store/interface.js";
+import { apiResourceKindName } from "../../../store/proto-fields.js";
+import { SqliteStore } from "../../../store/sqlite/store.js";
+import { tempStore } from "../../../store/sqlite/__tests__/support.js";
+import type { TempStore } from "../../../store/sqlite/__tests__/support.js";
+import { listOrganizationMemories, listSubjectMemories } from "../queries.js";
+
+let temp: TempStore;
+
+beforeEach(() => {
+  temp = tempStore();
+});
+
+afterEach(async () => {
+  await temp.cleanup();
+});
+
+async function seed(
+  store: Store,
+  row: {
+    id: string;
+    org: string;
+    subject: string;
+    day: number;
+    state?: MemoryLifecycleState;
+  },
+): Promise<void> {
+  await store.saveResource(
+    ApiResourceKind.memory,
+    row.id,
+    MemorySchema,
+    create(MemorySchema, {
+      metadata: { id: row.id, name: row.id, org: row.org },
+      spec: { content: row.id, subjectIdentityAccountId: row.subject },
+      status: {
+        lifecycleState:
+          row.state ?? MemoryLifecycleState.lifecycle_state_confirmed,
+        audit: {
+          specAudit: {
+            createdAt: timestampFromDate(new Date(Date.UTC(2026, 8, row.day))),
+          },
+        },
+      },
+    }),
+  );
+}
+
+/** Memory rows whose index facts are not proven under revision 1 (the store-contract reading). */
+function unprovenMemoryRows(): number {
+  const db = new DatabaseSync(temp.dbPath);
+  try {
+    return (
+      db
+        .prepare(
+          `SELECT COUNT(*) AS count FROM resources
+           WHERE kind = ? AND (list_indexed_at IS NOT updated_at
+             OR list_index_revision IS NULL OR list_index_revision <> 1)`,
+        )
+        .get(apiResourceKindName(ApiResourceKind.memory)) as { count: number }
+    ).count;
+  } finally {
+    db.close();
+  }
+}
+
+const ids = (memories: ReadonlyArray<Memory>): string[] =>
+  memories.map((memory) => memory.metadata?.id ?? "");
+
+async function seedTwoOrganizations(store: Store): Promise<void> {
+  await seed(store, {
+    id: "mem_carol_1",
+    org: "acme",
+    subject: "ida_carol",
+    day: 1,
+  });
+  await seed(store, {
+    id: "mem_carol_2",
+    org: "acme",
+    subject: "ida_carol",
+    day: 3,
+    state: MemoryLifecycleState.lifecycle_state_proposed,
+  });
+  await seed(store, {
+    id: "mem_dave",
+    org: "acme",
+    subject: "ida_dave",
+    day: 2,
+  });
+  await seed(store, { id: "mem_local", org: "acme", subject: "", day: 4 });
+  await seed(store, {
+    id: "mem_carol_zeta",
+    org: "zeta",
+    subject: "ida_carol",
+    day: 5,
+  });
+}
+
+describe("listSubjectMemories", () => {
+  it("answers one subject's rows in one organization, every state, newest first", async () => {
+    await seedTwoOrganizations(temp.store);
+    expect(
+      ids(await listSubjectMemories(temp.store, "acme", "ida_carol")),
+    ).toEqual(["mem_carol_2", "mem_carol_1"]);
+    expect(
+      ids(await listSubjectMemories(temp.store, "zeta", "ida_carol")),
+    ).toEqual(["mem_carol_zeta"]);
+    expect(await listSubjectMemories(temp.store, "zeta", "ida_dave")).toEqual(
+      [],
+    );
+  });
+
+  it("reads the single-operator sentinel by organization, and only its own rows", async () => {
+    await seedTwoOrganizations(temp.store);
+    expect(ids(await listSubjectMemories(temp.store, "acme", ""))).toEqual([
+      "mem_local",
+    ]);
+    expect(await listSubjectMemories(temp.store, "zeta", "")).toEqual([]);
+  });
+
+  it("answers rows a binary without the index wrote", async () => {
+    const older = SqliteStore.open(temp.dbPath);
+    try {
+      await seedTwoOrganizations(older);
+    } finally {
+      await older.close();
+    }
+    expect(unprovenMemoryRows(), "the rows carry no memory index facts").toBe(
+      5,
+    );
+    expect(
+      ids(await listSubjectMemories(temp.store, "acme", "ida_carol")),
+    ).toEqual(["mem_carol_2", "mem_carol_1"]);
+    expect(ids(await listSubjectMemories(temp.store, "acme", ""))).toEqual([
+      "mem_local",
+    ]);
+  });
+});
+
+describe("listOrganizationMemories", () => {
+  it("answers every subject's rows in the organization, newest first, and none elsewhere", async () => {
+    await seedTwoOrganizations(temp.store);
+    expect(ids(await listOrganizationMemories(temp.store, "acme"))).toEqual([
+      "mem_local",
+      "mem_carol_2",
+      "mem_dave",
+      "mem_carol_1",
+    ]);
+    expect(ids(await listOrganizationMemories(temp.store, "zeta"))).toEqual([
+      "mem_carol_zeta",
+    ]);
+  });
+});

package/src/domain/memory/controller.ts

@@ -185,7 +185,8 @@ function kindOf(ctx: HandlerContext): ApiResourceKind {
  * content is subject-only and must not surface in org-visible search).
  *
  * Authorization: GuardMemoryCapture decides WHO may capture (the composed
- * RunnerCredentialProvider), AuthorizeResolvedTarget decides WHERE
+ * RunnerCredentialProvider, then the first-party allow-list recall shares,
+ * extensions/identity.ts), AuthorizeResolvedTarget decides WHERE
  * (can_create_session on the organization), and CreateAuthorizationTuples
  * runs against the composed lifecycle. ResolveMemoryDefaults names the
  * person the memory is about and CheckMemoryEnablement requires both

package/src/domain/memory/list-index.ts

@@ -0,0 +1,32 @@
+/**
+ * The memory list index (store/list-index.ts): `subject` is the key
+ * recall and the per-subject cap read (queries.ts beside this file), so
+ * both answer from one person's rows instead of decoding every memory on
+ * the server — recall runs on every execution create in a memory-on
+ * organization (stigmer#1405). The organization needs no key: it is every
+ * declaration's first fact, which is how `memory.list` reads one
+ * organization's rows.
+ *
+ * Lifecycle state is not a key. A key reads a string field and the state
+ * is an enum; the rows it would narrow are one subject's in one
+ * organization, which the cap bounds (MAX_MEMORIES_PER_SUBJECT), so the
+ * readers filter it in process. The single-operator posture files every
+ * memory under the "" subject sentinel, and an empty value is no key
+ * (`listIndexFactsOf`), so that subject reads by organization alone.
+ *
+ * A change to `keys` bumps `revision` (boot/__tests__/list-indexes.test.ts
+ * pins the pair).
+ */
+import { MemorySchema } from "@stigmer/protos/ai/stigmer/agentic/memory/v1/api_pb";
+import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
+
+import { declareListIndex, field } from "../../store/list-index.js";
+
+export const memoryListIndex = declareListIndex({
+  kind: ApiResourceKind.memory,
+  schema: MemorySchema,
+  revision: 1,
+  keys: {
+    subject: field("spec.subject_identity_account_id"),
+  },
+});

package/src/domain/memory/queries.ts

@@ -0,0 +1,72 @@
+/**
+ * The memory kind's shared reads, all through the list index (list-index.ts
+ * beside this file; the store's contract in store/interface.ts): recall
+ * (domain/agentexecution/create-steps.ts) and the per-subject cap read one
+ * subject's rows in one organization, `memory.list` reads one
+ * organization's. Rows come newest created first, the index order, which
+ * is exactly `compareCreatedAtDesc` (store/list-index.ts states it).
+ *
+ * Every row is re-checked against the organization and the subject it was
+ * asked for, whatever the index returned, as the IamPolicy adapter
+ * re-checks its principal (domain/iampolicy/resource-store.ts): it keeps
+ * the "" subject exact, which reads the whole organization because an
+ * empty value is no key. Undecodable rows are skipped — one bad record
+ * must not take recall, the cap or the list down. A store fault is
+ * thrown as it came; each caller maps it with its own copy.
+ *
+ * Proven by __tests__/queries.test.ts and, end to end, by
+ * memory.conformance.test.ts.
+ */
+import { fromBinary } from "@bufbuild/protobuf";
+
+import { MemorySchema } from "@stigmer/protos/ai/stigmer/agentic/memory/v1/api_pb";
+import type { Memory } from "@stigmer/protos/ai/stigmer/agentic/memory/v1/api_pb";
+
+import type { Store } from "../../store/interface.js";
+import type { ListIndexRow } from "../../store/list-index.js";
+import { memoryListIndex } from "./list-index.js";
+
+/**
+ * Every memory `subject` holds in `org`, in every lifecycle state — the
+ * run's person's account id, or the single-operator "" sentinel.
+ */
+export async function listSubjectMemories(
+  store: Store,
+  org: string,
+  subject: string,
+): Promise<Memory[]> {
+  const rows = await store.queryResources(memoryListIndex, {
+    org,
+    ...(subject === ""
+      ? {}
+      : { anyKey: [{ name: "subject" as const, value: subject }] }),
+  });
+  return decodeMemories(rows).filter(
+    (memory) =>
+      (memory.metadata?.org ?? "") === org &&
+      (memory.spec?.subjectIdentityAccountId ?? "") === subject,
+  );
+}
+
+/** Every memory in `org`, whoever it is about. */
+export async function listOrganizationMemories(
+  store: Store,
+  org: string,
+): Promise<Memory[]> {
+  const rows = await store.queryResources(memoryListIndex, { org });
+  return decodeMemories(rows).filter(
+    (memory) => (memory.metadata?.org ?? "") === org,
+  );
+}
+
+function decodeMemories(rows: ReadonlyArray<ListIndexRow>): Memory[] {
+  const memories: Memory[] = [];
+  for (const row of rows) {
+    try {
+      memories.push(fromBinary(MemorySchema, row.data));
+    } catch {
+      continue;
+    }
+  }
+  return memories;
+}