@vellumai/assistant 0.12.0 → 0.12.1-dev.202609141913.5e16607

package/src/daemon/conversation-surfaces.ts

@@ -55,6 +55,7 @@ import {
   isActivationMomentParam,
 } from "../telemetry/activation-funnel.js";
 import { resolveAppId } from "../tools/apps/resolve-app-id.js";
+import { formatDesktopAppRequired } from "../tools/capability-offer.js";
 import { POINT_AT_PROXY_TOOL } from "../tools/computer-use/skill-proxy-bridge.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { getLogger } from "../util/logger.js";
@@ -2936,7 +2937,7 @@ export function buildAppOpenPreview(
 function describeComputerUseUnavailable(ctx: Conversation): string {
   const capable = assistantEventHub.listClientsByCapability("host_cu");
   if (capable.length === 0) {
-    return "Computer use is not available — no desktop client connected. Open the Vellum desktop app on the machine you want to control, then retry.";
+    return formatDesktopAppRequired("screen");
   }
   return `Computer use is not available for this conversation — ${capable.length} desktop client(s) advertise host_cu, but none of them can be driven from this conversation's interface (${ctx.transportInterface ?? "unknown"}) as its current user.`;
 }
@@ -3251,8 +3252,7 @@ export async function surfaceProxyResolver(
 
     if (!ctx.hostAppControlProxy || !ctx.hostAppControlProxy.isAvailable()) {
       return {
-        content:
-          "App control is not available — enable the `app-control` feature flag and connect a macOS client.",
+        content: formatDesktopAppRequired("apps"),
         isError: true,
       };
     }
@@ -3344,6 +3344,7 @@ export async function surfaceProxyResolver(
     const caps = ctx.channelCapabilities;
     if (
       caps &&
+      !ctx.hasNoClient &&
       !caps.supportsDynamicUi &&
       !isSlackTaskProgressUiException(ctx, toolName, input)
     ) {
@@ -3552,11 +3553,12 @@ export async function surfaceProxyResolver(
           : surfaceType === "table"
             ? hasActions
             : INTERACTIVE_SURFACE_TYPES.includes(surfaceType);
-    // An explicit `await_action: true` is honored for every other type; an
-    // actionless surface has nothing to await, so it is forced false.
-    const awaitAction = isActionless
-      ? false
-      : ((input.await_action as boolean) ?? isInteractive);
+    // Background turns persist surfaces for a later conversation open and
+    // return immediately. An actionless surface also has nothing to await.
+    const awaitAction =
+      !ctx.hasNoClient &&
+      !isActionless &&
+      ((input.await_action as boolean) ?? isInteractive);
 
     // Only one non-persistent interactive surface at a time. If another
     // surface is already awaiting user input, reject this one so the LLM

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

@@ -28,7 +28,6 @@ import { getAllDefaultPluginNames } from "../plugins/defaults/main.js";
 import { isActivationSession } from "../plugins/defaults/memory/activation-session-store.js";
 import { isPluginDisabled } from "../plugins/disabled-state.js";
 import type { Message, ToolDefinition } from "../providers/types.js";
-import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { registerConversationSender } from "../tools/browser/browser-screencast.js";
 import { supportsClientOsForSkillTool } from "../tools/client-os.js";
 import type { ToolExecutor } from "../tools/executor.js";
@@ -260,6 +259,24 @@ export function createToolExecutor(
   // see {@link SubagentToolGateMode}): rejects non-allowlisted calls BEFORE
   // any executor dispatch, so a non-allowlisted tool's executor never runs.
   // The error tool_result lets the model continue or finish.
+  const rejectUnattendedHostTool = (
+    toolName: string,
+  ): ToolExecutionResult | null => {
+    const { transportInterface } = resolveTurnClientOs(ctx);
+    const isUnattended = ctx.currentTurnIsNonInteractive ?? ctx.hasNoClient;
+    if (
+      HOST_TOOL_NAMES.has(toolName) &&
+      isUnattended &&
+      transportInterface !== "chrome-extension"
+    ) {
+      return {
+        content: `The "${toolName}" tool requires an interactive user turn and cannot run in the background.`,
+        isError: true,
+      };
+    }
+    return null;
+  };
+
   const rejectNonAllowlistedTool = (
     toolName: string,
   ): ToolExecutionResult | null => {
@@ -387,6 +404,10 @@ export function createToolExecutor(
       if (rejection) {
         return rejection;
       }
+      const unattendedRejection = rejectUnattendedHostTool(executionName);
+      if (unattendedRejection) {
+        return unattendedRejection;
+      }
     }
 
     if (isDoordashCommand(executionName, executionInput)) {
@@ -550,6 +571,10 @@ export function createToolExecutor(
       if (innerRejection) {
         return innerRejection;
       }
+      const unattendedRejection = rejectUnattendedHostTool(toolName);
+      if (unattendedRejection) {
+        return unattendedRejection;
+      }
 
       // Per-chat plugin scope: reject the resolved inner tool when it belongs
       // to a plugin outside the conversation's effective set.
@@ -628,7 +653,6 @@ export const DEFAULT_PREACTIVATED_SKILL_IDS = ["notifications", "subagent"];
 // ── Conditional tool sets ────────────────────────────────────────────
 
 const UI_SURFACE_TOOL_NAMES = new Set(["ui_show", "ui_update", "ui_dismiss"]);
-const SLACK_TASK_PROGRESS_UI_TOOL_NAMES = new Set(["ui_show", "ui_update"]);
 /**
  * Single source of truth for which tools are host tools and the capability
  * each one requires from the connected client interface. Adding a tool here
@@ -856,56 +880,26 @@ export function isToolActiveForContext(
     return supportsChannelReaction(turnChannel);
   }
   if (UI_SURFACE_TOOL_NAMES.has(name)) {
-    if (
-      channelCapabilities?.channel === "slack" &&
-      SLACK_TASK_PROGRESS_UI_TOOL_NAMES.has(name)
-    ) {
-      return !hasNoClient;
-    }
-    return channelCapabilities?.supportsDynamicUi ?? !hasNoClient;
+    // Surface calls write conversation content. Background turns persist that
+    // content for the next client that opens the conversation, so presence
+    // cannot change whether the model receives these definitions.
+    return true;
   }
   if (HOST_TOOL_NAMES.has(name)) {
     const capability = HOST_TOOL_TO_CAPABILITY.get(name);
     const transport = transportInterface;
 
-    // Per-capability check is authoritative for structural support: if the
-    // transport cannot service this capability, the tool is filtered out.
+    // A transport that does not implement a capability can invoke it through
+    // an eligible same-user client. Client selection happens when the call
+    // runs, so the wire schema stays stable across live and background turns.
     if (transport && capability && !supportsHostProxy(transport, capability)) {
-      // Cross-client exception: allow host tools whose capabilities have
-      // cross-client routing infrastructure (Phases 1–3 plus host_browser
-      // via PR #27489) to be exposed for non-host-proxy transports (e.g.
-      // "web", "ios") when at least one capable client is connected via
-      // the event hub. Members of CROSS_CLIENT_EXPOSED_CAPABILITIES
-      // (host_bash, host_file, host_browser) qualify.
-      // chrome-extension transport is excluded as a security boundary
-      // (extension only gets host_browser via its own executor path);
-      // hasNoClient turns are excluded (no interactive approval UI
-      // available).
-      if (
-        capability &&
+      return (
         CROSS_CLIENT_EXPOSED_CAPABILITIES.has(capability) &&
-        transport !== "chrome-extension" &&
-        !hasNoClient &&
-        assistantEventHub.listClientsByCapability(capability).length > 0
-      ) {
-        return true;
-      }
-      return false;
-    }
-
-    // chrome-extension is its own executor — the extension's popup gates
-    // commands via its own UI, and the transport does not use an SSE-level
-    // interactive approval channel. hasNoClient is intentionally `true` for
-    // chrome-extension turns (chrome-extension is not in INTERACTIVE_INTERFACES)
-    // and must not gate host_browser. Trust the per-capability check.
-    if (transport === "chrome-extension") {
-      return true;
+        transport !== "chrome-extension"
+      );
     }
 
-    // For transports that surface approvals over SSE (macos, backwards-compat
-    // fallback), deny when no client is present so the guardian auto-approve
-    // path cannot execute host commands unattended.
-    return !hasNoClient;
+    return true;
   }
   if (CLIENT_CAPABILITY_TOOL_NAMES.has(name)) {
     if (name === "ask_question" && channelCapabilities?.clientOS === "macos") {

package/src/daemon/conversation.ts

@@ -2366,9 +2366,6 @@ export class Conversation {
 
   markStale(): void {
     this.stale = true;
-    // Invalidate the cached skill catalog so the next projection picks up
-    // filesystem changes (e.g. a skill created during this run).
-    this.skillProjectionCache.catalog = undefined;
   }
 
   isStale(): boolean {

package/src/daemon/host-bash-proxy.ts

@@ -1,9 +1,9 @@
 import { getConfig } from "../config/loader.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import {
-  ambiguousSameUserError,
   enforceSameActorOrErrorResult,
-  pickSameUserAutoResolve,
+  pickMostRecentSameUserClient,
+  unavailableSameUserClientError,
 } from "../runtime/auth/same-actor.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { formatShellOutput } from "../tools/shared/shell-output.js";
@@ -93,21 +93,17 @@ export class HostBashProxy extends HostProxyBase<
       }
       resolvedTargetClientId = input.targetClientId;
     } else {
-      // Auto-resolve to the unique same-user client. Reject (rather than
-      // broadcast) when multiple same-user clients are connected so that
-      // a single targeted-style request cannot fan out across every one
-      // of the user's machines. Zero same-user matches falls through to
-      // the existing untargeted code path.
-      const resolved = pickSameUserAutoResolve({
+      resolvedTargetClientId = pickMostRecentSameUserClient({
         hub: assistantEventHub,
         capability: "host_bash",
         sourceActorPrincipalId,
       });
-      if (resolved.kind === "ambiguous") {
-        return ambiguousSameUserError("host_bash");
+      if (
+        resolvedTargetClientId === undefined &&
+        sourceActorPrincipalId !== undefined
+      ) {
+        return unavailableSameUserClientError("host_bash");
       }
-      resolvedTargetClientId =
-        resolved.kind === "match" ? resolved.clientId : undefined;
     }
 
     // Targeted requests must be bound to the same authenticated user as the

package/src/daemon/host-browser-proxy.ts

@@ -5,7 +5,10 @@ import {
   assistantEventHub,
   broadcastMessage,
 } from "../runtime/assistant-event-hub.js";
-import { enforceSameActorOrErrorResult } from "../runtime/auth/same-actor.js";
+import {
+  enforceSameActorOrErrorResult,
+  unavailableSameUserClientError,
+} from "../runtime/auth/same-actor.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { AssistantError, ErrorCode } from "../util/errors.js";
@@ -284,6 +287,17 @@ export class HostBrowserProxy {
       targetClientId,
     );
 
+    if (
+      preferredClient === undefined &&
+      sourceActorPrincipalId !== undefined &&
+      targetClientId === undefined
+    ) {
+      if (isExtensionOnlyMethod(input.cdpMethod)) {
+        return Promise.resolve(extensionRequiredResult(input.cdpMethod));
+      }
+      return Promise.resolve(unavailableSameUserClientError("host_browser"));
+    }
+
     // Same-user enforcement: when the caller's actor is known, refuse to
     // dispatch to a client owned by a different actor. This covers the
     // cross-client exposure case where a web/iOS turn for actor A would

package/src/daemon/host-file-proxy.ts

@@ -6,10 +6,10 @@ import {
   broadcastMessage,
 } from "../runtime/assistant-event-hub.js";
 import {
-  ambiguousSameUserError,
   enforceSameActorOrErrorResult,
-  pickSameUserAutoResolve,
+  pickMostRecentSameUserClient,
   snapshotHostProxyActorPrincipalId,
+  unavailableSameUserClientError,
 } from "../runtime/auth/same-actor.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { readAudioBase64 } from "../tools/shared/filesystem/audio-read.js";
@@ -102,19 +102,17 @@ export class HostFileProxy {
         });
       }
     } else {
-      // Auto-resolve to the unique same-user client. Reject ambiguous
-      // (multi-machine) cases so a single targeted-style request cannot
-      // fan out across the user's machines.
-      const resolved = pickSameUserAutoResolve({
+      resolvedTargetClientId = pickMostRecentSameUserClient({
         hub: assistantEventHub,
         capability: "host_file",
         sourceActorPrincipalId,
       });
-      if (resolved.kind === "ambiguous") {
-        return Promise.resolve(ambiguousSameUserError("host_file"));
+      if (
+        resolvedTargetClientId === undefined &&
+        sourceActorPrincipalId !== undefined
+      ) {
+        return Promise.resolve(unavailableSameUserClientError("host_file"));
       }
-      resolvedTargetClientId =
-        resolved.kind === "match" ? resolved.clientId : undefined;
     }
 
     // Same-user check: targeted host_file requests must be bound to the same

package/src/daemon/host-transfer-proxy.ts

@@ -10,10 +10,10 @@ import {
   broadcastMessage,
 } from "../runtime/assistant-event-hub.js";
 import {
-  ambiguousSameUserError,
   enforceSameActorOrErrorResult,
-  pickSameUserAutoResolve,
+  pickMostRecentSameUserClient,
   snapshotHostProxyActorPrincipalId,
+  unavailableSameUserClientError,
 } from "../runtime/auth/same-actor.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import type { ToolExecutionResult } from "../tools/types.js";
@@ -162,19 +162,17 @@ export class HostTransferProxy {
         });
       }
     } else {
-      // Auto-resolve to the unique same-user client; reject ambiguous
-      // (multi-machine) cases so a single targeted-style transfer cannot
-      // fan out across the user's machines.
-      const resolved = pickSameUserAutoResolve({
+      resolvedTargetClientId = pickMostRecentSameUserClient({
         hub: assistantEventHub,
         capability: "host_file",
         sourceActorPrincipalId,
       });
-      if (resolved.kind === "ambiguous") {
-        return Promise.resolve(ambiguousSameUserError("host_file"));
+      if (
+        resolvedTargetClientId === undefined &&
+        sourceActorPrincipalId !== undefined
+      ) {
+        return Promise.resolve(unavailableSameUserClientError("host_file"));
       }
-      resolvedTargetClientId =
-        resolved.kind === "match" ? resolved.clientId : undefined;
     }
 
     if (resolvedTargetClientId != null) {
@@ -364,19 +362,17 @@ export class HostTransferProxy {
         });
       }
     } else {
-      // Auto-resolve to the unique same-user client; reject ambiguous
-      // (multi-machine) cases so a single targeted-style transfer cannot
-      // fan out across the user's machines.
-      const resolved = pickSameUserAutoResolve({
+      resolvedTargetClientId = pickMostRecentSameUserClient({
         hub: assistantEventHub,
         capability: "host_file",
         sourceActorPrincipalId,
       });
-      if (resolved.kind === "ambiguous") {
-        return Promise.resolve(ambiguousSameUserError("host_file"));
+      if (
+        resolvedTargetClientId === undefined &&
+        sourceActorPrincipalId !== undefined
+      ) {
+        return Promise.resolve(unavailableSameUserClientError("host_file"));
       }
-      resolvedTargetClientId =
-        resolved.kind === "match" ? resolved.clientId : undefined;
     }
 
     if (resolvedTargetClientId != null) {

package/src/daemon/lifecycle.ts

@@ -71,7 +71,6 @@ import { ensureCompleteCustomProfiles } from "../workspace/custom-profile-ensure
 import { ensureDefaultProvider } from "../workspace/default-provider-ensure.js";
 import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
 import { runWorkspaceMigrations } from "../workspace/migrations/runner.js";
-import { startAppSourceWatcher } from "./app-source-watcher.js";
 import { startConfigWatcher } from "./config-watcher.js";
 import { startConversationEvictor } from "./conversation-evictor.js";
 import { writePid } from "./daemon-control.js";
@@ -706,10 +705,6 @@ export async function runDaemon(): Promise<void> {
   // config, and broadcast the relevant resource-changed events to clients.
   startConfigWatcher();
 
-  // Watch app source directories so edits recompile + refresh surfaces across
-  // all conversations.
-  startAppSourceWatcher();
-
   // Start the CLI IPC server. Throws on EADDRINUSE to abort startup when another
   // daemon already holds the socket, so this process never runs background jobs
   // against the shared database as an unmanageable duplicate.

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

@@ -1,11 +1,11 @@
 /**
  * Shared MCP reload business logic.
  *
- * Called by the ConfigWatcher when config.json changes or a reload signal
+ * Called by the ConfigWatcher when mcp.json changes or a reload signal
  * file is detected, so the daemon automatically reconnects MCP servers.
  */
 
-import { getConfig, invalidateConfigCache } from "../config/loader.js";
+import { invalidateConfigCache } from "../config/loader.js";
 import {
   buildEffectiveMcpConfig,
   pluginMcpServersChangedSinceLastBuild,
@@ -13,6 +13,7 @@ import {
 import { getMcpServerManager } from "../mcp/manager.js";
 import { migrateLegacyMcpHeaders } from "../mcp/mcp-header-store.js";
 import { signalMcpReloaded } from "../mcp/reload-signal.js";
+import { loadWorkspaceMcpConfig } from "../mcp/workspace-mcp-config.js";
 import { createMcpToolsFromServer } from "../tools/mcp/mcp-tool-factory.js";
 import { registerMcpTools, unregisterAllMcpTools } from "../tools/registry.js";
 import { getLogger } from "../util/logger.js";
@@ -95,16 +96,15 @@ async function doReload(): Promise<McpReloadResult> {
     //    If the config is broken we abort early, preserving the current
     //    working MCP setup instead of leaving zero servers.
     invalidateConfigCache();
-    const config = getConfig();
 
     // 2. Stop existing MCP servers + unregister their tools
     await manager.stop();
     unregisterAllMcpTools();
 
     // Plugins are re-read here too: installing or removing one changes the
-    // server set exactly like editing config.json does, and both arrive
+    // server set exactly like editing mcp.json does, and both arrive
     // through this same reload.
-    const mcpConfig = buildEffectiveMcpConfig(config.mcp);
+    const mcpConfig = buildEffectiveMcpConfig(loadWorkspaceMcpConfig());
     const serverIds = Object.keys(mcpConfig.servers);
 
     // 3. Restart MCP servers

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

@@ -13,6 +13,7 @@ export const SYNC_TAGS = {
   assistantConfig: "assistant:self:config",
   assistantSounds: "assistant:self:sounds",
   assistantSchedules: "assistant:self:schedules",
+  assistantDesktop: "assistant:self:desktop",
   assistantTheme: "assistant:self:theme",
   appsList: "apps:list",
   documentsList: "documents:list",

package/src/daemon/orphan-reaper.ts

@@ -3,7 +3,7 @@
  *
  * Tools run commands in their own process group (`detached: true`) and, on
  * timeout/abort, group-kill with `process.kill(-pgid, SIGKILL)` (the bash and
- * host_bash tools, the skill sandbox runner, and the debug-bash route). The
+ * host_bash tools, and the skill sandbox runner). The
  * immediate child is reaped by Bun/libuv, but its descendants — e.g. git's
  * transport helpers or a skill runner's `bun` process — were never spawned by
  * the daemon, so when the group dies they reparent to PID 1. When the daemon

package/src/daemon/providers-setup.ts

@@ -63,7 +63,7 @@ export async function initializeProvidersAndTools(
   // Start MCP servers — workspace-configured and plugin-declared alike —
   // and register their tools. Shared with the schedule worker, which hosts
   // agent turns in its own process and so needs its own connections.
-  await startConfiguredMcpServers(config.mcp);
+  await startConfiguredMcpServers();
 
   log.info("Daemon startup: providers and tools initialized");
 }

package/src/daemon/shutdown-handlers.ts

@@ -24,11 +24,7 @@ import { browserManager } from "../tools/browser/browser-manager.js";
 import { getLogger } from "../util/logger.js";
 import { APP_VERSION } from "../version.js";
 import { getEnrichmentService } from "../workspace/commit-message-enrichment-service.js";
-import {
-  commitAllPendingWorkspaceChanges,
-  stopWorkspaceHeartbeatService,
-} from "../workspace/heartbeat-service.js";
-import { stopAppSourceWatcher } from "./app-source-watcher.js";
+import { commitAllPendingWorkspaceChanges } from "../workspace/heartbeat-service.js";
 import { stopConfigWatcher } from "./config-watcher.js";
 import { stopConversationEvictor } from "./conversation-evictor.js";
 import { stopConversations } from "./conversation-store.js";
@@ -98,9 +94,6 @@ async function shutdown(): Promise<void> {
   }, 30_000);
   forceTimer.unref();
 
-  // Workspace git heartbeat timer lives in the monitor process. This
-  // in-process stop is a no-op unless the singleton was started here.
-  await stopWorkspaceHeartbeatService();
   await stopHeartbeatService();
 
   // Stop the periodic consent-cache refresh (a daemon-owned interval).
@@ -134,7 +127,6 @@ async function shutdown(): Promise<void> {
   disposeAcpSessionManager();
   stopConversationEvictor();
   stopConfigWatcher();
-  stopAppSourceWatcher();
   stopCliIpcServer();
   stopConversations();
   await stopCes();

package/src/daemon/skill-memory-refresh.ts

@@ -8,16 +8,24 @@ import {
   maybeSeedCapabilitySkills,
   maybeSeedCliCommandCards,
 } from "../plugins/defaults/memory/substrate/boot-maintenance.js";
+import { readWorkspaceSkillMdSignature } from "../skills/workspace-skill-md-signature.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("skill-memory-refresh");
 
+/** Poll interval for workspace `SKILL.md` mtimes. Stats only, no tree walk. */
+export const SKILL_MD_MTIME_POLL_MS = 1_500;
+
+let lastSignature: string | undefined;
+let pollTimer: ReturnType<typeof setInterval> | undefined;
+
 export function refreshSkillCapabilityMemories(
   config: AssistantConfig = getConfig(),
 ): void {
   seedSkillGraphNodes();
   maybeSeedCapabilitySkills(config);
   maybeSeedCliCommandCards(config);
+  lastSignature = readWorkspaceSkillMdSignature();
   void seedUninstalledCatalogSkillMemories()
     .then(() => {
       // Re-run after the async catalog fetch populates the cache so stale
@@ -31,3 +39,59 @@ export function refreshSkillCapabilityMemories(
       ),
     );
 }
+
+/**
+ * Reseed skill capability memories when the workspace `SKILL.md` set or
+ * mtimes have changed since the last refresh in this process. No-op when the
+ * signature is unchanged. First call in a process always reseeds so the
+ * memory worker, whose in-process skill cache starts empty, picks up the
+ * catalog without waiting for an install path.
+ */
+export function maybeRefreshSkillCapabilityMemoriesFromMtime(): boolean {
+  const signature = readWorkspaceSkillMdSignature();
+  if (lastSignature !== undefined && signature === lastSignature) {
+    return false;
+  }
+  if (lastSignature !== undefined) {
+    log.info("Workspace SKILL.md set changed, reseeding capability memories");
+  }
+  refreshSkillCapabilityMemories();
+  return true;
+}
+
+function pollOnce(): void {
+  try {
+    maybeRefreshSkillCapabilityMemoriesFromMtime();
+  } catch (err) {
+    log.warn({ err }, "SKILL.md mtime poll failed");
+  }
+}
+
+/**
+ * Start a per-process poll of workspace `SKILL.md` mtimes. Idempotent.
+ * The memory worker and the assistant each run this against their own
+ * in-process skill caches. Runs once immediately so a worker that has never
+ * seeded picks up the catalog without waiting a tick.
+ */
+export function startWorkspaceSkillMdMtimePoll(): void {
+  if (pollTimer !== undefined) {
+    return;
+  }
+  pollOnce();
+  pollTimer = setInterval(pollOnce, SKILL_MD_MTIME_POLL_MS);
+  pollTimer.unref?.();
+}
+
+export function stopWorkspaceSkillMdMtimePoll(): void {
+  if (pollTimer === undefined) {
+    return;
+  }
+  clearInterval(pollTimer);
+  pollTimer = undefined;
+}
+
+/** @internal Test-only: clear the in-process signature and poll timer. */
+export function _resetSkillMdMtimeStateForTests(): void {
+  lastSignature = undefined;
+  stopWorkspaceSkillMdMtimePoll();
+}

package/src/daemon/tool-side-effects.ts

@@ -18,17 +18,15 @@ import { invalidateEdgeIndex } from "../plugins/defaults/memory/substrate/edge-i
 import { invalidatePageIndex } from "../plugins/defaults/memory/substrate/page-index.js";
 import { getConceptsDir } from "../plugins/defaults/memory/substrate/page-store.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
-import {
-  publishAppsChanged,
-  publishDocumentsChanged,
-} from "../runtime/sync/resource-sync-events.js";
-import { updatePublishedAppDeployment } from "../services/published-app-updater.js";
+import { publishDocumentsChanged } from "../runtime/sync/resource-sync-events.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { getLogger } from "../util/logger.js";
 import { getWorkspaceDir } from "../util/platform.js";
-import { ensureAppSourceWatcher } from "./app-source-watcher.js";
+import {
+  broadcastAppFilesChanged,
+  notifyAppSurfacesChanged,
+} from "./app-change-notify.js";
 import type { Conversation } from "./conversation.js";
-import { refreshSurfacesForApp } from "./conversation-surfaces.js";
 import { isDoordashCommand, updateDoordashProgress } from "./doordash-steps.js";
 
 const log = getLogger("tool-side-effects");
@@ -54,7 +52,7 @@ export type PostExecutionHook = (
  * Compilation is the responsibility of the tool executor (see
  * `executeAppCreate`, `executeAppRefresh`): executors own the source→dist
  * transform and surface `compile_errors` in their result when it fails.
- * Post-execution hooks only observe the outcome and notify — they must
+ * Post-execution hooks only observe the outcome and notify. They must
  * not re-run a compile because `compileApp()` begins with `rm -rf dist/`
  * and would race with the executor's own output (LUM-1153).
  */
@@ -63,14 +61,7 @@ function notifyAppChanged(
   appId: string,
   opts?: { fileChange?: boolean; status?: string },
 ): void {
-  refreshSurfacesForApp(ctx, appId, opts);
-  broadcastAppFilesChanged(appId);
-  void updatePublishedAppDeployment(appId);
-}
-
-function broadcastAppFilesChanged(appId: string): void {
-  broadcastMessage({ type: "app_files_changed", appId });
-  publishAppsChanged();
+  notifyAppSurfacesChanged(appId, opts, ctx);
 }
 
 /**
@@ -128,8 +119,6 @@ registerHook("app_create", (_name, _input, result, { ctx }) => {
     log.warn({ err, appId }, "Failed to track conversation ID on app_create");
   }
 
-  ensureAppSourceWatcher();
-
   notifyAppChanged(ctx, appId);
 
   // Seed background icon generation from the created app's canonical record