@vellumai/assistant 0.12.3 → 0.12.4-dev.202609231620.a15f321

package/src/persistence/embeddings/embedding-local.ts

@@ -7,6 +7,8 @@ import {
 } from "node:fs";
 import { join } from "node:path";
 
+import type { Subprocess } from "bun";
+
 import { getIsContainerized } from "../../config/env-registry.js";
 import { getLogger } from "../../util/logger.js";
 import {
@@ -22,6 +24,7 @@ import {
   listWorkerProcesses,
   pid1OwnsWorkers,
 } from "../../util/worker-ownership.js";
+import { writeWorkerLine } from "../../util/worker-pipe.js";
 import { EmbeddingRuntimeManager } from "./embedding-runtime-manager.js";
 import {
   type EmbeddingBackend,
@@ -106,9 +109,7 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
   readonly provider = "local" as const;
   readonly model: string;
 
-  // Subprocess — typed loosely to avoid coupling to Bun's Subprocess generics
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private workerProc: any = null;
+  private workerProc: Subprocess<"pipe", "pipe", "pipe"> | null = null;
   private stdoutBuffer = "";
   private requestCounter = 0;
   private pendingRequests = new Map<
@@ -119,7 +120,10 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
   >();
   private stdoutReaderActive = false;
   private activeEmbeds = 0;
+  /** Release the worker once idle. {@link forModel} withdraws the request. */
   private disposeRequested = false;
+  /** Set by {@link shutdown}. The process is exiting, so nothing reopens this. */
+  private processExiting = false;
 
   private readonly initGuard = new PromiseGuard<void>();
   private initInFlight: Promise<void> | null = null;
@@ -130,7 +134,67 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
   /** Overridable so tests can exercise the escalation path without the wait. */
   private terminateGraceMs = WORKER_TERMINATE_GRACE_MS;
 
-  constructor(model: string) {
+  /**
+   * Every backend this process has handed out, one per model.
+   *
+   * {@link reclaimOwnedWorkers} terminates a same-model worker parented to this
+   * process that the instance holds no handle for. That is sound only while no
+   * other instance in this process can hold that worker, so instances come from
+   * {@link forModel} and are never constructed by callers.
+   *
+   * This is also the complete list of workers the process owns. The backend
+   * cache is not: it forgets a backend whose disposal is still pending.
+   */
+  private static readonly byModel = new Map<string, LocalEmbeddingBackend>();
+
+  /**
+   * The backend for `model`. A pending {@link dispose} is withdrawn, so embeds
+   * still running on the instance keep their worker.
+   */
+  static forModel(model: string): LocalEmbeddingBackend {
+    let backend = LocalEmbeddingBackend.byModel.get(model);
+    if (!backend) {
+      backend = new LocalEmbeddingBackend(model);
+      LocalEmbeddingBackend.byModel.set(model, backend);
+    }
+    if (!backend.processExiting) {
+      backend.disposeRequested = false;
+    }
+    return backend;
+  }
+
+  /** {@link shutdown} every backend, then reap any worker still parented here. */
+  static async shutdownAll(): Promise<void> {
+    await Promise.all(
+      [...LocalEmbeddingBackend.byModel.values()].map(async (backend) => {
+        try {
+          await backend.shutdown();
+          await backend.sweepOwnedWorkers();
+        } catch (err) {
+          log.warn(
+            { err, model: backend.model },
+            "Failed to shut down local embedding backend",
+          );
+        }
+      }),
+    );
+  }
+
+  /** {@link terminateNow} every backend. */
+  static terminateAllNow(): void {
+    for (const backend of LocalEmbeddingBackend.byModel.values()) {
+      try {
+        backend.terminateNow();
+      } catch (err) {
+        log.warn(
+          { err, model: backend.model },
+          "Failed to terminate local embedding worker",
+        );
+      }
+    }
+  }
+
+  private constructor(model: string) {
     this.model = model;
   }
 
@@ -193,19 +257,9 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
       }
       this.pendingRequests.set(id, { resolve });
 
-      // Writing to a worker that has already exited raises EPIPE. That must
-      // surface as an ordinary embed failure the caller can fall back from:
-      // an escaping EPIPE reaches the daemon's `unhandledRejection` handler,
-      // which tears down the whole process (JARVIS-1125).
-      //
-      // The guard covers `write` as well as `flush`: both are synchronous on
-      // Bun's FileSink, and `write` is the call that raises the broken pipe.
-      try {
-        proc.stdin.write(JSON.stringify({ id, texts }) + "\n");
-        proc.stdin.flush();
-      } catch (err) {
-        this.failPendingRequest(id, err);
-      }
+      writeWorkerLine(proc.stdin, JSON.stringify({ id, texts }), (err) =>
+        this.failPendingRequest(id, err),
+      );
     });
   }
 
@@ -929,6 +983,7 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
    * the OS confirms the worker is gone.
    */
   async shutdown(): Promise<void> {
+    this.processExiting = true;
     this.disposeRequested = true;
 
     // An initialization already in flight has not necessarily assigned

package/src/persistence/embeddings/embedding-types.ts

@@ -113,25 +113,6 @@ export interface EmbeddingBackend {
     options?: EmbeddingRequestOptions,
   ): Promise<number[][]>;
   dispose?(): void;
-  /**
-   * Deterministic teardown for daemon shutdown: release any OS resources the
-   * backend owns (e.g. a worker subprocess) and resolve only once they are
-   * confirmed gone. Unlike {@link dispose}, which may defer while embeds are
-   * in flight, this must not leave a child process behind.
-   */
-  shutdown?(): Promise<void>;
-  /**
-   * Release owned OS resources synchronously, for a process that must exit this
-   * tick. Unlike {@link shutdown} it cannot wait for confirmation, so it uses
-   * the uncatchable signal rather than the graceful one.
-   */
-  terminateNow?(): void;
-  /**
-   * Reap any owned child still attributable to this process, without needing a
-   * handle for it. Backstop for a teardown that could not resolve its handle in
-   * time.
-   */
-  sweepOwnedWorkers?(): Promise<void>;
 }
 
 /**

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/plugin-api/model-profiles.ts

@@ -1,4 +1,4 @@
-import { getUserSelectableProfilesForProvider } from "../config/default-profile-catalog.js";
+import { getConversationProfilesForProvider } from "../config/default-profile-catalog.js";
 import { getConfig } from "../config/loader.js";
 import { isDispatchableProfile } from "../config/profile-dispatchability.js";
 import { orderProfileKeys } from "../config/profile-order.js";
@@ -7,7 +7,9 @@ import type { ModelProfileInfo } from "./types.js";
 /**
  * List the workspace inference profiles a plugin can route to, in the order a
  * user-facing model picker presents them (`llm.profileOrder` first, then the
- * rest alphabetically). Managed backup routes are internal and omitted.
+ * rest alphabetically). Managed backup routes and the managed Jev profile
+ * are omitted with the rest of the conversation view: a plugin routes
+ * conversation turns, and a decision model cannot answer them.
  * Metadata-only entries without a provider, model, or mix are not routing
  * targets, so plugins never see them. Disabled profiles are included and flagged via
  * {@link ModelProfileInfo.isDisabled}; weighted "mix" profiles are included and
@@ -20,7 +22,7 @@ import type { ModelProfileInfo } from "./types.js";
 export function getModelProfiles(): ModelProfileInfo[] {
   const { llm } = getConfig();
   const { activeProfile } = llm;
-  const profiles = getUserSelectableProfilesForProvider(
+  const profiles = getConversationProfilesForProvider(
     llm.profiles,
     llm.defaultProvider ?? null,
   );

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__/memory-retrospective-skill-card.test.ts

@@ -238,6 +238,7 @@ describe("memory-retrospective skill card", () => {
       metadata: { kind: "skill-authored-card", automated: true },
       skipIndexing: true,
       clientMessageId: "skill-card-run-conv-1",
+      skipResurface: true,
     });
     // Disk view sync mirrors the wake-persist path, then clients are told to
     // refetch the message list.
@@ -423,6 +424,7 @@ describe("memory-retrospective skill card", () => {
       metadata: { kind: "skill-authored-card", automated: true },
       skipIndexing: true,
       clientMessageId: "skill-card-run-conv-1",
+      skipResurface: true,
     });
     expect(syncedToDisk).toHaveLength(1);
     expect(publishedConversationIds).toEqual(["src-conv-9"]);