@vellumai/assistant 0.10.2-dev.202606250318.5e7cfb0 → 0.10.2

package/src/daemon/handlers/config-channels.ts

@@ -1,10 +1,6 @@
 import { createHash, randomBytes } from "node:crypto";
 
-import type { GuardianDelivery } from "@vellumai/gateway-client";
-import {
-  GetContactIpcResponseSchema,
-  MarkChannelRevokedIpcResponseSchema,
-} from "@vellumai/gateway-client/gateway-ipc-contracts";
+import { MarkChannelRevokedIpcResponseSchema } from "@vellumai/gateway-client/gateway-ipc-contracts";
 
 import { startVerificationCall } from "../../calls/call-domain.js";
 import type { ChannelId } from "../../channels/types.js";
@@ -15,8 +11,7 @@ import {
   getChannelById,
   getContact,
 } from "../../contacts/contact-store.js";
-import { getGuardianDelivery } from "../../contacts/guardian-delivery-reader.js";
-import type { ContactChannel } from "../../contacts/types.js";
+import type { ChannelStatus } from "../../contacts/types.js";
 import { ipcCallPersistent } from "../../ipc/gateway-client.js";
 import { getBindingByChannelChat } from "../../memory/external-conversation-store.js";
 import { resolveGuardianName } from "../../prompts/user-reference.js";
@@ -33,7 +28,6 @@ import {
   findActiveSession,
   getGuardianBinding,
   getPendingSession,
-  isGuardianBoundForChannel,
   revokeBinding,
   revokePendingSessions,
   updateSessionDelivery,
@@ -82,64 +76,23 @@ export function getReadinessService(): ChannelReadinessService {
   return _readinessService;
 }
 
-// ---------------------------------------------------------------------------
-// Gateway delivery lookup
-// ---------------------------------------------------------------------------
-
-/**
- * Resolve the gateway-owned delivery (ACL source of truth) for a contact
- * channel, matching on type and either address or externalChatId. Returns
- * `undefined` when the gateway is unreachable or has no binding for it.
- */
-async function deliveryForChannel(
-  channel: Pick<ContactChannel, "type" | "address" | "externalChatId">,
-): Promise<GuardianDelivery | undefined> {
-  const guardians = await getGuardianDelivery({ channelTypes: [channel.type] });
-  if (!guardians) return undefined;
-  return guardians.find(
-    (g) =>
-      g.channelType === channel.type &&
-      ((channel.address && g.address === channel.address) ||
-        (channel.externalChatId != null &&
-          g.externalChatId === channel.externalChatId)),
-  );
-}
-
-/**
- * Read a contact channel's verified state from the gateway contact-channel read
- * (ACL source of truth). Covers all contacts, not just guardian deliveries.
- * Returns `undefined` when the gateway is unreachable or has no such channel.
- */
-async function gatewayContactChannelState(
-  channel: Pick<ContactChannel, "id" | "contactId">,
-): Promise<{ status: string; verifiedAt: number | null } | undefined> {
-  const result = await ipcCallPersistent("contacts_get_rich", {
-    contactId: channel.contactId,
-  });
-  if (!result || (result as { contact?: unknown }).contact == null) {
-    return undefined;
-  }
-  const { contact } = GetContactIpcResponseSchema.parse(result);
-  const ch = contact.channels.find((c) => c.id === channel.id);
-  return ch ? { status: ch.status, verifiedAt: ch.verifiedAt } : undefined;
-}
-
 // ---------------------------------------------------------------------------
 // Extracted business logic functions
 // ---------------------------------------------------------------------------
 
-export async function createInboundChallenge(
+export function createInboundChallenge(
   channel?: ChannelId,
   rebind?: boolean,
   conversationId?: string,
-): Promise<ChannelVerificationSessionResult> {
+): ChannelVerificationSessionResult {
+  const resolvedAssistantId = DAEMON_INTERNAL_ASSISTANT_ID;
   const resolvedChannel = channel ?? "telegram";
 
-  // Gateway-backed presence guard: block re-binding when a guardian is already
-  // bound. Null-list (gateway unreachable) is treated as bound, so a transient
-  // miss blocks rather than letting a second binding through.
-  const alreadyBound = await isGuardianBoundForChannel(resolvedChannel);
-  if (alreadyBound && !rebind) {
+  const existingBinding = getGuardianBinding(
+    resolvedAssistantId,
+    resolvedChannel,
+  );
+  if (existingBinding && !rebind) {
     return {
       success: false,
       error: "already_bound",
@@ -162,13 +115,13 @@ export async function createInboundChallenge(
   };
 }
 
-export async function getVerificationStatus(
+export function getVerificationStatus(
   channel?: ChannelId,
-): Promise<ChannelVerificationSessionResult> {
+): ChannelVerificationSessionResult {
   const resolvedAssistantId = DAEMON_INTERNAL_ASSISTANT_ID;
   const resolvedChannel = channel ?? "telegram";
 
-  const binding = await getGuardianBinding(resolvedAssistantId, resolvedChannel);
+  const binding = getGuardianBinding(resolvedAssistantId, resolvedChannel);
 
   // Read the contact directly to get displayName — getGuardianBinding is a
   // compatibility shim that doesn't carry metadataJson.
@@ -236,10 +189,7 @@ export async function revokeVerificationForChannel(
 
   // Capture binding before revoking so we can downgrade the guardian's
   // channel — without this, the guardian would still pass the ACL check.
-  const bindingBeforeRevoke = await getGuardianBinding(
-    assistantId,
-    resolvedChannel,
-  );
+  const bindingBeforeRevoke = getGuardianBinding(assistantId, resolvedChannel);
   if (!bindingBeforeRevoke) {
     return {
       success: true,
@@ -256,16 +206,13 @@ export async function revokeVerificationForChannel(
 
   // Relay the ACL downgrade to the gateway (source of truth). The gateway's
   // mark_channel_revoked enforces the guardian guard and dual-writes the
-  // contact-channel status back to the assistant DB. Gate on the gateway
-  // delivery's live status, not the assistant DB column, so a redundant revoke
-  // is still skipped for an already-revoked binding.
+  // contact-channel status back to the assistant DB.
   if (contactResult) {
-    const delivery = await deliveryForChannel(contactResult.channel);
-    const deliveryStatus = delivery?.status;
+    const channelStatus: ChannelStatus = contactResult.channel.status;
     if (
-      deliveryStatus === "active" ||
-      deliveryStatus === "pending" ||
-      deliveryStatus === "unverified"
+      channelStatus === "active" ||
+      channelStatus === "pending" ||
+      channelStatus === "unverified"
     ) {
       const result = await ipcCallPersistent("mark_channel_revoked", {
         contactChannelId: contactResult.channel.id,
@@ -347,10 +294,7 @@ export async function verifyTrustedContact(
     };
   }
 
-  // Already-verified short-circuit derived from the gateway contact-channel read
-  // (ACL SoT), which covers all contacts — not just guardian deliveries.
-  const gwState = await gatewayContactChannelState(channel);
-  if (gwState?.status === "active" && gwState.verifiedAt != null) {
+  if (channel.status === "active" && channel.verifiedAt != null) {
     return {
       success: false,
       error: "already_verified",
@@ -635,7 +579,7 @@ export async function handleChannelVerificationSession(
           ...publicResult,
         });
       } else {
-        const result = await createInboundChallenge(
+        const result = createInboundChallenge(
           channel,
           msg.rebind,
           msg.conversationId,
@@ -646,7 +590,7 @@ export async function handleChannelVerificationSession(
         });
       }
     } else if (msg.action === "status") {
-      const result = await getVerificationStatus(channel);
+      const result = getVerificationStatus(channel);
       broadcastMessage({
         type: "channel_verification_session_response",
         ...result,

package/src/daemon/handlers/conversations.ts

@@ -1,12 +1,10 @@
 import { v4 as uuid } from "uuid";
 
 import { peekAcpSessionManager } from "../../acp/index.js";
-import { resolveCanonicalGuardianRequest } from "../../memory/canonical-guardian-store.js";
 import { clearAll, getConversation } from "../../memory/conversation-crud.js";
 import { resolveConversationId } from "../../memory/conversation-key-store.js";
 import { broadcastMessage } from "../../runtime/assistant-event-hub.js";
 import { resolveCapabilities } from "../../runtime/capabilities.js";
-import * as pendingInteractions from "../../runtime/pending-interactions.js";
 import { getSubagentManager } from "../../subagent/index.js";
 import { createAbortReason } from "../../util/abort-reasons.js";
 import { UserError } from "../../util/errors.js";
@@ -391,81 +389,6 @@ export function steerToMessage(
   return { steered: true };
 }
 
-/**
- * Supersede an open `ask_question` prompt when a new chat message is enqueued
- * for the same conversation.
- *
- * A queued message while a clarification question is open means the user chose
- * to move on rather than answer it. Steering to that message aborts the parked
- * turn — which settles the open question via its turn-abort signal — repairs
- * the dangling `tool_use`, and drains the message, instead of stranding it
- * behind a prompt no one is going to answer. Only `ask_question` prompts
- * (`kind: "question"`) trigger this; pending confirmations are handled
- * separately by the enqueue path's auto-deny.
- *
- * Returns `true` when a parked question was found and a steer was issued.
- */
-export function steerOnEnqueuedMessageIfQuestionParked(
-  conversationId: string,
-  enqueuedRequestId: string,
-): boolean {
-  const hasParkedQuestion = pendingInteractions
-    .getByConversation(conversationId)
-    .some((interaction) => interaction.kind === "question");
-  if (!hasParkedQuestion) return false;
-  steerToMessage(conversationId, enqueuedRequestId);
-  return true;
-}
-
-/**
- * Supersede interactions left pending by an in-flight turn when a new message
- * is enqueued for a busy conversation. Centralized so every ingress path (the
- * HTTP send handler and the CLI signal path) gets identical handling:
- *
- *  1. Auto-deny pending confirmations — notify the client and sync the
- *     canonical guardian record *before* clearing the prompter-owned
- *     confirmations, so a later guardian reply can't match a stale "pending"
- *     record and fail with `pending_interaction_not_found`.
- *  2. Supersede a parked ask_question by steering to the enqueued message.
- *
- * Order matters: the steer aborts the turn, which denies the prompter's
- * confirmations as a side effect, so the canonical/notification sync must run
- * first. `removeByConversation` preserves `question` entries, so the parked
- * question is still registered for the steer even after the confirmation sweep.
- */
-export function supersedePendingInteractionsOnEnqueue(
-  conversationId: string,
-  enqueuedRequestId: string,
-): void {
-  const conversation = findConversation(conversationId);
-  if (!conversation) return;
-
-  if (conversation.hasAnyPendingConfirmation()) {
-    for (const interaction of pendingInteractions.getByConversation(
-      conversationId,
-    )) {
-      if (interaction.kind === "confirmation") {
-        // sendToClient (wired to the SSE hub) delivers the denial to clients.
-        conversation.emitConfirmationStateChanged({
-          conversationId,
-          requestId: interaction.requestId,
-          state: "denied" as const,
-          source: "auto_deny" as const,
-        });
-        // Sync the canonical guardian record so stale "pending" rows aren't
-        // matched by later guardian reply routing.
-        resolveCanonicalGuardianRequest(interaction.requestId, "pending", {
-          status: "denied",
-        });
-      }
-    }
-    conversation.denyAllPendingConfirmations();
-    pendingInteractions.removeByConversation(conversationId);
-  }
-
-  steerOnEnqueuedMessageIfQuestionParked(conversationId, enqueuedRequestId);
-}
-
 // ---------------------------------------------------------------------------
 // HTTP handler (delegates to shared logic)
 // ---------------------------------------------------------------------------

package/src/daemon/lifecycle.ts

@@ -966,10 +966,6 @@ export async function runDaemon(): Promise<void> {
         }
       }
 
-      // `startMemoryJobsWorker` selects the worker implementation based on
-      // `memory.worker.enabled` (in-process vs. a separate OS process).
-      // Shutdown stops whichever worker is actually running — see
-      // shutdown-handlers.ts.
       log.info("Daemon startup: starting memory worker");
       bgRefs.memoryWorker = startMemoryJobsWorker();
 

package/src/daemon/mcp-reload-service.ts

@@ -7,7 +7,6 @@
 
 import { getConfig, invalidateConfigCache } from "../config/loader.js";
 import { getMcpServerManager } from "../mcp/manager.js";
-import { migrateLegacyMcpHeaders } from "../mcp/mcp-header-store.js";
 import { createMcpToolsFromServer } from "../tools/mcp/mcp-tool-factory.js";
 import { registerMcpTools, unregisterAllMcpTools } from "../tools/registry.js";
 import { getLogger } from "../util/logger.js";
@@ -56,15 +55,6 @@ async function doReload(): Promise<McpReloadResult> {
   try {
     const manager = getMcpServerManager();
 
-    // 0. Migrate any legacy plaintext headers from config.json into
-    //    the credential store before loading config for server startup.
-    //    No-ops when no legacy headers remain; errors are logged, not thrown.
-    try {
-      await migrateLegacyMcpHeaders();
-    } catch (err) {
-      log.warn({ err }, "Legacy MCP header migration failed — continuing");
-    }
-
     // 1. Validate new config before tearing down existing servers.
     //    If the config is broken we abort early, preserving the current
     //    working MCP setup instead of leaving zero servers.

package/src/daemon/memory-v2-startup.test.ts

@@ -59,18 +59,6 @@ function configWithV2(enabled: boolean): AssistantConfig {
   return { memory: { v2: { enabled } } } as unknown as AssistantConfig;
 }
 
-/** Poll until `m` has been called at least `n` times, or `timeoutMs` elapses. */
-async function waitForCalls(
-  m: { mock: { calls: unknown[] } },
-  n: number,
-  timeoutMs = 1000,
-): Promise<void> {
-  const start = Date.now();
-  while (m.mock.calls.length < n && Date.now() - start < timeoutMs) {
-    await new Promise((resolve) => setTimeout(resolve, 5));
-  }
-}
-
 afterEach(() => {
   seedSkill.mockClear();
   seedCli.mockClear();
@@ -140,64 +128,4 @@ describe("maybeReseedCapabilitiesAfterManagedCredential", () => {
 
     expect(seedCli).toHaveBeenCalledTimes(1);
   });
-
-  test("enqueues the v3 maintain pass even when one catalog reseed rejects", async () => {
-    proxyState.prereqs = true;
-    v3State.live = true;
-    seedSkill.mockImplementationOnce(async () => {
-      throw new Error('Embedding backend "gemini" is not configured');
-    });
-
-    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true));
-
-    // The CLI catalog seeded, so v3 must still rebuild its lanes — a single
-    // catalog failure cannot suppress the maintain pass.
-    expect(seedCli).toHaveBeenCalledTimes(1);
-    expect(enqueueJob).toHaveBeenCalledTimes(1);
-    expect(enqueueJob).toHaveBeenCalledWith("memory_v3_maintain", {});
-  });
-
-  test("enqueues the v3 maintain pass without blocking when a catalog reseed exceeds the timeout", async () => {
-    proxyState.prereqs = true;
-    v3State.live = true;
-    // Skill reseed never settles — mirrors the wedged getCatalog()/embed seen in
-    // the field. The CLI reseed completes normally.
-    seedSkill.mockImplementationOnce(() => new Promise<void>(() => {}));
-
-    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true), {
-      reseedTimeoutMs: 20,
-    });
-
-    // An unbounded `Promise.all` barrier would hang here forever; the bounded
-    // barrier lets the CLI catalog's maintain pass enqueue regardless.
-    expect(seedCli).toHaveBeenCalledTimes(1);
-    expect(enqueueJob).toHaveBeenCalledTimes(1);
-    expect(enqueueJob).toHaveBeenCalledWith("memory_v3_maintain", {});
-  });
-
-  test("re-enqueues the v3 maintain pass when a straggler catalog finishes after the timeout", async () => {
-    proxyState.prereqs = true;
-    v3State.live = true;
-    let resolveSkill!: () => void;
-    seedSkill.mockImplementationOnce(
-      () =>
-        new Promise<void>((resolve) => {
-          resolveSkill = resolve;
-        }),
-    );
-
-    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true), {
-      reseedTimeoutMs: 10,
-    });
-
-    // Post-barrier enqueue fires once even though the skill catalog is still
-    // embedding.
-    expect(enqueueJob).toHaveBeenCalledTimes(1);
-
-    // The straggler lands; maintain re-enqueues so its late capability rows are
-    // reconciled without waiting out the 6h backstop.
-    resolveSkill();
-    await waitForCalls(enqueueJob, 2);
-    expect(enqueueJob).toHaveBeenCalledTimes(2);
-  });
 });

package/src/daemon/memory-v2-startup.ts

@@ -49,36 +49,6 @@ export function maybeSeedMemoryV2CliCommands(config: AssistantConfig): void {
     .catch((err) => log.warn({ err }, "Failed to seed v2 CLI-command entries"));
 }
 
-/**
- * Default upper bound on how long
- * {@link maybeReseedCapabilitiesAfterManagedCredential} waits for the capability
- * reseeds before enqueuing the v3 maintain pass. The reseeds keep running
- * detached past this bound — it only stops the barrier from waiting on a wedged
- * catalog (a stalled `getCatalog()` or a managed-proxy embed that never
- * returns). A straggler that finishes later re-enqueues maintain.
- */
-const RESEED_BARRIER_TIMEOUT_MS = 120_000;
-
-/**
- * Resolve to `true` if `p` settles within `ms`, or `false` if the timeout wins.
- * Always clears the timer, so a `p` that settles first leaves no pending timer
- * keeping the event loop (or a test) alive.
- */
-async function settledWithin(
-  p: Promise<unknown>,
-  ms: number,
-): Promise<boolean> {
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const timedOut = new Promise<false>((resolve) => {
-    timer = setTimeout(() => resolve(false), ms);
-  });
-  try {
-    return await Promise.race([p.then(() => true), timedOut]);
-  } finally {
-    if (timer) clearTimeout(timer);
-  }
-}
-
 /**
  * Re-seed the v2 skill and CLI-command capability entries once a managed-proxy
  * credential lands, closing the first-boot race where the daemon's startup seed
@@ -113,23 +83,9 @@ async function settledWithin(
  * dense store and its lane-invalidation stage forces a rebuild against the now-
  * populated index, so v3 surfaces the skill/CLI pages within seconds instead of
  * waiting out the backstop.
- *
- * The maintain enqueue must NOT be gated on both catalogs settling. The two
- * embeds are independent, and a single wedged catalog (a stalled `getCatalog()`
- * or a managed-proxy embed that never returns) would otherwise block the v3 lane
- * rebuild indefinitely, so the catalog that DID seed never reaches the selector.
- * The barrier is therefore bounded by `reseedTimeoutMs`: maintain is enqueued
- * once the barrier resolves (the pass is idempotent and reconciles whatever the
- * page index currently holds), and a straggler catalog that finishes after the
- * timeout re-enqueues maintain so its late rows are picked up without waiting out
- * the backstop.
- *
- * `reseedTimeoutMs` is injectable for tests; production uses
- * {@link RESEED_BARRIER_TIMEOUT_MS}.
  */
 export async function maybeReseedCapabilitiesAfterManagedCredential(
   config: AssistantConfig,
-  opts: { reseedTimeoutMs?: number } = {},
 ): Promise<void> {
   if (!config.memory.v2.enabled) return;
 
@@ -159,59 +115,35 @@ export async function maybeReseedCapabilitiesAfterManagedCredential(
     ],
   ];
 
-  // Each reseed is contained so one catalog's embed failure (or hang) never
-  // rejects the caller or aborts the other. Started here but not awaited as a
-  // single barrier — the bounded wait below decides when to stop waiting.
-  const reseeds = catalogs.map(([label, seed]) =>
-    seed().then(
-      () =>
+  await Promise.all(
+    catalogs.map(async ([label, seed]) => {
+      try {
+        await seed();
         log.info(
           `Memory v2 ${label} entries seeded after managed proxy credential update`,
-        ),
-      (err: unknown) =>
+        );
+      } catch (err) {
         log.warn(
           { err },
           `Failed to seed v2 ${label} entries after managed proxy credential update`,
-        ),
-    ),
+        );
+      }
+    }),
   );
 
-  // When v3 is live, a maintain pass embeds the freshly-seeded capability rows
-  // into `memory_v3_sections` and invalidates the lanes so v3 surfaces the
-  // skill/CLI pages within seconds instead of waiting out the 6h backstop.
-  // Resolve the gate + enqueuer once and reuse for the post-barrier enqueue and
-  // the straggler re-enqueue below.
+  // The stores (and the page index) are now populated; when v3 is live, kick a
+  // maintain pass so it embeds the capability rows into `memory_v3_sections` and
+  // invalidates its lanes immediately rather than waiting out the 6h backstop.
   const { isMemoryV3Live } = await import("../config/memory-v3-gate.js");
-  const v3Live = isMemoryV3Live(config);
-  const enqueueMaintain = async (): Promise<void> => {
-    if (!v3Live) return;
-    try {
-      const { enqueueMemoryJob } = await import("../memory/jobs-store.js");
-      enqueueMemoryJob("memory_v3_maintain", {});
-    } catch (err) {
-      log.warn(
-        { err },
-        "Failed to enqueue memory_v3_maintain after managed proxy credential update",
-      );
-    }
-  };
-
-  // Bound the barrier so a wedged catalog can't block the maintain enqueue
-  // indefinitely; the reseeds keep running detached past the timeout.
-  const timeoutMs = opts.reseedTimeoutMs ?? RESEED_BARRIER_TIMEOUT_MS;
-  const allReseeds = Promise.allSettled(reseeds);
-  const settledInTime = await settledWithin(allReseeds, timeoutMs);
-
-  await enqueueMaintain();
-
-  if (!settledInTime) {
+  if (!isMemoryV3Live(config)) return;
+  try {
+    const { enqueueMemoryJob } = await import("../memory/jobs-store.js");
+    enqueueMemoryJob("memory_v3_maintain", {});
+  } catch (err) {
     log.warn(
-      { timeoutMs },
-      "Capability reseed still running after the barrier timeout — enqueued v3 maintain now; will re-enqueue when the straggler catalog finishes",
+      { err },
+      "Failed to enqueue memory_v3_maintain after managed proxy credential update",
     );
-    // The straggler is still embedding; re-enqueue maintain once it lands so its
-    // late capability rows are reconciled without waiting out the 6h backstop.
-    void allReseeds.then(() => enqueueMaintain());
   }
 }
 

package/src/daemon/message-types/conversations.ts

@@ -4,7 +4,6 @@ import type { CompactionCircuitClosedEvent } from "../../api/events/compaction-c
 import type { CompactionCircuitOpenEvent } from "../../api/events/compaction-circuit-open.js";
 import type { ConversationErrorEvent } from "../../api/events/conversation-error.js";
 import type { ConversationListInvalidatedEvent } from "../../api/events/conversation-list-invalidated.js";
-import type { ConversationNoticeEvent } from "../../api/events/conversation-notice.js";
 import type { ConversationTitleUpdatedEvent } from "../../api/events/conversation-title-updated.js";
 import type { GenerationCancelledEvent } from "../../api/events/generation-cancelled.js";
 import type { GenerationHandoffEvent } from "../../api/events/generation-handoff.js";
@@ -544,7 +543,6 @@ export type _ConversationsServerMessages =
   | CompactionCircuitOpenEvent
   | CompactionCircuitClosedEvent
   | ConversationErrorEvent
-  | ConversationNoticeEvent
   | ConversationInfo
   | ConversationTitleUpdatedEvent
   | ConversationListResponse

package/src/daemon/message-types/surfaces.ts

@@ -3,21 +3,14 @@
 import {
   type CardSurfaceData,
   CardSurfaceDataSchema,
-  type FileUploadSurfaceData,
-  FileUploadSurfaceDataSchema,
 } from "../../api/surfaces.js";
 
 // Surface `data` shapes are wire payloads owned by `@vellumai/assistant-api`.
-// Card and file_upload are migrated (canonical Zod schemas); the remaining
-// types below are still hand-written interfaces pending migration. Re-exported
-// so the daemon's surface protocol barrel (`message-protocol.ts`) keeps
-// surfacing them to daemon consumers under their canonical names.
-export {
-  type CardSurfaceData,
-  CardSurfaceDataSchema,
-  type FileUploadSurfaceData,
-  FileUploadSurfaceDataSchema,
-};
+// Card is migrated (canonical Zod schema); the remaining types below are still
+// hand-written interfaces pending migration. Re-exported so the daemon's
+// surface protocol barrel (`message-protocol.ts`) keeps surfacing them to
+// daemon consumers under their canonical names.
+export { type CardSurfaceData, CardSurfaceDataSchema };
 
 // === Surface type definitions ===
 
@@ -162,6 +155,13 @@ export interface DynamicPageSurfaceData {
   preview?: DynamicPagePreview;
 }
 
+export interface FileUploadSurfaceData {
+  prompt: string;
+  acceptedTypes?: string[];
+  maxFiles?: number;
+  maxSizeBytes?: number;
+}
+
 export interface TableColumn {
   id: string;
   label: string;

package/src/daemon/server.ts

@@ -48,6 +48,7 @@ import { parseIdentityFields } from "./handlers/identity.js";
 import type { ConversationCreateOptions } from "./handlers/shared.js";
 import { setGlobalSkillIpcSender } from "./meet-host-supervisor.js";
 import { refreshSkillCapabilityMemories } from "./skill-memory-refresh.js";
+import { WorkspaceToolsWatcher } from "./workspace-tools-watcher.js";
 
 const log = getLogger("server");
 
@@ -307,6 +308,8 @@ export class DaemonServer {
 
     this.appSourceWatcher.start((appId) => this.handleAppSourceChange(appId));
 
+    WorkspaceToolsWatcher.getInstance().start();
+
     // Broadcast contacts_changed to all clients when any contact mutation occurs.
     this.unsubscribeContactChange = onContactChange(() => {
       broadcastMessage({ type: "contacts_changed" });
@@ -321,6 +324,7 @@ export class DaemonServer {
     this.evictor.stop();
     this.configWatcher.stop();
     this.appSourceWatcher.stop();
+    WorkspaceToolsWatcher.getInstance().stop();
     this.cliIpc.stop();
     this.skillIpc.stop();
     if (this.unsubscribeContactChange) {

package/src/daemon/shutdown-handlers.ts

@@ -5,7 +5,6 @@ import type { HeartbeatService } from "../heartbeat/heartbeat-service.js";
 import type { McpServerManager } from "../mcp/manager.js";
 import { getSqlite, resetDb } from "../memory/db-connection.js";
 import type { QdrantManager } from "../memory/qdrant-manager.js";
-import { stopMemoryWorkerProcess } from "../memory/worker-control.js";
 import type { RuntimeHttpServer } from "../runtime/http-server.js";
 import { browserManager } from "../tools/browser/browser-manager.js";
 import { cleanupShellOutputTempFiles } from "../tools/shared/shell-output.js";
@@ -118,27 +117,8 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
     await browserManager.closeAllPages();
     cleanupShellOutputTempFiles();
     deps.scheduler.stop();
-
-    // Stop the in-process memory worker if one was started on the daemon's
-    // event loop (memory.worker.enabled = false).
     deps.getMemoryWorker()?.stop();
 
-    // Stop the out-of-process memory worker if it's actually running. This is
-    // keyed off live state rather than config: the worker may have been
-    // spawned at startup (memory.worker.enabled = true) or out of band via
-    // `assistant memory worker start`, so we stop whatever is actually there.
-    try {
-      const workerStatus = stopMemoryWorkerProcess();
-      if (workerStatus.status === "running") {
-        log.info(
-          { pid: workerStatus.pid },
-          "Sent SIGTERM to memory worker process",
-        );
-      }
-    } catch (err) {
-      log.warn({ err }, "Failed to stop memory worker process (non-fatal)");
-    }
-
     if (deps.mcpManager) {
       try {
         await deps.mcpManager.stop();

package/src/daemon/tool-setup-types.ts

@@ -124,13 +124,4 @@ export interface ToolSetupContext extends SurfaceConversationContext {
    * return `undefined` for the in-flight (background) subagent.
    */
   currentTurnOverrideProfile?: string;
-  /**
-   * Whether the current turn has no human present to answer clarification
-   * prompts. Resolved once per turn by the agent loop — honoring an explicit
-   * per-run `isInteractive` option (e.g. scheduled/background turns) over the
-   * live client state — so tool execution sees turn-level interactivity rather
-   * than re-deriving it from `hasNoClient`/`headlessLock`, which would read a
-   * scheduled turn running on a client-attached conversation as interactive.
-   */
-  currentTurnIsNonInteractive?: boolean;
 }