@vellumai/assistant 0.11.6 → 0.11.7-staging.2

package/src/persistence/conversation-crud.ts

@@ -104,10 +104,6 @@ import {
   getSqliteFrom,
   getTelemetryDb,
 } from "./db-connection.js";
-import {
-  copyForkMessagesViaSubprocess,
-  type ForkIdPair,
-} from "./fork-message-copy.js";
 import {
   clearMessagesLexicalIndex,
   enqueueDeleteMessageLexical,
@@ -653,7 +649,7 @@ export interface ConversationRow {
   originInterface: string | null;
   forkParentConversationId: string | null;
   forkParentMessageId: string | null;
-  /** `"reference"` on referential forks; `"cloning"` or null on copied ones. */
+  /** `"reference"` on referential forks; null on copied ones. */
   forkStrategy: string | null;
   isAutoTitle: number;
   scheduleJobId: string | null;
@@ -1723,25 +1719,36 @@ function populateForkContentsInProcess(args: PopulateForkContentsArgs): void {
 }
 
 /**
- * Resolve the fork id + timestamp of the LAST assistant message among the
- * copied rows. The synchronous copy loop tracks this inline; the off-loop
- * subprocess copy does not, so the async fork derives it from the id map.
+ * How many leading rows of the inherited window sit behind the source's
+ * compaction boundary, counted in `getMessages` load order (`createdAt`
+ * only). The retrospective fork is referential: it reads the source's rows
+ * through the fork point, prefix included, so it must carry this count for
+ * the render to hide the same rows the source hides. Getting the count
+ * wrong does not lose data; it re-shows compacted history the summary
+ * already covers, or hides a visible row when a cutoff drops part of the
+ * hidden prefix from the lineage.
+ *
+ * Rows after the cutoff are skipped. The first in-window row that is not
+ * hidden ends the prefix, matching the source render's slice.
  */
-function latestForkedAssistantFrom(
-  messagesToCopy: MessageRow[],
-  forkedMessageIds: Map<string, string>,
-): { messageId: string; messageAt: number } | null {
-  for (let i = messagesToCopy.length - 1; i >= 0; i--) {
-    const message = messagesToCopy[i]!;
-    if (message.role !== "assistant") {
+function compactedPrefixLengthInWindow(
+  loadOrderIds: readonly string[],
+  compactedCount: number,
+  windowIds: ReadonlySet<string>,
+): number {
+  const hiddenIds = new Set(loadOrderIds.slice(0, compactedCount));
+  let count = 0;
+  for (const id of loadOrderIds) {
+    if (!windowIds.has(id)) {
       continue;
     }
-    const forkedMessageId = forkedMessageIds.get(message.id);
-    if (forkedMessageId) {
-      return { messageId: forkedMessageId, messageAt: message.createdAt };
+    if (hiddenIds.has(id)) {
+      count += 1;
+      continue;
     }
+    break;
   }
-  return null;
+  return count;
 }
 
 /**
@@ -1749,35 +1756,30 @@ function latestForkedAssistantFrom(
  * which forks the source conversation's visible window into a throwaway
  * background conversation on a hot path that must not stall the daemon.
  *
- * Only rows at-or-after the inherited compaction boundary are copied. The
- * retrospective wake always runs under guardian trust, whose history render
- * slices `contextCompactedMessageCount` rows off the front and prepends the
- * summary on `contextSummary` presence alone — so the fork carries the
- * inherited summary with a compacted count of 0 and renders identically to
- * the source (summary + tail) without materializing rows the agent cannot
- * see. The user-facing {@link forkConversation} keeps the full physical
- * history: user forks are long-lived and browsable, and untrusted-actor
- * views render the persisted history unsliced.
+ * The fork is referential: it holds only the rows written after it is
+ * created and reads the inherited window through `fork_parent_message_id`.
+ * The retrospective wake always runs under guardian trust, whose history
+ * render slices `contextCompactedMessageCount` rows off the front and
+ * prepends the summary on `contextSummary` presence alone, so the fork
+ * carries the source's own count and renders identically to the source
+ * (summary + tail). The user-facing {@link forkConversation} keeps the full
+ * physical history: user forks are long-lived and browsable, and
+ * untrusted-actor views render the persisted history unsliced.
  *
- * The dominant cost — copying the visible tail's message rows — runs OFF the
- * event loop in a `sqlite3` subprocess (see
- * {@link copyForkMessagesViaSubprocess}), so `/healthz` and gateway IPC stay
- * responsive during the copy. The cheap tail (conversation row, attachment
- * relink, memory-state seeding) runs in-process and reuses
- * {@link populateForkContentsInProcess}, the same helper the synchronous fork
- * uses, so the two paths cannot drift on that logic. The cutoff/boundary
- * computation mirrors {@link forkConversation} and is pinned by a parity
- * test.
+ * Creating the fork is a single conversation row plus memory-state
+ * seeding. There is no message-row copy and no attachment relink: lineage
+ * reads keep the source message ids, so `getAttachmentsForMessage` resolves
+ * against the source rows. The cutoff/boundary computation mirrors
+ * {@link forkConversation} and is pinned by a parity test.
  *
  * The disk-view projection (`syncMessageToDisk`) is intentionally skipped: the
  * fork is GC'd after the retrospective pass and never browsed, and the agent
  * reads it from the database, not the on-disk JSONL.
  *
- * Atomicity spans two connections (the in-process row/tail and the subprocess
- * copy), so a mid-flight failure can leave a partial fork. The partial is
- * deleted best-effort on error; a crash between phases is reclaimed by the
- * worker's startup orphan sweep. Callers only ever observe a fully-built fork
- * because the returned promise resolves after every phase commits.
+ * A mid-flight failure deletes the partial best-effort; a crash after the
+ * conversation row lands is reclaimed by the worker's startup orphan sweep.
+ * Callers only ever observe a fully-built fork because the returned promise
+ * resolves after every phase commits.
  */
 export async function forkConversationForRetrospective(params: {
   conversationId: string;
@@ -1850,10 +1852,6 @@ export async function forkConversationForRetrospective(params: {
   const inheritsLatestCompaction =
     inheritedCompaction != null &&
     inheritedCompaction.compactedAt === sourceConversation.contextCompactedAt;
-  // Copy only the visible tail: rows behind the inherited summary are never
-  // rendered on this fork (the retrospective wake runs under guardian trust,
-  // which slices `contextCompactedMessageCount` rows off the front), so
-  // copying them would hold the write lock for rows the agent cannot see.
   // The drop-set is the first `compactedMessageCount` rows in LOAD order —
   // the exact rows the source's render hides — rather than a positional
   // slice of the re-sorted array, whose tie order can differ at the
@@ -1862,43 +1860,29 @@ export async function forkConversationForRetrospective(params: {
   const hiddenRowIds = new Set(
     loadOrderIds.slice(0, inheritedCompaction?.compactedMessageCount ?? 0),
   );
-  // Read straight from config rather than taking a caller-supplied strategy:
-  // how a fork is materialized is a workspace-wide storage decision, and a
-  // per-call override would let two callers disagree about it on the same
-  // workspace.
-  const isReferential =
-    getConfig().memory.retrospective.forkStrategy === "reference";
-  // A referential fork copies nothing: its inherited window is read back
-  // through `forkParentMessageId` by the lineage resolver.
-  const rowsToCopy = isReferential
-    ? []
-    : messagesToCopy.filter((message) => !hiddenRowIds.has(message.id));
-  // The compacted prefix is dropped from a copied fork, so its own row count
-  // behind the boundary is 0. A referential fork reads the source's rows
-  // through the fork point, prefix included, so it must carry the source's
-  // own count for the render to hide the same rows the source hides. Getting
-  // this wrong does not lose data, it re-shows compacted history the summary
-  // already covers.
-  const forkCompactedMessageCount = isReferential
-    ? (inheritedCompaction?.compactedMessageCount ?? 0)
-    : 0;
+  const windowIds = new Set(messagesToCopy.map((message) => message.id));
+  // A referential fork reads the source's rows through the fork point,
+  // prefix included, so it carries the hidden-prefix length of that
+  // inherited window (not the source's raw count, which can hide a visible
+  // row when a cutoff drops part of the prefix from the lineage).
+  const forkCompactedMessageCount = compactedPrefixLengthInWindow(
+    loadOrderIds,
+    inheritedCompaction?.compactedMessageCount ?? 0,
+    windowIds,
+  );
+  // Visible source rows in the inherited window. Passed to memory seeding
+  // so a truncated fork re-derives `everInjected` from the child's rendered
+  // tail; attachments stay on the source ids and are not relinked.
+  const visibleSourceMessages = messagesToCopy.filter(
+    (message) => !hiddenRowIds.has(message.id),
+  );
   const forkParentMessageId = messagesToCopy.at(-1)?.id ?? null;
   const forkTitle =
     params.title ?? `${sourceConversation.title ?? "Untitled"} (Fork)`;
   const parentGroupId = getConversationGroupId(conversationId);
+  const forkedMessageIds = new Map<string, string>();
 
-  // Pre-generate the id map in JS so the same map drives the off-loop copy and
-  // the in-process attachment relink that follows.
-  const idPairs: ForkIdPair[] = rowsToCopy.map((message) => ({
-    oldId: message.id,
-    newId: uuidv7(),
-  }));
-  const forkedMessageIds = new Map<string, string>(
-    idPairs.map((pair) => [pair.oldId, pair.newId]),
-  );
-
-  // Phase 1 (in-process, tiny): create the fork conversation row + lineage so
-  // the subprocess connection sees it before inserting messages. The whole
+  // Phase 1: create the fork conversation row + lineage. The whole
   // transaction is the retry unit — it rolls back atomically on contention, so
   // re-running it (with a fresh conversation id) is safe.
   const fork = await withSqliteRetry(
@@ -1916,18 +1900,13 @@ export async function forkConversationForRetrospective(params: {
             forkParentMessageId,
             // Stamped at creation so the startup orphan sweep (which only
             // considers rows with a non-null `lastMessageAt`) can age this
-            // fork even if the daemon crashes before the copy or the
-            // retrospective instruction lands — including the empty-tail
-            // fork, which copies no rows at all. Phase 3 re-derives the same
-            // value from the copied rows when the tail is non-empty.
+            // fork even if the daemon crashes before the retrospective
+            // instruction lands — including the empty-tail fork, which
+            // copies no rows at all.
             lastMessageAt: boundaryMessageCreatedAt,
             contextSummary: inheritedCompaction?.summary ?? null,
-            // On a copied fork zero of its own rows sit behind the boundary
-            // (the compacted prefix is not copied). The summary still
-            // renders: the history render keys on `contextSummary` presence,
-            // not on this count.
             contextCompactedMessageCount: forkCompactedMessageCount,
-            forkStrategy: isReferential ? REFERENTIAL_FORK_STRATEGY : null,
+            forkStrategy: REFERENTIAL_FORK_STRATEGY,
             contextCompactedAt: inheritedCompaction?.compactedAt ?? null,
             slackContextCompactionWatermarkTs: inheritsLatestCompaction
               ? sourceConversation.slackContextCompactionWatermarkTs
@@ -1951,39 +1930,13 @@ export async function forkConversationForRetrospective(params: {
   );
 
   try {
-    // Phase 2 (off the event loop): copy the message rows in a sqlite3
-    // subprocess so the daemon stays responsive during the heavy copy. The
-    // referential fork has no rows to copy, which is the whole point of it:
-    // the write burst this phase exists to keep off the event loop does not
-    // happen at all.
-    if (!isReferential) {
-      const copy = await copyForkMessagesViaSubprocess({
-        forkConversationId: fork.id,
-        idPairs,
-      });
-      if (!copy.ok) {
-        throw new Error(
-          `fork message copy failed (${copy.backend}): ${copy.error ?? "unknown"}`,
-        );
-      }
-    }
-
-    // Phase 3 (in-process): attachments + memory-state seeding, reusing the
-    // same helper as the synchronous fork. Disk-view projection is skipped.
+    // Phase 2 (in-process): memory-state seeding. Disk-view projection and
+    // attachment relink are skipped: the fork owns no copied rows, and
+    // lineage reads keep the source message ids.
     //
-    // The populate transaction reads (attachment links) before its first
-    // write, so a deferred BEGIN would take its snapshot as a reader and any
-    // concurrent writer committing before the first write fails the
-    // read→write upgrade with SQLITE_BUSY_SNAPSHOT — a hard error
-    // `busy_timeout` cannot wait out, which would discard the entire batch
-    // copy from phase 2. `behavior: "immediate"` acquires the write lock at
-    // BEGIN so the snapshot postdates it, and the retry absorbs residual
-    // contention: the transaction rolls back atomically, so re-running it is
-    // safe.
-    const latestForkedAssistant = latestForkedAssistantFrom(
-      rowsToCopy,
-      forkedMessageIds,
-    );
+    // `behavior: "immediate"` acquires the write lock at BEGIN so the
+    // snapshot postdates it, and the retry absorbs residual contention: the
+    // transaction rolls back atomically, so re-running it is safe.
     await withSqliteRetry(
       () =>
         db.transaction(
@@ -1991,30 +1944,29 @@ export async function forkConversationForRetrospective(params: {
             populateForkContentsInProcess({
               fork,
               sourceConversationId: sourceConversation.id,
-              messagesToCopy: rowsToCopy,
+              messagesToCopy: visibleSourceMessages,
               forkedMessageIds,
-              latestForkedAssistant,
+              latestForkedAssistant: null,
               // Both conditions, for the same reason as `forkConversation`:
               // a tip boundary no longer implies an equal window once the
               // unfinalized filter dropped rows from the slice.
               isFullHistoryFork:
                 copyBoundaryIndex === sourceMessages.length - 1 &&
                 messagesToCopy.length === copyBoundaryIndex + 1,
-              // The copied range already starts at the visible window.
-              inheritedCompactedMessageCount: forkCompactedMessageCount,
+              // The seeding range already starts at the visible window.
+              inheritedCompactedMessageCount: 0,
               skipCompactionLedgerCopy: inheritedCompaction != null,
             });
             // The fork owns none of the source's ledger events — their
-            // counts index source-space row positions, and this fork row
-            // stores a count of 0. Seed a single event mirroring the fork
-            // row's compaction fields whenever a compaction is inherited
-            // (even when the hidden prefix fell outside the cutoff and
-            // nothing was dropped), so the ledger and the row cache agree
-            // and a fork of this fork inherits the summary with the
-            // fork-local count. With no inherited compaction the default
-            // ledger copy is a natural no-op (no source event is
-            // at-or-before the boundary). Rolls back with the transaction,
-            // so the retry unit stays atomic.
+            // counts index source-space row positions. Seed a single event
+            // mirroring the fork row's compaction fields whenever a
+            // compaction is inherited (even when the hidden prefix fell
+            // outside the cutoff and nothing was dropped), so the ledger
+            // and the row cache agree and a fork of this fork inherits the
+            // summary with the fork-local count. With no inherited
+            // compaction the default ledger copy is a natural no-op (no
+            // source event is at-or-before the boundary). Rolls back with
+            // the transaction, so the retry unit stays atomic.
             if (inheritedCompaction) {
               appendCompactionEvent(fork.id, {
                 compactedAt: inheritedCompaction.compactedAt,
@@ -4047,7 +3999,9 @@ export function updateMessageMetadata(
     .from(messages)
     .where(eq(messages.id, messageId))
     .get();
-  const existing = row?.metadata ? JSON.parse(row.metadata) : {};
+  // Sanitized like the transactional sibling above: a malformed stored
+  // envelope must not fail the update that is trying to stamp the row.
+  const existing = row?.metadata ? safeParseRecord(row.metadata) : {};
   db.update(messages)
     .set({ metadata: JSON.stringify({ ...existing, ...updates }) })
     .where(eq(messages.id, messageId))

package/src/persistence/conversation-title-service.ts

@@ -146,21 +146,22 @@ export function deriveDeterministicTitle(context: TitleContext): string {
  * inbound whose only content is a guardian access-request card: without this
  * the sidebar shows a permanent "Generating title…". Persisted as
  * `AUTO_TITLE_DETERMINISTIC` so a later genuine turn can still upgrade it, and
- * broadcast so connected clients converge. Returns whether the title changed.
+ * broadcast so connected clients converge. Returns the title the conversation
+ * carries once it settles, and whether this call is what set it.
  */
 export function applyDeterministicTitleIfReplaceable(
   conversationId: string,
   title: string,
-): boolean {
+): { title: string; updated: boolean } {
   const conversation = getConversation(conversationId);
   if (conversation && !isReplaceableTitle(conversation.title)) {
-    return false;
+    return { title: conversation.title!, updated: false };
   }
   const cleaned =
     truncateTitle(title.replace(/\s+/g, " ").trim()) || UNTITLED_FALLBACK;
   updateConversationTitle(conversationId, cleaned, AUTO_TITLE_DETERMINISTIC);
   publishConversationTitleChanged(conversationId, cleaned);
-  return true;
+  return { title: cleaned, updated: true };
 }
 
 // ── Title generation ─────────────────────────────────────────────────
@@ -195,19 +196,21 @@ export async function generateAndPersistConversationTitle(
     return { title: conversation.title!, updated: false };
   }
 
+  const prompt = buildTitlePrompt(context, userMessage, assistantResponse);
+  // A prompt carrying no text gives the model nothing to title from: an
+  // image-only turn submits an empty prompt, and the forced title tool makes
+  // the model fabricate a topic rather than decline.
+  if (prompt.trim() === "") {
+    return settleForDeterministicTitle(conversationId, context);
+  }
+
   const provider =
     params.provider ?? (await getConfiguredProvider("conversationTitle"));
   if (!provider) {
-    // No provider available — fall back to context-derived title or untitled.
-    // Deterministic, so keep it upgradeable by a later generation pass.
-    const fallback = deriveFallbackTitle(context) ?? UNTITLED_FALLBACK;
-    updateConversationTitle(conversationId, fallback, AUTO_TITLE_DETERMINISTIC);
-    publishConversationTitleChanged(conversationId, fallback);
     logRetryableFallback(params, "no_provider");
-    return { title: fallback, updated: true };
+    return settleForDeterministicTitle(conversationId, context);
   }
 
-  const prompt = buildTitlePrompt(context, userMessage, assistantResponse);
   const title = await generateTitleViaLLM(
     provider,
     prompt,
@@ -227,21 +230,26 @@ export async function generateAndPersistConversationTitle(
     return { title, updated: true };
   }
 
-  // No text in response — use fallback
-  // Re-check replaceability before persisting (race guard — same as the
-  // text-response path above). A concurrent custom rename may have landed
-  // while the LLM request was in-flight; writing unconditionally would
-  // clobber the user's intent.
-  const currentForFallback = getConversation(conversationId);
-  if (currentForFallback && !canReplaceTitle(currentForFallback)) {
-    return { title: currentForFallback.title!, updated: false };
-  }
-
-  const fallback = deriveFallbackTitle(context) ?? UNTITLED_FALLBACK;
-  updateConversationTitle(conversationId, fallback, AUTO_TITLE_DETERMINISTIC);
-  publishConversationTitleChanged(conversationId, fallback);
   logRetryableFallback(params, "empty_output");
-  return { title: fallback, updated: true };
+  return settleForDeterministicTitle(conversationId, context);
+}
+
+/**
+ * Settle a conversation on a title derived from its creation context, for the
+ * outcomes that produce no LLM title: the provider is unreachable, the model
+ * declined, or the prompt had no text to title from. Clearing a loading
+ * placeholder is worth doing; overwriting a title that already names the work
+ * (a background job's bootstrap title) is not, which is why this defers to
+ * `applyDeterministicTitleIfReplaceable` rather than writing directly.
+ */
+function settleForDeterministicTitle(
+  conversationId: string,
+  context: TitleContext | undefined,
+): { title: string; updated: boolean } {
+  return applyDeterministicTitleIfReplaceable(
+    conversationId,
+    deriveFallbackTitle(context) ?? UNTITLED_FALLBACK,
+  );
 }
 
 // ── Serial title-generation queue ────────────────────────────────────
@@ -531,11 +539,17 @@ function buildTitlePrompt(
     }
   }
 
-  if (userMessage) {
-    parts.push(`User: ${stripThinkingTags(userMessage)}`);
+  // Trim after stripping so a turn carrying nothing but thinking tags reads as
+  // no text at all, the same as an image-only or whitespace-only prompt.
+  const userText = userMessage ? stripThinkingTags(userMessage).trim() : "";
+  if (userText) {
+    parts.push(`User: ${userText}`);
   }
-  if (assistantResponse) {
-    parts.push(`Assistant: ${stripThinkingTags(assistantResponse)}`);
+  const assistantText = assistantResponse
+    ? stripThinkingTags(assistantResponse).trim()
+    : "";
+  if (assistantText) {
+    parts.push(`Assistant: ${assistantText}`);
   }
 
   return parts.join("\n");

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

@@ -1,6 +1,5 @@
 import {
   existsSync,
-  readdirSync,
   readFileSync,
   rmSync,
   unlinkSync,
@@ -14,6 +13,10 @@ import {
   getEmbeddingModelsDir,
   getEmbedWorkerPidPath,
 } from "../../util/platform.js";
+import {
+  listProcessTable,
+  readRawProcessCommand,
+} from "../../util/process-table.js";
 import { PromiseGuard } from "../../util/promise-guard.js";
 import { workerComputeEnv } from "../../util/worker-compute.js";
 import { workerMemoryEnv } from "../../util/worker-memory.js";
@@ -155,77 +158,7 @@ function pid1OwnsEmbedWorkers(): boolean {
   if (process.pid === 1) {
     return true;
   }
-  let cmd: string;
-  try {
-    cmd = readFileSync("/proc/1/cmdline", "utf8").split("\0").join(" ");
-  } catch {
-    const result = Bun.spawnSync({
-      cmd: ["ps", "-ww", "-p", "1", "-o", "command="],
-      stdout: "pipe",
-      stderr: "ignore",
-    });
-    if (result.exitCode !== 0) {
-      return false;
-    }
-    cmd = new TextDecoder().decode(result.stdout);
-  }
-  return cmd.includes(DAEMON_ENTRYPOINT_MARKER);
-}
-
-/** Enumerate `(pid, ppid, rawCommand)` rows from Linux `/proc`. */
-function listProcessRowsFromProc(): {
-  pid: number;
-  ppid: number;
-  cmd: string;
-}[] {
-  const rows: { pid: number; ppid: number; cmd: string }[] = [];
-  for (const entry of readdirSync("/proc")) {
-    const pid = Number(entry);
-    if (!Number.isInteger(pid) || pid <= 0) {
-      continue;
-    }
-    try {
-      // `stat` field 4 is ppid, but `comm` (field 2) may contain spaces or
-      // parens, so parse from the last ')' and a weird comm cannot shift fields.
-      const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
-      const after = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
-      const ppid = Number(after[1]);
-      const cmd = readFileSync(`/proc/${pid}/cmdline`, "utf8")
-        .split("\0")
-        .filter(Boolean)
-        .join(" ");
-      if (Number.isInteger(ppid)) {
-        rows.push({ pid, ppid, cmd });
-      }
-    } catch {
-      // Process exited between readdir and read, so skip it.
-    }
-  }
-  return rows;
-}
-
-/** Enumerate `(pid, ppid, rawCommand)` rows via `ps` (macOS / no `/proc`). */
-function listProcessRowsFromPs(): { pid: number; ppid: number; cmd: string }[] {
-  // `-ww` disables column-width truncation. Without it, macOS `ps` clips the
-  // command field to the terminal width, which can cut off the workerPath
-  // argument and hide a genuine match. Same flag is used by
-  // daemon-control.ts:123 for exactly this reason.
-  const result = Bun.spawnSync({
-    cmd: ["ps", "-A", "-ww", "-o", "pid=,ppid=,command="],
-    stdout: "pipe",
-    stderr: "ignore",
-  });
-  if (result.exitCode !== 0) {
-    return [];
-  }
-  const rows: { pid: number; ppid: number; cmd: string }[] = [];
-  for (const line of new TextDecoder().decode(result.stdout).split("\n")) {
-    const m = line.match(/^\s*(\d+)\s+(\d+)\s+(.*)$/);
-    if (m) {
-      rows.push({ pid: Number(m[1]), ppid: Number(m[2]), cmd: m[3].trim() });
-    }
-  }
-  return rows;
+  return readRawProcessCommand(1)?.includes(DAEMON_ENTRYPOINT_MARKER) ?? false;
 }
 
 /**
@@ -248,22 +181,17 @@ export function listWorkerProcesses(
   workerPath: string,
   model?: string,
 ): WorkerProcess[] {
-  let rows: { pid: number; ppid: number; cmd: string }[];
   try {
-    rows = listProcessRowsFromProc();
+    return listProcessTable()
+      .filter(
+        (row) =>
+          row.command.includes(workerPath) &&
+          (!model || row.command.split(/\s+/).includes(model)),
+      )
+      .map(({ pid, ppid }) => ({ pid, ppid }));
   } catch {
-    rows = listProcessRowsFromPs();
+    return [];
   }
-  return rows
-    .filter(
-      (r) =>
-        r.cmd.includes(workerPath) &&
-        // An argv token, not a substring: `foo/bar-small` must not match a
-        // `foo/bar-small-v2` worker, or a backend for the shorter name would
-        // reclaim the longer one's live worker. Model names carry no spaces.
-        (!model || r.cmd.split(/\s+/).includes(model)),
-    )
-    .map((r) => ({ pid: r.pid, ppid: r.ppid }));
 }
 
 /**
@@ -510,6 +438,7 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
 
     const proc = Bun.spawn({
       cmd: [bunPath, "--smol", workerPath, this.model, modelCacheDir],
+      windowsHide: true,
       env: { ...workerMemoryEnv(), ...workerComputeEnv() },
       stdin: "pipe",
       stdout: "pipe",

package/src/persistence/embeddings/embedding-runtime-manager.ts

@@ -102,6 +102,7 @@ async function downloadAndExtract(
     // Extract tarball, stripping the leading "package/" directory
     const proc = Bun.spawn({
       cmd: ["tar", "xzf", tmpTar, "-C", targetDir, "--strip-components=1"],
+      windowsHide: true,
       stdout: "ignore",
       stderr: "pipe",
     });

package/src/persistence/lifecycle-events-store.test.ts

@@ -58,6 +58,56 @@ describe("lifecycle-events-store", () => {
     });
   });
 
+  test("carries the optional attributes onto the wire payload", () => {
+    const event = recordLifecycleEvent("permission_prompt:bash", {
+      toolName: "bash",
+      riskLevel: "high",
+      riskThreshold: "low",
+      surface: "slack",
+      conversationId: "conv-xyz",
+    });
+    expect(event).not.toBeNull();
+
+    const rows = outboxRows();
+    expect(rows).toHaveLength(1);
+    // The conversation is stamped on the row too, so deleting the conversation
+    // deletes the pending event with it.
+    expect(rows[0]!.conversation_id).toBe("conv-xyz");
+    expect(JSON.parse(rows[0]!.payload)).toEqual({
+      type: "lifecycle",
+      daemon_event_id: event!.id,
+      event_name: "permission_prompt:bash",
+      recorded_at: event!.createdAt,
+      assistant_version: APP_VERSION,
+      tool_name: "bash",
+      risk_level: "high",
+      risk_threshold: "low",
+      surface: "slack",
+      conversation_id: "conv-xyz",
+    });
+  });
+
+  test("omits attributes that are unset or empty", () => {
+    // The wire schema requires at least one character, and one failing field
+    // makes the server drop the whole event.
+    const event = recordLifecycleEvent("permission_prompt:bash", {
+      toolName: "bash",
+      riskLevel: "high",
+      surface: "",
+    });
+
+    expect(JSON.parse(outboxRows()[0]!.payload)).toEqual({
+      type: "lifecycle",
+      daemon_event_id: event!.id,
+      event_name: "permission_prompt:bash",
+      recorded_at: event!.createdAt,
+      assistant_version: APP_VERSION,
+      tool_name: "bash",
+      risk_level: "high",
+    });
+    expect(outboxRows()[0]!.conversation_id).toBeNull();
+  });
+
   test("buildLifecycleTelemetryEvent stamps the record-time binary version", () => {
     expect(buildLifecycleTelemetryEvent("id-1", "hatch", 1234)).toEqual({
       type: "lifecycle",