vellum 0.0.16 → 0.2.0

package/src/daemon/handlers/index.ts

@@ -0,0 +1,355 @@
+import * as net from 'node:net';
+import type { ClientMessage } from '../ipc-protocol.js';
+import { handleRideShotgunStart, handleRideShotgunStop } from '../ride-shotgun-handler.js';
+import { handleWatchObservation } from '../watch-handler.js';
+import { handleOpenBundle } from './open-bundle-handler.js';
+import { log, pendingSignBundlePayload, pendingSigningIdentity, type HandlerContext } from './shared.js';
+import { browserManager } from '../../tools/browser/browser-manager.js';
+
+import {
+  handleUserMessage,
+  handleConfirmationResponse,
+  handleSecretResponse,
+  handleSessionList,
+  handleSessionsClear,
+  handleSessionCreate,
+  handleSessionSwitch,
+  handleCancel,
+  handleDeleteQueuedMessage,
+  handleHistoryRequest,
+  handleUndo,
+  handleRegenerate,
+  handleUsageRequest,
+  handleSandboxSet,
+} from './sessions.js';
+
+import {
+  handleSkillsList,
+  handleSkillDetail,
+  handleSkillsEnable,
+  handleSkillsDisable,
+  handleSkillsConfigure,
+  handleSkillsInstall,
+  handleSkillsUninstall,
+  handleSkillsUpdate,
+  handleSkillsCheckUpdates,
+  handleSkillsSearch,
+  handleSkillsInspect,
+} from './skills.js';
+
+import {
+  handleAppDataRequest,
+  handleAppOpenRequest,
+  handleAppUpdatePreview,
+  handleAppPreview,
+  handleAppsList,
+  handleSharedAppsList,
+  handleSharedAppDelete,
+  handleForkSharedApp,
+  handleShareAppCloud,
+  handleBundleApp,
+  handleGalleryList,
+  handleGalleryInstall,
+} from './apps.js';
+
+import {
+  handleModelGet,
+  handleModelSet,
+  handleAddTrustRule,
+  handleTrustRulesList,
+  handleRemoveTrustRule,
+  handleUpdateTrustRule,
+  handleAcceptStarterBundle,
+  handleSchedulesList,
+  handleScheduleToggle,
+  handleScheduleRemove,
+  handleRemindersList,
+  handleReminderCancel,
+  handleShareToSlack,
+  handleSlackWebhookConfig,
+  handleVercelApiConfig,
+  handleEnvVarsRequest,
+} from './config.js';
+
+import {
+  handleCuSessionCreate,
+  handleCuSessionAbort,
+  handleCuObservation,
+} from './computer-use.js';
+
+import {
+  handlePublishPage,
+  handleUnpublishPage,
+} from './publish.js';
+import { handleHomeBaseGet } from './home-base.js';
+import { handleDiagnosticsExport } from './diagnostics.js';
+
+import {
+  handleTaskSubmit,
+  handleSuggestionRequest,
+  handleLinkOpenRequest,
+  handleIpcBlobProbe,
+} from './misc.js';
+
+import {
+  handleDocumentSave,
+  handleDocumentLoad,
+  handleDocumentList,
+} from './documents.js';
+
+import {
+  handleWorkItemsList,
+  handleWorkItemGet,
+  handleWorkItemCreate,
+  handleWorkItemUpdate,
+  handleWorkItemComplete,
+  handleWorkItemRunTask,
+} from './work-items.js';
+
+import {
+  handleSubagentAbort,
+  handleSubagentStatus,
+  handleSubagentMessage,
+} from './subagents.js';
+
+// Re-export types and utilities for backwards compatibility
+export type {
+  HandlerContext,
+  SessionCreateOptions,
+  HistoryToolCall,
+  HistorySurface,
+  RenderedHistoryContent,
+  ParsedHistoryMessage,
+} from './shared.js';
+
+export {
+  renderHistoryContent,
+  mergeToolResults,
+} from './shared.js';
+
+// ─── Typed dispatch ──────────────────────────────────────────────────────────
+
+type MessageType = ClientMessage['type'];
+// 'auth' is handled at the transport layer (server.ts) and never reaches dispatch.
+type DispatchableType = Exclude<MessageType, 'auth'>;
+type MessageOfType<T extends MessageType> = Extract<ClientMessage, { type: T }>;
+type MessageHandler<T extends MessageType> = (
+  msg: MessageOfType<T>,
+  socket: net.Socket,
+  ctx: HandlerContext,
+) => void | Promise<void>;
+type DispatchMap = { [T in DispatchableType]: MessageHandler<T> };
+
+const handlers: DispatchMap = {
+  user_message: handleUserMessage,
+  confirmation_response: handleConfirmationResponse,
+  secret_response: handleSecretResponse,
+  session_list: (_msg, socket, ctx) => handleSessionList(socket, ctx),
+  session_create: handleSessionCreate,
+  sessions_clear: (_msg, socket, ctx) => handleSessionsClear(socket, ctx),
+  session_switch: handleSessionSwitch,
+  cancel: handleCancel,
+  delete_queued_message: handleDeleteQueuedMessage,
+  model_get: (_msg, socket, ctx) => handleModelGet(socket, ctx),
+  model_set: handleModelSet,
+  history_request: handleHistoryRequest,
+  undo: handleUndo,
+  regenerate: handleRegenerate,
+  usage_request: handleUsageRequest,
+  sandbox_set: handleSandboxSet,
+  cu_session_create: handleCuSessionCreate,
+  cu_session_abort: handleCuSessionAbort,
+  cu_observation: handleCuObservation,
+  ride_shotgun_start: handleRideShotgunStart,
+  ride_shotgun_stop: handleRideShotgunStop,
+  watch_observation: handleWatchObservation,
+  task_submit: handleTaskSubmit,
+  app_data_request: handleAppDataRequest,
+  skills_list: (_msg, socket, ctx) => handleSkillsList(socket, ctx),
+  skill_detail: handleSkillDetail,
+  skills_enable: handleSkillsEnable,
+  skills_disable: handleSkillsDisable,
+  skills_configure: handleSkillsConfigure,
+  skills_install: handleSkillsInstall,
+  skills_uninstall: handleSkillsUninstall,
+  skills_update: handleSkillsUpdate,
+  skills_check_updates: handleSkillsCheckUpdates,
+  skills_search: handleSkillsSearch,
+  skills_inspect: handleSkillsInspect,
+  suggestion_request: handleSuggestionRequest,
+  add_trust_rule: handleAddTrustRule,
+  trust_rules_list: (_msg, socket, ctx) => handleTrustRulesList(socket, ctx),
+  remove_trust_rule: handleRemoveTrustRule,
+  update_trust_rule: handleUpdateTrustRule,
+  accept_starter_bundle: (_msg, socket, ctx) => handleAcceptStarterBundle(socket, ctx),
+  schedules_list: (_msg, socket, ctx) => handleSchedulesList(socket, ctx),
+  schedule_toggle: handleScheduleToggle,
+  schedule_remove: handleScheduleRemove,
+  reminders_list: (_msg, socket, ctx) => handleRemindersList(socket, ctx),
+  reminder_cancel: handleReminderCancel,
+  share_app_cloud: handleShareAppCloud,
+  bundle_app: handleBundleApp,
+  open_bundle: handleOpenBundle,
+  app_open_request: (msg, socket, ctx) => handleAppOpenRequest(msg, socket, ctx),
+  app_update_preview: handleAppUpdatePreview,
+  apps_list: (_msg, socket, ctx) => handleAppsList(socket, ctx),
+  app_preview_request: handleAppPreview,
+  home_base_get: handleHomeBaseGet,
+  shared_apps_list: (_msg, socket, ctx) => handleSharedAppsList(socket, ctx),
+  shared_app_delete: handleSharedAppDelete,
+  fork_shared_app: handleForkSharedApp,
+  sign_bundle_payload_response: (msg) => {
+    const pending = pendingSignBundlePayload.get(msg.requestId);
+    if (pending) {
+      clearTimeout(pending.timer);
+      pendingSignBundlePayload.delete(msg.requestId);
+      pending.resolve({ signature: msg.signature, keyId: msg.keyId, publicKey: msg.publicKey });
+    } else {
+      log.warn({ requestId: msg.requestId }, 'Received sign_bundle_payload_response with no pending request');
+    }
+  },
+  get_signing_identity_response: (msg) => {
+    const pending = pendingSigningIdentity.get(msg.requestId);
+    if (pending) {
+      clearTimeout(pending.timer);
+      pendingSigningIdentity.delete(msg.requestId);
+      pending.resolve({ keyId: msg.keyId, publicKey: msg.publicKey });
+    } else {
+      log.warn({ requestId: msg.requestId }, 'Received get_signing_identity_response with no pending request');
+    }
+  },
+  gallery_list: (_msg, socket, ctx) => handleGalleryList(socket, ctx),
+  gallery_install: handleGalleryInstall,
+  share_to_slack: handleShareToSlack,
+  slack_webhook_config: handleSlackWebhookConfig,
+  vercel_api_config: handleVercelApiConfig,
+  publish_page: handlePublishPage,
+  unpublish_page: handleUnpublishPage,
+  ping: (_msg, socket, ctx) => { ctx.send(socket, { type: 'pong' }); },
+  link_open_request: handleLinkOpenRequest,
+  ipc_blob_probe: handleIpcBlobProbe,
+  ui_surface_action: (msg, _socket, ctx) => {
+    const cuSession = ctx.cuSessions.get(msg.sessionId);
+    if (cuSession) {
+      cuSession.handleSurfaceAction(msg.surfaceId, msg.actionId, msg.data);
+      return;
+    }
+    const session = ctx.sessions.get(msg.sessionId);
+    if (session) {
+      ctx.touchSession(msg.sessionId);
+      session.handleSurfaceAction(msg.surfaceId, msg.actionId, msg.data);
+      return;
+    }
+    log.warn({ sessionId: msg.sessionId, surfaceId: msg.surfaceId }, 'No session found for surface action');
+  },
+  ui_surface_undo: (msg, _socket, ctx) => {
+    const session = ctx.sessions.get(msg.sessionId);
+    if (session) {
+      ctx.touchSession(msg.sessionId);
+      session.handleSurfaceUndo(msg.surfaceId);
+      return;
+    }
+    log.warn({ sessionId: msg.sessionId, surfaceId: msg.surfaceId }, 'No session found for surface undo');
+  },
+  diagnostics_export_request: handleDiagnosticsExport,
+  env_vars_request: (_msg, socket, ctx) => handleEnvVarsRequest(socket, ctx),
+  document_save: handleDocumentSave,
+  document_load: handleDocumentLoad,
+  document_list: handleDocumentList,
+
+  browser_cdp_response: (msg) => {
+    browserManager.resolveCDPResponse(msg.sessionId, msg.success, msg.declined);
+  },
+
+  // Stub handlers: the integration registry was removed but the Swift client
+  // still sends these messages. Return safe no-op responses so the client
+  // doesn't hang waiting for a reply.
+  integration_list: (_msg, socket, ctx) => {
+    ctx.send(socket, { type: 'integration_list_response', integrations: [] });
+  },
+  integration_connect: (msg, socket, ctx) => {
+    ctx.send(socket, {
+      type: 'integration_connect_result',
+      integrationId: msg.integrationId,
+      success: false,
+      error: 'Please use chat to connect integrations.',
+    });
+  },
+
+  browser_user_click: async (msg) => {
+    try {
+      const page = await browserManager.getOrCreateSessionPage(msg.sessionId);
+      const viewport = await page.evaluate('(() => ({ vw: window.innerWidth, vh: window.innerHeight }))()') as { vw: number; vh: number };
+      const scale = Math.min(1280 / viewport.vw, 960 / viewport.vh);
+      const pageX = msg.x / scale;
+      const pageY = msg.y / scale;
+      const options: Record<string, unknown> = {};
+      if (msg.button === 'right') options.button = 'right';
+      if (msg.doubleClick) options.clickCount = 2;
+      await page.mouse.click(pageX, pageY, options);
+    } catch (err) {
+      log.warn({ err, sessionId: msg.sessionId }, 'Failed to forward user click');
+    }
+  },
+
+  browser_user_scroll: async (msg) => {
+    try {
+      const page = await browserManager.getOrCreateSessionPage(msg.sessionId);
+      await page.mouse.wheel(msg.deltaX, msg.deltaY);
+    } catch (err) {
+      log.warn({ err, sessionId: msg.sessionId }, 'Failed to forward user scroll');
+    }
+  },
+
+  browser_user_keypress: async (msg) => {
+    try {
+      const page = await browserManager.getOrCreateSessionPage(msg.sessionId);
+      const combo = msg.modifiers?.length ? [...msg.modifiers, msg.key].join('+') : msg.key;
+      await page.keyboard.press(combo);
+    } catch (err) {
+      log.warn({ err, sessionId: msg.sessionId }, 'Failed to forward user keypress');
+    }
+  },
+
+  browser_interactive_mode: (msg, socket, ctx) => {
+    log.info({ sessionId: msg.sessionId, enabled: msg.enabled }, 'Interactive mode toggled');
+    browserManager.setInteractiveMode(msg.sessionId, msg.enabled);
+    ctx.send(socket, {
+      type: 'browser_interactive_mode_changed',
+      sessionId: msg.sessionId,
+      surfaceId: msg.surfaceId,
+      enabled: msg.enabled,
+    });
+  },
+
+  integration_disconnect: () => { /* no-op — integration registry removed */ },
+
+  work_items_list: handleWorkItemsList,
+  work_item_get: handleWorkItemGet,
+  work_item_create: handleWorkItemCreate,
+  work_item_update: handleWorkItemUpdate,
+  work_item_complete: handleWorkItemComplete,
+  work_item_run_task: handleWorkItemRunTask,
+
+  subagent_abort: handleSubagentAbort,
+  subagent_status: handleSubagentStatus,
+  subagent_message: handleSubagentMessage,
+};
+
+export function handleMessage(
+  msg: ClientMessage,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  // 'auth' is handled at the transport layer and should never reach dispatch.
+  if (msg.type === 'auth') return;
+
+  const handler = handlers[msg.type] as
+    | ((msg: ClientMessage, socket: net.Socket, ctx: HandlerContext) => void)
+    | undefined;
+  if (!handler) {
+    log.warn({ type: msg.type }, 'Unknown message type, ignoring');
+    return;
+  }
+  handler(msg, socket, ctx);
+}

package/src/daemon/handlers/misc.ts

@@ -0,0 +1,323 @@
+import * as net from 'node:net';
+import { v4 as uuid } from 'uuid';
+import { readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import * as conversationStore from '../../memory/conversation-store.js';
+import { getConfig } from '../../config/loader.js';
+import { getFailoverProvider, listProviders } from '../../providers/registry.js';
+import type { Provider } from '../../providers/types.js';
+import { classifyInteraction } from '../classifier.js';
+import { checkIngressForSecrets } from '../../security/secret-ingress.js';
+import { parseSlashCandidate } from '../../skills/slash-commands.js';
+import { classifySessionError, buildSessionErrorMessage } from '../session-error.js';
+import { resolveBlobPath, deleteBlob, isValidBlobId } from '../ipc-blob-store.js';
+import type {
+  TaskSubmit,
+  SuggestionRequest,
+  LinkOpenRequest,
+  IpcBlobProbe,
+  CuSessionCreate,
+} from '../ipc-protocol.js';
+import { log, wireEscalationHandler, renderHistoryContent, type HandlerContext } from './shared.js';
+import { handleCuSessionCreate } from './computer-use.js';
+
+// ─── Task submit handler ────────────────────────────────────────────────────
+
+export async function handleTaskSubmit(
+  msg: TaskSubmit,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): Promise<void> {
+  const requestId = uuid();
+  const rlog = log.child({ requestId });
+
+  try {
+    // Block inbound tasks that contain secrets and redirect to secure prompt
+    const taskIngressCheck = checkIngressForSecrets(msg.task);
+    if (taskIngressCheck.blocked) {
+      rlog.warn({ detectedTypes: taskIngressCheck.detectedTypes }, 'Blocked task_submit containing secrets');
+      ctx.send(socket, {
+        type: 'error',
+        message: taskIngressCheck.userNotice!,
+      });
+      // Create an ephemeral session so the secret_response lifecycle works
+      // end-to-end. The conversation is deleted after the prompt resolves
+      // to avoid accumulating placeholder entries in session history.
+      const conversation = conversationStore.createConversation('(blocked — secret detected)');
+      ctx.socketToSession.set(socket, conversation.id);
+      const session = await ctx.getOrCreateSession(conversation.id, socket, true);
+      session.redirectToSecurePrompt(taskIngressCheck.detectedTypes, () => {
+        conversationStore.deleteConversation(conversation.id);
+        // Clean up in-memory session and socket binding so the ephemeral
+        // session doesn't accumulate in the daemon's session map.
+        const s = ctx.sessions.get(conversation.id);
+        if (s) {
+          s.dispose();
+          ctx.sessions.delete(conversation.id);
+        }
+        // Only unbind if the socket still points to this ephemeral conversation;
+        // a new task_submit may have already rebound it to a real session.
+        if (ctx.socketToSession.get(socket) === conversation.id) {
+          ctx.socketToSession.delete(socket);
+        }
+      });
+      return;
+    }
+
+    // Slash candidates always route to text_qa — bypass classifier
+    const slashCandidate = parseSlashCandidate(msg.task);
+    const interactionType = slashCandidate.kind === 'candidate'
+      ? 'text_qa' as const
+      : await classifyInteraction(msg.task, msg.source);
+    rlog.info({ interactionType, slashBypass: slashCandidate.kind === 'candidate', taskLength: msg.task.length }, 'Task classified');
+
+    if (interactionType === 'computer_use') {
+      // Create CU session (reuse handleCuSessionCreate logic)
+      const sessionId = uuid();
+      const cuMsg: CuSessionCreate = {
+        type: 'cu_session_create',
+        sessionId,
+        task: msg.task,
+        screenWidth: msg.screenWidth,
+        screenHeight: msg.screenHeight,
+        attachments: msg.attachments,
+        interactionType: 'computer_use',
+      };
+      handleCuSessionCreate(cuMsg, socket, ctx);
+
+      ctx.send(socket, {
+        type: 'task_routed',
+        sessionId,
+        interactionType: 'computer_use',
+      });
+    } else {
+      // Create text QA session and immediately start processing
+      const conversation = conversationStore.createConversation(msg.task);
+      ctx.socketToSession.set(socket, conversation.id);
+      const session = await ctx.getOrCreateSession(conversation.id, socket, true);
+
+      // Wire escalation handler so the agent can call computer_use_request_control
+      wireEscalationHandler(session, socket, ctx, msg.screenWidth, msg.screenHeight);
+
+      ctx.send(socket, {
+        type: 'task_routed',
+        sessionId: conversation.id,
+        interactionType: 'text_qa',
+      });
+
+      // Start streaming immediately — client doesn't need to send user_message
+      session.processMessage(msg.task, msg.attachments ?? [], (event) => {
+        ctx.send(socket, event);
+      }, requestId).catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        rlog.error({ err }, 'Error processing task_submit text QA');
+        ctx.send(socket, { type: 'error', message: `Failed to process message: ${message}` });
+        const classified = classifySessionError(err, { phase: 'agent_loop' });
+        ctx.send(socket, buildSessionErrorMessage(conversation.id, classified));
+      });
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    rlog.error({ err }, 'Error handling task_submit');
+    ctx.send(socket, { type: 'error', message: `Failed to route task: ${message}` });
+  }
+}
+
+// ─── Suggestion handler ─────────────────────────────────────────────────────
+
+const SUGGESTION_CACHE_MAX = 100;
+const suggestionCache = new Map<string, string>();
+const suggestionInFlight = new Map<string, Promise<string | null>>();
+
+export async function handleSuggestionRequest(
+  msg: SuggestionRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): Promise<void> {
+  const noSuggestion = () => {
+    ctx.send(socket, {
+      type: 'suggestion_response',
+      requestId: msg.requestId,
+      suggestion: null,
+      source: 'none' as const,
+    });
+  };
+
+  const rawMessages = conversationStore.getMessages(msg.sessionId);
+  if (rawMessages.length === 0) { noSuggestion(); return; }
+
+  // Find the most recent assistant message — only use it if it has text content.
+  // Do NOT fall back to older turns; if the latest assistant message is tool-only,
+  // return no suggestion rather than reusing stale text from a previous turn.
+  for (let i = rawMessages.length - 1; i >= 0; i--) {
+    const m = rawMessages[i];
+    if (m.role !== 'assistant') continue;
+
+    let content: unknown;
+    try { content = JSON.parse(m.content); } catch { content = m.content; }
+    const rendered = renderHistoryContent(content);
+    const text = rendered.text.trim();
+    if (!text) { noSuggestion(); return; }
+
+    // Return cached suggestion
+    const cached = suggestionCache.get(m.id);
+    if (cached !== undefined) {
+      ctx.send(socket, {
+        type: 'suggestion_response',
+        requestId: msg.requestId,
+        suggestion: cached,
+        source: 'llm' as const,
+      });
+      return;
+    }
+
+    // Try LLM suggestion using the configured provider
+    const config = getConfig();
+    if (listProviders().includes(config.provider)) {
+      try {
+        const provider = getFailoverProvider(config.provider, config.providerOrder);
+        let promise = suggestionInFlight.get(m.id);
+        if (!promise) {
+          promise = generateSuggestion(provider, text);
+          suggestionInFlight.set(m.id, promise);
+        }
+        const llmSuggestion = await promise;
+        suggestionInFlight.delete(m.id);
+
+        if (llmSuggestion) {
+          if (suggestionCache.size >= SUGGESTION_CACHE_MAX) {
+            const oldest = suggestionCache.keys().next().value!;
+            suggestionCache.delete(oldest);
+          }
+          suggestionCache.set(m.id, llmSuggestion);
+
+          ctx.send(socket, {
+            type: 'suggestion_response',
+            requestId: msg.requestId,
+            suggestion: llmSuggestion,
+            source: 'llm' as const,
+          });
+          return;
+        }
+      } catch (err) {
+        suggestionInFlight.delete(m.id);
+        log.warn({ err }, 'LLM suggestion failed');
+      }
+    }
+
+    noSuggestion();
+    return;
+  }
+
+  noSuggestion();
+}
+
+async function generateSuggestion(provider: Provider, assistantText: string): Promise<string | null> {
+  const truncated = assistantText.length > 2000
+    ? assistantText.slice(-2000)
+    : assistantText;
+
+  const prompt = `Given this assistant message, write a very short tab-complete suggestion (max 50 chars) the user could send next to keep the conversation going. Be casual, curious, or actionable — like a quick reply, not a formal request. Reply with ONLY the suggestion text.\n\nAssistant's message:\n${truncated}`;
+  const response = await provider.sendMessage(
+    [{ role: 'user', content: [{ type: 'text', text: prompt }] }],
+    [], // no tools
+    undefined, // no system prompt
+    { config: { max_tokens: 30 } },
+  );
+
+  const textBlock = response.content.find((b) => b.type === 'text');
+  const raw = textBlock && 'text' in textBlock ? textBlock.text.trim() : '';
+  if (!raw || raw.length > 50) return null;
+
+  const firstLine = raw.split('\n')[0].trim();
+  return firstLine || null;
+}
+
+// ─── Link open handler ──────────────────────────────────────────────────────
+
+export function handleLinkOpenRequest(
+  msg: LinkOpenRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  try {
+    const parsed = new URL(msg.url);
+    if (!['http:', 'https:'].includes(parsed.protocol)) {
+      log.warn({ url: msg.url }, 'link_open_request: blocked non-http URL');
+      return;
+    }
+  } catch {
+    log.warn({ url: msg.url }, 'link_open_request: invalid URL');
+    return;
+  }
+  // V1: passthrough. Future: affiliate param injection based on metadata
+  const finalUrl = msg.url;
+  ctx.send(socket, { type: 'open_url', url: finalUrl });
+}
+
+// ─── IPC blob probe handler ─────────────────────────────────────────────────
+
+export function handleIpcBlobProbe(
+  msg: IpcBlobProbe,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  if (!isValidBlobId(msg.probeId)) {
+    ctx.send(socket, {
+      type: 'ipc_blob_probe_result',
+      probeId: msg.probeId,
+      ok: false,
+      reason: 'invalid_probe_id',
+    });
+    return;
+  }
+
+  let filePath: string;
+  try {
+    filePath = resolveBlobPath(msg.probeId);
+  } catch {
+    ctx.send(socket, {
+      type: 'ipc_blob_probe_result',
+      probeId: msg.probeId,
+      ok: false,
+      reason: 'invalid_probe_id',
+    });
+    return;
+  }
+
+  let content: Buffer;
+  try {
+    content = readFileSync(filePath);
+  } catch {
+    ctx.send(socket, {
+      type: 'ipc_blob_probe_result',
+      probeId: msg.probeId,
+      ok: false,
+      reason: 'missing_probe_file',
+    });
+    return;
+  }
+
+  const observedHash = createHash('sha256').update(content).digest('hex');
+
+  // Best-effort cleanup regardless of match outcome
+  deleteBlob(msg.probeId);
+
+  if (observedHash !== msg.nonceSha256) {
+    ctx.send(socket, {
+      type: 'ipc_blob_probe_result',
+      probeId: msg.probeId,
+      ok: false,
+      observedNonceSha256: observedHash,
+      reason: 'hash_mismatch',
+    });
+    return;
+  }
+
+  ctx.send(socket, {
+    type: 'ipc_blob_probe_result',
+    probeId: msg.probeId,
+    ok: true,
+    observedNonceSha256: observedHash,
+  });
+}