@vercel/factory 0.0.17 → 0.0.18

package/dist/work-triage/find-existing-work.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"find-existing-work.mjs","names":[],"sources":["../../src/work-triage/find-existing-work.ts"],"sourcesContent":["import type { Change } from \"../schema/change\";\nimport type { Task } from \"../schema/task\";\nimport type { FactoryStores } from \"../store/engine\";\nimport type { OpenPullRequest } from \"../pull-requests/contracts\";\nimport type { RepositoryId } from \"../schema/id\";\nimport type { RepositorySlug } from \"../schema/repository\";\n\n/** Provider-neutral readers used to discover work already in progress. */\nexport interface ExistingWorkLookupOptions {\n  listOpenPullRequests: (repository: RepositorySlug) => Promise<readonly OpenPullRequest[]>;\n}\n\n/** Stores, repository identity, and provider lookup used for one existing-work query. */\nexport interface FindExistingWorkInput extends ExistingWorkLookupOptions {\n  stores: Pick<FactoryStores, \"changes\" | \"repositories\" | \"tasks\">;\n  repositoryId: RepositoryId;\n}\n\n/** The refusal or existing pull requests, Changes, and active Tasks found during triage. */\nexport type ExistingWorkLookupResult =\n  | { found: false; reasonCode: \"repository_not_found\"; reason: string }\n  | {\n      found: true;\n      openPullRequests: readonly OpenPullRequest[];\n      openChanges: readonly Change[];\n      activeTasks: readonly Task[];\n    };\n\nconst openChangeStates: ReadonlySet<Change[\"state\"]> = new Set([\"verifying\", \"ready\"]);\nconst activeTaskStates: ReadonlySet<Task[\"state\"]> = new Set([\"queued\", \"running\", \"needs_human\"]);\n\n/** Find open pull requests, Changes, and active Tasks for one repository. */\nexport async function findExistingWork(\n  input: FindExistingWorkInput,\n): Promise<ExistingWorkLookupResult> {\n  const repository = await input.stores.repositories.get(input.repositoryId);\n  if (repository === null) {\n    return {\n      found: false,\n      reasonCode: \"repository_not_found\",\n      reason: `repository ${input.repositoryId} does not exist`,\n    };\n  }\n  const [openPullRequests, changes, tasks] = await Promise.all([\n    input.listOpenPullRequests(repository.slug),\n    input.stores.changes.list(),\n    input.stores.tasks.list(),\n  ]);\n  return {\n    found: true,\n    openPullRequests,\n    openChanges: changes.filter(\n      (change) => change.repositoryId === input.repositoryId && openChangeStates.has(change.state),\n    ),\n    activeTasks: tasks.filter(\n      (task) => task.repositoryIds.includes(input.repositoryId) && activeTaskStates.has(task.state),\n    ),\n  };\n}\n"],"mappings":";AA4BA,MAAM,mCAAiD,IAAI,IAAI,CAAC,aAAa,OAAO,CAAC;AACrF,MAAM,mCAA+C,IAAI,IAAI;CAAC;CAAU;CAAW;AAAa,CAAC;;AAGjG,eAAsB,iBACpB,OACmC;CACnC,MAAM,aAAa,MAAM,MAAM,OAAO,aAAa,IAAI,MAAM,YAAY;CACzE,IAAI,eAAe,MACjB,OAAO;EACL,OAAO;EACP,YAAY;EACZ,QAAQ,cAAc,MAAM,aAAa;CAC3C;CAEF,MAAM,CAAC,kBAAkB,SAAS,SAAS,MAAM,QAAQ,IAAI;EAC3D,MAAM,qBAAqB,WAAW,IAAI;EAC1C,MAAM,OAAO,QAAQ,KAAK;EAC1B,MAAM,OAAO,MAAM,KAAK;CAC1B,CAAC;CACD,OAAO;EACL,OAAO;EACP;EACA,aAAa,QAAQ,QAClB,WAAW,OAAO,iBAAiB,MAAM,gBAAgB,iBAAiB,IAAI,OAAO,KAAK,CAC7F;EACA,aAAa,MAAM,QAChB,SAAS,KAAK,cAAc,SAAS,MAAM,YAAY,KAAK,iBAAiB,IAAI,KAAK,KAAK,CAC9F;CACF;AACF"}
+{"version":3,"file":"find-existing-work.mjs","names":[],"sources":["../../src/work-triage/find-existing-work.ts"],"sourcesContent":["import { collectFactoryRecords } from \"../store/iterate\";\nimport type { Change } from \"../schema/change\";\nimport type { Task } from \"../schema/task\";\nimport type { FactoryStores } from \"../store/engine\";\nimport type { OpenPullRequest } from \"../pull-requests/contracts\";\nimport type { RepositoryId } from \"../schema/id\";\nimport type { RepositorySlug } from \"../schema/repository\";\n\n/** Provider-neutral readers used to discover work already in progress. */\nexport interface ExistingWorkLookupOptions {\n  listOpenPullRequests: (repository: RepositorySlug) => Promise<readonly OpenPullRequest[]>;\n}\n\n/** Stores, repository identity, and provider lookup used for one existing-work query. */\nexport interface FindExistingWorkInput extends ExistingWorkLookupOptions {\n  stores: Pick<FactoryStores, \"changes\" | \"repositories\" | \"tasks\">;\n  repositoryId: RepositoryId;\n}\n\n/** The refusal or existing pull requests, Changes, and active Tasks found during triage. */\nexport type ExistingWorkLookupResult =\n  | { found: false; reasonCode: \"repository_not_found\"; reason: string }\n  | {\n      found: true;\n      openPullRequests: readonly OpenPullRequest[];\n      openChanges: readonly Change[];\n      activeTasks: readonly Task[];\n    };\n\nconst openChangeStates: ReadonlySet<Change[\"state\"]> = new Set([\"verifying\", \"ready\"]);\nconst activeTaskStates: ReadonlySet<Task[\"state\"]> = new Set([\"queued\", \"running\", \"needs_human\"]);\n\n/** Find open pull requests, Changes, and active Tasks for one repository. */\nexport async function findExistingWork(\n  input: FindExistingWorkInput,\n): Promise<ExistingWorkLookupResult> {\n  const repository = await input.stores.repositories.get(input.repositoryId);\n  if (repository === null) {\n    return {\n      found: false,\n      reasonCode: \"repository_not_found\",\n      reason: `repository ${input.repositoryId} does not exist`,\n    };\n  }\n  const [openPullRequests, changes, tasks] = await Promise.all([\n    input.listOpenPullRequests(repository.slug),\n    collectFactoryRecords(input.stores.changes.list, {\n      limit: 100,\n      match: [...openChangeStates].map((state) => ({ repositoryId: input.repositoryId, state })),\n    }),\n    collectFactoryRecords(input.stores.tasks.list, {\n      limit: 100,\n      match: { repositoryIds: [input.repositoryId] },\n    }),\n  ]);\n  return {\n    found: true,\n    openPullRequests,\n    openChanges: changes.filter(\n      (change) => change.repositoryId === input.repositoryId && openChangeStates.has(change.state),\n    ),\n    activeTasks: tasks.filter(\n      (task) => task.repositoryIds.includes(input.repositoryId) && activeTaskStates.has(task.state),\n    ),\n  };\n}\n"],"mappings":";;AA6BA,MAAM,mCAAiD,IAAI,IAAI,CAAC,aAAa,OAAO,CAAC;AACrF,MAAM,mCAA+C,IAAI,IAAI;CAAC;CAAU;CAAW;AAAa,CAAC;;AAGjG,eAAsB,iBACpB,OACmC;CACnC,MAAM,aAAa,MAAM,MAAM,OAAO,aAAa,IAAI,MAAM,YAAY;CACzE,IAAI,eAAe,MACjB,OAAO;EACL,OAAO;EACP,YAAY;EACZ,QAAQ,cAAc,MAAM,aAAa;CAC3C;CAEF,MAAM,CAAC,kBAAkB,SAAS,SAAS,MAAM,QAAQ,IAAI;EAC3D,MAAM,qBAAqB,WAAW,IAAI;EAC1C,sBAAsB,MAAM,OAAO,QAAQ,MAAM;GAC/C,OAAO;GACP,OAAO,CAAC,GAAG,gBAAgB,CAAC,CAAC,KAAK,WAAW;IAAE,cAAc,MAAM;IAAc;GAAM,EAAE;EAC3F,CAAC;EACD,sBAAsB,MAAM,OAAO,MAAM,MAAM;GAC7C,OAAO;GACP,OAAO,EAAE,eAAe,CAAC,MAAM,YAAY,EAAE;EAC/C,CAAC;CACH,CAAC;CACD,OAAO;EACL,OAAO;EACP;EACA,aAAa,QAAQ,QAClB,WAAW,OAAO,iBAAiB,MAAM,gBAAgB,iBAAiB,IAAI,OAAO,KAAK,CAC7F;EACA,aAAa,MAAM,QAChB,SAAS,KAAK,cAAc,SAAS,MAAM,YAAY,KAAK,iBAAiB,IAAI,KAAK,KAAK,CAC9F;CACF;AACF"}

package/docs/index.md

@@ -32,6 +32,10 @@ lifecycle recovery, and inter-Task communication.
 
 ## Behavioral contracts
 
+For the fresh-data storage transition, see [indexed Postgres persistence](recipes/postgres-indexed-storage.md)
+and [the indexed write engine](recipes/postgres-indexed-engine.md). The indexed engine exposes
+bounded source queries and is not a drop-in replacement for the catalog-based reference runtime.
+
 The installed declarations are the source of truth for operation semantics. In particular:
 
 - `createStores` and `FactoryStores.tasks` document persistence, deduplication, transition fences,

package/docs/recipes/persistence-recovery.md

@@ -172,17 +172,21 @@ async function verify() {
       throw new Error("Expected the completed Task to survive another restart");
     }
     const output = greetingWorkflow.output.parse(task.workResult?.output);
-    const succeededReceiptsBefore = (await stores.receipts.list()).filter(
-      (receipt) => receipt.taskId === task.id && receipt.state === "succeeded",
-    ).length;
+    const succeededReceiptsBefore = (
+      await stores.receipts
+        .list({ limit: 100, match: { taskId: task.id } })
+        .then((page) => page.items)
+    ).filter((receipt) => receipt.taskId === task.id && receipt.state === "succeeded").length;
     const replayed = await stores.work.completeWorkflow({
       task: { taskId: task.id, attempt: task.attempt },
       workflow: greetingWorkflow.binding,
       output,
     });
-    const succeededReceiptsAfterReplay = (await stores.receipts.list()).filter(
-      (receipt) => receipt.taskId === task.id && receipt.state === "succeeded",
-    ).length;
+    const succeededReceiptsAfterReplay = (
+      await stores.receipts
+        .list({ limit: 100, match: { taskId: task.id } })
+        .then((page) => page.items)
+    ).filter((receipt) => receipt.taskId === task.id && receipt.state === "succeeded").length;
 
     let conflictingOutputRejected = false;
     try {
@@ -194,9 +198,11 @@ async function verify() {
     } catch {
       conflictingOutputRejected = true;
     }
-    const succeededReceiptCount = (await stores.receipts.list()).filter(
-      (receipt) => receipt.taskId === task.id && receipt.state === "succeeded",
-    ).length;
+    const succeededReceiptCount = (
+      await stores.receipts
+        .list({ limit: 100, match: { taskId: task.id } })
+        .then((page) => page.items)
+    ).filter((receipt) => receipt.taskId === task.id && receipt.state === "succeeded").length;
     if (
       replayed.state !== "succeeded" ||
       replayed.workResult?.completedAt !== task.workResult?.completedAt ||

package/docs/recipes/postgres-indexed-engine.md

@@ -0,0 +1,108 @@
+# Indexed Factory writes
+
+`createIndexedStores` connects Factory's validating engine to `IndexedStore`. Task admission,
+transitions, receipts, sessions, Changes, transcripts, graph recovery, messages, outbox, and
+workflow records use the same structured backend. Each canonical write commits its compact
+source summary and membership counts atomically. The engine stops writing catalog shards and
+Task-route snapshots. Image bytes use a separately supplied object store.
+
+The reference application, scaffold, HTTP API, dispatch, and recovery readers use this engine.
+Canonical `.list(query)` methods require a page size and return `{ items, nextCursor }`.
+The optional `conversations` configuration supplies application routes, continuation agent,
+and the workspace owner for automatic Task attachment.
+There is no backfill, dual write, or Blob fallback in the indexed engine.
+
+## Queries and counts
+
+`indexes.query` accepts one typed scope and a required page size of 1–100. `indexes.count` reads
+the maintained count for that same scope. Pages contain validated source summaries and versions;
+they do not hydrate canonical records. Use the existing entity `get(id)` methods for point reads.
+
+| Source           | Additional scopes beyond all records and repository membership                                               |
+| ---------------- | ------------------------------------------------------------------------------------------------------------ |
+| Task             | State (optionally repository), root graph, exact reply destination, source attention (optionally repository) |
+| Session          | Owner (optionally repository), Task binding, exact execution                                                 |
+| External session | Owner (optionally repository), exact execution                                                               |
+| Change           | State (optionally repository), creating Task, source attention (optionally repository)                       |
+| Receipt          | Task                                                                                                         |
+| Transcript       | Source attention; exact execution remains a point read                                                       |
+
+Authentication and authorization belong to the application. These are trusted APIs, not raw HTTP
+parameters. An owner-scoped session query uses the authenticated owner. Repository membership is
+discovery, not an access grant: a caller must be allowed to read **every** repository on a record.
+An `all` scope requires authority across that collection in the namespace. Cursors carry position,
+not authorization. Unsupported filter combinations and search require indexed read models; do not
+exhaust pages and filter the whole result in memory.
+
+Attention here describes **source entities**: Tasks requiring approval/input or failed/stalled;
+ready Changes; transcripts waiting for input or failed. A Task and its Change can both need action.
+These separate counts must not be summed into the UI's conversation count. The integrated `stores.conversations` projection deduplicates conversations, preserves
+workflow-question precedence, and supports bounded policy-filtered pages and maintained facet totals. A transcript's state alone is not an internal session's attention decision.
+
+All entities retain the existing validating engine's receipt-first, graph-admission, retry, and
+version-fencing rules. Each canonical write and its derived projections share one storage transaction; external provider
+effects and separate engine operations are not one transaction. Each driver call has
+a fresh operation identity so repeated inserts and stale CAS writes still raise conflicts; the
+Postgres adapter retains that identity while reconciling an ambiguous commit response.
+
+The foundation limits still apply: 256 KiB per canonical record, 8 KiB per summary, and 32
+memberships. A Task consumes up to `5 + 3 × repositoryCount` memberships when it needs attention.
+Session notifications, continuations, execution histories, and transcript blocks/chunks use
+separate paged records. Oversized writes fail without committing that record or its memberships.
+Only compact summaries truncate display titles; canonical messages remain intact. Migrations,
+connection management, grants, and environment isolation follow the
+[Postgres foundation guide](postgres-indexed-storage.md).
+
+## Runnable local example
+
+This example uses PGlite and local image storage, without provider credentials. Use a pooled
+interactive Postgres connection and object storage for images in a deployed application.
+
+<!-- runnable-example:start -->
+
+```ts
+import assert from "node:assert/strict";
+import { PGlite } from "@electric-sql/pglite";
+import { drizzle } from "drizzle-orm/pglite";
+import { createIndexedStores, createInMemoryDriver } from "@vercel/factory/storage";
+import {
+  applyFactoryMigrations,
+  createPostgresIndexedStore,
+} from "@vercel/factory/storage/postgres";
+import { taskWork } from "@vercel/factory/workflows";
+
+const client = new PGlite();
+try {
+  const db = drizzle(client);
+  await applyFactoryMigrations(db);
+  const store = createPostgresIndexedStore({ db, namespace: "indexed-engine-example-v1" });
+  const stores = createIndexedStores({ store, images: createInMemoryDriver() });
+  const input = {
+    repositoryIds: ["repo_example"] as const,
+    kind: "investigation",
+    origin: { operator: "alice" },
+    replyTo: { channel: "api", address: "ses_example" },
+    work: taskWork({ title: "Investigate board latency", input: { privateContext: "full input" } }),
+    dedupeKey: "example-admission",
+  };
+  const task = await stores.tasks.create(input);
+  assert.equal((await stores.tasks.create(input)).id, task.id);
+  await stores.tasks.transition(task.id, "running");
+  assert.equal((await stores.tasks.create(input)).state, "running");
+  const scope = { collection: "tasks", by: "state", state: "running" } as const;
+  const page = await stores.indexes.query({ scope, limit: 30 });
+  assert.equal(page.entries.length, 1);
+  assert.equal(page.entries[0]?.summary.id, task.id);
+  assert.equal(JSON.stringify(page).includes("privateContext"), false);
+  assert.equal(await stores.indexes.count(scope), 1);
+  assert.equal(
+    (await stores.tasks.list({ limit: 1, match: { state: "running" } })).items[0]?.id,
+    task.id,
+  );
+  assert.equal((await stores.tasks.get(task.id))?.work.title, "Investigate board latency");
+} finally {
+  await client.close();
+}
+```
+
+<!-- runnable-example:end -->

package/docs/recipes/postgres-indexed-storage.md

@@ -0,0 +1,145 @@
+# Indexed Postgres storage
+
+Use `createPostgresIndexedStore` for new consumers that need compact ordered pages and maintained
+counts. It implements `IndexedStore`, the bounded contract first developed for the DynamoDB
+foundation. This implementation uses PostgreSQL B-trees, row-version conditions, and transactions.
+The reference runtime uses it through `createIndexedStores`; it never reads a legacy Blob catalog.
+
+## Tables and queries
+
+`applyFactoryMigrations` adds migration `0001_indexed_storage` with four tables:
+
+| Table                        | Contents                                                          |
+| ---------------------------- | ----------------------------------------------------------------- |
+| `factory_indexed_records`    | Full canonical JSON, version, namespace/collection/id primary key |
+| `factory_indexed_entries`    | Compact summaries, source versions, and ordered index memberships |
+| `factory_indexed_counts`     | Transactionally maintained total for each namespace/index         |
+| `factory_indexed_operations` | Durable operation fingerprints and committed versions for retries |
+
+Entries have a B-tree primary key on `(namespace, index_key, sort_key, collection, id)`. A second
+unique index on `(namespace, collection, id, index_key)` supports replacing one record's memberships.
+Query keys use `C` collation. Queries use tuple cursor comparisons and a limit of 1–100, fetching
+one additional row to determine whether another page exists. `query` returns summaries only. `queryRecords` applies bounded, parameterized JSON predicates
+and ordered point reads; conversation cards are compact records rather than full Tasks.
+Counts read a single counter row; they do not count or download the matching entries.
+
+The application supplies each complete membership set, including authorized workspace/owner scope.
+For example, a repository board, its state-filtered board, and its attention list are distinct query
+scopes. The validating engine defines those memberships and the operator conversation schema. Map supported
+filters to exact scopes or add indexed SQL projections during integration; never consume every
+page and filter in application memory. Arbitrary filter combinations and search need their own
+query/index design. Cursors are positions bound to namespace, index, and direction, not access
+tokens. Pages and counts from separate calls do not share a snapshot; mutable entries can move.
+
+Migration `0002_indexed_reads` adds count-group metadata and JSON/full-text indexes. Maintained
+facet counts provide totals without hydrating Tasks. Sparse filters can still visit many ordered
+memberships; exact search counts scale with matching compact records. The local benchmark in the
+cutover guide records actual handler timings and SQL plans at 1,000 and 10,000 conversations.
+
+## Connection and migration ownership
+
+Use Drizzle with `pg.Pool` or Neon’s WebSocket `Pool`, connected to the primary. Interactive
+transactions are required; `drizzle-orm/neon-http` is not supported. The caller owns bounded pool
+size, connection/statement timeouts, TLS, and cleanup. Initialize connections lazily when a build
+does not have database credentials. A pooled URL does not replace the need for interactive
+transaction support. Place the database near the application functions and measure cold starts.
+
+Run `applyFactoryMigrations(db)` explicitly with a migration role and serialize migration runners.
+Runtime requests never perform DDL. The runtime role needs schema USAGE and only these grants:
+
+```sql
+GRANT SELECT, INSERT, UPDATE ON factory_indexed_records, factory_indexed_counts TO factory_runtime;
+GRANT SELECT, INSERT, DELETE ON factory_indexed_entries TO factory_runtime;
+GRANT SELECT, INSERT ON factory_indexed_operations TO factory_runtime;
+```
+
+Namespaces separate environments and fresh generations logically; they are not database access
+controls. Use separate databases/credentials for Production and Preview. Start the fresh-data
+cutover with a new namespace, retire old pinned work, and avoid backfill, dual writes, or Blob
+fallback. Large files, images, diffs, and report artifacts remain in object storage. Growing transcripts/histories use paged records in the reference runtime. The
+[cutover guide](https://github.com/vercel-labs/agent-factory/blob/code/postgres-migration/docs/postgres-cutover.md) describes preview setup and the promotion boundary.
+
+## Write behavior
+
+Interactive transactions use serializable isolation with bounded retries for serialization failures
+and deadlocks. One transaction claims the operation ID, applies a version-fenced record write, replaces its
+memberships, adjusts counts, and commits the operation receipt. An insert expects version zero;
+an update expects the current positive version. Concurrent writers cannot both win the same
+version. Identical retries return the original version even after later updates. A different
+intent with the same operation ID raises `StoreOperationConflictError`. After an ambiguous commit
+response, the adapter checks the receipt; if that check is unavailable, retry the identical intent.
+Operation receipts are retained indefinitely. There is no generic delete or automatic cleanup.
+
+The engine owns entity schemas, lifecycle rules, immutable records, summary contents, and access
+policy. The adapter validates storage keys and finite JSON, but never infers Task attention.
+Bounds are 256 KiB per record, 8 KiB per summary, 32 memberships, and JSON depth 32. Shared counter
+rows serialize membership changes within a scope; benchmark write contention before activation.
+These limits require splitting growing histories instead of storing an unlimited JSON document.
+
+## Runnable local example
+
+This example uses PGlite to exercise the published interface without credentials. Install
+`@vercel/factory`, `@electric-sql/pglite`, `drizzle-orm`, `eve`, and `zod`, then run it with Node 24.
+
+<!-- runnable-example:start -->
+
+```ts
+import assert from "node:assert/strict";
+import { PGlite } from "@electric-sql/pglite";
+import { drizzle } from "drizzle-orm/pglite";
+import type { WriteIndexedRecordInput } from "@vercel/factory/storage";
+import {
+  applyFactoryMigrations,
+  createPostgresIndexedStore,
+} from "@vercel/factory/storage/postgres";
+
+const client = new PGlite();
+try {
+  const db = drizzle(client);
+  await applyFactoryMigrations(db);
+  const store = createPostgresIndexedStore({ db, namespace: "local-example-v1" });
+  // Values are opaque here; an application validates its full entity before calling storage.
+  const input: WriteIndexedRecordInput = {
+    collection: "sessions",
+    id: "ses_example",
+    operationId: "create-example",
+    expectedVersion: 0,
+    value: { title: "Example conversation", context: "Full data is read by ID" },
+    indexes: [
+      {
+        index: "workspace:example:conversations",
+        sortKey: "2026-09-22T12:00:00.000Z",
+        summary: { title: "Example conversation" },
+      },
+    ],
+  };
+  assert.deepEqual(await store.write(input), { version: 1 });
+  assert.deepEqual(await store.write(input), { version: 1 });
+  assert.equal(await store.count(input.indexes[0]!.index), 1);
+  const page = await store.query({ index: input.indexes[0]!.index, limit: 30 });
+  assert.equal(page.entries.length, 1);
+  assert.equal(page.nextCursor, null);
+  assert.deepEqual(page.entries[0]!.summary, { title: "Example conversation" });
+  assert.deepEqual((await store.get("sessions", input.id))?.value, input.value);
+} finally {
+  await client.close();
+}
+```
+
+<!-- runnable-example:end -->
+
+## Verification
+
+`pnpm check` runs the PGlite storage suite. The example is available for manual local use;
+it is not an additional packed-scaffold or consumer-docs smoke test. CI also uses a pinned
+PostgreSQL 17 service for concurrent transactions, retry/rollback behavior, least-privilege grants,
+and a 10,000-entry `EXPLAIN (ANALYZE, BUFFERS)` index-seek check. To run that suite locally, use an
+isolated PostgreSQL database named `factory_test` on loopback:
+
+```sh
+FACTORY_POSTGRES_TEST_URL=postgresql://factory:factory-test@127.0.0.1:55432/factory_test \
+  pnpm --filter @vercel/factory exec vitest run src/postgres/indexed.test.ts
+```
+
+These checks establish storage correctness and query shape. Deployed board, attention, and chat
+latency at realistic payload sizes and increasing record counts must be measured after integration.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/factory",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "description": "Schema, state machines, and kernel primitives for Agent Factory.",
   "homepage": "https://github.com/vercel-labs/agent-factory/tree/main/packages/factory",
   "bugs": "https://github.com/vercel-labs/agent-factory/issues",
@@ -145,10 +145,12 @@
     "@ai-sdk/harness-claude-code": "1.0.112",
     "@ai-sdk/sandbox-vercel": "1.0.108",
     "@electric-sql/pglite": "^0.5.7",
+    "@types/pg": "^8.23.1",
     "@vercel/blob": "^2.8.0",
     "@vercel/sandbox": "2.10.0-beta.0",
     "drizzle-orm": "^0.45.2",
     "eve": "^0.57.0",
+    "pg": "^8.23.0",
     "tsdown": "^0.22.14",
     "typescript": "5.9.3",
     "typescript-current": "npm:typescript@7.0.2",