@vellumai/assistant 0.8.8 → 0.8.9-staging.2

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/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/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

@@ -19,7 +19,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 +58,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 +136,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",

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.
     },
   };
 

package/src/workspace/migrations/097-enable-adaptive-thinking-managed-profiles.ts

@@ -20,65 +20,89 @@ import type { WorkspaceMigration } from "./types.js";
 // explicitly disabled. It skips profiles that:
 //   - Don't exist (no profile to patch)
 //   - Already have thinking enabled (idempotent)
-//   - Are not source: "managed" (user-created profiles are untouched)
+//   - Are source: "user" (user-created profiles are untouched)
+//   - Have a non-managed, non-absent source (unknown origin)
 //   - Use a non-Anthropic provider (adaptive thinking is Anthropic-specific)
 
 const ADAPTIVE_THINKING = { enabled: true, streamThinking: true } as const;
 const TARGET_PROFILES = ["balanced", "quality-optimized"] as const;
 
-export const enableAdaptiveThinkingManagedProfilesMigration: WorkspaceMigration =
-  {
-    id: "097-enable-adaptive-thinking-managed-profiles",
-    description:
-      "Enable adaptive thinking on managed balanced and quality-optimized profiles",
-    run(workspaceDir: string): void {
-      const configPath = join(workspaceDir, "config.json");
-      if (!existsSync(configPath)) return;
+/**
+ * Patch managed Anthropic profiles that are missing adaptive thinking.
+ *
+ * Exported so lifecycle.ts can re-run the repair after mergeDefaultWorkspaceConfig()
+ * and seedInferenceProfiles(). On-platform instances with a config overlay have their
+ * profiles overwritten by the overlay merge (which runs after workspace migrations),
+ * so the migration alone is insufficient — the post-overlay call ensures the repair
+ * sticks even when the overlay supplies profiles without thinking enabled.
+ *
+ * The function is idempotent: profiles that already have thinking enabled are skipped.
+ */
+export function repairAdaptiveThinkingOnManagedProfiles(
+  workspaceDir: string,
+): void {
+  const configPath = join(workspaceDir, "config.json");
+  if (!existsSync(configPath)) return;
 
-      let config: Record<string, unknown>;
-      try {
-        const raw = JSON.parse(readFileSync(configPath, "utf-8"));
-        if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
-        config = raw as Record<string, unknown>;
-      } catch {
-        return;
-      }
+  let config: Record<string, unknown>;
+  try {
+    const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+    config = raw as Record<string, unknown>;
+  } catch {
+    return;
+  }
 
-      const llm = readObject(config.llm);
-      if (llm === null) return;
+  const llm = readObject(config.llm);
+  if (llm === null) return;
 
-      const profiles = readObject(llm.profiles);
-      if (profiles === null) return;
+  const profiles = readObject(llm.profiles);
+  if (profiles === null) return;
 
-      let changed = false;
+  let changed = false;
 
-      for (const name of TARGET_PROFILES) {
-        const profile = readObject(profiles[name]);
-        if (profile === null) continue;
+  for (const name of TARGET_PROFILES) {
+    const profile = readObject(profiles[name]);
+    if (profile === null) continue;
 
-        // Only patch managed Anthropic profiles.
-        if (profile.source !== "managed") continue;
-        if (
-          typeof profile.provider === "string" &&
-          profile.provider !== "anthropic"
-        ) {
-          continue;
-        }
+    // Only patch managed Anthropic profiles.
+    // Legacy profiles created before the `source` metadata field was introduced
+    // have source=undefined. Treat these as managed when the profile name is one
+    // of the canonical managed names (which TARGET_PROFILES already guarantees)
+    // and the provider is Anthropic (or absent). Explicit `source: "user"`
+    // profiles are always skipped.
+    if (profile.source === "user") continue;
+    if (profile.source !== undefined && profile.source !== "managed") continue;
+    if (
+      typeof profile.provider === "string" &&
+      profile.provider !== "anthropic"
+    ) {
+      continue;
+    }
 
-        // Skip if thinking is already enabled.
-        const thinking = readObject(profile.thinking);
-        if (thinking !== null && thinking.enabled === true) continue;
+    // Skip if thinking is already enabled.
+    const thinking = readObject(profile.thinking);
+    if (thinking !== null && thinking.enabled === true) continue;
 
-        profile.thinking = { ...ADAPTIVE_THINKING };
-        profiles[name] = profile;
-        changed = true;
-      }
+    profile.thinking = { ...ADAPTIVE_THINKING };
+    profiles[name] = profile;
+    changed = true;
+  }
 
-      if (changed) {
-        llm.profiles = profiles;
-        config.llm = llm;
-        writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
-      }
+  if (changed) {
+    llm.profiles = profiles;
+    config.llm = llm;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  }
+}
+
+export const enableAdaptiveThinkingManagedProfilesMigration: WorkspaceMigration =
+  {
+    id: "097-enable-adaptive-thinking-managed-profiles",
+    description:
+      "Enable adaptive thinking on managed balanced and quality-optimized profiles",
+    run(workspaceDir: string): void {
+      repairAdaptiveThinkingOnManagedProfiles(workspaceDir);
     },
     down(_workspaceDir: string): void {
       // Forward-only.