@vellumai/assistant 0.11.10-dev.202609091820.7951ec9 → 0.11.10-dev.202609092016.c7aa45c

package/AGENTS.md

@@ -30,7 +30,7 @@ DB migrations run asynchronously during startup: the HTTP server binds (so `/hea
 
 Existing enforcement, which new code must not bypass:
 
-- **HTTP** requests are gated per-route in `runtime/http-server.ts`; **IPC** methods in `ipc/assistant-server.ts`; both derive their exempt set from `DB_MIGRATION_READINESS_EXEMPT_OPERATIONS` in `daemon-readiness.ts` (health/liveness probes only — anything exempted must never touch the DB).
+- **HTTP** requests are gated per-route in `runtime/http-server.ts`; **IPC** methods in `ipc/assistant-server.ts`; both derive their exempt set from `DB_MIGRATION_READINESS_EXEMPT_OPERATIONS` in `daemon-readiness.ts` (health/liveness probes plus in-memory diagnostics such as `debug/database` — anything exempted must never touch the DB).
 - **Message sinks** (`processMessage`, `processMessageInBackground`) guard via `assertDbMigrationsReadyForTurn()`.
 - **Background sweeps** are started by lifecycle only after migrations settle (`startRuntimeHttpServerBackgroundSweeps`).
 - The **migration-repair surface** (`admin/rollback-migrations` plus all `migrations/import*` / preflight transports and their job-status route) is additionally allowed in the terminal `failed` state only — see `DB_MIGRATION_FAILED_STATE_EXEMPT_OPERATIONS`. Never widen this to the `running` state: a rollback or import would race the in-flight migration runner. A successful repair does not clear the failed latch — the daemon must be restarted to re-run migrations and become ready.

package/node_modules/@vellumai/gateway-client/src/guardian-request-contract.ts

@@ -254,10 +254,15 @@ export type GuardianRequestMutationIpcResponse = z.infer<
 
 /**
  * Request for `guardian_requests_create`. `id` is REQUIRED and
- * caller-supplied — request ids are load-bearing (deterministic
- * access-request ids; `tool_approval` rows reuse the pending-interaction
- * requestId as PK). `requestCode` is generated gateway-side when omitted.
- * No `sourceType`: the gateway derives it from `sourceChannel`.
+ * caller-supplied. The interaction-promotion paths (`tool_approval`, and
+ * `pending_question` for `ask_question`) reuse the pending-interaction
+ * requestId as PK so a decision can find its interaction; every other
+ * create mints a UUID, including voice `pending_question` rows, which carry
+ * their interaction id in `pendingQuestionId` instead. The id is the row's
+ * primary key and the insert is strict, so a caller that can create
+ * concurrently must mint one unique per call. `requestCode` is generated
+ * gateway-side when omitted. No `sourceType`: the gateway derives it from
+ * `sourceChannel`.
  */
 export const CreateGuardianRequestIpcParamsSchema = z.object({
   id: z.string().min(1),

package/node_modules/@vellumai/gateway-client/src/ipc-client.ts

@@ -340,7 +340,8 @@ type PendingRequest = {
 export type PersistentIpcClientOptions = {
   /**
    * Additional delays (ms) before each reconnect attempt after a retryable
-   * connect failure. Pass `[]` to fail on the first miss (tests).
+   * connect failure. Pass `[]` to fail on the first miss (tests and callers
+   * that already own a retry budget, such as classify_risk).
    */
   connectRetryBackoffsMs?: readonly number[];
 };
@@ -350,8 +351,9 @@ export type PersistentIpcClientOptions = {
  * reconnection on failure. Multiplexes requests by ID so many concurrent
  * callers can share one socket.
  *
- * Designed for hot-path calls (e.g. classify_risk) where connecting per call
- * adds unacceptable overhead.
+ * Designed for multiplexed calls over one socket. Control-plane callers
+ * typically keep the default connect retries for sibling boot races.
+ * Callers that already own a retry budget pass `connectRetryBackoffsMs: []`.
  */
 export class PersistentIpcClient {
   private socket: Socket | null = null;

package/openapi.yaml

@@ -1713,6 +1713,99 @@ paths:
       responses:
         "204":
           description: Successful response
+    get:
+      operationId: attachments_get
+      summary: List conversation attachments
+      description:
+        Return metadata for every attachment linked to a conversation's messages, newest first, across fork
+        lineage. Camera frames kept by live vision are flagged. Bytes come from GET /attachments/{id}/content.
+      tags:
+        - attachments
+      parameters:
+        - name: conversationId
+          in: query
+          required: true
+          schema:
+            type: string
+          description: Conversation whose attachments to list
+        - name: sightFrames
+          in: query
+          required: false
+          schema:
+            type: string
+            enum:
+              - only
+              - exclude
+          description: Restrict to camera frames, or leave them out
+        - name: limit
+          in: query
+          required: false
+          schema:
+            type: integer
+          description: Page size, default 200, max 1000
+        - name: offset
+          in: query
+          required: false
+          schema:
+            type: integer
+      responses:
+        "200":
+          description: Successful response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  attachments:
+                    type: array
+                    items:
+                      type: object
+                      properties:
+                        id:
+                          type: string
+                        filename:
+                          type: string
+                        mimeType:
+                          type: string
+                        sizeBytes:
+                          type: number
+                        kind:
+                          type: string
+                        messageId:
+                          type: string
+                        createdAt:
+                          type: number
+                          description: "Capture time: the carrying message's created_at"
+                        fileBacked:
+                          type: boolean
+                        thumbnailData:
+                          type: string
+                        sightFrame:
+                          type: boolean
+                        ambientKeep:
+                          type: boolean
+                      required:
+                        - id
+                        - filename
+                        - mimeType
+                        - sizeBytes
+                        - kind
+                        - messageId
+                        - createdAt
+                        - sightFrame
+                        - ambientKeep
+                      additionalProperties: false
+                  total:
+                    type: number
+                  hasMore:
+                    type: boolean
+                required:
+                  - attachments
+                  - total
+                  - hasMore
+                additionalProperties: false
+        "400":
+          description: Missing or invalid query
     post:
       operationId: attachments_post
       summary: Upload attachment
@@ -11081,6 +11174,71 @@ paths:
                   - exitCode
                   - timedOut
                 additionalProperties: false
+  /v1/debug/database:
+    get:
+      operationId: debug_database_get
+      summary: Database migration diagnostics
+      description:
+        Return the in-memory DB migration latch, including failed and deferred steps. Does not query SQLite, so it
+        stays answerable while migrations are running or have failed.
+      tags:
+        - debug
+      responses:
+        "200":
+          description: Successful response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  ready:
+                    type: boolean
+                  state:
+                    type: string
+                    enum:
+                      - not_started
+                      - running
+                      - failed
+                      - ready
+                  reason:
+                    type: string
+                  error:
+                    type: string
+                  failed:
+                    type: array
+                    items:
+                      type: object
+                      properties:
+                        name:
+                          type: string
+                        error:
+                          type: string
+                      required:
+                        - name
+                      additionalProperties: false
+                  deferred:
+                    type: array
+                    items:
+                      type: object
+                      properties:
+                        name:
+                          type: string
+                        missing:
+                          type: array
+                          items:
+                            type: string
+                      required:
+                        - name
+                        - missing
+                      additionalProperties: false
+                  validationError:
+                    type: string
+                required:
+                  - ready
+                  - state
+                  - failed
+                  - deferred
+                additionalProperties: false
   /v1/defer/cancel:
     post:
       operationId: defer_cancel_post
@@ -13442,6 +13600,35 @@ paths:
                         type: string
                       error:
                         type: string
+                      failedMigrations:
+                        type: array
+                        items:
+                          type: object
+                          properties:
+                            name:
+                              type: string
+                            error:
+                              type: string
+                          required:
+                            - name
+                          additionalProperties: false
+                      deferredMigrations:
+                        type: array
+                        items:
+                          type: object
+                          properties:
+                            name:
+                              type: string
+                            missing:
+                              type: array
+                              items:
+                                type: string
+                          required:
+                            - name
+                            - missing
+                          additionalProperties: false
+                      validationError:
+                        type: string
                     required:
                       - ready
                       - state
@@ -13647,6 +13834,35 @@ paths:
                         type: string
                       error:
                         type: string
+                      failedMigrations:
+                        type: array
+                        items:
+                          type: object
+                          properties:
+                            name:
+                              type: string
+                            error:
+                              type: string
+                          required:
+                            - name
+                          additionalProperties: false
+                      deferredMigrations:
+                        type: array
+                        items:
+                          type: object
+                          properties:
+                            name:
+                              type: string
+                            missing:
+                              type: array
+                              items:
+                                type: string
+                          required:
+                            - name
+                            - missing
+                          additionalProperties: false
+                      validationError:
+                        type: string
                     required:
                       - ready
                       - state

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.10-dev.202609091820.7951ec9",
+  "version": "0.11.10-dev.202609092016.c7aa45c",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/config-schema.test.ts

@@ -757,6 +757,7 @@ describe("AssistantConfigSchema", () => {
       maxFileSizeBytes: 256000,
       historyCompaction: { enabled: true },
       interactiveGitTimeoutMs: 10000,
+      stageBatchSize: 1000,
       enrichmentQueueSize: 50,
       enrichmentConcurrency: 1,
       enrichmentJobTimeoutMs: 30000,
@@ -811,6 +812,31 @@ describe("AssistantConfigSchema", () => {
     expect(result.success).toBe(false);
   });
 
+  test("applies workspaceGit.stageBatchSize default", () => {
+    expect(AssistantConfigSchema.parse({}).workspaceGit.stageBatchSize).toBe(
+      1000,
+    );
+  });
+
+  test("accepts custom workspaceGit.stageBatchSize", () => {
+    const result = AssistantConfigSchema.parse({
+      workspaceGit: { stageBatchSize: 250 },
+    });
+    expect(result.workspaceGit.stageBatchSize).toBe(250);
+  });
+
+  test("rejects non-positive workspaceGit.stageBatchSize", () => {
+    const zeroResult = AssistantConfigSchema.safeParse({
+      workspaceGit: { stageBatchSize: 0 },
+    });
+    expect(zeroResult.success).toBe(false);
+
+    const negativeResult = AssistantConfigSchema.safeParse({
+      workspaceGit: { stageBatchSize: -1 },
+    });
+    expect(negativeResult.success).toBe(false);
+  });
+
   test("applies sight defaults", () => {
     expect(AssistantConfigSchema.parse({}).sight).toEqual({
       keepLatestFrames: 2,

package/src/__tests__/db-readiness-http-gate.test.ts

@@ -123,6 +123,49 @@ describe("DB migration readiness HTTP gate", () => {
     expect(body.reason).toBe("db_migrations_failed");
   });
 
+  test("continues serving debug/database while migrations are running", async () => {
+    setDbMigrating();
+    await startServer();
+
+    const response = await fetch(url("/debug/database"));
+    expect(response.status).toBe(200);
+
+    const body = (await response.json()) as Record<string, unknown>;
+    expect(body.ready).toBe(false);
+    expect(body.state).toBe("running");
+    expect(body.reason).toBe("db_migrations_running");
+    expect(body.failed).toEqual([]);
+    expect(body.deferred).toEqual([]);
+  });
+
+  test("continues serving debug/database when migrations have failed", async () => {
+    setDbMigrationFailed(new Error("boom"), {
+      failedMigrations: [{ name: "flakyStep", error: "transient failure" }],
+      deferredMigrations: [{ name: "dependentStep", missing: ["flakyStep"] }],
+      validationError: "schema mismatch",
+    });
+    await startServer();
+
+    const response = await fetch(url("/debug/database"));
+    expect(response.status).toBe(200);
+
+    const body = (await response.json()) as Record<string, unknown>;
+    expect(body.ready).toBe(false);
+    expect(body.state).toBe("failed");
+    expect(body.reason).toBe("db_migrations_failed");
+    expect(body.error).toBe("boom");
+    expect(body.failed).toEqual([
+      { name: "flakyStep", error: "transient failure" },
+    ]);
+    expect(body.deferred).toEqual([
+      { name: "dependentStep", missing: ["flakyStep"] },
+    ]);
+    expect(body.validationError).toBe("schema mismatch");
+
+    const conversations = await fetch(url("/conversations"));
+    expect(conversations.status).toBe(503);
+  });
+
   test("blocks config schema while migrations are running", async () => {
     setDbMigrating();
     await startServer();

package/src/__tests__/error-handler-friendly-messages.test.ts

@@ -1,5 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
+import { IpcConnectError } from "@vellumai/gateway-client/ipc-client";
+
 import { withErrorHandling } from "../runtime/middleware/error-handler.js";
 import { ConfigError, ProviderNotConfiguredError } from "../util/errors.js";
 
@@ -42,4 +44,17 @@ describe("withErrorHandling – friendly error messages", () => {
     };
     expect(body.error.message).toBe("Twilio phone number not configured.");
   });
+
+  test("IpcConnectError surfaces as 503 SERVICE_UNAVAILABLE", async () => {
+    const response = await withErrorHandling("test", async () => {
+      throw new IpcConnectError("connect ENOENT", "ENOENT");
+    });
+
+    expect(response.status).toBe(503);
+    const body = (await response.json()) as {
+      error: { code: string; message: string };
+    };
+    expect(body.error.code).toBe("SERVICE_UNAVAILABLE");
+    expect(body.error.message).toContain("Gateway is not reachable over IPC");
+  });
 });

package/src/__tests__/guardian-gateway-sim.ts

@@ -564,6 +564,11 @@ export function createGuardianGatewaySim() {
   async function createGuardianRequest(
     params: SeedRequestParams & { id: string; guardianPrincipalId: string },
   ): Promise<SimGuardianRequest> {
+    // The gateway insert is strict on the primary key; a silent overwrite
+    // here would hide a caller minting the same id twice.
+    if (requests.has(params.id)) {
+      throw new Error("UNIQUE constraint failed: guardian_requests.id");
+    }
     return seedRequest(params);
   }
 

package/src/__tests__/helpers/gateway-guardian-requests-store-bridge.ts

@@ -49,8 +49,9 @@ async function createGuardianRequest(
   params: CreateGuardianRequestIpcParams,
 ): Promise<SimGuardianRequest> {
   // The schema requires `guardianPrincipalId`, mirroring the gateway store's
-  // integrity guard (every contract kind is decisionable).
-  return bridgeState.seedRequest(
+  // integrity guard (every contract kind is decisionable). The sim's create
+  // then rejects a duplicate id, mirroring the store's strict insert.
+  return bridgeState.module.createGuardianRequest(
     CreateGuardianRequestIpcParamsSchema.parse(params),
   );
 }

package/src/__tests__/identity-routes.test.ts

@@ -483,13 +483,18 @@ describe("identity routes — /readyz readiness gate", () => {
   });
 
   test("returns 503 when DB migrations fail", async () => {
-    setDbMigrationFailed(new Error("migration failed"));
+    setDbMigrationFailed(new Error("migration failed"), {
+      failedMigrations: [{ name: "flakyStep", error: "transient failure" }],
+    });
     const res = handleReadyz();
     expect(res.status).toBe(503);
     const body = (await res.json()) as Record<string, unknown>;
     expect(body.ready).toBe(false);
     expect(body.reason).toBe("db_migrations_failed");
     expect((body.dbMigrations as Record<string, unknown>).state).toBe("failed");
+    expect((body.dbMigrations as Record<string, unknown>).failedMigrations).toEqual(
+      [{ name: "flakyStep", error: "transient failure" }],
+    );
   });
 
   test("returns 200 even if CES is down", async () => {

package/src/__tests__/tool-grant-request-escalation.test.ts

@@ -282,6 +282,49 @@ describe("ToolApprovalHandler / grant-miss escalation", () => {
     });
     expect(requests.length).toBe(0);
   });
+
+  test("sibling tool calls escalating concurrently each get their own request", async () => {
+    // The agent loop runs a turn's tool_use blocks under Promise.all, so two
+    // grant-gated calls reach the gateway create in the same tick. Each is a
+    // distinct invocation (different input digest), so each needs its own
+    // row; the create must never collide on the primary key.
+    const context = makeContext({ trustClass: "trusted_contact" });
+    const results = await Promise.all([
+      handler.checkPreExecutionGates(
+        "bash",
+        { command: "ls -la" },
+        context,
+        "high",
+        Date.now(),
+      ),
+      handler.checkPreExecutionGates(
+        "bash",
+        { command: "cat README.md" },
+        context,
+        "high",
+        Date.now(),
+      ),
+    ]);
+
+    // Both escalate and time out on the short inline wait: a denial for each,
+    // never a thrown persistence error that would fail the whole turn.
+    for (const result of results) {
+      expect(result.allowed).toBe(false);
+      if (result.allowed) {
+        return;
+      }
+      expect(result.result.content).toContain("guardian approval");
+    }
+
+    const requests = await sim.module.listGuardianRequestsOrEmpty({
+      kind: "tool_grant_request",
+      status: "pending",
+    });
+    expect(requests.length).toBe(2);
+    expect(new Set(requests.map((r) => r.id)).size).toBe(2);
+    expect(new Set(requests.map((r) => r.inputDigest)).size).toBe(2);
+    expect(emittedSignals.length).toBe(2);
+  });
 });
 
 // ---------------------------------------------------------------------------