@vellumai/assistant 0.10.9 → 0.10.10-dev.202607162206.d08e98e

package/src/config/schemas/stt.ts

@@ -12,6 +12,19 @@ export const VALID_STT_PROVIDERS = [
   "vellum",
 ] as const;
 
+/**
+ * Forgiving aliases normalized to a canonical provider id before the enum
+ * check, so a natural value like `openai` or `whisper` is accepted rather than
+ * silently reset (which cascades into a full `services` section reset).
+ */
+const STT_PROVIDER_ALIASES: Record<
+  string,
+  (typeof VALID_STT_PROVIDERS)[number]
+> = {
+  openai: "openai-whisper",
+  whisper: "openai-whisper",
+};
+
 /**
  * Sparse provider config map under `services.stt.providers`.
  *
@@ -33,11 +46,12 @@ export type SttProviders = z.infer<typeof SttProvidersSchema>;
 /**
  * Canonical STT service configuration.
  *
- * `mode` selects between the user's own provider key (`"your-own"`) and
- * Vellum-managed transcription billed to Vellum credits (`"managed"`).
- * The `provider` field always holds the user's BYOK choice so switching
- * back from managed mode restores it; use {@link effectiveSttProvider}
- * to resolve which provider is actually active.
+ * Managed transcription (through the user's Vellum account, billed to Vellum
+ * credits) is selectable two ways: `provider: "vellum"` directly, or
+ * `mode: "managed"` alongside a BYOK `provider` — the form the mode toggle
+ * writes, which leaves the BYOK choice untouched so switching back to
+ * `"your-own"` restores it. Use {@link effectiveSttProvider} to resolve
+ * which provider is actually active.
  */
 export const SttServiceSchema = z
   .object({
@@ -50,22 +64,21 @@ export const SttServiceSchema = z
         'STT service mode -- "your-own" uses the configured provider with your API key; "managed" transcribes through your Vellum account',
       ),
     provider: z
-      .enum(VALID_STT_PROVIDERS, {
-        error: `services.stt.provider must be one of: ${VALID_STT_PROVIDERS.join(", ")}`,
-      })
+      .preprocess(
+        (v) => {
+          if (typeof v !== "string") {
+            return v;
+          }
+          const k = v.trim().toLowerCase();
+          return STT_PROVIDER_ALIASES[k] ?? k;
+        },
+        z.enum(VALID_STT_PROVIDERS, {
+          error: `services.stt.provider must be one of: ${VALID_STT_PROVIDERS.join(", ")} (aliases: openai/whisper -> openai-whisper)`,
+        }),
+      )
       .describe("Active STT provider used for speech-to-text transcription"),
     providers: SttProvidersSchema.default({}),
   })
-  .superRefine((service, ctx) => {
-    if (service.provider === "vellum" && service.mode !== "managed") {
-      ctx.addIssue({
-        code: "custom",
-        path: ["provider"],
-        message:
-          'services.stt.provider "vellum" requires services.stt.mode "managed"',
-      });
-    }
-  })
   .describe(
     "Speech-to-text service configuration -- provider selection and per-provider settings",
   );
@@ -75,13 +88,17 @@ export type SttService = z.infer<typeof SttServiceSchema>;
 /**
  * Resolve the provider that is actually active for the service config.
  *
- * Managed mode always routes to the `vellum` provider while leaving the
- * user's BYOK `provider` choice untouched, so toggling back to
- * `"your-own"` restores their previous setup.
+ * `provider: "vellum"` selects managed transcription directly. Otherwise
+ * `mode: "managed"` routes to `vellum` while leaving the user's BYOK
+ * `provider` choice untouched, so toggling back to `"your-own"` restores
+ * their previous setup.
  */
 export function effectiveSttProvider(service: {
   mode: SttService["mode"];
   provider: string;
 }): string {
+  if (service.provider === "vellum") {
+    return "vellum";
+  }
   return service.mode === "managed" ? "vellum" : service.provider;
 }

package/src/config/schemas/tts.ts

@@ -273,11 +273,12 @@ for (const id of schemaKeys) {
 /**
  * Canonical TTS service configuration.
  *
- * `mode` selects between the user's own provider key (`"your-own"`) and
- * Vellum-managed synthesis billed to Vellum credits (`"managed"`). The
- * `provider` field always holds the user's BYOK choice so switching back
- * from managed mode restores it; use {@link effectiveTtsProvider} to
- * resolve which provider is actually active.
+ * Managed synthesis (through the user's Vellum account, billed to Vellum
+ * credits) is selectable two ways: `provider: "vellum"` directly, or
+ * `mode: "managed"` alongside a BYOK `provider` — the form the mode toggle
+ * writes, which leaves the BYOK choice untouched so switching back to
+ * `"your-own"` restores it. Use {@link effectiveTtsProvider} to resolve
+ * which provider is actually active.
  */
 export const TtsServiceSchema = z
   .object({
@@ -297,16 +298,6 @@ export const TtsServiceSchema = z
       .describe("Active TTS provider used for speech synthesis"),
     providers: TtsProvidersSchema.default(TtsProvidersSchema.parse({})),
   })
-  .superRefine((service, ctx) => {
-    if (service.provider === "vellum" && service.mode !== "managed") {
-      ctx.addIssue({
-        code: "custom",
-        path: ["provider"],
-        message:
-          'services.tts.provider "vellum" requires services.tts.mode "managed"',
-      });
-    }
-  })
   .describe(
     "Text-to-speech service configuration — provider selection and per-provider settings",
   );
@@ -316,14 +307,18 @@ export type TtsService = z.infer<typeof TtsServiceSchema>;
 /**
  * Resolve the provider that is actually active for the service config.
  *
- * Managed mode always routes to the `vellum` provider while leaving the
- * user's BYOK `provider` choice untouched, so toggling back to
- * `"your-own"` restores their previous setup.
+ * `provider: "vellum"` selects managed synthesis directly. Otherwise
+ * `mode: "managed"` routes to `vellum` while leaving the user's BYOK
+ * `provider` choice untouched, so toggling back to `"your-own"` restores
+ * their previous setup.
  */
 export function effectiveTtsProvider(service: {
   mode: TtsService["mode"];
   provider?: string;
 }): string {
+  if (service.provider === "vellum") {
+    return "vellum";
+  }
   if (service.mode === "managed") {
     return "vellum";
   }

package/src/config/skills.ts

@@ -684,25 +684,26 @@ function discoverSkillDirectories(skillsDir: string): string[] {
 }
 
 /**
- * Whether `pluginDir` is a recognized installed plugin: it must carry a
- * parseable `package.json` whose `name` equals the directory name. This
- * mirrors the external plugin loader's recognition gate, which skips any
- * directory whose `manifest.name` does not match its directory name.
+ * Whether `pluginDir` carries a plugin manifest the runtime can load: a
+ * parseable `package.json` with a non-empty string `name`. This mirrors the
+ * external plugin loader (`buildPluginFromDir`), which builds a plugin from
+ * any such directory and derives the plugin's identity from `package.json`
+ * `name` — it imposes no match between that `name` and the directory name.
+ *
+ * The directory name is the install slug (a marketplace slug or a GitHub path
+ * leaf), which routinely differs from the plugin's own `package.json` `name`;
+ * requiring the two to match would silently drop the resident skills of every
+ * such plugin even though the runtime loads its hooks and tools fine.
  *
  * The caller is responsible for the missing-`package.json` case (it emits a
  * diagnostic warning); this function only judges a manifest that is present.
  */
-function isRecognizedPluginDir(pluginDir: string, dirName: string): boolean {
+function hasLoadablePluginManifest(pluginDir: string): boolean {
   const manifestPath = join(pluginDir, "package.json");
   if (!existsSync(manifestPath)) return false;
+  let parsed: unknown;
   try {
-    const parsed: unknown = JSON.parse(readFileSync(manifestPath, "utf-8"));
-    return (
-      typeof parsed === "object" &&
-      parsed !== null &&
-      "name" in parsed &&
-      (parsed as { name: unknown }).name === dirName
-    );
+    parsed = JSON.parse(readFileSync(manifestPath, "utf-8"));
   } catch (err) {
     log.warn(
       { err, manifestPath },
@@ -710,12 +711,19 @@ function isRecognizedPluginDir(pluginDir: string, dirName: string): boolean {
     );
     return false;
   }
+  return (
+    typeof parsed === "object" &&
+    parsed !== null &&
+    "name" in parsed &&
+    typeof (parsed as { name: unknown }).name === "string" &&
+    (parsed as { name: string }).name.length > 0
+  );
 }
 
 /**
  * Discover skills shipped on disk inside installed plugins. Each installed
  * plugin — a directory under `<workspaceDir>/plugins/` recognized by
- * {@link isRecognizedPluginDir} — may ship skills at `skills/<id>/SKILL.md`.
+ * {@link hasLoadablePluginManifest} — may ship skills at `skills/<id>/SKILL.md`.
  * Returned summaries are attributed to the owning plugin via their `owner`
  * descriptor (`{ kind: "plugin", id: <plugin dir name> }`).
  */
@@ -747,7 +755,7 @@ function discoverPluginResidentSkills(): SkillSummary[] {
     if (!existsSync(join(pluginDir, "package.json"))) {
       log.warn(
         { pluginDir },
-        "Plugin directory is missing package.json — skipping; its skills will not be available. Add a package.json whose `name` matches the directory.",
+        "Plugin directory is missing package.json — skipping; its skills will not be available. Add a package.json with a `name`.",
       );
       continue;
     }
@@ -757,13 +765,15 @@ function discoverPluginResidentSkills(): SkillSummary[] {
     // tools, so its resident skills must not be loadable either.
     if (existsSync(join(pluginDir, ".disabled"))) continue;
 
-    // Mirror the plugin loader's recognition gate: a directory is a real
-    // installed plugin only if its `package.json` `name` matches the directory.
-    // This rejects staging dirs and malformed/mismatched clones (e.g. an
-    // un-adapted `caveman-installer`) that the loader itself would skip, so the
-    // catalog never surfaces skills from a directory the runtime would refuse
-    // to load.
-    if (!isRecognizedPluginDir(pluginDir, entry.name)) continue;
+    // Mirror the plugin loader: a directory contributes its resident skills
+    // when it carries a loadable manifest (parseable `package.json` with a
+    // non-empty `name`). The manifest `name` need not equal the directory name
+    // — the loader imposes no such match — so a plugin installed under a
+    // marketplace slug or GitHub path leaf that differs from its `package.json`
+    // `name` still surfaces its skills, matching the hooks and tools the
+    // runtime already loads from it. A parseable manifest still rejects staging
+    // dirs and malformed clones the loader would itself refuse.
+    if (!hasLoadablePluginManifest(pluginDir)) continue;
 
     const skillsDir = join(pluginDir, "skills");
     if (!existsSync(skillsDir)) continue;

package/src/context/compactor.ts

@@ -82,10 +82,13 @@ function recordCompactionRequestLog(
   conversationId: string,
   response: ProviderResponse,
   provider: Provider,
-): void {
-  if (!response.rawRequest || !response.rawResponse) return;
+): string | null {
+  if (!response.rawRequest || !response.rawResponse) return null;
   try {
-    recordRequestLog(
+    // Inserted unlinked (no message id) — user-initiated compaction flows
+    // (/compact, summarize-up-to) link the row to their result card after
+    // it persists, via `linkRequestLogsToMessage`.
+    return recordRequestLog(
       conversationId,
       JSON.stringify(response.rawRequest),
       JSON.stringify(response.rawResponse),
@@ -98,6 +101,7 @@ function recordCompactionRequestLog(
       { err, conversationId },
       "Failed to persist compaction LLM request log (non-fatal)",
     );
+    return null;
   }
 }
 
@@ -280,6 +284,14 @@ export interface CompactionRunArgs {
    * `[1, messages.length)` — otherwise the run returns `compacted: false`.
    */
   fixedTailStartIndex?: number;
+  /**
+   * Row-space twin of `fixedTailStartIndex`: index into the conversation's
+   * persisted rows of the first message kept verbatim. Bounds the image
+   * manifest to rows that are actually being summarized away — kept-tail
+   * images stay in context verbatim, so offering them for retention would
+   * only duplicate them. Only meaningful alongside `fixedTailStartIndex`.
+   */
+  fixedBoundaryRowIndex?: number;
 }
 
 export interface CompactionRunResult {
@@ -305,6 +317,14 @@ export interface CompactionRunResult {
   summaryCacheCreationInputTokens?: number;
   summaryCacheReadInputTokens?: number;
   summaryRawResponses?: unknown[];
+  /**
+   * `llm_request_logs.id` of this pass's compaction call, `null` when the
+   * row was not written (logging disabled, missing raw payloads, DB error).
+   * User-initiated flows (/compact, summarize-up-to) link the row to their
+   * persisted result card so the inspector attributes the call to the card
+   * instead of the unlinked-row recovery guessing an enclosing turn.
+   */
+  summaryRequestLogId?: string | null;
   summaryText: string;
   /** Inline structured pending state from the model's `<key_state>` block. */
   keyState?: string;
@@ -457,15 +477,23 @@ interface ManifestEntry {
  * `loadFromDb` applies when assembling history — so guardian-only images
  * never enter the manifest and therefore can never be retained back into
  * an untrusted actor's view.
+ *
+ * `endRowIndex` (exclusive, row-space) bounds the walk to rows before a
+ * caller-fixed compaction boundary — images in the kept tail survive
+ * verbatim and must not be offered for retention. The slice happens before
+ * the trust filter because the boundary indexes the full row list.
  */
 export function collectImageManifest(
   conversationId: string,
   actorTrustClass?: TrustClass,
+  endRowIndex?: number,
 ): ManifestEntry[] {
   const allRows = getMessages(conversationId);
+  const boundedRows =
+    endRowIndex != null ? allRows.slice(0, endRowIndex) : allRows;
   const rows = !resolveCapabilities(actorTrustClass).canAccessMemory
-    ? filterMessagesForUntrustedActor(allRows)
-    : allRows;
+    ? filterMessagesForUntrustedActor(boundedRows)
+    : boundedRows;
   const entries: ManifestEntry[] = [];
   for (const row of rows) {
     const atts = getAttachmentMetadataForMessage(row.id);
@@ -1096,10 +1124,12 @@ export async function runAssistantDrivenCompaction(
   // Build image manifest from the DB before invoking the model so the
   // instruction message carries a faithful picture of available images.
   // Filtered by actor trust so untrusted turns never see guardian-only
-  // attachments.
+  // attachments, and bounded to pre-boundary rows on fixed-boundary runs
+  // so kept-tail images are never offered for retention.
   const manifest = collectImageManifest(
     args.conversationId,
     args.actorTrustClass,
+    fixedTailStartIndex != null ? args.fixedBoundaryRowIndex : undefined,
   );
   const manifestText = renderImageManifest(manifest);
   const instruction = buildInstructionMessage(
@@ -1159,7 +1189,11 @@ export async function runAssistantDrivenCompaction(
 
   // Persist the compaction LLM call into `llm_request_logs` with
   // `call_site = "compactionAgent"`. Non-fatal on DB error — see helper.
-  recordCompactionRequestLog(args.conversationId, response, args.provider);
+  const summaryRequestLogId = recordCompactionRequestLog(
+    args.conversationId,
+    response,
+    args.provider,
+  );
 
   const rawText = extractTextFromResponse(response.content);
   const parsed = parseCompactionResult(rawText, {
@@ -1182,6 +1216,7 @@ export async function runAssistantDrivenCompaction(
       summaryCallSite: COMPACTION_CALL_SITE,
       summaryOverrideProfile: args.overrideProfile ?? null,
       summaryRawResponses: response.rawResponse ? [response.rawResponse] : [],
+      summaryRequestLogId,
       summaryCalls: 1,
     };
   }
@@ -1387,6 +1422,7 @@ export async function runAssistantDrivenCompaction(
       summaryCallSite: COMPACTION_CALL_SITE,
       summaryOverrideProfile: args.overrideProfile ?? null,
       summaryRawResponses: response.rawResponse ? [response.rawResponse] : [],
+      summaryRequestLogId,
       summaryCalls: 1,
     };
   }
@@ -1459,6 +1495,7 @@ export async function runAssistantDrivenCompaction(
       response.usage.cacheCreationInputTokens ?? 0,
     summaryCacheReadInputTokens: response.usage.cacheReadInputTokens ?? 0,
     summaryRawResponses: response.rawResponse ? [response.rawResponse] : [],
+    summaryRequestLogId,
     summaryText: finalSummaryText,
     keyState: parsed.keyState,
     summaryFailed: false,

package/src/context/post-turn-tool-result-truncation.ts

@@ -104,7 +104,9 @@ export function getToolResultFilePath(
 /**
  * Build the truncated stub that replaces a large tool result in context.
  * Preserves the first and last halves of TARGET_CHARS, with a middle marker
- * indicating how many tokens were omitted and where to find the full result.
+ * indicating how many tokens were omitted, where to find the full result, and
+ * how to page it back in — the marker is the model's only signal that the
+ * omitted content is recoverable at all.
  */
 export function buildTruncatedContent(
   original: string,
@@ -119,7 +121,7 @@ export function buildTruncatedContent(
   );
   const omittedChars = original.length - TARGET_CHARS;
   const estimatedTokens = Math.round(omittedChars / 4);
-  return `${prefix}\n\n...(${estimatedTokens} tokens omitted ${TRUNCATION_MARKER} ${filePath})\n\n${suffix}`;
+  return `${prefix}\n\n...(${estimatedTokens} tokens omitted ${TRUNCATION_MARKER} ${filePath} — use file_read to view)\n\n${suffix}`;
 }
 
 /**

package/src/context/tool-result-spool.ts

@@ -18,11 +18,24 @@ import {
  */
 const AX_TREE_TAG = "<ax-tree>";
 
+/**
+ * Tools whose results are explicit, self-sized reads the model paginates
+ * itself: `web_fetch` takes `max_chars`/`start_index` and reports a
+ * "Character Window: X-Y of Z", so the model pages by character index against
+ * the window it requested. Stubbing such a result at result time hands the
+ * model ~a tenth of the window it just sized — and it keeps paging blind
+ * against content it never saw. Like the file-read tools, these explicit
+ * reads are honored in full for the turn that made them; the post-turn pass
+ * still truncates them at turn end, after the model has consumed the content.
+ */
+export const RESULT_TIME_SPOOL_EXEMPT_TOOLS = new Set<string>(["web_fetch"]);
+
 /**
  * Whether a tool result is eligible for the result-time spool/stub pass: the
  * post-turn pass's shared rules plus the AX-tree exemption, minus the file-read
- * tools ({@link FILE_READ_TOOL_NAMES}). The file-read tools are the model's only
- * way to page spooled content back into context: stubbing a read of a
+ * tools ({@link FILE_READ_TOOL_NAMES}) and the explicit self-sized reads
+ * ({@link RESULT_TIME_SPOOL_EXEMPT_TOOLS}). The file-read tools are the model's
+ * only way to page spooled content back into context: stubbing a read of a
  * `.tool-results/` file would spool a fresh copy and hand back another stub, so
  * oversized content could never be read at all. Explicit reads are therefore
  * honored in full; the post-turn pass still truncates them at turn end, after
@@ -32,11 +45,19 @@ function isSpoolEligible(
   tr: ToolResultContent,
   toolName: string | undefined,
 ): boolean {
-  if (!isTruncationEligible(tr, toolName)) return false;
-  if (toolName !== undefined && FILE_READ_TOOL_NAMES.has(toolName)) {
+  if (!isTruncationEligible(tr, toolName)) {
+    return false;
+  }
+  if (
+    toolName !== undefined &&
+    (FILE_READ_TOOL_NAMES.has(toolName) ||
+      RESULT_TIME_SPOOL_EXEMPT_TOOLS.has(toolName))
+  ) {
+    return false;
+  }
+  if (tr.content.includes(AX_TREE_TAG)) {
     return false;
   }
-  if (tr.content.includes(AX_TREE_TAG)) return false;
   return true;
 }
 

package/src/conversations/__tests__/message-consolidation.test.ts

@@ -333,3 +333,51 @@ describe("mergeConsecutiveAssistantMessages", () => {
     expect(result).toHaveLength(3);
   });
 });
+
+describe("system-card boundaries", () => {
+  const cardMeta = JSON.stringify({ messageKind: "system_card" });
+
+  test("a card never merges into the preceding assistant run", () => {
+    const { messages } = mergeConsecutiveAssistantMessages([
+      makeMsg("assistant", JSON.stringify([{ type: "text", text: "reply" }])),
+      makeMsg(
+        "assistant",
+        JSON.stringify([{ type: "text", text: "**Conversation summarized**" }]),
+        { metadata: cardMeta },
+      ),
+    ]);
+    expect(messages).toHaveLength(2);
+  });
+
+  test("an assistant row never merges into a preceding card", () => {
+    const { messages } = mergeConsecutiveAssistantMessages([
+      makeMsg(
+        "assistant",
+        JSON.stringify([{ type: "text", text: "**Context Cleaned**" }]),
+        { metadata: cardMeta },
+      ),
+      makeMsg("assistant", JSON.stringify([{ type: "text", text: "reply" }])),
+    ]);
+    expect(messages).toHaveLength(2);
+  });
+
+  test("findDisplayTurnEndIndex treats a card as a single-row turn", () => {
+    const rows = [
+      makeMsg("assistant", JSON.stringify([{ type: "text", text: "card" }]), {
+        metadata: cardMeta,
+      }),
+      makeMsg("assistant", JSON.stringify([{ type: "text", text: "reply" }])),
+    ];
+    expect(findDisplayTurnEndIndex(rows, 0)).toBe(0);
+  });
+
+  test("findDisplayTurnEndIndex stops an assistant run before a card", () => {
+    const rows = [
+      makeMsg("assistant", JSON.stringify([{ type: "text", text: "reply" }])),
+      makeMsg("assistant", JSON.stringify([{ type: "text", text: "card" }]), {
+        metadata: cardMeta,
+      }),
+    ];
+    expect(findDisplayTurnEndIndex(rows, 0)).toBe(0);
+  });
+});

package/src/conversations/message-consolidation.ts

@@ -32,11 +32,22 @@
  */
 
 import type { MessageRow } from "../persistence/conversation-crud.js";
+import { isSystemCardMessage } from "../persistence/conversation-crud.js";
 import type { ContentBlock } from "../providers/types.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("message-consolidation");
 
+/**
+ * True when a row is a daemon-authored system card (`messageKind:
+ * "system_card"` metadata). Cards are standalone display turns: they never
+ * fold into an adjacent assistant run and adjacent assistant rows never
+ * fold into them.
+ */
+export function isSystemCardRow(msg: MessageRow): boolean {
+  return isSystemCardMessage(msg.role, msg.metadata);
+}
+
 // ── Block predicates ────────────────────────────────────────────────
 
 function isToolResultType(type: string): boolean {
@@ -109,6 +120,10 @@ export function findDisplayTurnEndIndex(
   if (messages[startIdx]?.role !== "assistant") {
     return startIdx;
   }
+  // A system card is a single-row display turn — never spans neighbours.
+  if (isSystemCardRow(messages[startIdx]!)) {
+    return startIdx;
+  }
 
   let endIdx = startIdx;
   while (endIdx + 1 < messages.length) {
@@ -116,7 +131,7 @@ export function findDisplayTurnEndIndex(
     if (!next) {
       break;
     }
-    if (next.role === "assistant") {
+    if (next.role === "assistant" && !isSystemCardRow(next)) {
       endIdx += 1;
       continue;
     }
@@ -282,10 +297,15 @@ export function mergeConsecutiveAssistantMessages(messages: MessageRow[]): {
 
   for (const msg of messages) {
     const lastIdx = result.length - 1;
+    // System cards stay standalone in both directions: a card never folds
+    // into the preceding assistant run, and the following assistant row
+    // never folds into a card.
     const isConsecutiveAssistant =
       msg.role === "assistant" &&
+      !isSystemCardRow(msg) &&
       lastIdx >= 0 &&
-      result[lastIdx].role === "assistant";
+      result[lastIdx].role === "assistant" &&
+      !isSystemCardRow(result[lastIdx]);
 
     if (!isConsecutiveAssistant) {
       result.push(msg);

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

@@ -582,19 +582,12 @@ describe("isToolActiveForContext — ask_question macOS gating", () => {
     ).toBe(false);
   });
 
-  test("other client-capability tools (app_open) are NOT affected by the macos gate", () => {
+  test("app_open is skill-owned and not client-capability gated", () => {
+    // The app-builder skill provides app_open; its executor degrades
+    // gracefully when no client is connected, so the context filter does
+    // not hide it even on clientless turns.
     expect(
-      isToolActiveForContext(
-        "app_open",
-        makeCtx({
-          hasNoClient: false,
-          channelCapabilities: {
-            channel: "macos",
-            supportsDynamicUi: true,
-            clientOS: "macos",
-          },
-        }),
-      ),
+      isToolActiveForContext("app_open", makeCtx({ hasNoClient: true })),
     ).toBe(true);
   });
 });

package/src/daemon/app-source-watcher.ts

@@ -15,7 +15,6 @@ import {
   getApp,
   getAppDirPath,
   getAppsDir,
-  isMultifileApp,
   resolveAppIdByDirName,
 } from "../apps/app-store.js";
 import { compileApp } from "../bundler/app-compiler.js";
@@ -159,8 +158,8 @@ export class AppSourceWatcher {
 }
 
 /**
- * Handle a detected app source file change. Recompiles multifile apps and
- * refreshes surfaces across ALL conversations.
+ * Handle a detected app source file change. Recompiles the app and refreshes
+ * surfaces across ALL conversations.
  */
 function handleAppSourceChange(appId: string): void {
   const app = getApp(appId);
@@ -175,26 +174,21 @@ function handleAppSourceChange(appId: string): void {
     void updatePublishedAppDeployment(appId);
   };
 
-  if (isMultifileApp(app)) {
-    const appDir = getAppDirPath(appId);
-    void compileApp(appDir)
-      .then((result) => {
-        if (!result.ok) {
-          log.warn(
-            { appId, errors: result.errors },
-            "Recompile failed on app source change",
-          );
-        }
-        doRefresh();
-      })
-      .catch((err) => {
-        log.warn({ appId, err }, "Recompile threw on app source change");
-        doRefresh();
-      });
-    return;
-  }
-
-  doRefresh();
+  const appDir = getAppDirPath(appId);
+  void compileApp(appDir)
+    .then((result) => {
+      if (!result.ok) {
+        log.warn(
+          { appId, errors: result.errors },
+          "Recompile failed on app source change",
+        );
+      }
+      doRefresh();
+    })
+    .catch((err) => {
+      log.warn({ appId, err }, "Recompile threw on app source change");
+      doRefresh();
+    });
 }
 
 /** Start watching app source directories for the life of the daemon. */