@vellumai/assistant 0.12.4 → 0.12.5-dev.202609251017.e467a6c

package/src/persistence/embeddings/__tests__/embedding-local-lifecycle.test.ts

@@ -54,6 +54,62 @@ function brokenPipeProc(pid = 4242) {
   };
 }
 
+/**
+ * A stand-in for a Bun subprocess whose stdin write outruns the pipe buffer:
+ * `write` and `flush` hand back one pending promise, and killing the worker
+ * rejects it with EPIPE, the way Bun settles a pending write once the child
+ * is reaped.
+ */
+function pendingWriteProc(pid = 4244) {
+  const pending = Promise.withResolvers<number>();
+  return {
+    pid,
+    killed: false,
+    exited: Promise.resolve(0),
+    kill() {
+      this.killed = true;
+      pending.reject(
+        Object.assign(new Error("EPIPE: broken pipe, write"), {
+          code: "EPIPE",
+        }),
+      );
+    },
+    stdin: {
+      write: () => pending.promise,
+      flush: () => pending.promise,
+    },
+  };
+}
+
+/**
+ * A subprocess whose stdout the test closes, to drive the reader loop that
+ * settles requests the pipe never reported a failure for.
+ */
+function stdoutProc(pid = 4245) {
+  let closeStdout: () => void = () => {};
+  const stdout = new ReadableStream<Uint8Array>({
+    start(controller) {
+      closeStdout = () => controller.close();
+    },
+  });
+  let resolveExit: (code: number) => void = () => {};
+  const exited = new Promise<number>((r) => {
+    resolveExit = r;
+  });
+  return {
+    pid,
+    killed: false,
+    exited,
+    stdout,
+    closeStdout: () => closeStdout(),
+    kill() {
+      this.killed = true;
+      resolveExit(0);
+    },
+    stdin: { write: () => 0, flush: () => 0 },
+  };
+}
+
 /** A subprocess that stays "alive" until killed, so exit can be observed. */
 function liveProc(pid = 4243) {
   let resolveExit: (code: number) => void = () => {};
@@ -263,31 +319,46 @@ describe("broken worker pipe", () => {
   });
 
   /**
-   * A real pipe, because the failure lives in Bun's behaviour rather than in
-   * ours: a batch larger than the pipe buffer, sent to a worker too busy to
-   * drain stdin, leaves the write pending, and the pending write rejects when
-   * the worker dies. A synchronous guard never sees that rejection.
+   * A batch larger than the pipe buffer, sent to a worker too busy to drain
+   * stdin, leaves the write pending, and the pending write rejects after
+   * `sendRequest` has returned, once the worker dies. A synchronous guard
+   * never sees that rejection.
    */
   test("a write still pending when the worker dies resolves the request as an error", async () => {
     const backend = newBackend();
-    const proc = Bun.spawn({
-      cmd: [process.execPath, "-e", "setTimeout(() => {}, 60_000)"],
-      windowsHide: true,
-      stdin: "pipe",
-      stdout: "ignore",
-      stderr: "ignore",
-    });
-    spawned.push(proc);
+    const proc = pendingWriteProc();
     backend.workerProc = proc;
 
-    const request = backend.sendRequest(["x".repeat(4 * 1024 * 1024)]);
-    proc.kill("SIGKILL");
+    const request = backend.sendRequest(["hello"]);
+    proc.kill();
     const response = await request;
 
     expect(response.error).toContain("worker pipe write failed");
     expect(backend.pendingRequests.size).toBe(0);
   });
 
+  /**
+   * Bun does not always report a dead worker through the write: on Linux it
+   * occasionally resolves the pending write with a short count instead of
+   * rejecting it, and `writeWorkerLine` then stays silent. Nothing times a
+   * request out, so the stdout reader ending is the only thing that settles
+   * it.
+   */
+  test("stdout ending settles a request the pipe never reported a failure for", async () => {
+    const backend = newBackend();
+    const proc = stdoutProc();
+    backend.workerProc = proc;
+    backend.startStdoutReader();
+
+    const inFlight = backend.sendRequest(["hello"]);
+    proc.closeStdout();
+
+    await expect(inFlight).resolves.toMatchObject({
+      error: expect.stringContaining("exited unexpectedly"),
+    });
+    expect(backend.pendingRequests.size).toBe(0);
+  });
+
   test("a failed write does not leak the pending request", async () => {
     const backend = newBackend();
     backend.workerProc = brokenPipeProc();

package/src/persistence/jobs-store.ts

@@ -72,6 +72,7 @@ export type MemoryJobType =
   | "delete_message_lexical"
   | "backfill_lexical_index"
   | "skill_card_insert"
+  | "skill_update_receipt"
   | "memory_retrospective"
   | "memory_retrospective_sweep"
   // Retired/legacy — no live handler; persisted rows drop via LEGACY_JOB_TYPES.
@@ -379,6 +380,234 @@ function mergeSkillCardEntries(
   return merged;
 }
 
+/**
+ * One rewrite of a managed skill by a background pass, as the receipt job's
+ * payload carries it. `entryId` is the producing tool call's, so a replayed
+ * call merges as a no-op; the conversation ids are what the receipt links
+ * to and what a conversation delete purges by.
+ */
+export interface SkillUpdateReceiptEntry {
+  entryId: string;
+  skillId: string;
+  name: string;
+  changeSummary: string;
+  sourceConversationId?: string;
+  runConversationId: string;
+  createdAt: number;
+}
+
+/** Payload of a `skill_update_receipt` job: one burst's rewrites so far. */
+export interface SkillUpdateReceiptJobPayload {
+  /** When the burst's earliest rewrite landed; the cap is measured from it. */
+  firstEntryAt: number;
+  /** When its latest rewrite landed; the quiet window is measured from it. */
+  lastEntryAt: number;
+  entries: SkillUpdateReceiptEntry[];
+}
+
+/**
+ * Upsert a pending `skill_update_receipt` job: the one open receipt for the
+ * burst of background skill rewrites in progress. Every append merges into
+ * the pending row rather than creating a duplicate; the receipt handler
+ * re-upserts the same payload when it defers, and merges into a sibling
+ * that opened while it evaluated (see `skill-update-receipt-job.ts`).
+ *
+ * Merge rules, each load-bearing: entries dedupe by `entryId`, with the
+ * pending entry winning so a replay changes nothing; `firstEntryAt` is the
+ * EARLIEST of the two, so a continuous stream of rewrites cannot ratchet the
+ * cap forward and hold the burst's first entries past their own cap;
+ * `lastEntryAt` is the latest; and `runAfter` is the earliest, mirroring
+ * `upsertMemoryRetrospectiveJob`. A running row never matches (its payload
+ * is frozen at claim), so an append during evaluation opens the sibling the
+ * handler merges into.
+ */
+export function upsertSkillUpdateReceiptJob(
+  payload: SkillUpdateReceiptJobPayload,
+  runAfter: number = Date.now(),
+): void {
+  const db = memoryDb();
+  const existing = db
+    .select()
+    .from(memoryJobs)
+    .where(
+      and(
+        eq(memoryJobs.type, "skill_update_receipt"),
+        eq(memoryJobs.status, "pending"),
+      ),
+    )
+    .orderBy(asc(memoryJobs.createdAt))
+    .get();
+  if (existing) {
+    const existingPayload = parseSkillUpdateReceiptPayload(existing.payload);
+    const merged: SkillUpdateReceiptJobPayload = {
+      firstEntryAt: Math.min(
+        existingPayload?.firstEntryAt ?? payload.firstEntryAt,
+        payload.firstEntryAt,
+      ),
+      lastEntryAt: Math.max(
+        existingPayload?.lastEntryAt ?? payload.lastEntryAt,
+        payload.lastEntryAt,
+      ),
+      entries: mergeSkillUpdateReceiptEntries(
+        existingPayload?.entries ?? [],
+        payload.entries,
+      ),
+    };
+    db.update(memoryJobs)
+      .set({
+        payload: JSON.stringify(merged),
+        runAfter: Math.min(existing.runAfter, runAfter),
+        updatedAt: Date.now(),
+      })
+      .where(eq(memoryJobs.id, existing.id))
+      .run();
+    return;
+  }
+  enqueueMemoryJob(
+    "skill_update_receipt",
+    payload as unknown as Record<string, unknown>,
+    runAfter,
+  );
+}
+
+/**
+ * Validate a `skill_update_receipt` payload back into its typed shape, or
+ * null for a corrupted or foreign row. Entries missing a usable id, skill,
+ * name, summary, or run are dropped rather than failing the whole payload.
+ */
+export function parseSkillUpdateReceiptPayload(
+  raw: unknown,
+): SkillUpdateReceiptJobPayload | null {
+  let payload: unknown = raw;
+  if (typeof raw === "string") {
+    try {
+      payload = JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  if (!payload || typeof payload !== "object") {
+    return null;
+  }
+  const rec = payload as Record<string, unknown>;
+  if (
+    typeof rec.firstEntryAt !== "number" ||
+    typeof rec.lastEntryAt !== "number" ||
+    !Array.isArray(rec.entries)
+  ) {
+    return null;
+  }
+  return {
+    firstEntryAt: rec.firstEntryAt,
+    lastEntryAt: rec.lastEntryAt,
+    entries: mergeSkillUpdateReceiptEntries([], rec.entries),
+  };
+}
+
+function mergeSkillUpdateReceiptEntries(
+  existing: unknown,
+  incoming: unknown,
+): SkillUpdateReceiptEntry[] {
+  const merged: SkillUpdateReceiptEntry[] = [];
+  const seen = new Set<string>();
+  const candidates = [
+    ...(Array.isArray(existing) ? existing : []),
+    ...(Array.isArray(incoming) ? incoming : []),
+  ];
+  for (const entry of candidates) {
+    if (!entry || typeof entry !== "object") {
+      continue;
+    }
+    const rec = entry as Record<string, unknown>;
+    if (
+      typeof rec.entryId !== "string" ||
+      rec.entryId.length === 0 ||
+      typeof rec.skillId !== "string" ||
+      typeof rec.name !== "string" ||
+      typeof rec.changeSummary !== "string" ||
+      typeof rec.runConversationId !== "string" ||
+      typeof rec.createdAt !== "number" ||
+      seen.has(rec.entryId)
+    ) {
+      continue;
+    }
+    seen.add(rec.entryId);
+    merged.push({
+      entryId: rec.entryId,
+      skillId: rec.skillId,
+      name: rec.name,
+      changeSummary: rec.changeSummary,
+      runConversationId: rec.runConversationId,
+      createdAt: rec.createdAt,
+      ...(typeof rec.sourceConversationId === "string"
+        ? { sourceConversationId: rec.sourceConversationId }
+        : {}),
+    });
+  }
+  // Rewrite order is the receipt's order, and a merge into a sibling puts
+  // the older payload behind the newer one; the stamp restores it, with
+  // the id as a deterministic tie-break.
+  return merged.sort(
+    (a, b) => a.createdAt - b.createdAt || a.entryId.localeCompare(b.entryId),
+  );
+}
+
+/**
+ * Drop a deleted source conversation's entries from every pending
+ * `skill_update_receipt` row, deleting a row left with none. The plugin's
+ * `conversation-deleted` hook calls this beside its other per-conversation
+ * purges; the entries carry that conversation's id and a summary distilled
+ * from it. The run conversation is never a purge key: a run is an ephemeral
+ * fork that the next successful retrospective garbage-collects, and the
+ * handler reads a missing run as finished precisely so its entries still
+ * get announced. The burst's bounds are recomputed from what remains, so a
+ * dropped edge entry neither holds the rest past their quiet window nor
+ * caps them early.
+ */
+export function removeSkillUpdateReceiptEntriesForConversation(
+  conversationId: string,
+): void {
+  const db = memoryDb();
+  const rows = db
+    .select()
+    .from(memoryJobs)
+    .where(
+      and(
+        eq(memoryJobs.type, "skill_update_receipt"),
+        eq(memoryJobs.status, "pending"),
+      ),
+    )
+    .all();
+  for (const row of rows) {
+    const payload = parseSkillUpdateReceiptPayload(row.payload);
+    if (!payload) {
+      continue;
+    }
+    const kept = payload.entries.filter(
+      (entry) => entry.sourceConversationId !== conversationId,
+    );
+    if (kept.length === payload.entries.length) {
+      continue;
+    }
+    if (kept.length === 0) {
+      db.delete(memoryJobs).where(eq(memoryJobs.id, row.id)).run();
+      continue;
+    }
+    const stamps = kept.map((entry) => entry.createdAt);
+    db.update(memoryJobs)
+      .set({
+        payload: JSON.stringify({
+          firstEntryAt: Math.min(...stamps),
+          lastEntryAt: Math.max(...stamps),
+          entries: kept,
+        } satisfies SkillUpdateReceiptJobPayload),
+        updatedAt: Date.now(),
+      })
+      .where(eq(memoryJobs.id, row.id))
+      .run();
+  }
+}
+
 /**
  * Source-conversation ids of every PENDING `memory_retrospective` job. The
  * retrospective sweep skips these up front: a pending row already covers the

package/src/persistence/migrations/383-normalize-opencode-host-connections.ts

@@ -0,0 +1,44 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Restamp openai-compatible rows whose endpoint host is opencode.ai (or a
+ * subdomain) as provider "opencode". The generic adapter never sends the
+ * session headers zen/go requires, so such rows fail every request; the
+ * create route applies the same normalization on write. Hosts are judged
+ * by URL parsing, not pattern matching, so a path that merely mentions
+ * opencode.ai is left alone. Idempotent: a restamped row no longer matches.
+ * Workspace migration 158 repoints legacy-shape profile fragments bound to
+ * these rows.
+ */
+export function migrateNormalizeOpencodeHostConnections(
+  database: DrizzleDb,
+): void {
+  const raw = getSqliteFrom(database);
+
+  const rows = raw
+    .query(
+      `SELECT name, base_url FROM provider_connections
+        WHERE provider = 'openai-compatible' AND base_url IS NOT NULL`,
+    )
+    .all() as Array<{ name: string; base_url: string }>;
+
+  const restamp = raw.prepare(
+    `UPDATE provider_connections SET provider = 'opencode', updated_at = ? WHERE name = ?`,
+  );
+  const now = Date.now();
+  for (const row of rows) {
+    if (isOpenCodeHost(row.base_url)) {
+      restamp.run(now, row.name);
+    }
+  }
+}
+
+function isOpenCodeHost(baseUrl: string): boolean {
+  let host: string;
+  try {
+    host = new URL(baseUrl).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  return host === "opencode.ai" || host.endsWith(".opencode.ai");
+}

package/src/persistence/migrations/__tests__/383-normalize-opencode-host-connections.test.ts

@@ -0,0 +1,102 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import * as schema from "../../schema.js";
+import { migrateNormalizeOpencodeHostConnections } from "../383-normalize-opencode-host-connections.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec(/*sql*/ `
+    CREATE TABLE provider_connections (
+      name        TEXT PRIMARY KEY,
+      provider    TEXT NOT NULL,
+      auth        TEXT NOT NULL,
+      label       TEXT,
+      base_url    TEXT,
+      models      TEXT,
+      created_at  INTEGER NOT NULL,
+      updated_at  INTEGER NOT NULL
+    );
+  `);
+  return { sqlite, db: drizzle(sqlite, { schema }) };
+}
+
+function insertRow(
+  sqlite: Database,
+  name: string,
+  provider: string,
+  baseUrl: string | null,
+): void {
+  sqlite
+    .query(
+      /*sql*/ `INSERT INTO provider_connections (name, provider, auth, base_url, created_at, updated_at)
+       VALUES (?, ?, '{"type":"api_key","credential":"cred"}', ?, 1, 1)`,
+    )
+    .run(name, provider, baseUrl);
+}
+
+function readProvider(sqlite: Database, name: string): string | undefined {
+  const row = sqlite
+    .query(`SELECT provider FROM provider_connections WHERE name = ?`)
+    .get(name) as { provider: string } | null;
+  return row?.provider;
+}
+
+describe("migration 383: normalize opencode-host connections", () => {
+  test("restamps openai-compatible rows whose host is opencode.ai", () => {
+    const { sqlite, db } = createTestDb();
+    insertRow(
+      sqlite,
+      "go",
+      "openai-compatible",
+      "https://opencode.ai/zen/go/v1",
+    );
+    insertRow(sqlite, "zen", "openai-compatible", "https://opencode.ai/zen/v1");
+    insertRow(sqlite, "sub", "openai-compatible", "https://api.opencode.ai/v1");
+    insertRow(sqlite, "port", "openai-compatible", "https://opencode.ai:443");
+    insertRow(sqlite, "vllm", "openai-compatible", "http://localhost:8080/v1");
+    insertRow(sqlite, "no-url", "openai-compatible", null);
+    insertRow(
+      sqlite,
+      "lookalike",
+      "openai-compatible",
+      "https://opencode.ai.evil.example/v1",
+    );
+    insertRow(
+      sqlite,
+      "path-only",
+      "openai-compatible",
+      "https://proxy.example/cache/api.opencode.ai/v1",
+    );
+    insertRow(sqlite, "garbage", "openai-compatible", "not a url");
+    insertRow(sqlite, "ollama", "ollama", "https://opencode.ai/v1");
+
+    migrateNormalizeOpencodeHostConnections(db);
+
+    expect(readProvider(sqlite, "go")).toBe("opencode");
+    expect(readProvider(sqlite, "zen")).toBe("opencode");
+    expect(readProvider(sqlite, "sub")).toBe("opencode");
+    expect(readProvider(sqlite, "port")).toBe("opencode");
+    expect(readProvider(sqlite, "vllm")).toBe("openai-compatible");
+    expect(readProvider(sqlite, "no-url")).toBe("openai-compatible");
+    expect(readProvider(sqlite, "lookalike")).toBe("openai-compatible");
+    expect(readProvider(sqlite, "path-only")).toBe("openai-compatible");
+    expect(readProvider(sqlite, "garbage")).toBe("openai-compatible");
+    expect(readProvider(sqlite, "ollama")).toBe("ollama");
+  });
+
+  test("is idempotent", () => {
+    const { sqlite, db } = createTestDb();
+    insertRow(
+      sqlite,
+      "go",
+      "openai-compatible",
+      "https://opencode.ai/zen/go/v1",
+    );
+    migrateNormalizeOpencodeHostConnections(db);
+    migrateNormalizeOpencodeHostConnections(db);
+    expect(readProvider(sqlite, "go")).toBe("opencode");
+  });
+});

package/src/persistence/steps.ts

@@ -493,6 +493,7 @@ import {
   migrateCreateConversationModeSessions,
 } from "./migrations/381-create-conversation-mode-sessions.js";
 import { migrateCreateClientConnectionEvents } from "./migrations/382-create-client-connection-events.js";
+import { migrateNormalizeOpencodeHostConnections } from "./migrations/383-normalize-opencode-host-connections.js";
 import type { MigrationStep } from "./migrations/run-migrations.js";
 
 export const migrationSteps: MigrationStep[] = [
@@ -1649,4 +1650,15 @@ export const migrationSteps: MigrationStep[] = [
     ],
   },
   migrateCreateClientConnectionEvents,
+  {
+    name: "migrateNormalizeOpencodeHostConnections",
+    run: migrateNormalizeOpencodeHostConnections,
+    // Reads and rewrites provider_connections.base_url; the table and the
+    // column come from these steps, so a database where either failed must
+    // not checkpoint this one against nothing.
+    dependsOn: [
+      "migrateCreateProviderConnections",
+      "migrateProviderConnectionBaseUrlAndModels",
+    ],
+  },
 ];

package/src/platform/sync-avatar.test.ts

@@ -709,6 +709,35 @@ describe("syncAvatarToPlatform", () => {
     expect(patches).toHaveLength(1);
   });
 
+  test("an older rendering spec re-uploads the same avatar once", async () => {
+    mockResvgAvailable = true;
+    syncAvatarToPlatform();
+    await settle();
+    const current = JSON.parse(readFileSync(syncStatePath, "utf-8"));
+    const previous = {
+      ...current,
+      key: current.key.replace(
+        `:${NOTIFICATION_AVATAR_SPEC_VERSION}:`,
+        `:${NOTIFICATION_AVATAR_SPEC_VERSION - 1}:`,
+      ),
+    };
+    expect(previous.key).not.toBe(current.key);
+    writeFileSync(syncStatePath, JSON.stringify(previous));
+
+    _resetSyncAvatarStateForTests();
+    syncAvatarToPlatform();
+    await settle();
+    _resetSyncAvatarStateForTests();
+    syncAvatarToPlatform();
+    await settle();
+
+    expect(patches).toHaveLength(2);
+    expect(patches[1].body.notification_avatar_base64).toBeDefined();
+    expect(JSON.parse(readFileSync(syncStatePath, "utf-8")).key).toBe(
+      current.key,
+    );
+  });
+
   test("a restart re-uploads when the destination or raster changed", async () => {
     syncAvatarToPlatform();
     await settle();

package/src/plugins/defaults/memory/AGENTS.md

@@ -82,8 +82,10 @@ Everything else under the plugin root is **spine**:
   `conversation-memory-orphan-sweep`, `fork-conversation-memory`,
   `find-most-recent-retrospective-for`.
 - The `memory-retrospective-*` family — tier-agnostic, gated on
-  `memory.enabled` alone. The one exception is
-  `memory-retrospective-skill-card.ts`, whose upstream enqueue only fires when
+  `memory.enabled` alone. The exceptions are
+  `memory-retrospective-skill-card.ts` and `skill-update-receipt-job.ts` (one
+  pending job collects a burst of background skill rewrites and announces it
+  once it settles), whose upstream producers only fire when
   `isV3TierActive()` holds (memory on and v3 live).
 - The rest of the spine: `startup.ts`, `jobs-worker.ts`, `job-handlers.ts`,
   `job-handler-registration.ts`, `indexer.ts`, `injectors.ts`, `tools.ts`,
@@ -499,7 +501,7 @@ Persisted in job rows; unknown types either throw or get silently drained.
 - v2 engine: `memory_v2_migrate`, `memory_v2_activation_recompute`
 - v3: `memory_v3_maintain`
 - Retrospective: `memory_retrospective`, `memory_retrospective_sweep`,
-  `skill_card_insert`
+  `skill_card_insert`, `skill_update_receipt`
 - v1: `graph_extract`, `graph_decay`, `graph_consolidate`, `graph_pattern_scan`,
   `graph_narrative_refine`, `graph_bootstrap`, `embed_pkb_file`, `pkb_filing`,
   `pkb_compaction`, `rebuild_index`, `backfill`, `delete_qdrant_vectors`,

package/src/plugins/defaults/memory/__tests__/skill-update-receipt-boundary-guard.test.ts

@@ -0,0 +1,45 @@
+/**
+ * The receipt job announces a receipt through the notification pipeline and
+ * reads what the pipeline did; it never writes the home feed itself and
+ * never releases a dedupe key the pipeline kept. A verdict the pipeline
+ * reached (a block, a suppression, a no-notify decision) is the pipeline's to
+ * make, and a home-feed row written from here would be a notification the
+ * routing declined. This guard pins the import surface that keeps that so.
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+const MODULE_DIR = join(import.meta.dir, "..");
+
+function importedNames(file: string): string[] {
+  const source = readFileSync(join(MODULE_DIR, file), "utf-8");
+  const names: string[] = [];
+  for (const match of source.matchAll(
+    /import\s*(?:type\s*)?\{([^}]*)\}\s*from/g,
+  )) {
+    for (const raw of match[1]!.split(",")) {
+      const name = raw
+        .replace(/^\s*type\s+/, "")
+        .split(/\s+as\s+/)[0]!
+        .trim();
+      if (name) {
+        names.push(name);
+      }
+    }
+  }
+  return names;
+}
+
+describe("skill-update receipt boundary", () => {
+  for (const file of ["skill-update-receipt-job.ts"]) {
+    test(`${file} neither writes the home feed nor releases a dedupe key`, () => {
+      const names = importedNames(file);
+      expect(names).not.toContain("appendFeedItem");
+      expect(names).not.toContain("patchFeedItemContent");
+      expect(names).not.toContain("writeHomeFeedItemForSignal");
+      expect(names).not.toContain("setEventDedupeKey");
+    });
+  }
+});