@vellumai/assistant 0.12.4-staging.1 → 0.12.4-staging.3

package/src/skills/validate-input.ts

@@ -3,10 +3,11 @@
  *
  * Deliberate strict subset of JSON Schema: it covers only the keywords
  * actually used by `assistant/src/config/bundled-skills/**\/TOOLS.json`
- * (required / type / enum / items.type) plus unknown-key detection. Anything
- * else (`$ref`, `oneOf`, `anyOf`, `allOf`, `format`, `pattern`, `minimum`,
- * `maximum`, object-shape `additionalProperties`, etc.) is silently skipped so
- * a richer schema can never cause us to reject a legitimate call.
+ * (required / type / enum / nested properties and items / required-only oneOf)
+ * plus unknown-key detection. Anything else (`$ref`, richer `oneOf`, `anyOf`,
+ * `allOf`, `format`, `pattern`, `minimum`, `maximum`, object-shape
+ * `additionalProperties`, etc.) is skipped. Nested objects allow extra keys
+ * unless their schema explicitly closes them.
  *
  * Each error message is written to be agent-readable and self-correcting
  * (e.g. `surface_id is required`, `mode must be one of "replace", "append"`).
@@ -313,6 +314,15 @@ export function validateInputAgainstSchema(
   _toolName: string,
   input: Record<string, unknown>,
   schema: Record<string, unknown> | undefined,
+): InputValidationResult {
+  return validateObjectInput(input, schema, "", true);
+}
+
+function validateObjectInput(
+  input: Record<string, unknown>,
+  schema: Record<string, unknown> | undefined,
+  path: string,
+  rejectUnknown: boolean,
 ): InputValidationResult {
   // Skip when there's no schema or no properties block — matches today's
   // lenient behaviour for tools that declare only `{ type: "object" }`.
@@ -338,17 +348,46 @@ export function validateInputAgainstSchema(
         continue;
       }
       if (!(key in input)) {
-        errors.push(`${key} is required`);
+        errors.push(`${path}${key} is required`);
       }
     }
   }
 
+  // Only enforce alternatives whose complete contract is field presence.
+  // Richer unions stay permissive because unsupported keywords can decide
+  // which branch matches.
+  const alternatives = schema.oneOf;
+  if (
+    Array.isArray(alternatives) &&
+    alternatives.length > 0 &&
+    alternatives.every(
+      (branch) =>
+        isPlainObject(branch) &&
+        Object.keys(branch).every(
+          (key) => key === "required" || key === "description",
+        ) &&
+        Array.isArray(branch.required) &&
+        branch.required.every((key: unknown) => typeof key === "string"),
+    )
+  ) {
+    const choices = alternatives as { required: string[] }[];
+    if (
+      choices.filter((branch) => branch.required.every((key) => key in input))
+        .length !== 1
+    ) {
+      errors.push(
+        `${path ? path.slice(0, -1) : "input"} must match exactly one required field set: ${choices.map((branch) => quoteList(branch.required)).join(" or ")}`,
+      );
+    }
+  }
+
   // 2. Per-property checks: type, enum, items.type.
-  for (const [key, rawSubSchema] of Object.entries(properties)) {
-    if (!(key in input)) {
+  for (const [property, rawSubSchema] of Object.entries(properties)) {
+    if (!(property in input)) {
       continue;
     }
-    const value = input[key];
+    const key = `${path}${property}`;
+    const value = input[property];
     // Skip type-checking for absent values; presence is enforced by the
     // `required` check above. Note: `null` IS a present value and is
     // type-checked below — only schemas that explicitly opt in to null via
@@ -381,13 +420,25 @@ export function validateInputAgainstSchema(
       if (!matchesType(value, type)) {
         errors.push(
           type === "boolean" && typeof value === "string"
-            ? `${key} must be a boolean — pass true or false as a JSON boolean, not a string`
+            ? `${key} must be a boolean: pass true or false as a JSON boolean, not a string`
             : `${key} must be ${typeArticle(type)} ${type}`,
         );
         // No point checking enum/items if the base type is wrong.
         continue;
       }
 
+      if (type === "object" && isPlainObject(value)) {
+        const nested = validateObjectInput(
+          value,
+          rawSubSchema,
+          `${key}.`,
+          rawSubSchema.additionalProperties === false,
+        );
+        if (!nested.ok) {
+          errors.push(...nested.errors);
+        }
+      }
+
       // 2a. Enum (string enums are the only shape used today).
       const enumValues = rawSubSchema.enum;
       if (Array.isArray(enumValues) && enumValues.length > 0) {
@@ -412,6 +463,17 @@ export function validateInputAgainstSchema(
               errors.push(
                 `${key}[${index}] must be ${typeArticle(itemTypeName)} ${itemTypeName}`,
               );
+            } else if (itemTypeName === "object" && isPlainObject(element)) {
+              const itemSchema = rawSubSchema.items as Record<string, unknown>;
+              const nested = validateObjectInput(
+                element,
+                itemSchema,
+                `${key}[${index}].`,
+                itemSchema.additionalProperties === false,
+              );
+              if (!nested.ok) {
+                errors.push(...nested.errors);
+              }
             }
           });
         }
@@ -420,10 +482,12 @@ export function validateInputAgainstSchema(
   }
 
   // 3. Unknown keys — parity with the previous `validateNoUnknownParams`.
-  const unknownKeys = Object.keys(input).filter((k) => !knownKeySet.has(k));
+  const unknownKeys = rejectUnknown
+    ? Object.keys(input).filter((k) => !knownKeySet.has(k))
+    : [];
   for (const key of unknownKeys) {
     errors.push(
-      `Unknown parameter "${key}". Supported: ${quoteList(knownKeys)}`,
+      `Unknown parameter "${path}${key}". Supported: ${quoteList(knownKeys)}`,
     );
   }
 

package/src/tools/skills/execute.ts

@@ -178,7 +178,7 @@ export function augmentSkillExecuteError(
 export const skillExecuteTool = {
   name: "skill_execute",
   description:
-    "Execute a tool provided by a loaded skill. Use this instead of calling skill tools directly. The skill's instructions (from skill_load) describe available tools and their parameters. For browser automation, use the `assistant browser` CLI commands instead.",
+    "Execute a tool provided by a loaded skill. When skill_load is available, call it for the owning skill before first use, even if a capability card says it is available. Use the current instructions and input schema over remembered arguments. Use this instead of calling skill tools directly. For browser automation, use the `assistant browser` CLI commands instead.",
   category: "skills",
   executionTarget: "sandbox",
   defaultRiskLevel: RiskLevel.Low,

package/src/tools/skills/format-input-schema.ts

@@ -0,0 +1,15 @@
+import { getWorkspaceDirDisplay } from "../../util/platform.js";
+
+/** Preserve nested fields and alternatives when disclosing a skill's input. */
+export function formatSkillInputSchema(schema: object): string {
+  const workspaceDir = getWorkspaceDirDisplay();
+  const json = JSON.stringify(
+    schema,
+    (_key, value: unknown) =>
+      typeof value === "string"
+        ? value.replaceAll("{workspaceDir}", workspaceDir)
+        : value,
+    2,
+  );
+  return `Input schema for \`skill_execute.input\`:\n\`\`\`json\n${json}\n\`\`\``;
+}

package/src/tools/skills/load.ts

@@ -35,6 +35,7 @@ import type {
   ToolDefinition,
   ToolExecutionResult,
 } from "../types.js";
+import { formatSkillInputSchema } from "./format-input-schema.js";
 
 /** Skill sources eligible for inline command expansion in v1. */
 const INLINE_COMMAND_ELIGIBLE_SOURCES = new Set([
@@ -123,32 +124,7 @@ function formatToolSchemas(
       tool.description.replaceAll("{workspaceDir}", getWorkspaceDirDisplay()),
     );
 
-    const schema = tool.input_schema;
-    const properties = schema.properties as
-      | Record<string, Record<string, unknown>>
-      | undefined;
-    if (properties && Object.keys(properties).length > 0) {
-      const requiredSet = new Set<string>(
-        Array.isArray(schema.required) ? (schema.required as string[]) : [],
-      );
-
-      lines.push("Parameters:");
-      for (const [paramName, paramDef] of Object.entries(properties)) {
-        const paramType =
-          typeof paramDef.type === "string" ? paramDef.type : "any";
-        const requiredLabel = requiredSet.has(paramName)
-          ? "required"
-          : "optional";
-        const descPart =
-          typeof paramDef.description === "string"
-            ? `: ${paramDef.description.replaceAll("{workspaceDir}", getWorkspaceDirDisplay())}`
-            : "";
-        lines.push(
-          `- ${paramName} (${paramType}, ${requiredLabel})${descPart}`,
-        );
-      }
-    }
-
+    lines.push(formatSkillInputSchema(tool.input_schema));
     lines.push("");
   }
 

package/src/tools/skills/skill-tool-factory.ts

@@ -15,6 +15,7 @@ import { bundledToolInputMisuseMessage } from "../shared/input-misuse.js";
 import { bundledToolInputRepairs } from "../shared/input-repairs.js";
 import type { ExecutionTarget } from "../tool-types.js";
 import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
+import { formatSkillInputSchema } from "./format-input-schema.js";
 import { runSkillToolScript } from "./skill-script-runner.js";
 
 const riskMap: Record<SkillToolEntry["risk"], RiskLevel> = {
@@ -94,7 +95,7 @@ export function createSkillTool(
         return {
           content:
             misuse ??
-            `Invalid input for tool "${entry.name}": ${validation.errors.join("; ")}. Fix the arguments and retry.`,
+            `Invalid input for tool "${entry.name}": ${validation.errors.join("; ")}. If skill_load is available, load the owning skill for its current instructions. Retry with arguments matching this schema.\n\n${formatSkillInputSchema(entry.input_schema)}`,
           isError: true,
         };
       }

package/src/tools/workflows/manage-workflows.ts

@@ -15,7 +15,7 @@
 
 import { z } from "zod";
 
-import { getUserSelectableProfilesForProvider } from "../../config/default-profile-catalog.js";
+import { getConversationProfilesForProvider } from "../../config/default-profile-catalog.js";
 import { loadConfig } from "../../config/loader.js";
 import { callerOwnsWorkflowRun } from "../../workflows/capabilities.js";
 import type { WorkflowRun } from "../../workflows/journal-store.js";
@@ -199,7 +199,9 @@ export async function executeManageWorkflows(
       // workspace-wide active profile. Read-only — leaves use this to pick a
       // valid `profile` for `run_workflow` (an unknown profile throws).
       const { llm } = loadConfig();
-      const profiles = getUserSelectableProfilesForProvider(
+      // A workflow leaf runs chat turns, so this is the conversation view,
+      // which leaves out the managed Jev profile.
+      const profiles = getConversationProfilesForProvider(
         llm?.profiles,
         llm?.defaultProvider ?? null,
       );

package/src/workspace/migrations/159-rename-colliding-jev-profile-name.ts

@@ -0,0 +1,344 @@
+/**
+ * Workspace migration `159-rename-colliding-jev-profile-name`.
+ *
+ * `jev-managed` became a reserved code-owned profile name (the managed Jev
+ * profile). From this release on, that name resolves to the code body no
+ * matter what `llm.profiles` holds, and the schema rejects it as
+ * `activeProfile` or `advisorProfile`, so a user-created profile that
+ * happens to carry the name would be silently replaced in the effective
+ * catalog and its selections stranded.
+ *
+ * This migration runs before the reservation can take effect (workspace
+ * migrations run ahead of the first config load and the profile seeder) and
+ * gives such a profile a fresh key, rewriting every reference to it so the
+ * user keeps both the profile and its wiring:
+ *
+ *   - `llm.profiles` key (insertion order preserved)
+ *   - `llm.activeProfile`, `llm.advisorProfile`
+ *   - `llm.profileOrder` entries
+ *   - `llm.callSites.<site>.profile` pins
+ *   - `llm.profiles.<key>.mix[].profile` arms
+ *   - `llm.profiles.<key>.fallbackProfile` targets
+ *   - `conversations.inference_profile` and `cron_jobs.inference_profile`
+ *     rows
+ *
+ * The new key is `jev-managed-custom`, suffixed `-custom-2`, `-custom-3`,
+ * ... when that is taken. Candidates are checked against every existing
+ * profile key AND every reserved code-defined name, so a rename never lands
+ * on another name the catalog owns.
+ *
+ * Only a workspace-owned profile is renamed. An entry whose `source` is
+ * `managed` is a thin stub for the code-owned profile, and a non-object
+ * value under the key is not a profile at all; both are left alone.
+ *
+ * The DB rewrite is not best effort: a pin the rewrite abandons would route
+ * through the managed Jev profile instead of the user's own, so a database
+ * that exists but cannot be written is retried with a short backoff and a
+ * failure that outlives the retries throws; `retryFailedCheckpoint` re-runs
+ * the whole migration on the next boot. The DB rewrite runs before the
+ * config write, so a throw leaves config.json holding the old key.
+ *
+ * Idempotent: after a successful run no workspace-owned profile carries the
+ * reserved name, so a re-run finds nothing to rename and writes nothing.
+ */
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+
+import { getLogger } from "../../util/logger.js";
+import type { WorkspaceMigration } from "./types.js";
+
+const log = getLogger(
+  "workspace-migration-159-rename-colliding-jev-profile-name",
+);
+
+/**
+ * The newly reserved key this migration clears. Frozen snapshot as of
+ * 2026-09-22 (migrations are self-contained).
+ */
+const RESERVED_KEYS = ["jev-managed"];
+
+/**
+ * Every code-defined profile name as of 2026-09-22: the default keys, the
+ * backups, the flag-gated `os-beta`, and the Jev profile. A renamed profile
+ * must not land on any of them, or the rename would just move the collision.
+ */
+const RESERVED_PROFILE_NAMES = new Set<string>([
+  "balanced",
+  "quality-optimized",
+  "cost-optimized",
+  "latency-optimized",
+  "balanced-backup",
+  "quality-optimized-backup",
+  "cost-optimized-backup",
+  "latency-optimized-backup",
+  "os-beta",
+  ...RESERVED_KEYS,
+]);
+
+const RENAME_SUFFIX = "-custom";
+
+/** Total attempts at the pin rewrite, the first one included. */
+const DB_ATTEMPTS = 4;
+
+/** First backoff step; each further wait doubles it (50, 100, 200 ms). */
+const DB_RETRY_BASE_DELAY_MS = 50;
+
+export const renameCollidingJevProfileNameMigration: WorkspaceMigration = {
+  id: "159-rename-colliding-jev-profile-name",
+  description:
+    "Rename a user profile colliding with the reserved managed Jev profile key and rewrite its references",
+  // The failure this migration can hit is a database it cannot write, and
+  // both halves of the run are idempotent, so a failed checkpoint is worth
+  // re-running: the config still holds the old keys, the mapping rebuilds
+  // from them, and the pin rewrite matches on the old name.
+  retryFailedCheckpoint: true,
+
+  async run(workspaceDir: string): Promise<void> {
+    const configPath = join(workspaceDir, "config.json");
+    if (!existsSync(configPath)) {
+      return;
+    }
+
+    let config: Record<string, unknown>;
+    try {
+      const parsed = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (!isPlainObject(parsed)) {
+        return;
+      }
+      config = parsed;
+    } catch {
+      return;
+    }
+
+    const llm = asObject(config.llm);
+    const profiles = llm === null ? null : asObject(llm.profiles);
+    if (llm === null || profiles === null) {
+      return;
+    }
+
+    const renames = planRenames(profiles);
+    if (renames.size === 0) {
+      return;
+    }
+
+    // The DB rewrite runs first so an interrupted or failed migration re-runs
+    // with the config still holding the old keys, i.e. with the mapping
+    // intact. A rewrite that cannot be completed throws out of here, which
+    // stops the config rename below rather than stranding the pins.
+    await rewriteDbReferences(workspaceDir, renames);
+
+    llm.profiles = renameProfileKeys(profiles, renames);
+    rewriteConfigReferences(llm, renames);
+
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    log.info(
+      { renames: Object.fromEntries(renames) },
+      "Renamed a user profile colliding with the reserved managed Jev profile key",
+    );
+  },
+
+  down(_workspaceDir: string): void {
+    // Forward-only: the reserved names cannot be handed back.
+  },
+};
+
+/**
+ * Old key -> new key for a workspace-owned profile sitting on the reserved
+ * name. Deterministic: each assigned name is reserved against later
+ * candidates, so the same config always produces the same mapping.
+ */
+function planRenames(profiles: Record<string, unknown>): Map<string, string> {
+  const renames = new Map<string, string>();
+  const taken = new Set<string>([
+    ...Object.keys(profiles),
+    ...RESERVED_PROFILE_NAMES,
+  ]);
+
+  for (const key of RESERVED_KEYS) {
+    if (!(key in profiles)) {
+      continue;
+    }
+    const entry = asObject(profiles[key]);
+    if (entry === null) {
+      log.warn(
+        { profile: key },
+        "Left a non-object value under the reserved Jev profile key; it is not a profile to preserve",
+      );
+      continue;
+    }
+    if (entry.source === "managed") {
+      // A managed stub is the workspace's overlay slot for the code-owned
+      // profile, not a user profile; renaming it would manufacture a phantom
+      // user profile.
+      continue;
+    }
+    let candidate = `${key}${RENAME_SUFFIX}`;
+    let counter = 2;
+    while (taken.has(candidate)) {
+      candidate = `${key}${RENAME_SUFFIX}-${counter}`;
+      counter += 1;
+    }
+    taken.add(candidate);
+    renames.set(key, candidate);
+  }
+
+  return renames;
+}
+
+/** Rebuild the profiles record with the renamed keys, preserving order. */
+function renameProfileKeys(
+  profiles: Record<string, unknown>,
+  renames: Map<string, string>,
+): Record<string, unknown> {
+  const renamed: Record<string, unknown> = {};
+  for (const [name, value] of Object.entries(profiles)) {
+    renamed[renames.get(name) ?? name] = value;
+  }
+  return renamed;
+}
+
+/** Point every config reference at the renamed key. */
+function rewriteConfigReferences(
+  llm: Record<string, unknown>,
+  renames: Map<string, string>,
+): void {
+  for (const field of ["activeProfile", "advisorProfile"]) {
+    const current = llm[field];
+    if (typeof current === "string" && renames.has(current)) {
+      llm[field] = renames.get(current);
+    }
+  }
+
+  if (Array.isArray(llm.profileOrder)) {
+    llm.profileOrder = (llm.profileOrder as unknown[]).map((name) =>
+      typeof name === "string" ? (renames.get(name) ?? name) : name,
+    );
+  }
+
+  const callSites = asObject(llm.callSites);
+  if (callSites !== null) {
+    for (const value of Object.values(callSites)) {
+      const site = asObject(value);
+      if (
+        site !== null &&
+        typeof site.profile === "string" &&
+        renames.has(site.profile)
+      ) {
+        site.profile = renames.get(site.profile);
+      }
+    }
+  }
+
+  const profiles = asObject(llm.profiles);
+  if (profiles === null) {
+    return;
+  }
+  for (const value of Object.values(profiles)) {
+    const entry = asObject(value);
+    if (entry === null) {
+      continue;
+    }
+    if (
+      typeof entry.fallbackProfile === "string" &&
+      renames.has(entry.fallbackProfile)
+    ) {
+      entry.fallbackProfile = renames.get(entry.fallbackProfile);
+    }
+    if (!Array.isArray(entry.mix)) {
+      continue;
+    }
+    for (const armValue of entry.mix as unknown[]) {
+      const arm = asObject(armValue);
+      if (
+        arm !== null &&
+        typeof arm.profile === "string" &&
+        renames.has(arm.profile)
+      ) {
+        arm.profile = renames.get(arm.profile);
+      }
+    }
+  }
+}
+
+/**
+ * Repoint the profile pins stored outside config.json: the sticky
+ * per-conversation profile and the per-schedule profile.
+ *
+ * Retried as a whole rather than per statement: opening the database, reading
+ * `sqlite_master` and running the updates all fail the same way under write
+ * contention (`SQLITE_BUSY` from a second connection), and every step is
+ * idempotent, so re-running the block is the simplest recovery that cannot
+ * double-apply. A failure that outlives the attempts throws, which fails the
+ * migration for `retryFailedCheckpoint` to pick up on the next boot.
+ */
+async function rewriteDbReferences(
+  workspaceDir: string,
+  renames: Map<string, string>,
+): Promise<void> {
+  const dbPath = join(workspaceDir, "data", "db", "assistant.db");
+  if (!existsSync(dbPath)) {
+    // No database yet, so there are no pins that could be stranded.
+    return;
+  }
+  await withDbRetry(() => {
+    const db = new Database(dbPath);
+    try {
+      for (const table of ["conversations", "cron_jobs"]) {
+        const present = db
+          .query(
+            `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?`,
+          )
+          .get(table);
+        if (!present) {
+          // A workspace whose schema does not carry this table holds no pins
+          // in it. Nothing to rewrite, and nothing to fail over.
+          log.info({ table }, "No profile pin table to repoint");
+          continue;
+        }
+        for (const [from, to] of renames) {
+          db.query(
+            `UPDATE ${table} SET inference_profile = ? WHERE inference_profile = ?`,
+          ).run(to, from);
+        }
+      }
+    } finally {
+      db.close();
+    }
+  });
+}
+
+/**
+ * Run the pin rewrite, retrying a transient database failure with a short
+ * doubling backoff. Rethrows once the attempts are spent so the caller stops
+ * before the config rename.
+ */
+async function withDbRetry(attempt: () => void): Promise<void> {
+  for (let index = 0; ; index += 1) {
+    try {
+      attempt();
+      return;
+    } catch (err) {
+      if (index >= DB_ATTEMPTS - 1) {
+        throw new Error(
+          `Could not repoint conversation and schedule profile pins after ${DB_ATTEMPTS} attempts; leaving the config unrenamed so the next boot retries`,
+          { cause: err },
+        );
+      }
+      log.warn(
+        { err, attempt: index },
+        "Could not repoint profile pins; retrying",
+      );
+      await Bun.sleep(DB_RETRY_BASE_DELAY_MS * 2 ** index);
+    }
+  }
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function asObject(value: unknown): Record<string, unknown> | null {
+  return isPlainObject(value) ? value : null;
+}

package/src/workspace/migrations/registry.ts

@@ -155,6 +155,7 @@ import { repairRetiredCodexGpt54ModelIdsMigration } from "./154-repair-retired-c
 import { moveFrontModelConfigToVoiceMigration } from "./155-move-front-model-config-to-voice.js";
 import { extractWorkspaceMcpJsonMigration } from "./156-extract-workspace-mcp-json.js";
 import { addDesktopFilesLauncherMigration } from "./157-add-desktop-files-launcher.js";
+import { renameCollidingJevProfileNameMigration } from "./159-rename-colliding-jev-profile-name.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -325,4 +326,5 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   moveFrontModelConfigToVoiceMigration,
   extractWorkspaceMcpJsonMigration,
   addDesktopFilesLauncherMigration,
+  renameCollidingJevProfileNameMigration,
 ];