@vellumai/assistant 0.9.0 → 0.9.1-staging.1

package/src/subagent/manager.ts

@@ -453,6 +453,9 @@ export class SubagentManager {
         ...(managed.state.config.overrideProfile
           ? { overrideProfile: managed.state.config.overrideProfile }
           : {}),
+        ...(managed.state.config.forceOverrideProfile
+          ? { forceOverrideProfile: true }
+          : {}),
       });
 
       // Agent loop completed successfully.
@@ -641,6 +644,9 @@ export class SubagentManager {
           ...(managed.state.config.overrideProfile
             ? { overrideProfile: managed.state.config.overrideProfile }
             : {}),
+          ...(managed.state.config.forceOverrideProfile
+            ? { forceOverrideProfile: true }
+            : {}),
         })
         .catch((err) => {
           log.error({ subagentId, err }, "Subagent message processing failed");

package/src/subagent/types.ts

@@ -69,6 +69,12 @@ export interface SubagentConfig {
    * profile, every spawned subagent inherits it automatically.
    */
   overrideProfile?: string;
+  /**
+   * When true, the subagent's `overrideProfile` is an explicit spawn-time
+   * request and must float above call-site layers. Inherited parent profiles
+   * leave this unset so existing call-site precedence stays intact.
+   */
+  forceOverrideProfile?: boolean;
   /**
    * Tool-use id of the `skill_execute` call that spawned this subagent.
    * Forwarded into the `subagent_spawned` event so the client can anchor the

package/src/tools/AGENTS.md

@@ -2,7 +2,7 @@
 
 ## New Non-Skill Tools Are Strongly Discouraged
 
-**Prefer skills over new non-skill tool registrations.** Non-skill tools require approval from Team Jarvis.
+**Prefer skills over new non-skill tool registrations.** Non-skill tools require approval from the core team.
 
 Skills are the preferred approach for adding new capabilities — they are progressively disclosed into context, more portable, and can be iterated on independently. New non-skill tool registrations (`class ... implements Tool` + `registerTool()`) carry additional costs:
 
@@ -48,7 +48,7 @@ See [`assistant/docs/credential-execution-service.md`](../../docs/credential-exe
 
 ## If You Have Approval
 
-If Team Jarvis has approved your new tool:
+If the core team has approved your new tool:
 
 1. The pre-commit hook will block your commit by default
 2. Use `git commit --no-verify` to bypass the hook
@@ -56,4 +56,4 @@ If Team Jarvis has approved your new tool:
 
 ## Questions?
 
-Contact Team Jarvis before shipping a new tool.
+Contact the core team before shipping a new tool.

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

@@ -1093,7 +1093,7 @@ export async function executeBrowserNavigate(
           }
         } else {
           // Login / 2FA / OAuth - the agent should handle these itself
-          // using browser operations + credential_store. Don't hand off.
+          // using browser operations + stored credentials. Don't hand off.
           lines.push("");
           lines.push(formatAuthChallenge(challenge));
           lines.push("");

package/src/tools/network/web-search-error.ts

@@ -2,7 +2,7 @@
 // failures and the user-facing copy we surface for them (ATL-727).
 //
 // This is a pure leaf module: it has NO imports from `daemon/`, `agent/`,
-// `apps/`, or any client/UI package. It may only import the logger and pino
+// `clients/`, or any client/UI package. It may only import the logger and pino
 // types (for the telemetry helper). Every web_search code path — native
 // Anthropic handler, app-side providers, and the web client default — funnels
 // failures through `classifyWebSearchFailure` so the same friendly message

package/src/tools/permission-checker.ts

@@ -173,7 +173,7 @@ export class PermissionChecker {
       if (
         context.forcePromptSideEffects &&
         result.decision === "allow" &&
-        isSideEffectTool(name, input)
+        isSideEffectTool(name)
       ) {
         result.decision = "prompt";
         result.reason = "Side-effect tool requires explicit approval";

package/src/tools/schedule/create.ts

@@ -1,5 +1,3 @@
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
-import { getConfig } from "../../config/loader.js";
 import { validateScheduleInferenceProfile } from "../../schedule/inference-profile.js";
 import { formatIntegrationSummary } from "../../schedule/integration-status.js";
 import { validateRruleSetLines } from "../../schedule/recurrence-engine.js";
@@ -121,13 +119,9 @@ export async function executeScheduleCreate(
       };
     }
   } else if (mode === "workflow") {
-    // Workflow mode is gated by the `workflows` flag (a scheduled run would
-    // otherwise hard-fail at trigger time) and requires a saved workflow name —
-    // mirrors the HTTP route's create-side validation so the assistant-facing
-    // path and the settings route enforce the same shape.
-    if (!isAssistantFeatureFlagEnabled("workflows", getConfig())) {
-      return { content: "Error: workflows are not enabled.", isError: true };
-    }
+    // Workflow mode requires a saved workflow name — mirrors the HTTP route's
+    // create-side validation so the assistant-facing path and the settings route
+    // enforce the same shape.
     if (!workflowName) {
       return {
         content:

package/src/tools/schedule/update.ts

@@ -1,5 +1,3 @@
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
-import { getConfig } from "../../config/loader.js";
 import { validateScheduleInferenceProfile } from "../../schedule/inference-profile.js";
 import { validateRruleSetLines } from "../../schedule/recurrence-engine.js";
 import {
@@ -205,8 +203,8 @@ export async function executeScheduleUpdate(
     };
   }
 
-  // Mirror the HTTP route: a schedule whose RESULTING mode is `workflow` must be
-  // flag-enabled and carry a non-empty workflowName. Compute the post-update
+  // Mirror the HTTP route: a schedule whose RESULTING mode is `workflow` must
+  // carry a non-empty workflowName. Compute the post-update
   // state (the update's value if present, else the persisted one) so both
   // "switch to workflow without a name" and "clear the name on a workflow
   // schedule" are rejected — otherwise the scheduler hits the `!job.workflowName`
@@ -217,12 +215,6 @@ export async function executeScheduleUpdate(
       const resultingMode =
         updates.mode !== undefined ? (updates.mode as string) : existing.mode;
       if (resultingMode === "workflow") {
-        if (!isAssistantFeatureFlagEnabled("workflows", getConfig())) {
-          return {
-            content: "Error: workflows are not enabled.",
-            isError: true,
-          };
-        }
         const resultingWorkflowName =
           updates.workflowName !== undefined
             ? ((updates.workflowName as string | null) ?? "")

package/src/tools/side-effects.ts

@@ -25,22 +25,7 @@ const SIDE_EFFECT_TOOLS: ReadonlySet<string> = new Set([
  * Returns `true` if the given tool name is classified as having side effects
  * (i.e. it can modify the filesystem, execute arbitrary commands, or trigger
  * external actions). Read-only and informational tools return `false`.
- *
- * For mixed-action tools (e.g. credential_store), the optional
- * `input` parameter is inspected to distinguish mutating actions (create,
- * update, cancel) from read-only ones (list, get).
  */
-export function isSideEffectTool(
-  toolName: string,
-  input?: Record<string, unknown>,
-): boolean {
-  if (SIDE_EFFECT_TOOLS.has(toolName)) return true;
-
-  // Action-aware checks for mixed-action tools
-  if (toolName === "credential_store") {
-    const action = input?.action;
-    return action === "store" || action === "delete" || action === "prompt";
-  }
-
-  return false;
+export function isSideEffectTool(toolName: string): boolean {
+  return SIDE_EFFECT_TOOLS.has(toolName);
 }

package/src/tools/skills/execute.ts

@@ -62,6 +62,40 @@ export function resolveSkillExecuteInput(
   return {};
 }
 
+/**
+ * Augment an inner-tool error with `skill_execute` envelope guidance when the
+ * call carried no inner parameters.
+ *
+ * {@link resolveSkillExecuteInput} rescues *misplaced* parameters (siblings, a
+ * JSON-encoded string). It cannot rescue a genuinely empty call — there is
+ * nothing to relocate — so the inner tool runs with `{}` and rejects it with a
+ * field-level message ("<field> is required") that says nothing about the
+ * envelope. Weak models then retry the identical empty shape, oscillating over
+ * whether parameters belong under `input`, as siblings, or as a JSON string.
+ *
+ * Appending the canonical envelope shape gives the next attempt a concrete
+ * template. Fires only when the resolved inner input was empty AND the tool
+ * errored, so well-formed calls and tools that legitimately accept no
+ * parameters are untouched.
+ */
+export function augmentSkillExecuteError(
+  toolName: string,
+  resolvedInput: Record<string, unknown>,
+  result: ToolExecutionResult,
+): ToolExecutionResult {
+  if (!result.isError || Object.keys(resolvedInput).length > 0) return result;
+
+  const guidance =
+    `\n\nThis skill_execute call carried no parameters for "${toolName}". ` +
+    `Put the tool's parameters inside \`input\` as a JSON object — not as ` +
+    `siblings of \`tool\`, and not as a JSON-encoded string. For example: ` +
+    `{"tool": "${toolName}", "input": { /* the tool's parameters */ }, ` +
+    `"activity": "..."}. The skill's instructions (from skill_load) list ` +
+    `"${toolName}"'s required fields.`;
+
+  return { ...result, content: result.content + guidance };
+}
+
 export const skillExecuteTool = {
   name: "skill_execute",
   description:

package/src/tools/subagent/spawn.ts

@@ -1,3 +1,4 @@
+import { validateInferenceProfileKey } from "../../config/inference-profile-validation.js";
 import { findConversation } from "../../daemon/conversation-registry.js";
 import { getConversationOverrideProfile } from "../../memory/conversation-crud.js";
 import type { Message } from "../../providers/types.js";
@@ -14,6 +15,7 @@ export async function executeSubagentSpawn(
   const extraContext = input.context as string | undefined;
   const fork = input.fork === true;
   const role = (input.role as string | undefined) ?? undefined;
+  const inferenceProfile = input.inference_profile;
 
   // For fork mode, sendResultToUser defaults to false unless explicitly set to true.
   // For regular mode, sendResultToUser defaults to true (existing behavior).
@@ -28,6 +30,26 @@ export async function executeSubagentSpawn(
     };
   }
 
+  let requestedOverrideProfile: string | undefined;
+  let forceOverrideProfile = false;
+  if (inferenceProfile !== undefined) {
+    if (typeof inferenceProfile !== "string") {
+      return {
+        content: "Error: inference_profile must be a string",
+        isError: true,
+      };
+    }
+    const profileError = validateInferenceProfileKey(inferenceProfile);
+    if (profileError) {
+      return {
+        content: `Error: ${profileError}`,
+        isError: true,
+      };
+    }
+    requestedOverrideProfile = inferenceProfile;
+    forceOverrideProfile = true;
+  }
+
   const manager = getSubagentManager();
   const sendToClient = context.sendToClient as
     | ((msg: { type: string; [key: string]: unknown }) => void)
@@ -75,16 +97,18 @@ export async function executeSubagentSpawn(
   // `SubagentManager.spawn` forwards it back into the subagent's
   // `runAgentLoop` call as `options.overrideProfile`.
   //
-  // Prefer the per-turn `context.overrideProfile` (populated by
-  // `runAgentLoopImpl` from its resolved `turnOverrideProfile`) over a
-  // row read so nested spawns inherit correctly. The current subagent's
-  // own conversation row never has `inferenceProfile` set — its override
-  // arrived via in-memory `SubagentConfig.overrideProfile` — and even if it
-  // were set, `getConversationOverrideProfile` short-circuits for
-  // background conversations and returns `undefined`. Falling back to the
-  // row read preserves behavior for tool calls that originate outside an
-  // agent-loop turn.
+  // Prefer an explicit spawn-time profile, then the per-turn
+  // `context.overrideProfile` (populated by `runAgentLoopImpl` from its
+  // resolved `turnOverrideProfile`) over a row read so nested spawns inherit
+  // correctly. The current subagent's own conversation row never has
+  // `inferenceProfile` set — its override arrived via in-memory
+  // `SubagentConfig.overrideProfile` — and even if it were set,
+  // `getConversationOverrideProfile` short-circuits for background
+  // conversations and returns `undefined`. Falling back to the row read
+  // preserves behavior for tool calls that originate outside an agent-loop
+  // turn.
   const inheritedOverrideProfile =
+    requestedOverrideProfile ??
     context.overrideProfile ??
     getConversationOverrideProfile(context.conversationId);
 
@@ -102,6 +126,7 @@ export async function executeSubagentSpawn(
         ...(inheritedOverrideProfile
           ? { overrideProfile: inheritedOverrideProfile }
           : {}),
+        ...(forceOverrideProfile ? { forceOverrideProfile: true } : {}),
         ...(context.toolUseId ? { parentToolUseId: context.toolUseId } : {}),
         ...forkFields,
       },

package/src/tools/tool-approval-handler.ts

@@ -157,7 +157,6 @@ const UI_SURFACE_TOOLS = new Set(["ui_show", "ui_update", "ui_dismiss"]);
 
 function requiresGuardianApprovalForActor(
   toolName: string,
-  input: Record<string, unknown>,
   executionTarget: ExecutionTarget,
 ): boolean {
   // UI surface tools are passive, user-visible operations (cards, forms,
@@ -170,7 +169,7 @@ function requiresGuardianApprovalForActor(
   // Side-effect tools always require guardian approval for untrusted actors.
   // Read-only host execution is also blocked because it can leak sensitive
   // local information (e.g. shell/file reads).
-  return isSideEffectTool(toolName, input) || executionTarget === "host";
+  return isSideEffectTool(toolName) || executionTarget === "host";
 }
 
 function guardianApprovalDeniedMessage(
@@ -320,7 +319,6 @@ export class ToolApprovalHandler {
 
     const guardianApprovalRequired = requiresGuardianApprovalForActor(
       name,
-      input,
       executionTarget,
     );
 

package/src/tools/tool-manifest.ts

@@ -15,7 +15,6 @@ import { askQuestionTool } from "./ask-question/ask-question-tool.js";
 import { makeAuthenticatedRequestTool } from "./credential-execution/make-authenticated-request.js";
 import { manageSecureCommandTool } from "./credential-execution/manage-secure-command-tool.js";
 import { runAuthenticatedCommandTool } from "./credential-execution/run-authenticated-command.js";
-import { credentialStoreTool } from "./credentials/vault.js";
 import { fileEditTool } from "./filesystem/edit.js";
 import { fileListTool } from "./filesystem/list.js";
 import { fileReadTool } from "./filesystem/read.js";
@@ -90,7 +89,6 @@ export const explicitTools: ToolDefinition[] = [
   // Always-explicit tools
   rememberTool,
   recallTool,
-  credentialStoreTool,
   notifyParentTool,
   askQuestionTool,
   // NOTE: external skill tools (registered via registerExternalTools in

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

@@ -59,6 +59,14 @@ function proxyExecute(toolName: string) {
       };
     }
 
+    if (toolName === "ui_update" && isEmptyUpdate(input)) {
+      return {
+        content:
+          'Error: ui_update received an empty `data` payload, so the surface was unchanged — the user still sees its previous state. The provided data is merged into the surface\'s current data, and merging nothing is a no-op. To advance a task_progress card, send the full step list: ui_update { surface_id: "<id>", data: { templateData: { steps: [{ label: "<step>", status: "completed" }, { label: "<step>", status: "in_progress" }] } } }. Resend ui_update with the fields you intend to change under `data`.',
+        isError: true,
+      };
+    }
+
     if (!context.proxyToolResolver) {
       return {
         content: `No proxy resolver configured for proxy tool "${toolName}". This tool requires an external resolver (e.g. a connected macOS client).`,
@@ -98,6 +106,36 @@ function isTaskProgressCardShow(input: Record<string, unknown>): boolean {
   return data?.template === "task_progress";
 }
 
+/**
+ * A `ui_update` whose `data` merge would change nothing: missing, not an
+ * object, or containing only (recursively) empty objects. Merging such a
+ * payload is a silent no-op — the surface keeps its prior state while the
+ * client still reports "Surface updated" — so the model never learns its
+ * update was hollow and a live card (e.g. task_progress) appears frozen.
+ * Arrays (e.g. `templateData.steps`) and any non-empty primitive leaf count
+ * as content.
+ */
+function isEmptyUpdate(input: Record<string, unknown>): boolean {
+  const data = asRecord(input.data);
+  return data === null || !hasContent(data);
+}
+
+function hasContent(value: unknown): boolean {
+  if (value === null || value === undefined) {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (typeof value === "object") {
+    return Object.values(value).some(hasContent);
+  }
+  if (typeof value === "string") {
+    return value.trim().length > 0;
+  }
+  return true;
+}
+
 function isEmptyDynamicPage(input: Record<string, unknown>): boolean {
   if (input.surface_type !== "dynamic_page") {
     return false;
@@ -311,7 +349,7 @@ export const uiShowTool = {
 // ui_update
 // ---------------------------------------------------------------------------
 
-const uiUpdateTool = {
+export const uiUpdateTool = {
   name: "ui_update",
   description:
     "Update an existing surface's data. The provided data object is merged into the surface's current data.\n" +

package/src/tools/workflows/run-workflow.test.ts

@@ -11,11 +11,9 @@ mock.module("../../util/logger.js", () => ({
 }));
 
 // ── Mutable mock state ────────────────────────────────────────────────
-// `flagEnabled` toggles the `workflows` feature flag; `configThrows`
-// simulates config not yet loaded (test-setup race). The run-manager mock
-// records the args of the last `start()` call for assertion.
+// `configThrows` simulates config not yet loaded (test-setup race). The
+// run-manager mock records the args of the last `start()` call for assertion.
 
-let flagEnabled = true;
 let configThrows = false;
 
 const realLoader = await import("../../config/loader.js");
@@ -35,13 +33,6 @@ mock.module("../../config/loader.js", () => ({
     }) as unknown as ReturnType<typeof realLoader.loadConfig>,
 }));
 
-const realFlags = await import("../../config/assistant-feature-flags.js");
-mock.module("../../config/assistant-feature-flags.js", () => ({
-  ...realFlags,
-  isAssistantFeatureFlagEnabled: (key: string) =>
-    key === "workflows" ? flagEnabled : false,
-}));
-
 // No live conversation in tests — the tool falls back to a synthetic trust
 // context built from the tool context's trustClass.
 const realRegistry = await import("../../daemon/conversation-registry.js");
@@ -92,7 +83,6 @@ function makeContext(): Parameters<typeof executeRunWorkflow>[1] {
 }
 
 beforeEach(() => {
-  flagEnabled = true;
   configThrows = false;
   startThrows = null;
   lastStartArgs = null;
@@ -105,10 +95,10 @@ beforeEach(() => {
 });
 
 describe("workflow tools are served by the workflows skill", () => {
-  // The cutover moved run_workflow / manage_workflows out of the always-on tool
-  // manifest into the flag-gated `workflows` bundled skill (loaded via
-  // skill_load, invoked via skill_execute). The skill manifest is the
-  // source of truth; assert it declares both as in-process host tools.
+  // run_workflow / manage_workflows are served by the `workflows` bundled skill
+  // (loaded via skill_load, invoked via skill_execute), not the always-on tool
+  // manifest. The skill manifest is the source of truth; assert it declares both
+  // as in-process host tools.
   test("the workflows skill TOOLS.json declares both host-executed tools", async () => {
     const { readFileSync } = await import("node:fs");
     const { join } = await import("node:path");
@@ -211,13 +201,13 @@ describe("run_workflow launch", () => {
   });
 
   test("surfaces a run-manager start error as a tool error", async () => {
-    startThrows = new Error("Workflows are not enabled.");
+    startThrows = new Error("run manager exploded");
     const res = await executeRunWorkflow(
       { script: "export const meta = {};" },
       makeContext(),
     );
     expect(res.isError).toBe(true);
-    expect(res.content).toContain("Workflows are not enabled.");
+    expect(res.content).toContain("run manager exploded");
   });
 });
 

package/src/util/platform.ts

@@ -402,8 +402,8 @@ export function getSkillRuntimePath(
  *
  * Resolution order:
  *
- *   1. macOS `.app` bundle: `Contents/Resources/bun` — shipped by
- *      `clients/macos/build.sh` at a version that matches `.tool-versions`.
+ *   1. macOS `.app` bundle: `Contents/Resources/bun` — bundled at a version
+ *      that matches `.tool-versions`.
  *   2. Next-to-binary: `<execDir>/bun` for Docker/generic compiled layouts
  *      that stage a bun binary alongside the daemon (PR 29 wires this up).
  *

package/src/workflows/capabilities.ts

@@ -29,9 +29,8 @@
  *   (If host execution is ever wanted, the deliberate path is to thread the
  *   originating tool context through the engine — not to relax this gate.)
  *
- * This module is pure logic: it performs no feature-flag checks and no I/O
- * beyond the synchronous tool-registry lookup. The `workflows` flag gates the
- * callers, not this code.
+ * This module is pure logic: it performs no I/O beyond the synchronous
+ * tool-registry lookup.
  */
 
 import { z } from "zod";

package/src/workflows/run-manager.test.ts

@@ -22,7 +22,6 @@ import {
   WorkflowRunCapError,
   WorkflowRunManager,
   type WorkflowRunManagerDeps,
-  WorkflowsDisabledError,
 } from "./run-manager.js";
 
 const TRUST: TrustContext = {
@@ -144,7 +143,6 @@ interface EngineResult {
  * deterministically), an in-memory journal, and spies for broadcast + wake.
  */
 function makeHarness(opts?: {
-  flagEnabled?: boolean;
   maxConcurrentRuns?: number;
   /** Custom engine impl; defaults to the deferred-resolver fake. */
   engine?: WorkflowRunManagerDeps["executeWorkflow"];
@@ -190,7 +188,6 @@ function makeHarness(opts?: {
     }) as unknown as WorkflowRunManagerDeps["leafRunner"],
     journal: fake.journal,
     getConfig: () => makeConfig(opts?.maxConcurrentRuns),
-    isFlagEnabled: () => opts?.flagEnabled ?? true,
     wake: (async (wakeOpts) => {
       wakes.push({
         conversationId: wakeOpts.conversationId,
@@ -227,22 +224,6 @@ function makeHarness(opts?: {
   };
 }
 
-describe("WorkflowRunManager.start — flag gate", () => {
-  test("flag off → start throws and the engine is never invoked", () => {
-    const h = makeHarness({ flagEnabled: false });
-    expect(() =>
-      h.manager.start({
-        scriptSource: "export const meta = { name: 'x', description: 'y' }",
-        args: {},
-        manifest: { tools: [], hostFunctions: [], persona: false },
-        trustContext: TRUST,
-      }),
-    ).toThrow(WorkflowsDisabledError);
-    expect(h.executeCalls).toHaveLength(0);
-    expect(h.fake.rows.size).toBe(0);
-  });
-});
-
 describe("WorkflowRunManager.start — concurrent-run cap", () => {
   test("the (N+1)th concurrent start is rejected", () => {
     const h = makeHarness({ maxConcurrentRuns: 2 });
@@ -702,10 +683,4 @@ describe("WorkflowRunManager.resume", () => {
 
     expect(() => h.manager.resume("run-x")).toThrow(WorkflowRunCapError);
   });
-
-  test("resume is rejected when the flag is off", () => {
-    const h = makeHarness({ flagEnabled: false });
-    seedRun(h, { id: "run-x", status: "interrupted" });
-    expect(() => h.manager.resume("run-x")).toThrow(WorkflowsDisabledError);
-  });
 });

package/src/workflows/run-manager.ts

@@ -5,8 +5,6 @@
  * and routes (later PRs) drive. It owns everything the raw {@link executeWorkflow}
  * engine deliberately does NOT:
  *
- *  - **Feature-flag gate.** `start` hard-fails with {@link WorkflowsDisabledError}
- *    when the `workflows` flag is off, BEFORE any engine code path is reachable.
  *  - **Concurrent-run cap.** At most `config.workflows.maxConcurrentRuns` runs
  *    may be in flight; the (N+1)th `start` throws {@link WorkflowRunCapError}.
  *  - **Async launch.** `start` resolves capabilities, creates the journal run
@@ -28,7 +26,6 @@
 
 import { createHash, randomUUID } from "node:crypto";
 
-import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getConfig } from "../config/loader.js";
 import type { AssistantConfig } from "../config/schema.js";
 import {
@@ -58,15 +55,6 @@ const log = getLogger("workflow-run-manager");
 /** Source tag for the completion wake (shows up in the wake's structured log). */
 const WORKFLOW_WAKE_SOURCE = "workflow_completed";
 
-/** Thrown by `start` when the `workflows` feature flag is disabled. */
-export class WorkflowsDisabledError extends Error {
-  readonly code = "workflows_disabled" as const;
-  constructor() {
-    super("Workflows are not enabled.");
-    this.name = "WorkflowsDisabledError";
-  }
-}
-
 /** Thrown by `start` when the concurrent-run cap is already reached. */
 export class WorkflowRunCapError extends Error {
   readonly code = "workflow_run_cap_exceeded" as const;
@@ -141,7 +129,6 @@ export interface WorkflowRunManagerDeps {
   leafRunner: typeof runLeaf;
   journal: typeof journalStore;
   getConfig: () => AssistantConfig;
-  isFlagEnabled: (config: AssistantConfig) => boolean;
   wake: typeof wakeAgentForOpportunity;
   broadcast: typeof broadcastMessage;
   newRunId: () => string;
@@ -155,8 +142,6 @@ function defaultDeps(): WorkflowRunManagerDeps {
     leafRunner: runLeaf,
     journal: journalStore,
     getConfig,
-    isFlagEnabled: (config) =>
-      isAssistantFeatureFlagEnabled("workflows", config),
     wake: wakeAgentForOpportunity,
     broadcast: broadcastMessage,
     newRunId: () => randomUUID(),
@@ -178,18 +163,14 @@ export class WorkflowRunManager {
   }
 
   /**
-   * Launch a workflow run. Gates on the `workflows` flag and the concurrent-run
-   * cap (both throw before any engine code is reachable), resolves capabilities,
+   * Launch a workflow run. Gates on the concurrent-run cap (which throws before
+   * any engine code is reachable), resolves capabilities,
    * creates the journal run row, and kicks off {@link executeWorkflow}
    * asynchronously. Returns the `runId` immediately — completion is surfaced via
    * events and a conversation wake.
    */
   start(opts: StartWorkflowOptions): { runId: string } {
     const config = this.deps.getConfig();
-    if (!this.deps.isFlagEnabled(config)) {
-      throw new WorkflowsDisabledError();
-    }
-
     const limit = config.workflows.maxConcurrentRuns;
     if (this.inflight.size >= limit) {
       throw new WorkflowRunCapError(limit);
@@ -282,9 +263,6 @@ export class WorkflowRunManager {
    */
   resume(runId: string): { runId: string } {
     const config = this.deps.getConfig();
-    if (!this.deps.isFlagEnabled(config)) {
-      throw new WorkflowsDisabledError();
-    }
 
     if (this.inflight.has(runId)) {
       throw new WorkflowResumeNotPossibleError(runId, "in_flight");