@vellumai/assistant 0.9.0 → 0.10.0-dev.202606192226.8ed8a6a

package/src/runtime/routes/plugins-routes.ts

@@ -25,6 +25,10 @@
 
 import { z } from "zod";
 
+import {
+  diffPlugin,
+  PluginDiffUnavailableError,
+} from "../../cli/lib/diff-plugin.js";
 import {
   inspectPlugin,
   PluginInspectNotFoundError,
@@ -46,6 +50,12 @@ import {
   getPluginDetails,
   PluginDetailsNotFoundError,
 } from "../../cli/lib/plugin-details.js";
+import {
+  DEFAULT_PIN_HISTORY_LIMIT,
+  listPinHistory,
+  PluginPinHistoryError,
+  resolvePinToMarketplaceCommit,
+} from "../../cli/lib/plugin-pin-history.js";
 import {
   assertValidSearchPattern,
   filterPluginCatalog,
@@ -58,7 +68,9 @@ import {
   uninstallPlugin,
 } from "../../cli/lib/uninstall-plugin.js";
 import {
+  PluginMergeBaselineError,
   PluginNotUpgradableError,
+  type PluginUpgradeStrategy,
   upgradePlugin,
 } from "../../cli/lib/upgrade-plugin.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
@@ -67,6 +79,7 @@ import {
   ConflictError,
   InternalError,
   NotFoundError,
+  RouteError,
   ServiceUnavailableError,
 } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
@@ -230,6 +243,12 @@ const pluginInstallRequestSchema = z.object({
     .boolean()
     .optional()
     .describe("Overwrite an existing install in place. Defaults to false."),
+  pin: z
+    .string()
+    .optional()
+    .describe(
+      "Install a specific reviewed marketplace pin (full commit SHA) instead of the current one. The pin is validated against the plugin's marketplace pin history (`GET /v1/plugins/:name/versions`) and installed from the marketplace revision that introduced it; an unreviewed SHA is rejected. Use this to roll a plugin back to an older reviewed version.",
+    ),
 });
 
 const pluginInstallResponseSchema = z.object({
@@ -244,6 +263,32 @@ const pluginInstallResponseSchema = z.object({
   ref: z.string().describe("Git ref the plugin was fetched from."),
 });
 
+const pluginPinHistoryEntrySchema = z.object({
+  pin: z
+    .string()
+    .describe("Plugin commit SHA pinned at this point in marketplace history."),
+  marketplaceCommit: z
+    .string()
+    .describe(
+      "Marketplace-manifest commit to install this pin from (the newest commit carrying it).",
+    ),
+  promotedAt: z
+    .string()
+    .nullable()
+    .describe(
+      "ISO-8601 committer date (UTC) of the marketplace commit that promoted this pin; null when unreadable.",
+    ),
+  current: z
+    .boolean()
+    .describe("True for the pin currently active on the default branch."),
+});
+
+const pluginVersionsResponseSchema = z
+  .array(pluginPinHistoryEntrySchema)
+  .describe(
+    "Distinct marketplace pins a plugin has been promoted to, newest first; the first entry is the current pin. Empty when the plugin has no resolvable history.",
+  );
+
 const fingerprintComparisonSchema = z
   .object({
     modified: z
@@ -366,6 +411,26 @@ const pluginRemoteInfoSchema = z
   })
   .describe("The marketplace's current pin and advertised metadata.");
 
+const pluginSurfacesSchema = z
+  .object({
+    skills: z
+      .array(z.string())
+      .describe("Skill ids shipped at `skills/<id>/SKILL.md`."),
+    hooks: z
+      .array(z.string())
+      .describe(
+        "Lifecycle hook names from `hooks/<name>.{ts,js}` (e.g. `pre-model-call`).",
+      ),
+    tools: z
+      .array(z.string())
+      .describe(
+        "Registered tool names from `tools/<name>.{ts,js}` (filenames derived to tool names, e.g. `create-issue` \u2192 `create_issue`).",
+      ),
+  })
+  .describe(
+    "Surfaces the installed copy contributes, read from its on-disk tree.",
+  );
+
 const pluginInspectResponseSchema = z.object({
   name: z
     .string()
@@ -401,6 +466,11 @@ const pluginInspectResponseSchema = z.object({
     .describe(
       "Marketplace fetch error message, when the catalog could not be read.",
     ),
+  surfaces: pluginSurfacesSchema
+    .nullable()
+    .describe(
+      "Surfaces the installed copy contributes (skills, hooks, tools); null when the plugin is not installed.",
+    ),
 });
 
 const pluginUpgradeRequestSchema = z.object({
@@ -410,6 +480,12 @@ const pluginUpgradeRequestSchema = z.object({
     .describe(
       "Report what would change without modifying the install. Defaults to false.",
     ),
+  strategy: z
+    .enum(["ours", "theirs", "overwrite", "assistant"])
+    .optional()
+    .describe(
+      "How to reconcile local edits with the pin. `overwrite` (default) discards local edits and re-installs the pin; `ours`/`theirs` three-way merge, resolving conflicting hunks toward the local edit or the pin respectively; `assistant` is not yet supported.",
+    ),
 });
 
 const pluginUpgradeResponseSchema = z.object({
@@ -452,6 +528,19 @@ const pluginUpgradeResponseSchema = z.object({
       "Files materialized by the upgrade; null for a no-op or dry run.",
     ),
   dryRun: z.boolean().describe("Whether this was a dry run (no changes made)."),
+  strategy: z
+    .enum(["ours", "theirs", "overwrite", "assistant"])
+    .describe("Conflict-resolution strategy the upgrade applied."),
+  conflicts: z
+    .array(z.string())
+    .describe(
+      "Paths left for the assistant to resolve under the `assistant` strategy: text files carry git conflict markers, modify/delete divergences keep the surviving content. Empty for other strategies.",
+    ),
+  binaryConflicts: z
+    .array(z.string())
+    .describe(
+      "Binary files that conflicted under the `assistant` strategy; the local copy was kept since markers cannot be written into binary content. Empty for other strategies.",
+    ),
   provenanceWasUnknown: z
     .boolean()
     .describe(
@@ -459,6 +548,62 @@ const pluginUpgradeResponseSchema = z.object({
     ),
 });
 
+const pluginFileDiffSchema = z
+  .object({
+    path: z.string().describe("POSIX-relative path within the plugin root."),
+    status: z
+      .enum(["modified", "added", "removed"])
+      .describe(
+        "Whether the file was edited, newly added, or deleted since install.",
+      ),
+    diff: z
+      .string()
+      .describe(
+        "Unified diff (`--- a/… / +++ b/…`) of the file. A short `Binary files differ` marker for binary files, or a `Baseline unavailable` marker when `reconstructed` is false.",
+      ),
+    binary: z
+      .boolean()
+      .describe(
+        "True when either side was detected as binary (NUL byte present).",
+      ),
+    reconstructed: z
+      .boolean()
+      .describe(
+        "True when the install-time baseline for this file was faithfully recovered (re-materialized bytes hash-match the install fingerprint). False when it could not be reconstructed (e.g. the curated adapter overlay changed since install), in which case `diff` is a marker, not a patch. Always true for added files.",
+      ),
+  })
+  .describe("Unified diff of a single drifted file.");
+
+const pluginDiffResponseSchema = z.object({
+  name: z
+    .string()
+    .describe("Install name. Matches `assistant plugins install <name>`."),
+  target: z
+    .string()
+    .describe("Absolute path to the installed plugin directory on the host."),
+  commit: z
+    .string()
+    .describe(
+      "Commit the baseline was re-materialized from (the recorded install SHA).",
+    ),
+  committedAt: z
+    .string()
+    .nullable()
+    .describe(
+      "ISO-8601 committer timestamp (UTC) of `commit`; null when not recorded.",
+    ),
+  clean: z
+    .boolean()
+    .describe(
+      "True when the on-disk tree exactly matches the re-materialized baseline.",
+    ),
+  files: z
+    .array(pluginFileDiffSchema)
+    .describe(
+      "One entry per drifted file, sorted by path. Empty when `clean`.",
+    ),
+});
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -665,23 +810,52 @@ async function handleGetPluginDetails({
 // Handler — install
 // ---------------------------------------------------------------------------
 
+/**
+ * Resolve the marketplace ref an install should read from. With no `pin`, that
+ * is the default reviewed branch. With a `pin`, it is the marketplace commit
+ * that introduced that pin — but only when the pin appears in the plugin's
+ * reviewed history; an unreviewed SHA is rejected as a bad request so the route
+ * never installs an unvetted revision.
+ */
+async function resolveInstallMarketplaceRef(
+  name: string,
+  pin: string | undefined,
+): Promise<string> {
+  if (!pin) return DEFAULT_PLUGIN_REF;
+  const entry = await resolvePinToMarketplaceCommit(name, pin, {
+    fetch: globalThis.fetch.bind(globalThis),
+  });
+  if (!entry) {
+    throw new BadRequestError(
+      `"${pin}" is not a reviewed marketplace pin for "${name}". ` +
+        `Use GET /v1/plugins/${name}/versions to list installable pins.`,
+    );
+  }
+  return entry.marketplaceCommit;
+}
+
 async function handleInstallPlugin({ body = {} }: RouteHandlerArgs) {
   const name = typeof body.name === "string" ? body.name : "";
   if (!name) {
     throw new BadRequestError("`name` is required");
   }
   const force = typeof body.force === "boolean" ? body.force : undefined;
+  const pin = typeof body.pin === "string" ? body.pin : undefined;
 
-  // The ref is pinned to the curated `DEFAULT_PLUGIN_REF` rather than taken
-  // from the request: a caller-supplied ref would let any `settings.write`
-  // principal install from an unreviewed revision (a PR branch, fork ref,
-  // ...) whose marketplace manifest could carry attacker code that the loader
-  // then dynamically imports. Installs over HTTP therefore only ever resolve
-  // against the reviewed catalog on the default ref. Operators who need
-  // another ref use the local CLI's `assistant plugins install --ref`.
+  // The marketplace ref is never taken raw from the request: a caller-supplied
+  // ref would let any `settings.write` principal install from an unreviewed
+  // revision (a PR branch, fork ref, ...) whose manifest could carry attacker
+  // code the loader then dynamically imports. Installs over HTTP therefore
+  // resolve only against reviewed history. A `pin` is honored by mapping it —
+  // server-side — to the marketplace commit that introduced it, but only if it
+  // appears in the plugin's reviewed pin history; an unreviewed SHA is refused.
+  // The default install reads the current catalog on `DEFAULT_PLUGIN_REF`.
+  // Operators who need an unreviewed revision use the local CLI's
+  // `assistant plugins install --pin <sha> --allow-unreviewed`.
   try {
+    const marketplaceRef = await resolveInstallMarketplaceRef(name, pin);
     const result = await installPlugin(
-      { name, ref: DEFAULT_PLUGIN_REF, force },
+      { name, ref: marketplaceRef, force },
       { fetch: globalThis.fetch.bind(globalThis) },
     );
     return {
@@ -692,6 +866,11 @@ async function handleInstallPlugin({ body = {} }: RouteHandlerArgs) {
       ref: result.ref,
     };
   } catch (err) {
+    // Pin resolution already maps unreviewed/bad-pin cases to a RouteError;
+    // re-throw those verbatim rather than masking them as a 500.
+    if (err instanceof RouteError) {
+      throw err;
+    }
     if (err instanceof InvalidPluginNameError) {
       throw new BadRequestError(err.message);
     }
@@ -706,6 +885,10 @@ async function handleInstallPlugin({ body = {} }: RouteHandlerArgs) {
     if (err instanceof PluginSourceUnavailableError) {
       throw new ServiceUnavailableError(err.message);
     }
+    // The pin-history read hits GitHub too; treat its failures as retryable.
+    if (err instanceof PluginPinHistoryError) {
+      throw new ServiceUnavailableError(err.message);
+    }
     throw new InternalError(
       err instanceof Error ? err.message : "plugin install failed",
     );
@@ -740,6 +923,84 @@ async function handleInspectPlugin({ pathParams = {} }: RouteHandlerArgs) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Handler — versions (marketplace pin history)
+// ---------------------------------------------------------------------------
+
+async function handlePluginVersions({
+  pathParams = {},
+  queryParams = {},
+}: RouteHandlerArgs) {
+  const rawName = pathParams.name ?? "";
+
+  let limit: number | undefined;
+  if (queryParams.limit !== undefined) {
+    const parsed = Number.parseInt(queryParams.limit, 10);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+      throw new BadRequestError("`limit` must be a positive integer.");
+    }
+    limit = parsed;
+  }
+
+  try {
+    return await listPinHistory(
+      rawName,
+      { fetch: globalThis.fetch.bind(globalThis) },
+      limit !== undefined ? { limit } : {},
+    );
+  } catch (err) {
+    if (err instanceof InvalidPluginNameError) {
+      throw new BadRequestError(err.message);
+    }
+    // The history read hits GitHub; its failures are retryable upstream errors.
+    if (err instanceof PluginPinHistoryError) {
+      throw new ServiceUnavailableError(err.message);
+    }
+    throw new InternalError(
+      err instanceof Error ? err.message : "plugin versions failed",
+    );
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Handler — diff
+// ---------------------------------------------------------------------------
+
+async function handleDiffPlugin({ pathParams = {} }: RouteHandlerArgs) {
+  const rawName = pathParams.name ?? "";
+
+  try {
+    return await diffPlugin(
+      { name: rawName },
+      { fetch: globalThis.fetch.bind(globalThis) },
+    );
+  } catch (err) {
+    if (err instanceof InvalidPluginNameError) {
+      throw new BadRequestError(err.message);
+    }
+    if (
+      err instanceof PluginNotInstalledError ||
+      err instanceof PluginNotFoundError
+    ) {
+      throw new NotFoundError(err.message);
+    }
+    // The install exists but recorded no commit to re-materialize a baseline
+    // from — a permanent state the caller cannot resolve by retrying. 409
+    // marks the request as well-formed but not actionable in the current state.
+    if (err instanceof PluginDiffUnavailableError) {
+      throw new ConflictError(err.message);
+    }
+    // A rate-limited or temporarily-down source (the plugin repo) is a
+    // retryable outage, not a conflict — 503.
+    if (err instanceof PluginSourceUnavailableError) {
+      throw new ServiceUnavailableError(err.message);
+    }
+    throw new InternalError(
+      err instanceof Error ? err.message : "plugin diff failed",
+    );
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Handler — upgrade
 // ---------------------------------------------------------------------------
@@ -750,6 +1011,10 @@ async function handleUpgradePlugin({
 }: RouteHandlerArgs) {
   const rawName = pathParams.name ?? "";
   const dryRun = typeof body.dryRun === "boolean" ? body.dryRun : undefined;
+  const strategy =
+    typeof body.strategy === "string"
+      ? (body.strategy as PluginUpgradeStrategy)
+      : undefined;
 
   // Like install, the upgrade target ref is the curated marketplace pin
   // (resolved inside `upgradePlugin` via `inspectPlugin`), never a
@@ -757,7 +1022,7 @@ async function handleUpgradePlugin({
   // upgrade at an unreviewed revision.
   try {
     const result = await upgradePlugin(
-      { name: rawName, dryRun },
+      { name: rawName, dryRun, strategy },
       { fetch: globalThis.fetch.bind(globalThis) },
     );
     return {
@@ -770,6 +1035,9 @@ async function handleUpgradePlugin({
       target: result.target,
       fileCount: result.fileCount,
       dryRun: result.dryRun,
+      strategy: result.strategy,
+      conflicts: result.conflicts,
+      binaryConflicts: result.binaryConflicts,
       provenanceWasUnknown: result.provenanceWasUnknown,
     };
   } catch (err) {
@@ -782,6 +1050,12 @@ async function handleUpgradePlugin({
     if (err instanceof PluginNotFoundError) {
       throw new NotFoundError(err.message);
     }
+    // A merge strategy was requested but the install-time baseline can't be
+    // reconstructed — a well-formed request that isn't actionable in the
+    // current state (the caller can retry with `overwrite` or reinstall).
+    if (err instanceof PluginMergeBaselineError) {
+      throw new ConflictError(err.message);
+    }
     // The install exists but has no marketplace entry to advance to — a
     // permanent state the caller cannot resolve by retrying. 409 marks the
     // request as well-formed but not actionable in the current state.
@@ -992,6 +1266,87 @@ export const ROUTES: RouteDefinition[] = [
     },
     handler: handleInspectPlugin,
   },
+  {
+    operationId: "plugins_versions",
+    endpoint: "plugins/:name/versions",
+    method: "GET",
+    policy: {
+      requiredScopes: ["settings.read"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    summary: "List a plugin's reviewed marketplace pins",
+    description: `Report the distinct marketplace pins a plugin has been promoted to over time, newest first (the first entry is the current pin), capped at \`limit\` (default ${DEFAULT_PIN_HISTORY_LIMIT}). The curated \`marketplace.json\` stores only the current pin, so this is reconstructed from the manifest's own commit history on the default branch — every entry is therefore a reviewed, known-good revision. Pair with \`POST /v1/plugins/install\`'s \`pin\` field to roll a plugin back to an older reviewed version. An unknown name (never in the manifest) returns an empty array, not 404.`,
+    tags: ["plugins"],
+    pathParams: [
+      {
+        name: "name",
+        type: "string",
+        description:
+          "Install name. Must match the kebab-case name accepted by `assistant plugins install`.",
+      },
+    ],
+    queryParams: [
+      {
+        name: "limit",
+        type: "string",
+        required: false,
+        description: `Maximum number of pins to return (positive integer; default ${DEFAULT_PIN_HISTORY_LIMIT}).`,
+      },
+    ],
+    responseBody: pluginVersionsResponseSchema,
+    additionalResponses: {
+      "400": {
+        description:
+          "The plugin name failed sanitization, or `limit` was not a positive integer.",
+      },
+      "503": {
+        description:
+          "The marketplace pin history could not be read from GitHub (rate-limited or upstream error); retryable.",
+      },
+    },
+    handler: handlePluginVersions,
+  },
+  {
+    operationId: "plugins_diff",
+    endpoint: "plugins/:name/diff",
+    method: "POST",
+    policy: {
+      requiredScopes: ["settings.read"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    summary: "Diff a plugin against its install commit",
+    description:
+      "Show a unified diff of local edits to an installed plugin against the exact commit it was installed at (recorded in its `install-meta.json`). Computing the diff re-materializes the baseline through the install pipeline — a network clone plus a temp-dir write — so this is a POST: it is not a safe, cacheable GET even though it leaves persistent state untouched (requires only `settings.read`). Drift is classified against the install-time fingerprint so an adapter overlay that moved since install never reads as a local change. Returns the baseline `commit`, a `clean` flag, and a `files` array of `{ path, status, diff, binary, reconstructed }` for each modified/added/removed file. The baseline is the install commit, not the marketplace pin — comparing against the current pin is `POST /v1/plugins/:name/upgrade` with `dryRun`. A name with no installed copy returns 404; an install that recorded no commit or fingerprint returns 409; an unreachable source returns 503. Mirrors the CLI's `assistant plugins diff <name>`.",
+    tags: ["plugins"],
+    pathParams: [
+      {
+        name: "name",
+        type: "string",
+        description:
+          "Install name. Must match the kebab-case name accepted by `assistant plugins install`.",
+      },
+    ],
+    responseBody: pluginDiffResponseSchema,
+    additionalResponses: {
+      "400": {
+        description:
+          "The plugin name failed sanitization (e.g. contained slashes, dots, or uppercase letters).",
+      },
+      "404": {
+        description:
+          "No copy of the plugin is installed, or its recorded commit resolves to nothing.",
+      },
+      "409": {
+        description:
+          "The install recorded no commit or no fingerprint to re-materialize and verify a baseline from.",
+      },
+      "503": {
+        description:
+          "The plugin source (GitHub) was temporarily unavailable; the diff is retryable.",
+      },
+    },
+    handler: handleDiffPlugin,
+  },
   {
     operationId: "plugins_upgrade",
     endpoint: "plugins/:name/upgrade",
@@ -1002,7 +1357,7 @@ export const ROUTES: RouteDefinition[] = [
     },
     summary: "Upgrade a plugin to the marketplace pin",
     description:
-      'Move an installed plugin to the marketplace\'s current pinned commit, re-materializing it under `<workspaceDir>/plugins/<name>/`. Always resolves against the curated marketplace pin (no caller-supplied ref), mirroring `plugins install`\'s curation boundary. A no-op (`outcome: "already-up-to-date"`) when the installed commit already equals the pin; pass `dryRun` to preview the move (`outcome: "would-upgrade"`) without touching the install. Installs lacking provenance are re-pinned to the current SHA. The assistant must be restarted to load the upgraded code. This does not gate on local edits — callers should consult `GET /v1/plugins/:name/inspect` (`local.localChanges`) first and confirm before overwriting. Mirrors the CLI\'s `assistant plugins upgrade <name>`.',
+      'Move an installed plugin to the marketplace\'s current pinned commit, re-materializing it under `<workspaceDir>/plugins/<name>/`. Always resolves against the curated marketplace pin (no caller-supplied ref), mirroring `plugins install`\'s curation boundary. A no-op (`outcome: "already-up-to-date"`) when the installed commit already equals the pin; pass `dryRun` to preview the move (`outcome: "would-upgrade"`) without touching the install. Installs lacking provenance are re-pinned to the current SHA. The assistant must be restarted to load the upgraded code. `strategy` controls how local edits are reconciled: `overwrite` (default) discards them and re-installs the pin wholesale; `ours`/`theirs`/`assistant` perform a three-way merge against the re-materialized install commit, carrying non-conflicting edits from both sides forward and resolving conflicting hunks toward the local edit (`ours`) or the pin (`theirs`), or writing git conflict markers into the file and reporting them in `conflicts`/`binaryConflicts` for the assistant to resolve (`assistant`). A merge strategy whose install-time baseline cannot be reconstructed returns 409. Mirrors the CLI\'s `assistant plugins upgrade <name> [--strategy <s>]`.',
     tags: ["plugins"],
     pathParams: [
       {
@@ -1025,7 +1380,7 @@ export const ROUTES: RouteDefinition[] = [
       },
       "409": {
         description:
-          "The install exists but has no marketplace entry to advance to.",
+          "The install exists but has no marketplace entry to advance to, or a merge strategy was requested whose install-time baseline cannot be reconstructed.",
       },
       "503": {
         description:

package/src/runtime/routes/schedule-routes.ts

@@ -7,8 +7,6 @@
 
 import { z } from "zod";
 
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
-import { getConfig } from "../../config/loader.js";
 import { getOrCreateConversation } from "../../daemon/conversation-store.js";
 import { INTERNAL_GUARDIAN_TRUST_CONTEXT } from "../../daemon/trust-context.js";
 import { bootstrapConversation } from "../../memory/conversation-bootstrap.js";
@@ -299,7 +297,6 @@ function handleCreateSchedule(body: Record<string, unknown>) {
   }
 
   if (mode === "workflow") {
-    assertWorkflowsEnabled();
     const workflowName =
       typeof body.workflowName === "string" ? body.workflowName.trim() : "";
     if (!workflowName) {
@@ -351,17 +348,6 @@ function handleCreateSchedule(body: Record<string, unknown>) {
   return handleListSchedules({});
 }
 
-/**
- * Reject workflow-mode schedule operations when the `workflows` feature flag
- * is off. Scheduled workflow runs would fail at trigger time (the run manager
- * hard-fails with WorkflowsDisabledError), so we fail fast at the route.
- */
-function assertWorkflowsEnabled(): void {
-  if (!isAssistantFeatureFlagEnabled("workflows", getConfig())) {
-    throw new BadRequestError("Workflows are not enabled.");
-  }
-}
-
 function handleToggleSchedule(id: string, body: Record<string, unknown>) {
   const enabled = body.enabled;
   if (typeof enabled !== "boolean") {
@@ -427,11 +413,6 @@ function handleUpdateSchedule(id: string, body: Record<string, unknown>) {
     );
   }
 
-  // Switching a schedule into workflow mode requires the workflows flag.
-  if (body.mode === "workflow") {
-    assertWorkflowsEnabled();
-  }
-
   // Mirror the create-side validation: a schedule whose RESULTING mode is
   // `workflow` must carry a non-empty `workflowName`. Without this, a PATCH can
   // leave a workflow-mode schedule nameless — the scheduler then hits the
@@ -946,9 +927,6 @@ async function handleRunScheduleNow(id: string) {
   // `schedule.message` (usually empty — workflow-mode create no longer requires
   // a message), running a no-op normal turn instead of the workflow.
   if (schedule.mode === "workflow") {
-    // Fail fast at the route when the flag is off (the run manager would also
-    // hard-fail with WorkflowsDisabledError); matches create/update handling.
-    assertWorkflowsEnabled();
     if (!schedule.workflowName) {
       throw new BadRequestError("Workflow schedule has no workflowName");
     }

package/src/runtime/routes/secret-routes.ts

@@ -22,10 +22,12 @@ import {
   invalidateConfigCache,
 } from "../../config/loader.js";
 import type { CesClient } from "../../credential-execution/client.js";
+import { maybeReseedCapabilitiesAfterManagedCredential } from "../../daemon/memory-v2-startup.js";
 import { setSentryOrganizationId, setSentryUserId } from "../../instrument.js";
 import { clearEmbeddingBackendCache } from "../../memory/embedding-backend.js";
 import { syncManualTokenConnection } from "../../oauth/manual-token-connection.js";
 import { validateAnthropicApiKey } from "../../providers/anthropic/client.js";
+import { validateAtlasCloudApiKey } from "../../providers/atlascloud/client.js";
 import { validateGeminiApiKey } from "../../providers/gemini/client.js";
 import { validateMinimaxApiKey } from "../../providers/minimax/client.js";
 import { validateOpenAIApiKey } from "../../providers/openai/client.js";
@@ -206,6 +208,15 @@ async function handleAddSecret({ body }: RouteHandlerArgs) {
           );
           return { success: false, error: validation.reason };
         }
+      } else if (name === "atlascloud") {
+        const validation = await validateAtlasCloudApiKey(value);
+        if (!validation.valid) {
+          log.warn(
+            { provider: name, reason: validation.reason },
+            "API key validation failed",
+          );
+          return { success: false, error: validation.reason };
+        }
       }
 
       const stored = await setSecureKeyAsync(
@@ -286,6 +297,10 @@ async function handleAddSecret({ body }: RouteHandlerArgs) {
       }
       if (isManagedProxyCredential(service, field)) {
         await refreshProvidersAfterSecretChange();
+        // Close the first-boot race where the startup capability seed ran before
+        // the managed embedding credential was provisioned, leaving skill/CLI
+        // pages unseeded until restart. Detached — must not block the response.
+        void maybeReseedCapabilitiesAfterManagedCredential(getConfig());
         if (service === "vellum" && field === "assistant_api_key") {
           const generation = ++apiKeyGeneration;
           const deps = getSecretsDeps();

package/src/runtime/routes/surface-action-routes.ts

@@ -13,6 +13,7 @@ import type { ChannelId } from "../../channels/types.js";
 import { isHttpAuthDisabled } from "../../config/env.js";
 import { findGuardianForChannel } from "../../contacts/contact-store.js";
 import { getLogger } from "../../util/logger.js";
+import type { TrustClass } from "../actor-trust-resolver.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import { processGuardianDecision } from "../guardian-action-service.js";
@@ -47,7 +48,7 @@ const log = getLogger("surface-action-routes");
 function applyTrustContext(
   conversation: {
     setTrustContext?(ctx: {
-      trustClass: "guardian" | "trusted_contact" | "unknown";
+      trustClass: TrustClass;
       sourceChannel: ChannelId;
     }): void;
   },