@vellumai/assistant 0.7.0 → 0.7.1

package/src/ipc/skill-routes/events.ts

@@ -23,8 +23,8 @@
  *
  * - `host.events.buildEvent` — deterministic helper. Params
  *   `{ message, conversationId? }`. Returns the `AssistantEvent` envelope a
- *   skill would otherwise construct via `DAEMON_INTERNAL_ASSISTANT_ID` —
- *   keeping event-id allocation and timestamp generation on the daemon side
+ *   skill would otherwise construct locally — keeping event-id allocation
+ *   and timestamp generation on the daemon side
  *   so skill processes do not drift on UUID / clock sources.
  */
 
@@ -32,9 +32,8 @@ import { z } from "zod";
 
 import { buildAssistantEvent } from "../../runtime/assistant-event.js";
 import { assistantEventHub } from "../../runtime/assistant-event-hub.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../../runtime/assistant-scope.js";
 import type { SkillIpcRoute } from "../skill-ipc-types.js";
-import type { SkillIpcStreamingRoute } from "../skill-server.js";
+import type { SkillIpcStreamingRoute } from "../skill-ipc-types.js";
 
 // ---------------------------------------------------------------------------
 // Param schemas
@@ -42,14 +41,13 @@ import type { SkillIpcStreamingRoute } from "../skill-server.js";
 
 /**
  * `AssistantEvent` wire shape accepted by `host.events.publish`. The
- * envelope fields (`id`, `assistantId`, `emittedAt`, `message`) are
- * required; `conversationId` is optional. The `message` payload is an
- * opaque JSON object — the daemon does not narrow it before handing it to
+ * envelope fields (`id`, `emittedAt`, `message`) are required;
+ * `conversationId` is optional. The `message` payload is an opaque JSON
+ * object — the daemon does not narrow it before handing it to
  * `assistantEventHub.publish`, matching the in-process hub contract.
  */
 const AssistantEventSchema = z.object({
   id: z.string().min(1),
-  assistantId: z.string().min(1),
   conversationId: z.string().optional(),
   emittedAt: z.string().min(1),
   message: z.record(z.string(), z.unknown()),
@@ -60,7 +58,6 @@ const PublishParams = z.object({
 });
 
 const FilterSchema = z.object({
-  assistantId: z.string().min(1),
   conversationId: z.string().optional(),
 });
 
@@ -90,11 +87,7 @@ async function handlePublish(
 
 function handleBuildEvent(params?: Record<string, unknown>): unknown {
   const { message, conversationId } = BuildEventParams.parse(params);
-  return buildAssistantEvent(
-    DAEMON_INTERNAL_ASSISTANT_ID,
-    message as never,
-    conversationId,
-  );
+  return buildAssistantEvent(message as never, conversationId);
 }
 
 // ---------------------------------------------------------------------------
@@ -111,18 +104,14 @@ export const eventsStreamingRoutes: SkillIpcStreamingRoute[] = [
     method: "host.events.subscribe",
     handler: (stream, params) => {
       const { filter } = SubscribeParams.parse(params);
-      const subscription = assistantEventHub.subscribe(
+      const subscription = assistantEventHub.subscribe({
+        type: "process",
         filter,
-        (event) => {
+        callback: (event) => {
           stream.send(event);
         },
-        // The hub evicts the oldest subscriber when its cap fills. Without
-        // this callback the IPC stream would silently stop receiving events
-        // while the client still believed it was subscribed. Mirror the SSE
-        // route's behavior by tearing the stream down with a terminal error
-        // frame so the client can resubscribe.
-        { onEvict: () => stream.close("subscription evicted by hub cap") },
-      );
+        onEvict: () => stream.close("subscription evicted by hub cap"),
+      });
       return () => {
         subscription.dispose();
       };

package/src/ipc/skill-routes/identity.ts

@@ -1,17 +1,12 @@
 /**
- * Skill IPC routes: `host.identity.getAssistantName` and
- * `host.identity.getInternalAssistantId`.
+ * Skill IPC route: `host.identity.getAssistantName`.
  *
- * Match the `IdentityFacet` surface exposed by `DaemonSkillHost`:
- * - `getAssistantName` reads the assistant's display name from IDENTITY.md,
- *   normalizing the daemon helper's `null` to `undefined` (serialized as
- *   `null` over JSON, which clients translate back to `undefined`).
- * - `getInternalAssistantId` returns the `DAEMON_INTERNAL_ASSISTANT_ID`
- *   constant (`"self"`) so skill-side code uses the same internal scope.
+ * Reads the assistant's display name from IDENTITY.md, normalizing the
+ * daemon helper's `null` to `undefined` (serialized as `null` over JSON,
+ * which clients translate back to `undefined`).
  */
 
 import { getAssistantName } from "../../daemon/identity-helpers.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../../runtime/assistant-scope.js";
 import type { SkillIpcRoute } from "../skill-ipc-types.js";
 
 export const hostIdentityGetAssistantNameRoute: SkillIpcRoute = {
@@ -21,14 +16,6 @@ export const hostIdentityGetAssistantNameRoute: SkillIpcRoute = {
   },
 };
 
-export const hostIdentityGetInternalAssistantIdRoute: SkillIpcRoute = {
-  method: "host.identity.getInternalAssistantId",
-  handler: () => {
-    return DAEMON_INTERNAL_ASSISTANT_ID;
-  },
-};
-
 export const identityRoutes: SkillIpcRoute[] = [
   hostIdentityGetAssistantNameRoute,
-  hostIdentityGetInternalAssistantIdRoute,
 ];

package/src/ipc/skill-routes/index.ts

@@ -1,5 +1,5 @@
 import type { SkillIpcRoute } from "../skill-ipc-types.js";
-import type { SkillIpcStreamingRoute } from "../skill-server.js";
+import type { SkillIpcStreamingRoute } from "../skill-ipc-types.js";
 import { configRoutes } from "./config.js";
 import { eventsRoutes, eventsStreamingRoutes } from "./events.js";
 import { identityRoutes } from "./identity.js";

package/src/ipc/skill-server.ts

@@ -50,7 +50,11 @@ import { getLogger } from "../util/logger.js";
 import type { IpcRequest, IpcResponse } from "./assistant-server.js";
 
 export type { SkillIpcRoute, SkillMethodHandler } from "./skill-ipc-types.js";
-import type { SkillMethodHandler } from "./skill-ipc-types.js";
+import type {
+  SkillIpcStream,
+  SkillIpcStreamingHandler,
+  SkillMethodHandler,
+} from "./skill-ipc-types.js";
 import {
   skillIpcRoutes,
   skillIpcStreamingRoutes,
@@ -82,28 +86,6 @@ const DEFAULT_SEND_REQUEST_TIMEOUT_MS = 30_000;
 const SKILL_IPC_SUBSCRIBE_CLOSE_METHOD = "host.events.subscribe.close" as const;
 
 /** Stream handle passed to streaming-handler implementations. */
-export interface SkillIpcStream {
-  /** The original request id that opened this stream (used as the stream id). */
-  readonly id: string;
-  /**
-   * Send a delivery frame to the client. No-op after the stream has been
-   * closed (client disconnect, explicit close, or server shutdown).
-   */
-  send(payload: unknown): void;
-  /**
-   * Terminate the stream from the server side. Sends a final error frame to
-   * the client (if `errorMessage` is provided and the socket is still
-   * writable), invokes the handler-returned dispose, and unregisters the
-   * stream from the per-socket subscription map. Idempotent — subsequent
-   * calls are no-ops. Use from `onEvict`-style callbacks where the upstream
-   * source has decided to terminate the subscription, or to surface
-   * unrecoverable conditions like backpressure.
-   */
-  close(errorMessage?: string): void;
-  /** True until the stream has been disposed. */
-  readonly active: boolean;
-}
-
 /**
  * Maximum bytes Node may have queued in the socket's outbound buffer before
  * the next streaming `send` will close the stream with a backpressure error.
@@ -115,22 +97,7 @@ export interface SkillIpcStream {
  */
 const STREAM_BACKPRESSURE_BYTES = 1024 * 1024;
 
-/**
- * Handler signature for long-lived streaming methods (e.g.
- * `host.events.subscribe`). Runs synchronously with the opening request and
- * returns a dispose callback that the server invokes on client disconnect,
- * explicit close, or server shutdown.
- */
-export type SkillIpcStreamingHandler = (
-  stream: SkillIpcStream,
-  params?: Record<string, unknown>,
-) => () => void;
-
-/** Long-lived streaming route — method name + handler function. */
-export type SkillIpcStreamingRoute = {
-  method: string;
-  handler: SkillIpcStreamingHandler;
-};
+
 
 // ---------------------------------------------------------------------------
 // Per-connection context

package/src/live-voice/__tests__/runtime-websocket-shell.test.ts

@@ -97,7 +97,6 @@ type JsonFrame = Record<string, unknown>;
 
 const savedAuthEnv = {
   DISABLE_HTTP_AUTH: process.env.DISABLE_HTTP_AUTH,
-  VELLUM_UNSAFE_AUTH_BYPASS: process.env.VELLUM_UNSAFE_AUTH_BYPASS,
 };
 
 function mintGatewayToken(): string {
@@ -238,7 +237,6 @@ describe("RuntimeHttpServer live voice WebSocket shell", () => {
 
   beforeEach(async () => {
     delete process.env.DISABLE_HTTP_AUTH;
-    delete process.env.VELLUM_UNSAFE_AUTH_BYPASS;
     resolveStreamingTranscriberImpl = async () => createResolvedTranscriber();
     resolveStreamingTranscriberMock.mockClear();
     resolvedTranscribers.length = 0;
@@ -260,12 +258,6 @@ describe("RuntimeHttpServer live voice WebSocket shell", () => {
     } else {
       process.env.DISABLE_HTTP_AUTH = savedAuthEnv.DISABLE_HTTP_AUTH;
     }
-    if (savedAuthEnv.VELLUM_UNSAFE_AUTH_BYPASS === undefined) {
-      delete process.env.VELLUM_UNSAFE_AUTH_BYPASS;
-    } else {
-      process.env.VELLUM_UNSAFE_AUTH_BYPASS =
-        savedAuthEnv.VELLUM_UNSAFE_AUTH_BYPASS;
-    }
   });
 
   function openLiveVoiceClient(token = mintGatewayToken()): WebSocket {

package/src/live-voice/protocol.ts

@@ -1,4 +1,4 @@
-export const LIVE_VOICE_CLIENT_FRAME_TYPES = [
+const LIVE_VOICE_CLIENT_FRAME_TYPES = [
   "start",
   "audio",
   "ptt_release",
@@ -9,7 +9,7 @@ export const LIVE_VOICE_CLIENT_FRAME_TYPES = [
 export type LiveVoiceClientFrameType =
   (typeof LIVE_VOICE_CLIENT_FRAME_TYPES)[number];
 
-export const LIVE_VOICE_SERVER_FRAME_TYPES = [
+const _LIVE_VOICE_SERVER_FRAME_TYPES = [
   "ready",
   "busy",
   "stt_partial",
@@ -24,7 +24,7 @@ export const LIVE_VOICE_SERVER_FRAME_TYPES = [
 ] as const;
 
 export type LiveVoiceServerFrameType =
-  (typeof LIVE_VOICE_SERVER_FRAME_TYPES)[number];
+  (typeof _LIVE_VOICE_SERVER_FRAME_TYPES)[number];
 
 export const LiveVoiceProtocolErrorCode = {
   InvalidJson: "invalid_json",
@@ -38,15 +38,6 @@ export const LiveVoiceProtocolErrorCode = {
 export type LiveVoiceProtocolErrorCode =
   (typeof LiveVoiceProtocolErrorCode)[keyof typeof LiveVoiceProtocolErrorCode];
 
-export const LIVE_VOICE_PROTOCOL_ERROR_CODES = [
-  LiveVoiceProtocolErrorCode.InvalidJson,
-  LiveVoiceProtocolErrorCode.InvalidFrame,
-  LiveVoiceProtocolErrorCode.UnknownType,
-  LiveVoiceProtocolErrorCode.MissingRequiredField,
-  LiveVoiceProtocolErrorCode.InvalidField,
-  LiveVoiceProtocolErrorCode.InvalidAudioPayload,
-] as const satisfies readonly LiveVoiceProtocolErrorCode[];
-
 export interface LiveVoiceProtocolError {
   readonly code: LiveVoiceProtocolErrorCode;
   readonly message: string;
@@ -208,7 +199,7 @@ export type LiveVoiceServerFramePayload =
   | WithoutSeq<LiveVoiceArchivedServerFrame>
   | WithoutSeq<LiveVoiceErrorServerFrame>;
 
-export class LiveVoiceServerFrameSequencer {
+class LiveVoiceServerFrameSequencer {
   private seq: number;
 
   constructor(initialSeq = 0) {

package/src/mcp/manager.ts

@@ -169,8 +169,3 @@ export function getMcpServerManager(): McpServerManager {
   }
   return instance;
 }
-
-/** Reset singleton for testing. */
-export function __resetMcpManagerForTesting(): void {
-  instance = null;
-}

package/src/memory/__tests__/fixtures/memory-v2-activation-fixtures.ts

@@ -0,0 +1,55 @@
+import type {
+  MemoryV2ConceptRowRecord,
+  MemoryV2ConfigSnapshot,
+  MemoryV2SkillRowRecord,
+} from "../../memory-v2-activation-log-store.js";
+
+export const sampleConcepts: MemoryV2ConceptRowRecord[] = [
+  {
+    slug: "concept-a",
+    finalActivation: 0.9,
+    ownActivation: 0.7,
+    priorActivation: 0.5,
+    simUser: 0.6,
+    simAssistant: 0.4,
+    simNow: 0.3,
+    spreadContribution: 0.2,
+    source: "both",
+    status: "injected",
+  },
+  {
+    slug: "concept-b",
+    finalActivation: 0.4,
+    ownActivation: 0.3,
+    priorActivation: 0.1,
+    simUser: 0.2,
+    simAssistant: 0.1,
+    simNow: 0.05,
+    spreadContribution: 0.0,
+    source: "ann_top50",
+    status: "not_injected",
+  },
+];
+
+export const sampleSkills: MemoryV2SkillRowRecord[] = [
+  {
+    id: "skill-1",
+    activation: 0.8,
+    simUser: 0.5,
+    simAssistant: 0.4,
+    simNow: 0.3,
+    status: "injected",
+  },
+];
+
+export const sampleConfig: MemoryV2ConfigSnapshot = {
+  d: 0.85,
+  c_user: 1.0,
+  c_assistant: 0.5,
+  c_now: 0.25,
+  k: 5,
+  hops: 2,
+  top_k: 10,
+  top_k_skills: 3,
+  epsilon: 0.001,
+};

package/src/memory/__tests__/memory-v2-activation-log-store.test.ts

@@ -0,0 +1,127 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+  }),
+}));
+
+import { getDb } from "../db-connection.js";
+import { initializeDb } from "../db-init.js";
+import {
+  backfillMemoryV2ActivationMessageId,
+  getMemoryV2ActivationLogByMessageIds,
+  recordMemoryV2ActivationLog,
+} from "../memory-v2-activation-log-store.js";
+import { memoryV2ActivationLogs } from "../schema.js";
+import {
+  sampleConcepts,
+  sampleConfig,
+  sampleSkills,
+} from "./fixtures/memory-v2-activation-fixtures.js";
+
+initializeDb();
+
+function resetTables(): void {
+  const db = getDb();
+  db.delete(memoryV2ActivationLogs).run();
+}
+
+describe("memory-v2-activation-log-store", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("round-trip: record → backfill messageId → query by messageId", () => {
+    const conversationId = "conv-1";
+    const messageId = "msg-1";
+
+    recordMemoryV2ActivationLog({
+      conversationId,
+      turn: 3,
+      mode: "per-turn",
+      concepts: sampleConcepts,
+      skills: sampleSkills,
+      config: sampleConfig,
+    });
+
+    backfillMemoryV2ActivationMessageId(conversationId, messageId);
+
+    const result = getMemoryV2ActivationLogByMessageIds([messageId]);
+    expect(result).not.toBeNull();
+    expect(result!.conversationId).toBe(conversationId);
+    expect(result!.turn).toBe(3);
+    expect(result!.mode).toBe("per-turn");
+    expect(result!.concepts).toEqual(sampleConcepts);
+    expect(result!.skills).toEqual(sampleSkills);
+    expect(result!.config).toEqual(sampleConfig);
+  });
+
+  test("returns null for empty messageIds array", () => {
+    const result = getMemoryV2ActivationLogByMessageIds([]);
+    expect(result).toBeNull();
+  });
+
+  test("backfill only updates rows with NULL messageId", () => {
+    const conversationId = "conv-2";
+
+    recordMemoryV2ActivationLog({
+      conversationId,
+      turn: 1,
+      mode: "context-load",
+      concepts: sampleConcepts,
+      skills: sampleSkills,
+      config: sampleConfig,
+    });
+    recordMemoryV2ActivationLog({
+      conversationId,
+      turn: 2,
+      mode: "per-turn",
+      concepts: sampleConcepts,
+      skills: sampleSkills,
+      config: sampleConfig,
+    });
+
+    // First backfill: both rows should now have msg-a.
+    backfillMemoryV2ActivationMessageId(conversationId, "msg-a");
+
+    const db = getDb();
+    const afterFirstBackfill = db.select().from(memoryV2ActivationLogs).all();
+    expect(afterFirstBackfill).toHaveLength(2);
+    for (const row of afterFirstBackfill) {
+      expect(row.messageId).toBe("msg-a");
+    }
+
+    // Record a third row (messageId is NULL initially).
+    recordMemoryV2ActivationLog({
+      conversationId,
+      turn: 3,
+      mode: "per-turn",
+      concepts: sampleConcepts,
+      skills: sampleSkills,
+      config: sampleConfig,
+    });
+
+    // Second backfill with msg-b should only set the third row,
+    // and must not overwrite the first two rows already set to msg-a.
+    backfillMemoryV2ActivationMessageId(conversationId, "msg-b");
+
+    const afterSecondBackfill = db.select().from(memoryV2ActivationLogs).all();
+    const byTurn = new Map(afterSecondBackfill.map((r) => [r.turn, r]));
+    expect(byTurn.get(1)!.messageId).toBe("msg-a");
+    expect(byTurn.get(2)!.messageId).toBe("msg-a");
+    expect(byTurn.get(3)!.messageId).toBe("msg-b");
+  });
+});

package/src/memory/app-git-service.ts

@@ -132,38 +132,6 @@ function validateRelativePath(path: string): void {
   }
 }
 
-// ---------------------------------------------------------------------------
-// Initialization & commit
-// ---------------------------------------------------------------------------
-
-/**
- * Eagerly initialize the app git repo so that the "Initial commit" is
- * created before any app files are written. Without this, the first
- * mutation's files get absorbed into WorkspaceGitService's bootstrap
- * commit and the "Create app: ..." commit ends up empty.
- *
- * Safe to call multiple times -- ensureInitialized() is idempotent.
- * Commit app changes to the apps git repository.
- *
- * This is fire-and-forget: errors are logged but never thrown.
- * The caller should not await the returned promise unless it needs
- * to guarantee the commit completed (e.g. in tests).
- */
-export async function commitAppChange(message: string): Promise<void> {
-  try {
-    const appsDir = getAppsDir();
-
-    // Re-check .gitignore rules every call in case the apps dir was
-    // recreated while the process was running.
-    ensureAppGitignoreRules(appsDir);
-
-    const gitService = getWorkspaceGitService(appsDir);
-    await gitService.commitChanges(message);
-  } catch (err) {
-    log.error({ err, message }, "Failed to commit app change");
-  }
-}
-
 /**
  * Commit app changes at turn boundaries.
  *

package/src/memory/app-store.ts

@@ -36,7 +36,9 @@ import {
 
 import type { EditEngineResult } from "../tools/shared/filesystem/edit-engine.js";
 import { applyEdit } from "../tools/shared/filesystem/edit-engine.js";
+import { getLogger } from "../util/logger.js";
 import { getDataDir } from "../util/platform.js";
+import { rawAll } from "./raw-query.js";
 
 export interface AppDefinition {
   id: string;
@@ -55,6 +57,8 @@ export interface AppDefinition {
   formatVersion?: number;
   /** Filesystem directory/file stem. Frozen at creation -- never changes on rename. */
   dirName?: string;
+  /** Conversation IDs that have interacted with this app (create/open/refresh). */
+  conversationIds?: string[];
 }
 
 /**
@@ -901,4 +905,154 @@ export function editAppFile(
   return result;
 }
 
+// ---------------------------------------------------------------------------
+// Conversation association helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Associate a conversation with an app. Writes directly to the JSON metadata
+ * file without bumping `updatedAt` so the app list ordering is preserved.
+ *
+ * @returns `true` if the association was added, `false` if the app was not
+ *   found or the conversationId was already present (dedup).
+ */
+export function addAppConversationId(
+  appId: string,
+  conversationId: string,
+): boolean {
+  const app = getApp(appId);
+  if (!app) return false;
+
+  const { dirName } = resolveAppDir(appId);
+  const dir = getAppsDir();
+  const jsonPath = join(dir, `${dirName}.json`);
+
+  // Atomic read-modify-write: re-read the file immediately before writing
+  // so concurrent callers (e.g. two tool_result handlers for the same app
+  // in different conversations) merge against the latest on-disk state.
+  // Because readFileSync → JSON.parse → writeFileSync is a synchronous
+  // chain with no async gaps, Node/Bun's single-threaded event loop
+  // guarantees no interleaving between the read and the write.
+  const raw = readFileSync(jsonPath, "utf-8");
+  const parsed = JSON.parse(raw) as Record<string, unknown>;
+  const onDiskIds = Array.isArray(parsed.conversationIds)
+    ? (parsed.conversationIds as string[])
+    : [];
+
+  if (onDiskIds.includes(conversationId)) return false;
+
+  parsed.conversationIds = [...onDiskIds, conversationId];
+  writeFileSync(jsonPath, JSON.stringify(parsed, null, 2));
+
+  return true;
+}
+
+/**
+ * Return all apps associated with a given conversation ID.
+ */
+export function listAppsByConversation(
+  conversationId: string,
+): AppDefinition[] {
+  return listApps().filter((app) =>
+    app.conversationIds?.includes(conversationId),
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Backfill: scan message history for ui_surface blocks referencing apps
+// ---------------------------------------------------------------------------
+
+/**
+ * Single-pass scan over the messages table to populate `conversationIds` on
+ * existing app definitions. Finds messages containing `ui_surface` blocks
+ * with a `data.appId`, then calls `addAppConversationId` for each pair.
+ *
+ * Runs once per workspace: after a successful backfill a sentinel file
+ * (`<appsDir>/.conversation-ids-backfilled`) is written. Subsequent daemon
+ * startups skip the scan entirely. If the apps directory is wiped the
+ * sentinel disappears and the backfill re-runs — which is correct behavior.
+ *
+ * Wrapped in try/catch so failures never block daemon start.
+ */
+export function backfillAppConversationIds(): void {
+  const log = getLogger("app-store");
+
+  // Check sentinel — skip the potentially expensive scan when already done.
+  const sentinelPath = join(getAppsDir(), ".conversation-ids-backfilled");
+  if (existsSync(sentinelPath)) {
+    log.debug("Skipping backfillAppConversationIds — sentinel exists");
+    return;
+  }
+
+  try {
+    const rows = rawAll<{ conversation_id: string; content: string }>(
+      `SELECT conversation_id, content FROM messages WHERE content LIKE '%"type":"ui_surface"%'`,
+    );
+
+    // Build appId → Set<conversationId> map in a single pass
+    const appConvMap = new Map<string, Set<string>>();
+
+    for (const row of rows) {
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(row.content);
+      } catch {
+        // Skip rows that fail to parse
+        continue;
+      }
+
+      if (!Array.isArray(parsed)) continue;
+
+      for (const block of parsed) {
+        if (
+          block &&
+          typeof block === "object" &&
+          (block as Record<string, unknown>).type === "ui_surface"
+        ) {
+          const data = (block as Record<string, unknown>).data;
+          if (data && typeof data === "object") {
+            const appId = (data as Record<string, unknown>).appId;
+            if (typeof appId === "string" && appId.length > 0) {
+              let convIds = appConvMap.get(appId);
+              if (!convIds) {
+                convIds = new Set<string>();
+                appConvMap.set(appId, convIds);
+              }
+              convIds.add(row.conversation_id);
+            }
+          }
+        }
+      }
+    }
+
+    // Apply associations
+    let appsUpdated = 0;
+    let associationsAdded = 0;
+
+    for (const [appId, conversationIds] of appConvMap) {
+      let appHadNewAssociation = false;
+      for (const conversationId of conversationIds) {
+        const added = addAppConversationId(appId, conversationId);
+        if (added) {
+          associationsAdded++;
+          appHadNewAssociation = true;
+        }
+      }
+      if (appHadNewAssociation) {
+        appsUpdated++;
+      }
+    }
+
+    log.info(
+      { appsUpdated, associationsAdded },
+      `Backfilled app conversationIds: ${appsUpdated} apps, ${associationsAdded} associations`,
+    );
+
+    // Write sentinel so subsequent startups skip this scan.
+    writeFileSync(sentinelPath, new Date().toISOString(), "utf-8");
+  } catch (err) {
+    log.error({ err }, "Failed to backfill app conversationIds");
+  }
+}
+
 export type { EditEngineResult };