@pikku/mongodb 0.12.18 → 0.12.20

package/CHANGELOG.md

@@ -1,5 +1,139 @@
 # @pikku/mongodb
 
+## 0.12.20
+
+### Patch Changes
+
+- 3c0012c: Gate console agent-thread reads and deletes on thread ownership, claim MongoDB workflow steps atomically, and reach the deployment fallback from `rpcWithWire`
+
+  `getAgentThreadMessages` and `deleteAgentThread` in the console addon took a
+  caller-supplied `threadId` straight to storage, while their siblings
+  `getAgentThreads` and `getAgentThreadRuns` already filtered to what the session
+  owns. Both now carry an `isThreadOwner` permission: an admin reaches any thread,
+  everyone else only their own, and a missing thread is refused rather than 404'd
+  so it is indistinguishable from someone else's.
+
+  `MongoDBWorkflowService` claimed a step by reading its status and then writing
+  it, under a `withStepLock` that is a pass-through — so two dispatches racing for
+  the same step could both proceed and run a side-effecting step twice. The claim
+  is now a single status-guarded update, atomic on one document.
+
+  `rpcWithWire` threw `RPCNotFoundError` for any unresolved namespaced call
+  instead of falling through to the deployment service, so a namespaced RPC that
+  `rpc()` would have dispatched remotely failed when called with an explicit wire.
+
+- Updated dependencies [3c0012c]
+- Updated dependencies [05e47cf]
+- Updated dependencies [cfd364a]
+- Updated dependencies [05e47cf]
+- Updated dependencies [05e47cf]
+- Updated dependencies [05e47cf]
+  - @pikku/core@0.12.90
+
+## 0.12.19
+
+### Patch Changes
+
+- 266e3bc: One door per name: `@pikku/core/ecosystem/*` and the package root are gone
+
+  `@pikku/core` published every module twice. `ecosystem/http` re-exported
+  `./http`, `ecosystem/services` re-exported `./services`, and a name was
+  reachable through either — so every addition had to be made in two places, and a
+  consumer's import said nothing about what it actually used. The package root was
+  the same problem at a larger scale: a single barrel of 206 names that no bundler
+  could take apart, and the one specifier that revealed nothing at all.
+
+  Both are deleted. Every name now lives on the subpath that owns it, and every
+  import carries that subpath — `@pikku/core/http`, `@pikku/core/services`,
+  `@pikku/core/errors`, `@pikku/core/types`.
+
+  Deleting the facades meant the raw subpaths had to become a superset of them,
+  which they were not: the facade tree had accumulated 25 names with no raw home
+  and about 26 more filed under a different area than the module they came from.
+  Those names moved to the area that owns them, and three areas were published as
+  new entry points rather than left on a root that is going away — `./types` (the
+  shared type surface, the largest single destination), `./state` and
+  `./classification`.
+
+  `./classification` is one door onto one subject: what a value is and how it must
+  be handled. Its three halves would each have been an entry point — the brands
+  and manifest types, the stored-form helpers (`hashToken`, `unsafeAsSealed` and
+  friends), and `SecretValue` — split by whether a name happens to be a type or a
+  value, which is the same defect as the facades. The duration and versioned-id
+  helpers went to `./utils`, which already published, and `PikkuRequest` went to
+  `./function`: it is the transport-agnostic request base, not an HTTP one — HTTP
+  has `PikkuHTTPAbstractRequest`, and the only thing outside core that extends
+  `PikkuRequest` is Azure's timer request.
+
+  `./types` inherited the root barrel's habit before it inherited its contents, so
+  the names with an owner elsewhere were moved off it. The middleware types and the
+  five middleware factories — `pikkuMiddleware`, `pikkuMiddlewareFactory`,
+  `pikkuChannelMiddleware`, `pikkuChannelMiddlewareFactory` and
+  `pikkuAgentMiddleware`, runtime values on a types entry point — are now
+  `@pikku/core/middleware`; the function meta types are `@pikku/core/function`;
+  `SerializedError` is `@pikku/core/errors`; and the generic TypeScript helpers
+  (`MakeRequired`, `PickRequired`, `PickOptional`, `RequireAtLeastOne`,
+  `JSONPrimitive`, `JSONValue`) are `@pikku/core/utils`. What is left on `./types`
+  is the vocabulary the wirings share, which no single module owns.
+
+  `pikku` was itself a root barrel — `export * from '@pikku/core'` — and
+  now exports only the services it bundles.
+
+  One module survives at the old specifier, and only for the bootstrap:
+  `packages/cli` is generated by the _published_ CLI pinned in its `build.sh`, and
+  that CLI still writes a bare `@pikku/core` into the files it generates for the
+  CLI itself. `bootstrap-compat/root.ts` carries the eight types it names, a test
+  in core fails if that list grows, and it goes when the pin moves to a CLI
+  released from this branch. The adapter names the pinned CLI reaches for —
+  `pikkuState` and `CreateWireServices` — are rewritten to `@pikku/core/state` and
+  `@pikku/core/types` by the same `build.sh` patch pass, so no second shim is
+  needed for them.
+
+  A guard test keeps the root shut: it parses imports and rejects a bare
+  `@pikku/core` rather than grepping for it, because several tests hold a user's
+  file as a template literal, where `import … from '@pikku/core'` is fixture text
+  rather than an import this repo makes.
+
+  An agent scaffold a project generated under an older CLI is refreshed rather
+  than left to fail: `pikku all` already deleted one importing an entry point
+  `@pikku/core` no longer publishes, and the `#pikku` hub joins that list.
+  Without it a project that scaffolds the agent endpoint but
+  declares no agents keeps the old file forever — the generator that would rewrite
+  it only runs when agents exist, and the file being present is what stops it
+  being regenerated as missing.
+
+  `pikku new addon` also wrote a tsconfig `paths` map naming only the deleted hub.
+  An addon's `imports` map points into `dist`, so `paths` is what resolves
+  `#pikku/<leaf>` for the addon's own source build — it now names the two leaf
+  patterns, in both the addon and its test harness.
+
+- 786dae5: Bump every dependency whose latest release is a major across the monorepo, and
+  port the code the majors broke: `cookie` 2's `parseCookie`/`stringifySetCookie`
+  API in `@pikku/core` and the three runtime HTTP adapters, and assistant-ui 0.15's
+  store client in `@pikku/assistant-ui`.
+- 6eef0a0: Bump every dependency to its latest compatible minor/patch across the monorepo.
+- Updated dependencies [7722ceb]
+- Updated dependencies [375c1ff]
+- Updated dependencies [02a70cd]
+- Updated dependencies [aeef159]
+- Updated dependencies [a281de6]
+- Updated dependencies [266e3bc]
+- Updated dependencies [02a70cd]
+- Updated dependencies [786dae5]
+- Updated dependencies [6eef0a0]
+- Updated dependencies [3561d67]
+- Updated dependencies [a91c433]
+- Updated dependencies [02a70cd]
+- Updated dependencies [9537f74]
+- Updated dependencies [2b57ca8]
+- Updated dependencies [266e3bc]
+- Updated dependencies [9fce0f1]
+- Updated dependencies [83683a0]
+- Updated dependencies [456c88b]
+- Updated dependencies [456c88b]
+- Updated dependencies [c127273]
+  - @pikku/core@0.12.85
+
 ## 0.12.18
 
 ### Patch Changes

package/dist/src/index.d.ts

@@ -7,6 +7,6 @@ export { MongoDBDeploymentService } from './mongodb-deployment-service.js';
 export { MongoDBAgentStorageService } from './mongodb-agent-storage-service.js';
 export { MongoDBAgentRunService } from './mongodb-agent-run-service.js';
 export { MongoDBSecretService } from './mongodb-secret-service.js';
-export type { WorkflowRunService } from '@pikku/core/ecosystem/workflow';
-export type { AgentRunService, AgentRunRow, } from '@pikku/core/ecosystem/agent';
+export type { WorkflowRunService } from '@pikku/core/workflow';
+export type { AgentRunService, AgentRunRow } from '@pikku/core/agent';
 export { MongoDBSessionStore } from './mongodb-session-store.js';

package/dist/src/mongodb-agent-run-service.d.ts

@@ -1,5 +1,4 @@
-import type { AgentThread, AgentMessage } from '@pikku/core/agent';
-import type { AgentRunRow, AgentRunService } from '@pikku/core/ecosystem/agent';
+import type { AgentThread, AgentMessage, AgentRunRow, AgentRunService } from '@pikku/core/agent';
 import type { Db } from 'mongodb';
 export declare class MongoDBAgentRunService implements AgentRunService {
     private threads;

package/dist/src/mongodb-agent-storage-service.d.ts

@@ -1,6 +1,6 @@
-import type { AgentStorageService, AgentRunStateService, CreateRunInput, SaveScoreInput } from '@pikku/core/services';
-import type { AgentThread, AgentMessage, AgentRunState } from '@pikku/core/agent';
+import type { AgentMessage, AgentRunState, AgentThread } from '@pikku/core/agent';
 import type { AgentRunScore } from '@pikku/core/agent-scorer';
+import type { AgentRunStateService, AgentStorageService, CreateRunInput, SaveScoreInput } from '@pikku/core/services';
 import type { Db } from 'mongodb';
 export declare class MongoDBAgentStorageService implements AgentStorageService, AgentRunStateService {
     private db;

package/dist/src/mongodb-channel-store.d.ts

@@ -1,5 +1,5 @@
-import type { Channel } from '@pikku/core/channel';
 import { ChannelStore } from '@pikku/core/channel';
+import type { Channel } from '@pikku/core/channel';
 import type { Db } from 'mongodb';
 export declare class MongoDBChannelStore extends ChannelStore {
     private db;

package/dist/src/mongodb-deployment-service.d.ts

@@ -1,5 +1,6 @@
-import type { DeploymentService, DeploymentServiceConfig, DeploymentConfig } from '@pikku/core/ecosystem/services';
-import type { JWTService, SecretService } from '@pikku/core/services';
+import type { DeploymentService, DeploymentServiceConfig, DeploymentConfig } from '@pikku/core/services';
+import type { JWTService } from '@pikku/core/services';
+import type { SecretService } from '@pikku/core/services';
 import type { Db } from 'mongodb';
 export declare class MongoDBDeploymentService implements DeploymentService {
     private db;

package/dist/src/mongodb-deployment-service.js

@@ -1,5 +1,5 @@
-import { buildRemoteHeaders } from '@pikku/core/ecosystem/remote';
-import { getAllFunctionNames } from '@pikku/core/ecosystem/function';
+import { buildRemoteHeaders } from '@pikku/core/remote';
+import { getAllFunctionNames } from '@pikku/core/function';
 export class MongoDBDeploymentService {
     db;
     jwt;

package/dist/src/mongodb-eventhub-store.d.ts

@@ -1,4 +1,4 @@
-import { EventHubStore } from '@pikku/core/ecosystem/channel';
+import { EventHubStore } from '@pikku/core/channel';
 import type { Db } from 'mongodb';
 export declare class MongoDBEventHubStore extends EventHubStore {
     private db;

package/dist/src/mongodb-eventhub-store.js

@@ -1,4 +1,4 @@
-import { EventHubStore } from '@pikku/core/ecosystem/channel';
+import { EventHubStore } from '@pikku/core/channel';
 export class MongoDBEventHubStore extends EventHubStore {
     db;
     initialized = false;

package/dist/src/mongodb-secret-service.d.ts

@@ -1,5 +1,5 @@
-import { type SecretValue } from '@pikku/core';
 import type { SecretService, SecretValues } from '@pikku/core/services';
+import type { SecretValue } from '@pikku/core/classification';
 import type { Db } from 'mongodb';
 export interface MongoDBSecretServiceConfig {
     key: string;

package/dist/src/mongodb-secret-service.js

@@ -1,5 +1,5 @@
-import { createSecretValue, isSecretValue } from '@pikku/core';
-import { deriveKEK, generateKEKSalt, envelopeEncrypt, envelopeDecrypt, envelopeRewrap, } from '@pikku/core/crypto-utils';
+import { deriveKEK, envelopeDecrypt, envelopeEncrypt, envelopeRewrap, generateKEKSalt, } from '@pikku/core/crypto-utils';
+import { createSecretValue, isSecretValue } from '@pikku/core/classification';
 export class MongoDBSecretService {
     db;
     initialized = false;

package/dist/src/mongodb-session-store.d.ts

@@ -1,5 +1,5 @@
-import type { CoreUserSession } from '@pikku/core';
 import type { SessionStore } from '@pikku/core/services';
+import type { CoreUserSession } from '@pikku/core/types';
 import type { Db } from 'mongodb';
 export declare class MongoDBSessionStore implements SessionStore {
     private db;

package/dist/src/mongodb-workflow-run-service.d.ts

@@ -1,4 +1,4 @@
-import type { WorkflowRun, StepState, WorkflowRunService } from '@pikku/core/ecosystem/workflow';
+import type { WorkflowRun, StepState, WorkflowRunService } from '@pikku/core/workflow';
 import type { Db } from 'mongodb';
 export declare class MongoDBWorkflowRunService implements WorkflowRunService {
     private runs;

package/dist/src/mongodb-workflow-service.d.ts

@@ -1,6 +1,6 @@
-import type { SerializedError } from '@pikku/core/ecosystem/types';
+import type { SerializedError } from '@pikku/core/errors';
 import { PikkuWorkflowService } from '@pikku/core/workflow';
-import type { WorkflowPlannedStep, WorkflowQueueOptions, WorkflowRun, WorkflowRunWire, StepState, StepStatus, WorkflowStatus, WorkflowVersionStatus } from '@pikku/core/ecosystem/workflow';
+import type { WorkflowPlannedStep, WorkflowQueueOptions, WorkflowRun, WorkflowRunWire, StepState, StepStatus, WorkflowStatus, WorkflowVersionStatus } from '@pikku/core/workflow';
 import type { Db } from 'mongodb';
 export declare class MongoDBWorkflowService extends PikkuWorkflowService {
     private initialized;
@@ -44,7 +44,29 @@ export declare class MongoDBWorkflowService extends PikkuWorkflowService {
     protected setStepErrorImpl(stepId: string, error: Error): Promise<void>;
     protected createRetryAttemptImpl(stepId: string, status: 'pending' | 'running'): Promise<StepState>;
     withRunLock<T>(id: string, fn: () => Promise<T>): Promise<T>;
+    /**
+     * A pass-through: MongoDB has no advisory-lock primitive to build one on.
+     * The one decision that must exclude — claiming a step to execute it — is
+     * made by `claimStepForExecution` below as a single conditional write, which
+     * needs no lock to be exclusive.
+     */
     withStepLock<T>(_runId: string, _stepName: string, fn: () => Promise<T>): Promise<T>;
+    /**
+     * Claim the step with a status-guarded update and read the modified count:
+     * a single-document update is atomic in MongoDB, so two dispatches racing for
+     * the same step cannot both proceed.
+     *
+     * This replaces the read-then-write the base engine does under
+     * `withStepLock`, which excludes nothing here — the lock above is a
+     * pass-through. The winner then goes through the ordinary transition methods,
+     * so history rows see exactly what they saw before.
+     */
+    protected claimStepForExecution(runId: string, stepName: string, rpcName: string): Promise<StepState | null>;
+    /**
+     * Move a step to `running` only if it is still in one of `from`, reporting
+     * whether this caller is the one that moved it.
+     */
+    private claimStepStatus;
     getCompletedGraphState(runId: string): Promise<{
         completedNodeIds: string[];
         failedNodeIds: string[];

package/dist/src/mongodb-workflow-service.js

@@ -1,4 +1,4 @@
-import { PikkuWorkflowService } from '@pikku/core/workflow';
+import { PikkuWorkflowService, WorkflowStepFunctionMismatchError, } from '@pikku/core/workflow';
 import { MongoDBWorkflowRunService } from './mongodb-workflow-run-service.js';
 export class MongoDBWorkflowService extends PikkuWorkflowService {
     initialized = false;
@@ -254,9 +254,61 @@ export class MongoDBWorkflowService extends PikkuWorkflowService {
     async withRunLock(id, fn) {
         return fn();
     }
+    /**
+     * A pass-through: MongoDB has no advisory-lock primitive to build one on.
+     * The one decision that must exclude — claiming a step to execute it — is
+     * made by `claimStepForExecution` below as a single conditional write, which
+     * needs no lock to be exclusive.
+     */
     async withStepLock(_runId, _stepName, fn) {
         return fn();
     }
+    /**
+     * Claim the step with a status-guarded update and read the modified count:
+     * a single-document update is atomic in MongoDB, so two dispatches racing for
+     * the same step cannot both proceed.
+     *
+     * This replaces the read-then-write the base engine does under
+     * `withStepLock`, which excludes nothing here — the lock above is a
+     * pass-through. The winner then goes through the ordinary transition methods,
+     * so history rows see exactly what they saw before.
+     */
+    async claimStepForExecution(runId, stepName, rpcName) {
+        const stepState = await this.getStepState(runId, stepName);
+        // knowledge: decisions/security/a-step-runs-the-function-the-workflow-dispatched-it-with.md
+        if (stepState.rpcName !== undefined &&
+            stepState.rpcName !== (rpcName ?? null)) {
+            throw new WorkflowStepFunctionMismatchError(runId, stepName);
+        }
+        if (stepState.status === 'succeeded' || stepState.status === 'running') {
+            return null;
+        }
+        if (stepState.status === 'failed') {
+            if (!(await this.claimStepStatus(stepState.stepId, ['failed']))) {
+                return null;
+            }
+            return this.createRetryAttempt(stepState.stepId, 'running');
+        }
+        if (stepState.status === 'pending' || stepState.status === 'scheduled') {
+            if (!(await this.claimStepStatus(stepState.stepId, [
+                'pending',
+                'scheduled',
+            ]))) {
+                return null;
+            }
+            await this.setStepRunning(stepState.stepId);
+            return { ...stepState, status: 'running' };
+        }
+        return stepState;
+    }
+    /**
+     * Move a step to `running` only if it is still in one of `from`, reporting
+     * whether this caller is the one that moved it.
+     */
+    async claimStepStatus(stepId, from) {
+        const claimed = await this.steps.updateOne({ _id: stepId, status: { $in: from } }, { $set: { status: 'running', updatedAt: new Date() } });
+        return claimed.modifiedCount > 0;
+    }
     async getCompletedGraphState(runId) {
         const results = await this.steps
             .find({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/mongodb",
-  "version": "0.12.18",
+  "version": "0.12.20",
   "description": "MongoDB services for Pikku — workflow state, agent runs, secrets and channel stores",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
@@ -18,17 +18,17 @@
     "prepublishOnly": "yarn build"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.84"
+    "@pikku/core": "^0.12.90"
   },
   "dependencies": {
-    "mongodb": "^6.12.0"
+    "mongodb": "^7.5.0"
   },
   "devDependencies": {
-    "mongodb": "^6.12.0",
-    "mongodb-memory-server": "^10.4.0",
+    "mongodb": "^7.5.0",
+    "mongodb-memory-server": "^11.2.0",
     "typescript": "^6.0.3"
   },
   "exports": {
     ".": "./dist/src/index.js"
   }
-}
+}

package/src/index.ts

@@ -9,9 +9,6 @@ export { MongoDBAgentStorageService } from './mongodb-agent-storage-service.js'
 export { MongoDBAgentRunService } from './mongodb-agent-run-service.js'
 export { MongoDBSecretService } from './mongodb-secret-service.js'
 
-export type { WorkflowRunService } from '@pikku/core/ecosystem/workflow'
-export type {
-  AgentRunService,
-  AgentRunRow,
-} from '@pikku/core/ecosystem/agent'
+export type { WorkflowRunService } from '@pikku/core/workflow'
+export type { AgentRunService, AgentRunRow } from '@pikku/core/agent'
 export { MongoDBSessionStore } from './mongodb-session-store.js'

package/src/mongodb-agent-run-service.ts

@@ -1,8 +1,9 @@
-import type { AgentThread, AgentMessage } from '@pikku/core/agent'
 import type {
+  AgentThread,
+  AgentMessage,
   AgentRunRow,
   AgentRunService,
-} from '@pikku/core/ecosystem/agent'
+} from '@pikku/core/agent'
 import type { Db, Collection } from 'mongodb'
 
 // Owner ids are untrusted input to the regex, so metacharacters must not be

package/src/mongodb-agent-storage-service.ts

@@ -1,15 +1,15 @@
 import type {
-  AgentStorageService,
-  AgentRunStateService,
-  CreateRunInput,
-  SaveScoreInput,
-} from '@pikku/core/services'
-import type {
-  AgentThread,
   AgentMessage,
   AgentRunState,
+  AgentThread,
 } from '@pikku/core/agent'
 import type { AgentRunScore } from '@pikku/core/agent-scorer'
+import type {
+  AgentRunStateService,
+  AgentStorageService,
+  CreateRunInput,
+  SaveScoreInput,
+} from '@pikku/core/services'
 import type { Db, Collection } from 'mongodb'
 
 interface AgentThreadDoc {

package/src/mongodb-channel-store.ts

@@ -1,5 +1,5 @@
-import type { Channel } from '@pikku/core/channel'
 import { ChannelStore } from '@pikku/core/channel'
+import type { Channel } from '@pikku/core/channel'
 import type { Db, Collection } from 'mongodb'
 
 interface ChannelDoc {

package/src/mongodb-deployment-service.ts

@@ -1,11 +1,12 @@
-import { buildRemoteHeaders } from '@pikku/core/ecosystem/remote'
+import { buildRemoteHeaders } from '@pikku/core/remote'
 import type {
   DeploymentService,
   DeploymentServiceConfig,
   DeploymentConfig,
-} from '@pikku/core/ecosystem/services'
-import type { JWTService, SecretService } from '@pikku/core/services'
-import { getAllFunctionNames } from '@pikku/core/ecosystem/function'
+} from '@pikku/core/services'
+import type { JWTService } from '@pikku/core/services'
+import type { SecretService } from '@pikku/core/services'
+import { getAllFunctionNames } from '@pikku/core/function'
 import type { Db, Collection } from 'mongodb'
 
 interface DeploymentDoc {

package/src/mongodb-eventhub-store.ts

@@ -1,4 +1,4 @@
-import { EventHubStore } from '@pikku/core/ecosystem/channel'
+import { EventHubStore } from '@pikku/core/channel'
 import type { Db, Collection } from 'mongodb'
 
 interface ChannelSubscriptionDoc {

package/src/mongodb-secret-service.ts

@@ -1,13 +1,14 @@
-import { createSecretValue, isSecretValue, type SecretValue } from '@pikku/core'
-import type { SecretService, SecretValues } from '@pikku/core/services'
-import type { Db, Collection } from 'mongodb'
 import {
   deriveKEK,
-  generateKEKSalt,
-  envelopeEncrypt,
   envelopeDecrypt,
+  envelopeEncrypt,
   envelopeRewrap,
+  generateKEKSalt,
 } from '@pikku/core/crypto-utils'
+import { createSecretValue, isSecretValue } from '@pikku/core/classification'
+import type { SecretService, SecretValues } from '@pikku/core/services'
+import type { SecretValue } from '@pikku/core/classification'
+import type { Db, Collection } from 'mongodb'
 
 export interface MongoDBSecretServiceConfig {
   key: string

package/src/mongodb-services.test.ts

@@ -2,7 +2,7 @@ import { describe, test, before, after } from 'node:test'
 import assert from 'node:assert/strict'
 import { MongoClient, type Db } from 'mongodb'
 import { MongoMemoryServer } from 'mongodb-memory-server'
-import { defineServiceTests } from '@pikku/core/ecosystem/testing'
+import { defineServiceTests } from '@pikku/core/testing'
 
 import { MongoDBChannelStore } from './mongodb-channel-store.js'
 import { MongoDBEventHubStore } from './mongodb-eventhub-store.js'

package/src/mongodb-session-store.ts

@@ -1,5 +1,5 @@
-import type { CoreUserSession } from '@pikku/core'
 import type { SessionStore } from '@pikku/core/services'
+import type { CoreUserSession } from '@pikku/core/types'
 import type { Db, Collection } from 'mongodb'
 
 interface SessionDoc {

package/src/mongodb-workflow-run-service.ts

@@ -4,7 +4,7 @@ import type {
   StepState,
   WorkflowStatus,
   WorkflowRunService,
-} from '@pikku/core/ecosystem/workflow'
+} from '@pikku/core/workflow'
 import type { Db, Collection } from 'mongodb'
 
 interface WorkflowRunDoc {

package/src/mongodb-workflow-service.test.ts

@@ -3,6 +3,7 @@ import assert from 'node:assert/strict'
 import { MongoClient, type Db } from 'mongodb'
 import { MongoMemoryServer } from 'mongodb-memory-server'
 
+import type { StepState } from '@pikku/core/workflow'
 import { MongoDBWorkflowService } from './mongodb-workflow-service.js'
 
 let mongod: MongoMemoryServer
@@ -119,3 +120,119 @@ describe('a step transition reaches the history', () => {
     assert.equal(state.attemptCount, 2)
   })
 })
+
+/**
+ * Dispatch is at-least-once — the relay re-dispatches a step it believes was
+ * dropped, and a queue can redeliver a job it already handed out — so the claim
+ * is the only thing standing between a duplicate dispatch and a second
+ * execution of a side-effecting step.
+ */
+describe('claiming a step for execution', () => {
+  const claim = (runId: string, stepName: string, rpcName = 'rpc.fn') =>
+    (ws as any).claimStepForExecution(
+      runId,
+      stepName,
+      rpcName
+    ) as Promise<StepState | null>
+
+  const seedRun = () =>
+    ws.createRun('flow', {}, false, 'hash', { type: 'test' } as any)
+
+  test('two dispatches racing for the same pending step: exactly one wins', async () => {
+    const runId = await seedRun()
+    await ws.insertStepState(runId, 's1', 'rpc.fn', { x: 1 })
+
+    const claims = await Promise.all([claim(runId, 's1'), claim(runId, 's1')])
+    const winners = claims.filter((c) => c !== null)
+
+    assert.equal(
+      winners.length,
+      1,
+      `both dispatches claimed the step, so a side-effecting step would run twice: ${JSON.stringify(claims)}`
+    )
+    assert.equal((await ws.getStepState(runId, 's1')).status, 'running')
+  })
+
+  test('two dispatches racing to retry the same failed step: exactly one wins', async () => {
+    const runId = await seedRun()
+    const step = await ws.insertStepState(runId, 's1', 'rpc.fn', { x: 1 })
+    await ws.setStepRunning(step.stepId)
+    await ws.setStepError(step.stepId, new Error('boom'))
+
+    const claims = await Promise.all([claim(runId, 's1'), claim(runId, 's1')])
+    const winners = claims.filter((c) => c !== null)
+
+    assert.equal(
+      winners.length,
+      1,
+      `both dispatches started a retry, so the failed step would be retried twice concurrently: ${JSON.stringify(claims)}`
+    )
+    assert.equal(
+      (await ws.getStepState(runId, 's1')).attemptCount,
+      2,
+      'the retry raced itself and burned more than one attempt'
+    )
+  })
+
+  test('two dispatches racing for the same scheduled step: exactly one wins', async () => {
+    const runId = await seedRun()
+    const step = await ws.insertStepState(runId, 's1', 'rpc.fn', { x: 1 })
+    await ws.setStepScheduled(step.stepId)
+
+    const claims = await Promise.all([claim(runId, 's1'), claim(runId, 's1')])
+    const winners = claims.filter((c) => c !== null)
+
+    assert.equal(
+      winners.length,
+      1,
+      `both dispatches claimed the queued step, so a redelivered job would run it a second time: ${JSON.stringify(claims)}`
+    )
+    assert.equal((await ws.getStepState(runId, 's1')).status, 'running')
+  })
+
+  test('a step already claimed is not claimable again', async () => {
+    const runId = await seedRun()
+    await ws.insertStepState(runId, 's1', 'rpc.fn', { x: 1 })
+
+    assert.notEqual(await claim(runId, 's1'), null)
+    assert.equal(
+      await claim(runId, 's1'),
+      null,
+      'a redelivered job re-claimed a step that is already running'
+    )
+  })
+
+  test('a succeeded step is not claimable', async () => {
+    const runId = await seedRun()
+    const step = await ws.insertStepState(runId, 's1', 'rpc.fn', { x: 1 })
+    await ws.setStepRunning(step.stepId)
+    await ws.setStepResult(step.stepId, { ok: true })
+
+    assert.equal(await claim(runId, 's1'), null)
+  })
+
+  test('a claim that fails releases the step, so it is retryable', async () => {
+    const runId = await seedRun()
+    const step = await ws.insertStepState(runId, 's1', 'rpc.fn', { x: 1 })
+
+    assert.notEqual(await claim(runId, 's1'), null)
+    await ws.setStepError(step.stepId, new Error('boom'))
+
+    const retry = await claim(runId, 's1')
+    assert.notEqual(
+      retry,
+      null,
+      'the failed step stayed claimed, so it can never be retried'
+    )
+    assert.equal(retry?.status, 'running')
+    assert.equal(retry?.attemptCount, 2)
+  })
+
+  test('a claim for a different function than the step was dispatched with is refused', async () => {
+    const runId = await seedRun()
+    await ws.insertStepState(runId, 's1', 'rpc.fn', { x: 1 })
+
+    await assert.rejects(() => claim(runId, 's1', 'rpc.other'))
+    assert.equal((await ws.getStepState(runId, 's1')).status, 'pending')
+  })
+})

package/src/mongodb-workflow-service.ts

@@ -1,6 +1,18 @@
-import type { SerializedError } from '@pikku/core/ecosystem/types'
-import { PikkuWorkflowService } from '@pikku/core/workflow'
-import type { WorkflowPlannedStep, WorkflowQueueOptions, WorkflowRun, WorkflowRunWire, StepState, StepStatus, WorkflowStatus, WorkflowVersionStatus } from '@pikku/core/ecosystem/workflow'
+import type { SerializedError } from '@pikku/core/errors'
+import {
+  PikkuWorkflowService,
+  WorkflowStepFunctionMismatchError,
+} from '@pikku/core/workflow'
+import type {
+  WorkflowPlannedStep,
+  WorkflowQueueOptions,
+  WorkflowRun,
+  WorkflowRunWire,
+  StepState,
+  StepStatus,
+  WorkflowStatus,
+  WorkflowVersionStatus,
+} from '@pikku/core/workflow'
 import type { Db, Collection } from 'mongodb'
 import { MongoDBWorkflowRunService } from './mongodb-workflow-run-service.js'
 
@@ -435,6 +447,12 @@ export class MongoDBWorkflowService extends PikkuWorkflowService {
     return fn()
   }
 
+  /**
+   * A pass-through: MongoDB has no advisory-lock primitive to build one on.
+   * The one decision that must exclude — claiming a step to execute it — is
+   * made by `claimStepForExecution` below as a single conditional write, which
+   * needs no lock to be exclusive.
+   */
   async withStepLock<T>(
     _runId: string,
     _stepName: string,
@@ -443,6 +461,74 @@ export class MongoDBWorkflowService extends PikkuWorkflowService {
     return fn()
   }
 
+  /**
+   * Claim the step with a status-guarded update and read the modified count:
+   * a single-document update is atomic in MongoDB, so two dispatches racing for
+   * the same step cannot both proceed.
+   *
+   * This replaces the read-then-write the base engine does under
+   * `withStepLock`, which excludes nothing here — the lock above is a
+   * pass-through. The winner then goes through the ordinary transition methods,
+   * so history rows see exactly what they saw before.
+   */
+  protected override async claimStepForExecution(
+    runId: string,
+    stepName: string,
+    rpcName: string
+  ): Promise<StepState | null> {
+    const stepState = await this.getStepState(runId, stepName)
+
+    // knowledge: decisions/security/a-step-runs-the-function-the-workflow-dispatched-it-with.md
+    if (
+      stepState.rpcName !== undefined &&
+      stepState.rpcName !== (rpcName ?? null)
+    ) {
+      throw new WorkflowStepFunctionMismatchError(runId, stepName)
+    }
+
+    if (stepState.status === 'succeeded' || stepState.status === 'running') {
+      return null
+    }
+
+    if (stepState.status === 'failed') {
+      if (!(await this.claimStepStatus(stepState.stepId, ['failed']))) {
+        return null
+      }
+      return this.createRetryAttempt(stepState.stepId, 'running')
+    }
+
+    if (stepState.status === 'pending' || stepState.status === 'scheduled') {
+      if (
+        !(await this.claimStepStatus(stepState.stepId, [
+          'pending',
+          'scheduled',
+        ]))
+      ) {
+        return null
+      }
+      await this.setStepRunning(stepState.stepId)
+      return { ...stepState, status: 'running' }
+    }
+
+    return stepState
+  }
+
+  /**
+   * Move a step to `running` only if it is still in one of `from`, reporting
+   * whether this caller is the one that moved it.
+   */
+  private async claimStepStatus(
+    stepId: string,
+    from: StepStatus[]
+  ): Promise<boolean> {
+    const claimed = await this.steps.updateOne(
+      { _id: stepId, status: { $in: from } },
+      { $set: { status: 'running', updatedAt: new Date() } }
+    )
+
+    return claimed.modifiedCount > 0
+  }
+
   async getCompletedGraphState(runId: string): Promise<{
     completedNodeIds: string[]
     failedNodeIds: string[]

package/dist/src/mongodb-ai-storage-service.d.ts

@@ -1,45 +0,0 @@
-import type { AIStorageService, AIRunStateService, CreateRunInput, SaveScoreInput } from '@pikku/core/services';
-import type { AIThread, AIMessage, AgentRunState } from '@pikku/core/ai-agent';
-import type { AIRunScore } from '@pikku/core/ai-scorer';
-import type { Db } from 'mongodb';
-export declare class MongoDBAIStorageService implements AIStorageService, AIRunStateService {
-    private db;
-    private initialized;
-    private threads;
-    private aiMessages;
-    private toolCalls;
-    private workingMemory;
-    private aiRuns;
-    private aiRunScores;
-    constructor(db: Db);
-    init(): Promise<void>;
-    createThread(resourceId: string, options?: {
-        threadId?: string;
-        title?: string;
-        metadata?: Record<string, unknown>;
-    }): Promise<AIThread>;
-    getThread(threadId: string): Promise<AIThread>;
-    getThreads(resourceId: string): Promise<AIThread[]>;
-    deleteThread(threadId: string): Promise<void>;
-    getMessages(threadId: string, options?: {
-        lastN?: number;
-        cursor?: string;
-    }): Promise<AIMessage[]>;
-    saveMessages(threadId: string, messages: AIMessage[]): Promise<void>;
-    getWorkingMemory(id: string, scope: 'resource' | 'thread'): Promise<Record<string, unknown> | null>;
-    saveWorkingMemory(id: string, scope: 'resource' | 'thread', data: Record<string, unknown>): Promise<void>;
-    createRun(run: CreateRunInput): Promise<string>;
-    updateRun(runId: string, updates: Partial<AgentRunState>): Promise<void>;
-    getRun(runId: string): Promise<AgentRunState | null>;
-    getRunsByThread(threadId: string): Promise<AgentRunState[]>;
-    private setApprovals;
-    private mapRunRow;
-    findRunByToolCallId(toolCallId: string): Promise<{
-        run: AgentRunState;
-        approval: NonNullable<AgentRunState['pendingApprovals']>[number];
-    } | null>;
-    resolveApproval(toolCallId: string, status: 'approved' | 'denied'): Promise<boolean>;
-    saveScore(score: SaveScoreInput): Promise<void>;
-    getScores(runId: string): Promise<AIRunScore[]>;
-    close(): Promise<void>;
-}

package/dist/src/mongodb-ai-storage-service.js

@@ -1,438 +0,0 @@
-export class MongoDBAIStorageService {
-    db;
-    initialized = false;
-    threads;
-    aiMessages;
-    toolCalls;
-    workingMemory;
-    aiRuns;
-    aiRunScores;
-    constructor(db) {
-        this.db = db;
-    }
-    async init() {
-        if (this.initialized)
-            return;
-        this.threads = this.db.collection('ai_threads');
-        this.aiMessages = this.db.collection('ai_message');
-        this.toolCalls = this.db.collection('ai_tool_call');
-        this.workingMemory =
-            this.db.collection('ai_working_memory');
-        this.aiRuns = this.db.collection('ai_run');
-        this.aiRunScores = this.db.collection('ai_run_score');
-        await this.threads.createIndex({ resourceId: 1 });
-        await this.aiMessages.createIndex({ threadId: 1, createdAt: 1 });
-        await this.toolCalls.createIndex({ threadId: 1 });
-        await this.toolCalls.createIndex({ messageId: 1 });
-        await this.workingMemory.createIndex({ id: 1, scope: 1 }, { unique: true });
-        await this.aiRuns.createIndex({ threadId: 1, createdAt: 1 });
-        await this.aiRunScores.createIndex({ runId: 1, createdAt: 1 });
-        this.initialized = true;
-    }
-    async createThread(resourceId, options) {
-        const id = options?.threadId ?? crypto.randomUUID();
-        const now = new Date();
-        await this.threads.insertOne({
-            _id: id,
-            resourceId,
-            title: options?.title ?? null,
-            metadata: options?.metadata ?? null,
-            createdAt: now,
-            updatedAt: now,
-        });
-        return {
-            id,
-            resourceId,
-            title: options?.title,
-            metadata: options?.metadata,
-            createdAt: now,
-            updatedAt: now,
-        };
-    }
-    async getThread(threadId) {
-        const row = await this.threads.findOne({ _id: threadId });
-        if (!row) {
-            throw new Error(`Thread not found: ${threadId}`);
-        }
-        return {
-            id: row._id,
-            resourceId: row.resourceId,
-            title: row.title ?? undefined,
-            metadata: row.metadata ?? undefined,
-            createdAt: new Date(row.createdAt),
-            updatedAt: new Date(row.updatedAt),
-        };
-    }
-    async getThreads(resourceId) {
-        const result = await this.threads
-            .find({ resourceId })
-            .sort({ updatedAt: -1 })
-            .toArray();
-        return result.map((row) => ({
-            id: row._id,
-            resourceId: row.resourceId,
-            title: row.title ?? undefined,
-            metadata: row.metadata ?? undefined,
-            createdAt: new Date(row.createdAt),
-            updatedAt: new Date(row.updatedAt),
-        }));
-    }
-    async deleteThread(threadId) {
-        await this.toolCalls.deleteMany({ threadId });
-        await this.aiMessages.deleteMany({ threadId });
-        await this.aiRuns.deleteMany({ threadId });
-        await this.threads.deleteOne({ _id: threadId });
-    }
-    async getMessages(threadId, options) {
-        let filter = { threadId };
-        if (options?.cursor) {
-            const cursorRow = await this.aiMessages.findOne({ _id: options.cursor });
-            if (cursorRow) {
-                filter.createdAt = { $lt: cursorRow.createdAt };
-            }
-        }
-        let msgResult;
-        if (options?.cursor || options?.lastN) {
-            const innerResult = await this.aiMessages
-                .find(filter)
-                .sort({ createdAt: -1 })
-                .limit(options?.lastN ?? 50)
-                .toArray();
-            innerResult.reverse();
-            msgResult = innerResult;
-        }
-        else {
-            msgResult = await this.aiMessages
-                .find(filter)
-                .sort({ createdAt: 1 })
-                .toArray();
-        }
-        const tcResult = await this.toolCalls
-            .find({ threadId })
-            .sort({ createdAt: 1 })
-            .toArray();
-        const tcByMessage = new Map();
-        for (const tc of tcResult) {
-            const msgId = tc.messageId;
-            if (!tcByMessage.has(msgId))
-                tcByMessage.set(msgId, []);
-            tcByMessage.get(msgId).push(tc);
-        }
-        const messages = [];
-        for (const row of msgResult) {
-            let parsedContent = row.content ?? undefined;
-            if (typeof row.content === 'string') {
-                try {
-                    const parsed = JSON.parse(row.content);
-                    if (Array.isArray(parsed)) {
-                        parsedContent = parsed;
-                    }
-                    else if (typeof parsed === 'string') {
-                        parsedContent = parsed;
-                    }
-                }
-                catch {
-                    // Not JSON, use raw string
-                }
-            }
-            const msg = {
-                id: row._id,
-                role: row.role,
-                content: parsedContent,
-                createdAt: new Date(row.createdAt),
-            };
-            const tcs = tcByMessage.get(msg.id);
-            if (tcs?.length) {
-                msg.toolCalls = tcs.map((tc) => ({
-                    id: tc._id,
-                    name: tc.toolName,
-                    args: tc.args,
-                }));
-                const completed = tcs.filter((tc) => tc.result != null);
-                if (completed.length) {
-                    messages.push(msg);
-                    messages.push({
-                        id: `tool-results-${msg.id}`,
-                        role: 'tool',
-                        toolResults: completed.map((tc) => ({
-                            id: tc._id,
-                            name: tc.toolName,
-                            result: tc.result,
-                        })),
-                        createdAt: msg.createdAt,
-                    });
-                    continue;
-                }
-            }
-            messages.push(msg);
-        }
-        return messages;
-    }
-    async saveMessages(threadId, messages) {
-        if (messages.length === 0)
-            return;
-        const toolMessages = messages.filter((m) => m.role === 'tool');
-        const nonToolMessages = messages.filter((m) => m.role !== 'tool');
-        if (nonToolMessages.length > 0) {
-            await this.aiMessages.insertMany(nonToolMessages.map((msg) => ({
-                _id: msg.id,
-                threadId,
-                role: msg.role,
-                content: msg.content != null ? JSON.stringify(msg.content) : null,
-                createdAt: msg.createdAt ?? new Date(),
-            })));
-        }
-        const toolCallDocs = nonToolMessages.flatMap((msg) => msg.toolCalls?.map((tc) => ({ ...tc, messageId: msg.id })) ?? []);
-        if (toolCallDocs.length > 0) {
-            await this.toolCalls.insertMany(toolCallDocs.map((tc) => ({
-                _id: tc.id,
-                threadId,
-                messageId: tc.messageId,
-                runId: null,
-                toolName: tc.name,
-                args: tc.args,
-                result: null,
-                approvalStatus: null,
-                approvalType: null,
-                agentRunId: null,
-                displayToolName: null,
-                displayArgs: null,
-                createdAt: new Date(),
-            })));
-        }
-        for (const toolMsg of toolMessages) {
-            if (!toolMsg.toolResults)
-                continue;
-            for (const tr of toolMsg.toolResults) {
-                await this.toolCalls.updateOne({ _id: tr.id }, { $set: { result: tr.result } });
-            }
-        }
-        await this.threads.updateOne({ _id: threadId }, { $set: { updatedAt: new Date() } });
-    }
-    async getWorkingMemory(id, scope) {
-        const row = await this.workingMemory.findOne({ id, scope });
-        if (!row)
-            return null;
-        return row.data;
-    }
-    async saveWorkingMemory(id, scope, data) {
-        await this.workingMemory.updateOne({ id, scope }, {
-            $set: {
-                data,
-                updatedAt: new Date(),
-            },
-            $setOnInsert: {
-                id,
-                scope,
-            },
-        }, { upsert: true });
-    }
-    async createRun(run) {
-        const runId = crypto.randomUUID();
-        await this.aiRuns.insertOne({
-            _id: runId,
-            agentName: run.agentName,
-            threadId: run.threadId,
-            resourceId: run.resourceId,
-            status: run.status,
-            errorMessage: run.errorMessage ?? null,
-            suspendReason: run.suspendReason ?? null,
-            missingRpcs: run.missingRpcs ?? null,
-            usageInputTokens: run.usage.inputTokens,
-            usageOutputTokens: run.usage.outputTokens,
-            usageModel: run.usage.model,
-            createdAt: run.createdAt,
-            updatedAt: run.updatedAt,
-        });
-        if (run.pendingApprovals?.length) {
-            await this.setApprovals(runId, run.pendingApprovals);
-        }
-        return runId;
-    }
-    async updateRun(runId, updates) {
-        const setValues = { updatedAt: new Date() };
-        if (updates.status !== undefined) {
-            setValues.status = updates.status;
-        }
-        if (updates.errorMessage !== undefined) {
-            setValues.errorMessage = updates.errorMessage;
-        }
-        if (updates.suspendReason !== undefined) {
-            setValues.suspendReason = updates.suspendReason;
-        }
-        if (updates.missingRpcs !== undefined) {
-            setValues.missingRpcs = updates.missingRpcs;
-        }
-        if (updates.usage !== undefined) {
-            setValues.usageInputTokens = updates.usage.inputTokens;
-            setValues.usageOutputTokens = updates.usage.outputTokens;
-            setValues.usageModel = updates.usage.model;
-        }
-        await this.aiRuns.updateOne({ _id: runId }, { $set: setValues });
-        if (updates.pendingApprovals !== undefined) {
-            await this.toolCalls.updateMany({ runId, approvalStatus: { $ne: null } }, {
-                $set: {
-                    approvalStatus: null,
-                    runId: null,
-                    approvalType: null,
-                    agentRunId: null,
-                    displayToolName: null,
-                    displayArgs: null,
-                },
-            });
-            if (updates.pendingApprovals.length) {
-                await this.setApprovals(runId, updates.pendingApprovals);
-            }
-        }
-    }
-    async getRun(runId) {
-        const row = await this.aiRuns.findOne({ _id: runId });
-        if (!row)
-            return null;
-        const approvals = await this.toolCalls
-            .find({ runId, approvalStatus: 'pending' })
-            .toArray();
-        return this.mapRunRow(row, approvals);
-    }
-    async getRunsByThread(threadId) {
-        const result = await this.aiRuns
-            .find({ threadId })
-            .sort({ createdAt: -1 })
-            .toArray();
-        const runs = [];
-        for (const row of result) {
-            const approvals = await this.toolCalls
-                .find({ runId: row._id, approvalStatus: 'pending' })
-                .toArray();
-            runs.push(this.mapRunRow(row, approvals));
-        }
-        return runs;
-    }
-    async setApprovals(runId, approvals) {
-        for (const a of approvals) {
-            if (a.type === 'agent-call') {
-                await this.toolCalls.updateOne({ _id: a.toolCallId }, {
-                    $set: {
-                        approvalStatus: 'pending',
-                        runId,
-                        approvalType: 'agent-call',
-                        agentRunId: a.agentRunId,
-                        displayToolName: a.displayToolName,
-                        displayArgs: a.displayArgs,
-                    },
-                });
-            }
-            else {
-                await this.toolCalls.updateOne({ _id: a.toolCallId }, {
-                    $set: {
-                        approvalStatus: 'pending',
-                        runId,
-                        approvalType: 'tool-call',
-                    },
-                });
-            }
-        }
-    }
-    mapRunRow(row, approvalRows) {
-        const pendingApprovals = approvalRows?.length
-            ? approvalRows.map((a) => {
-                if (a.approvalType === 'agent-call') {
-                    return {
-                        type: 'agent-call',
-                        toolCallId: a._id,
-                        agentName: a.toolName,
-                        agentRunId: a.agentRunId,
-                        displayToolName: a.displayToolName,
-                        displayArgs: a.displayArgs,
-                    };
-                }
-                return {
-                    type: 'tool-call',
-                    toolCallId: a._id,
-                    toolName: a.toolName,
-                    args: a.args,
-                };
-            })
-            : undefined;
-        return {
-            runId: row._id,
-            agentName: row.agentName,
-            threadId: row.threadId,
-            resourceId: row.resourceId,
-            status: row.status,
-            errorMessage: row.errorMessage ?? undefined,
-            suspendReason: row.suspendReason,
-            missingRpcs: row.missingRpcs ?? undefined,
-            pendingApprovals,
-            usage: {
-                inputTokens: Number(row.usageInputTokens),
-                outputTokens: Number(row.usageOutputTokens),
-                model: row.usageModel,
-            },
-            createdAt: new Date(row.createdAt),
-            updatedAt: new Date(row.updatedAt),
-        };
-    }
-    async findRunByToolCallId(toolCallId) {
-        const tc = await this.toolCalls.findOne({
-            _id: toolCallId,
-            approvalStatus: 'pending',
-        });
-        if (!tc || !tc.runId)
-            return null;
-        const run = await this.getRun(tc.runId);
-        if (!run)
-            return null;
-        let approval;
-        if (tc.approvalType === 'agent-call') {
-            approval = {
-                type: 'agent-call',
-                toolCallId: tc._id,
-                agentName: tc.toolName,
-                agentRunId: tc.agentRunId,
-                displayToolName: tc.displayToolName,
-                displayArgs: tc.displayArgs,
-            };
-        }
-        else {
-            approval = {
-                type: 'tool-call',
-                toolCallId: tc._id,
-                toolName: tc.toolName,
-                args: tc.args,
-            };
-        }
-        return { run, approval };
-    }
-    async resolveApproval(toolCallId, status) {
-        // Only the caller that moves the tool call off 'pending' has claimed it.
-        const result = await this.toolCalls.updateOne({ _id: toolCallId, approvalStatus: 'pending' }, { $set: { approvalStatus: status } });
-        return result.modifiedCount > 0;
-    }
-    async saveScore(score) {
-        await this.aiRunScores.insertOne({
-            _id: crypto.randomUUID(),
-            runId: score.runId,
-            scorerName: score.scorerName,
-            score: score.score,
-            reason: score.reason ?? null,
-            metadata: score.metadata ?? null,
-            createdAt: new Date(),
-        });
-    }
-    async getScores(runId) {
-        const rows = await this.aiRunScores
-            .find({ runId })
-            .sort({ createdAt: 1 })
-            .toArray();
-        return rows.map((row) => ({
-            runId: row.runId,
-            scorerName: row.scorerName,
-            score: row.score,
-            reason: row.reason ?? undefined,
-            metadata: row.metadata ?? undefined,
-            createdAt: row.createdAt,
-        }));
-    }
-    async close() { }
-}