@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091853.fbaa2ae

package/src/tools/apps/executors.ts

@@ -68,6 +68,73 @@ export type ProxyResolver = (
   input: Record<string, unknown>,
 ) => Promise<ExecutorResult>;
 
+/**
+ * Validate a `source_files` map (LLM input is not type-checked at runtime).
+ * Returns an error ExecutorResult when invalid, or null when absent/valid.
+ */
+function validateSourceFiles(sourceFiles: unknown): ExecutorResult | null {
+  if (sourceFiles == null) {
+    return null;
+  }
+  if (typeof sourceFiles !== "object" || Array.isArray(sourceFiles)) {
+    return {
+      content: JSON.stringify({
+        error:
+          "source_files must be an object mapping relative file paths to string contents",
+      }),
+      isError: true,
+    };
+  }
+  for (const [key, val] of Object.entries(sourceFiles)) {
+    if (typeof val !== "string") {
+      return {
+        content: JSON.stringify({
+          error: `source_files["${key}"] must be a string, got ${typeof val}`,
+        }),
+        isError: true,
+      };
+    }
+  }
+  return null;
+}
+
+/**
+ * Resolve an app name when the model omits it. The preview card's title is
+ * "always include" guidance and almost always present, so it's the best
+ * fallback — a real, meaningful name — before a generic placeholder.
+ */
+function resolveAppName(input: AppCreateInput): string {
+  const previewTitle =
+    input.preview && typeof input.preview.title === "string"
+      ? input.preview.title
+      : undefined;
+  for (const candidate of [input.name, previewTitle]) {
+    if (typeof candidate === "string" && candidate.trim() !== "") {
+      return candidate.trim();
+    }
+  }
+  return "New App";
+}
+
+/**
+ * Compile-result fields shared by the app_refresh and app_update responses.
+ * On failure the errors/warnings are surfaced so the agent can fix them.
+ */
+function compileResultPayload(
+  compileResult: Awaited<ReturnType<typeof compileApp>>,
+): Record<string, unknown> {
+  return {
+    compiled: compileResult.ok,
+    ...(compileResult.ok
+      ? { compile_duration_ms: compileResult.durationMs }
+      : {
+          compile_errors: compileResult.errors,
+          compile_warnings: compileResult.warnings,
+          compile_duration_ms: compileResult.durationMs,
+        }),
+  };
+}
+
 // ---------------------------------------------------------------------------
 // app_create
 // ---------------------------------------------------------------------------
@@ -76,14 +143,12 @@ export interface AppCreateInput {
   name: string;
   description?: string;
   schema_json?: string;
-  /**
-   * Retired single-file shortcut. Kept in the type so legacy or stale callers
-   * get a clear tool error instead of silently creating a v2 app with stale
-   * scaffold content.
-   */
+  /** Retired single-file shortcut. Returns a guidance error. */
   html?: unknown;
-  /** Retired single-file multi-page shortcut. */
+  /** Retired single-file multi-page shortcut. Returns a guidance error. */
   pages?: unknown;
+  /** Lenient alias. Folded into preview.icon when preview.icon is absent. */
+  icon?: unknown;
   auto_open?: boolean;
   preview?: Record<string, unknown>;
   source_files?: Record<string, string>;
@@ -94,15 +159,20 @@ export async function executeAppCreate(
   store: AppStore,
   proxyToolResolver?: ProxyResolver,
 ): Promise<ExecutorResult> {
-  const name = input.name;
+  // The model sometimes omits a name; resolve a sensible one rather than
+  // erroring out so the build still succeeds. Users can rename via app_update.
+  const name = resolveAppName(input);
   const description = input.description;
   const schemaJson = input.schema_json ?? "{}";
 
+  // Retired shortcut: a top-level `html` is no longer accepted. Reject with a
+  // helpful message (rather than a cryptic schema error) so the model writes a
+  // multi-file TSX app under src/ instead.
   if (Object.prototype.hasOwnProperty.call(input, "html")) {
     return {
       content: JSON.stringify({
         error:
-          "app_create no longer accepts html. Create the app scaffold, write src/index.html and src/main.tsx with file_write, then call app_refresh.",
+          "app_create no longer accepts html. Build a multi-file TSX app under src/ (src/index.html + src/main.tsx + src/App.tsx) instead.",
       }),
       isError: true,
     };
@@ -120,44 +190,18 @@ export async function executeAppCreate(
   const autoOpen = input.auto_open !== false; // default true
   const preview = input.preview;
 
-  // Validate required fields - LLM input is not type-checked at runtime
-  if (typeof name !== "string" || name.trim() === "") {
-    return {
-      content: JSON.stringify({
-        error: "name is required and must be a non-empty string",
-      }),
-      isError: true,
-    };
-  }
-
-  if (input.source_files != null) {
-    if (
-      typeof input.source_files !== "object" ||
-      Array.isArray(input.source_files)
-    ) {
-      return {
-        content: JSON.stringify({
-          error:
-            "source_files must be an object mapping relative file paths to string contents",
-        }),
-        isError: true,
-      };
-    }
-    for (const [key, val] of Object.entries(input.source_files)) {
-      if (typeof val !== "string") {
-        return {
-          content: JSON.stringify({
-            error: `source_files["${key}"] must be a string, got ${typeof val}`,
-          }),
-          isError: true,
-        };
-      }
-    }
+  const sourceFilesError = validateSourceFiles(input.source_files);
+  if (sourceFilesError) {
+    return sourceFilesError;
   }
 
   // Extract icon from preview if provided - only persist emoji-like values,
   // not URLs which would render as raw strings in UI and bundle manifests.
-  const rawIcon = preview?.icon as string | undefined;
+  // Lenient alias: a top-level `icon` is folded in when preview.icon is absent.
+  const rawIcon = (preview?.icon ??
+    (typeof input.icon === "string" ? input.icon : undefined)) as
+    | string
+    | undefined;
   const icon = rawIcon && !rawIcon.startsWith("http") ? rawIcon : undefined;
 
   const app = store.createApp({
@@ -351,14 +395,7 @@ export async function executeAppRefresh(
         refreshed: true,
         appId: updated.id,
         name: updated.name,
-        compiled: compileResult.ok,
-        ...(compileResult.ok
-          ? { compile_duration_ms: compileResult.durationMs }
-          : {
-              compile_errors: compileResult.errors,
-              compile_warnings: compileResult.warnings,
-              compile_duration_ms: compileResult.durationMs,
-            }),
+        ...compileResultPayload(compileResult),
       }),
       isError: false,
     };
@@ -374,6 +411,85 @@ export async function executeAppRefresh(
   };
 }
 
+// ---------------------------------------------------------------------------
+// app_update
+// ---------------------------------------------------------------------------
+
+export interface AppUpdateInput {
+  app_id: string;
+  name?: string;
+  description?: string;
+  schema_json?: string;
+  source_files?: Record<string, string>;
+}
+
+export async function executeAppUpdate(
+  input: AppUpdateInput,
+  store: AppStore,
+): Promise<ExecutorResult> {
+  const app = store.getApp(input.app_id);
+  if (!app) {
+    return {
+      content: JSON.stringify({ error: `App '${input.app_id}' not found` }),
+      isError: true,
+    };
+  }
+
+  const sourceFilesError = validateSourceFiles(input.source_files);
+  if (sourceFilesError) {
+    return sourceFilesError;
+  }
+
+  if (input.source_files) {
+    for (const [filePath, content] of Object.entries(input.source_files)) {
+      store.writeAppFile(input.app_id, filePath, content);
+    }
+  }
+
+  const updates: Partial<
+    Pick<AppDefinition, "name" | "description" | "schemaJson">
+  > = {};
+  if (typeof input.name === "string" && input.name.trim() !== "") {
+    updates.name = input.name.trim();
+  }
+  if (typeof input.description === "string") {
+    updates.description = input.description;
+  }
+  if (typeof input.schema_json === "string") {
+    updates.schemaJson = input.schema_json;
+  }
+
+  // An empty update still bumps updatedAt, triggering a client surface refresh.
+  const updated = store.updateApp(input.app_id, updates);
+
+  // Multifile apps recompile so the agent sees any errors from the edited
+  // source instead of serving a stale dist (mirrors app_refresh).
+  if (app.formatVersion === 2) {
+    const appDir = getAppDirPath(input.app_id);
+    const compileResult = await compileApp(appDir);
+    return {
+      content: JSON.stringify({
+        updated: true,
+        appId: updated.id,
+        name: updated.name,
+        description: updated.description,
+        ...compileResultPayload(compileResult),
+      }),
+      isError: false,
+    };
+  }
+
+  return {
+    content: JSON.stringify({
+      updated: true,
+      appId: updated.id,
+      name: updated.name,
+      description: updated.description,
+    }),
+    isError: false,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // app_generate_icon
 // ---------------------------------------------------------------------------

package/src/tools/browser/browser-execution.ts

@@ -1,3 +1,4 @@
+import { optimizeImageForTransport } from "../../agent/image-optimize.js";
 import { getConfig } from "../../config/loader.js";
 import { HostBrowserProxy } from "../../daemon/host-browser-proxy.js";
 import type { ImageContent } from "../../providers/types.js";
@@ -1206,13 +1207,22 @@ export async function executeBrowserScreenshot(
       { quality: 80, fullPage },
       context.signal,
     );
-    const base64Data = buffer.toString("base64");
+    const rawBase64 = buffer.toString("base64");
+
+    // Downscale before handing the screenshot to the model. A full-page
+    // capture of a tall or high-DPI page can exceed Anthropic's 5 MB
+    // per-image cap, which would otherwise persist into the conversation
+    // history inside this tool_result and reject every subsequent turn.
+    const { data: base64Data, mediaType } = optimizeImageForTransport(
+      rawBase64,
+      "image/jpeg",
+    );
 
     const imageBlock: ImageContent = {
       type: "image" as const,
       source: {
         type: "base64" as const,
-        media_type: "image/jpeg",
+        media_type: mediaType,
         data: base64Data,
       },
     };

package/src/tools/filesystem/write.ts

@@ -1,5 +1,6 @@
 import { join, resolve, sep } from "node:path";
 
+import { getAppsDir } from "../../memory/app-store.js";
 import { enqueuePkbIndexJob } from "../../memory/jobs/embed-pkb-file.js";
 import { PKB_WORKSPACE_SCOPE } from "../../memory/pkb/types.js";
 import { RiskLevel } from "../../permissions/types.js";
@@ -17,6 +18,29 @@ import type {
 
 const logger = getLogger("file-write");
 
+/**
+ * Detects an attempt to write a self-contained interactive HTML document —
+ * the signature of a "visualization" / "artifact" the model should be
+ * building as a real app via the app-builder skill, not dumping as a loose
+ * file. We deliberately trip ONLY on standalone docs with a substantial
+ * INLINE script (the data + rendering live in the file). app-builder's own
+ * scaffold writes a thin shell whose only script is an external module
+ * (`<script type="module" src="/src/main.tsx">`) with an empty body, so this
+ * never blocks the app-builder workflow it redirects to.
+ */
+const STANDALONE_HTML_RE = /<!doctype\s+html|<html[\s>]/i;
+const INLINE_SCRIPT_RE = /<script\b(?![^>]*\bsrc=)[^>]*>[\s\S]{400,}?<\/script>/i;
+
+function isSelfContainedArtifactHtml(path: string, content: string): boolean {
+  if (!/\.html?$/i.test(path)) return false;
+  if (content.length < 3000) return false;
+  if (!STANDALONE_HTML_RE.test(content)) return false;
+  return INLINE_SCRIPT_RE.test(content);
+}
+
+const ARTIFACT_REDIRECT_MESSAGE =
+  'Error: This looks like a self-contained interactive visualization/artifact written as a loose HTML file. Do not build these as standalone .html files. Load the app-builder skill first with `skill_load` using `skill: "app-builder"`, then build it as a real persistent app with `app_create` (the skill loads frontend-design for the visual pass and provides chart widgets). If this genuinely needs to be a raw HTML file inside an existing code project, write it under that project folder.';
+
 /**
  * Returns `true` iff `absPath` is an absolute path that resolves strictly
  * inside `pkbRoot`. Matches the containment semantics used elsewhere in the
@@ -82,6 +106,16 @@ export const fileWriteTool = {
       };
     }
 
+    // Redirect self-contained interactive HTML artifacts to app-builder.
+    // Exempt writes that land inside the apps directory (app-builder's own
+    // scaffold/iteration writes) so we never block the workflow we point to.
+    if (isSelfContainedArtifactHtml(rawPath, fileContent)) {
+      const candidate = resolve(context.workingDir, rawPath);
+      if (!isInsidePkbRoot(candidate, getAppsDir())) {
+        return { content: ARTIFACT_REDIRECT_MESSAGE, isError: true };
+      }
+    }
+
     const ops = new FileSystemOps((path, opts) =>
       sandboxPolicy(path, context.workingDir, opts),
     );

package/src/tools/network/web-fetch.ts

@@ -152,25 +152,56 @@ function isNullBodyStatus(status: number): boolean {
   return status === 204 || status === 205 || status === 304;
 }
 
+// The WHATWG `Response` constructor only accepts 101 or the range 200–599 and
+// throws a `RangeError` for anything else. Some servers — notably anti-bot
+// gateways like LinkedIn and various job boards — reply with non-standard codes
+// such as 999. Map those onto 502 so we can still build a Response; the real
+// upstream status is preserved via `upstreamStatusByResponse` for reporting.
+// See https://developer.mozilla.org/en-US/docs/Web/API/Response/Response
+const RESPONSE_STATUS_SWITCHING_PROTOCOLS = 101;
+const RESPONSE_STATUS_MIN = 200;
+const RESPONSE_STATUS_MAX = 599;
+
+function toConstructableStatus(status: number): number {
+  if (status === RESPONSE_STATUS_SWITCHING_PROTOCOLS) return status;
+  if (status >= RESPONSE_STATUS_MIN && status <= RESPONSE_STATUS_MAX) {
+    return status;
+  }
+  return 502;
+}
+
+const upstreamStatusByResponse = new WeakMap<Response, number>();
+
+// Returns the real status the upstream server sent, which may fall outside the
+// range the `Response` object can represent (e.g. 999). Falls back to
+// `response.status` for responses built by native `fetch`, whose undici
+// implementation already exposes non-standard codes directly.
+export function getUpstreamStatus(response: Response): number {
+  return upstreamStatusByResponse.get(response) ?? response.status;
+}
+
 export function buildFetchResponseFromNodeResponse(
   res: NodeHttpResponseLike,
 ): Response {
-  const status = res.statusCode ?? 502;
+  const upstreamStatus = res.statusCode ?? 502;
+  const status = toConstructableStatus(upstreamStatus);
   const responseHeaders = buildResponseHeaders(res.headers);
   const statusText = res.statusMessage ?? "";
 
-  if (isNullBodyStatus(status)) {
-    // Drain any unexpected bytes and produce a valid null-body fetch Response.
-    res.resume();
-    return new Response(null, { status, statusText, headers: responseHeaders });
-  }
+  const response = isNullBodyStatus(status)
+    ? // Drain any unexpected bytes and produce a valid null-body fetch Response.
+      (res.resume(),
+      new Response(null, { status, statusText, headers: responseHeaders }))
+    : new Response(Readable.toWeb(res) as unknown as BodyInit, {
+        status,
+        statusText,
+        headers: responseHeaders,
+      });
 
-  const body = Readable.toWeb(res);
-  return new Response(body as unknown as BodyInit, {
-    status,
-    statusText,
-    headers: responseHeaders,
-  });
+  if (status !== upstreamStatus) {
+    upstreamStatusByResponse.set(response, upstreamStatus);
+  }
+  return response;
 }
 
 function createAbortError(): Error {
@@ -252,7 +283,16 @@ const defaultRequestExecutor: WebFetchRequestExecutor = async (
 
   return await new Promise<Response>((resolve, reject) => {
     const req = requestFn(requestOptions, (res) => {
-      resolve(buildFetchResponseFromNodeResponse(res));
+      // Building the fetch Response runs inside this HTTP `response` event
+      // callback. Any synchronous throw here would escape as an uncaught
+      // exception and crash the daemon, so funnel failures into `reject` to
+      // keep them local to this request.
+      try {
+        resolve(buildFetchResponseFromNodeResponse(res));
+      } catch (err) {
+        res.resume();
+        reject(err);
+      }
     });
     req.once("error", reject);
     req.end();
@@ -730,9 +770,10 @@ export async function executeWebFetch(
         );
       }
 
+      const upstreamStatus = getUpstreamStatus(response);
       const location = response.headers.get("location");
       const isRedirect =
-        response.status >= 300 && response.status < 400 && !!location;
+        upstreamStatus >= 300 && upstreamStatus < 400 && !!location;
       if (!isRedirect) break;
 
       if (redirectCount >= MAX_REDIRECTS) {
@@ -741,7 +782,7 @@ export async function executeWebFetch(
           {
             url: requestedUrl,
             finalUrl: currentUrl.href,
-            status: response.status,
+            status: getUpstreamStatus(response),
             redirectCount,
           },
         );
@@ -761,7 +802,7 @@ export async function executeWebFetch(
           {
             url: requestedUrl,
             finalUrl: currentUrl.href,
-            status: response.status,
+            status: getUpstreamStatus(response),
             redirectCount,
           },
         );
@@ -773,7 +814,7 @@ export async function executeWebFetch(
           {
             url: requestedUrl,
             finalUrl: currentUrl.href,
-            status: response.status,
+            status: getUpstreamStatus(response),
             redirectCount,
           },
         );
@@ -785,7 +826,7 @@ export async function executeWebFetch(
           {
             url: requestedUrl,
             finalUrl: currentUrl.href,
-            status: response.status,
+            status: getUpstreamStatus(response),
             redirectCount,
           },
         );
@@ -805,7 +846,7 @@ export async function executeWebFetch(
             {
               url: requestedUrl,
               finalUrl: currentUrl.href,
-              status: response.status,
+              status: getUpstreamStatus(response),
               redirectCount,
             },
           );
@@ -817,7 +858,7 @@ export async function executeWebFetch(
             {
               url: requestedUrl,
               finalUrl: currentUrl.href,
-              status: response.status,
+              status: getUpstreamStatus(response),
               redirectCount,
             },
           );
@@ -844,7 +885,7 @@ export async function executeWebFetch(
         {
           url: requestedUrl,
           finalUrl: currentUrl.href,
-          status: response.status,
+          status: getUpstreamStatus(response),
           contentType,
           redirectCount,
         },
@@ -909,7 +950,7 @@ export async function executeWebFetch(
     const content = formatWebFetchOutput({
       requestedUrl: safeRequestedUrl,
       finalUrl: sanitizeUrlForOutput(currentUrl),
-      status: response.status,
+      status: getUpstreamStatus(response),
       statusText: response.statusText,
       contentType,
       bytesRead: body.bytesRead,
@@ -931,7 +972,7 @@ export async function executeWebFetch(
     const meta: WebFetchMetadata = {
       url: safeRequestedUrl,
       finalUrl: sanitizeUrlForOutput(currentUrl),
-      status: response.status,
+      status: getUpstreamStatus(response),
       contentType: contentType || undefined,
       byteCount: body.bytesRead,
       charCount: sliced.length,
@@ -945,7 +986,7 @@ export async function executeWebFetch(
     };
 
     if (!response.ok) {
-      const errorMessage = `Error: HTTP ${response.status}`;
+      const errorMessage = `Error: HTTP ${getUpstreamStatus(response)}`;
       return {
         content: `${errorMessage}\n\n${content}`,
         isError: true,

package/src/tools/skills/load.ts

@@ -128,7 +128,7 @@ export const skillLoadTool = {
   name: "skill_load",
 
   description:
-    'Load full instructions for a skill. Works for both bundled skills (listed in the catalog) and custom workspace skills. For app, website, dashboard, game, calculator, tracker, visualization, or interactive tool requests, load `app-builder` with `skill: "app-builder"`.',
+    'Load full instructions for a skill. Works for both bundled skills (listed in the catalog) and custom workspace skills. Bundled/first-party skills (like `app-builder`) are already installed — loading only activates their instructions for the current conversation, since skills unload between turns; treat "load" as activation, not installation, and don\'t tell users a bundled skill needs installing. Loading can still fail (e.g. a feature-gated skill returns "currently unavailable", or the load errors) — if it does, relay that specific error rather than claiming the skill is not installed or offering to install it. For app, website, dashboard, game, calculator, tracker, visualization, or interactive tool requests, load `app-builder` with `skill: "app-builder"`.',
 
   category: "skills",
 

package/src/tools/subagent/spawn.ts

@@ -1,4 +1,4 @@
-import { findConversation } from "../../daemon/conversation-store.js";
+import { findConversation } from "../../daemon/conversation-registry.js";
 import { getConversationOverrideProfile } from "../../memory/conversation-crud.js";
 import type { Message } from "../../providers/types.js";
 import { getSubagentManager } from "../../subagent/index.js";
@@ -102,9 +102,7 @@ export async function executeSubagentSpawn(
         ...(inheritedOverrideProfile
           ? { overrideProfile: inheritedOverrideProfile }
           : {}),
-        ...(context.toolUseId
-          ? { parentToolUseId: context.toolUseId }
-          : {}),
+        ...(context.toolUseId ? { parentToolUseId: context.toolUseId } : {}),
         ...forkFields,
       },
       sendToClient as (msg: unknown) => void,

package/src/tools/ui-surface/definitions.ts

@@ -8,6 +8,7 @@
  */
 
 import { RiskLevel } from "../../permissions/types.js";
+import { ACTIVATION_MOMENT_PARAMS } from "../../telemetry/activation-funnel.js";
 import type {
   ToolContext,
   ToolDefinition,
@@ -19,7 +20,7 @@ import type {
 // ---------------------------------------------------------------------------
 
 const APP_BUILDER_ARTIFACT_RE =
-  /\b(app|apps|application|applications|website|websites|site|sites|dashboard|dashboards|game|games|calculator|calculators|tracker|trackers|visualization|visualizations|visualisation|visualisations|tool|tools|utility|utilities|counter|counters)\b/i;
+  /\b(app|apps|application|applications|website|websites|site|sites|dashboard|dashboards|game|games|calculator|calculators|tracker|trackers|visualization|visualizations|visualisation|visualisations|visualize|visualise|artifact|artifacts|chart|charts|graph|graphs|tool|tools|utility|utilities|counter|counters)\b/i;
 const APP_BUILDER_BUILD_RE =
   /\b(build|building|built|create|creating|created|make|making|made|generate|generating|generated)\b/i;
 
@@ -58,11 +59,31 @@ function isDynamicPageAppSubstitute(input: Record<string, unknown>): boolean {
   }
 
   const text = collectRoutingText(input).join(" ");
-  if (!APP_BUILDER_ARTIFACT_RE.test(text)) {
-    return false;
+  if (
+    APP_BUILDER_ARTIFACT_RE.test(text) &&
+    (APP_BUILDER_BUILD_RE.test(text) || /\b(app|application)\b/i.test(text))
+  ) {
+    return true;
   }
 
-  return APP_BUILDER_BUILD_RE.test(text) || /\b(app|application)\b/i.test(text);
+  // Second signal: even when the model gives the surface a clean,
+  // non-app-sounding title (dodging the text regex above), substantial
+  // interactive HTML is an app being smuggled in as a transient surface.
+  // A genuinely transient page is small and static; an app has real
+  // scripted markup. Keep the bar high so simple snippets still pass.
+  return isSubstantialInteractiveHtml(input);
+}
+
+const INTERACTIVE_HTML_RE =
+  /<script\b|on[a-z]+\s*=|addEventListener|new Chart\b|window\.vellum\b/i;
+
+function isSubstantialInteractiveHtml(input: Record<string, unknown>): boolean {
+  const data = asRecord(input.data);
+  const html = data?.html;
+  if (typeof html !== "string") {
+    return false;
+  }
+  return html.length > 2000 && INTERACTIVE_HTML_RE.test(html);
 }
 
 function collectRoutingText(input: Record<string, unknown>): string[] {
@@ -116,7 +137,7 @@ export const uiShowTool = {
     "- file_upload: { prompt, acceptedTypes?, maxFiles? }\n" +
     "- task_preferences: {} (no data needed — categories are rendered client-side)\n" +
     '- work_result: { eyebrow?, status?: "completed"|"partial"|"failed"|"in_progress", summary?, metrics?: [{ label, value, detail?, tone?: "neutral"|"positive"|"warning"|"negative" }], sections?: [{ id?, title, description?, type?: "items"|"timeline"|"diff"|"artifacts"|"warnings", items?: [{ id?, title, description?, status?, tone?, metadata?: [{ label, value }], href? }], diffs?: [{ label?, before?, after? }] }] }. Shows a structured receipt after real work: what changed, what was skipped, proof points, and next actions. Keep display-only unless explicit follow-up buttons are needed.\n\n' +
-    "Proactively show a task_progress card before multi-step or long-running work (web searches, file operations, research). Show it before your first tool call, then update steps as work progresses.",
+    "Emit a task_progress card BEFORE your first tool call on any multi-step, long-running, or post-form turn (web searches, file operations, research), and keep its steps updated as work progresses. Skills that estimate >30s of work should declare progress upfront with concrete step labels (and counts when known).",
   category: "ui-surface",
   defaultRiskLevel: RiskLevel.Low,
   executionTarget: "host",
@@ -184,6 +205,12 @@ export const uiShowTool = {
         description:
           "When true, clicking an action does not dismiss the surface — the card stays visible and only the clicked action is marked as spent. Use for launcher or menu-style cards where multiple buttons may be clicked. Defaults to false.",
       },
+      activation_moment: {
+        type: "string",
+        enum: ACTIVATION_MOMENT_PARAMS,
+        description:
+          "Activation-rail telemetry tag (cohort only). Set this when this surface IS one of the activation funnel moments; the milestone is recorded automatically when the user commits the surface. Omit for all non-activation surfaces.",
+      },
     },
     required: ["surface_type", "data"],
   },

package/src/workspace/migrations/051-seed-conversation-summarization-callsite.ts

@@ -9,10 +9,9 @@ import type { WorkspaceMigration } from "./types.js";
  * `conversationSummarization` is invoked from `ContextWindowManager.
  * updateSummary()` during mid-loop compaction. Without a call-site entry it
  * falls through to `llm.default` (opus + `effort: "max"` + `thinking:
- * { enabled: true }` + `maxTokens: 64000`), which is far too expensive for
- * summarizing a ~150k-token transcript inside the agent-loop plugin
- * pipeline's 30s budget — we were hitting `PluginTimeoutError` and hard-
- * failing the turn.
+ * { enabled: true }` + `maxTokens: 64000`), which is far too expensive and
+ * slow for summarizing a ~150k-token transcript inside the agent loop —
+ * the summary call would stall the turn.
  *
  * This migration seeds `effort: "low"` and `thinking: { enabled: false }`
  * (and opus-4.7 as the model when absent) so the summary call runs cheaply
@@ -99,7 +98,7 @@ export const seedConversationSummarizationCallsiteMigration: WorkspaceMigration
     },
     down(_workspaceDir: string): void {
       // Forward-only: removing the seeded defaults would reintroduce the
-      // 30s pipeline-budget timeout this migration fixes.
+      // expensive, slow summary call this migration fixes.
     },
   };