@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/runtime/routes/inference-provider-connection-routes.ts

@@ -455,22 +455,6 @@ async function handleUpdateConnection({
       `Invalid label: must be a non-blank string or null`,
     );
   }
-  // Managed connections: lock auth to `{type:"platform"}`. The boot upsert in
-  // `seedCanonicalConnections` would revert any other value on next restart;
-  // reject the write here so the surprise loop never happens. Label remains
-  // user-editable (the boot upsert leaves it alone). Gated on the row for the
-  // same reason as deletion: a user-owned row under the canonical name is not
-  // re-upserted by boot seeding, so its own auth stays editable.
-  if (
-    MANAGED_CONNECTION_NAMES.has(name) &&
-    isVellumManagedConnection(existing) &&
-    authResult.data.type !== "platform"
-  ) {
-    throw new BadRequestError(
-      `Cannot change auth on managed connection "${name}". Auth is locked to platform.`,
-    );
-  }
-
   const customFields = await parseCustomProviderFields(body, existing.provider);
 
   // Only a CHANGED label is validated: keeping a stored label — whatever it

package/src/runtime/routes/llm-call-sites-routes.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 
+import { CALL_SITE_DEFAULTS } from "../../config/call-site-defaults.js";
 import { getEffectiveProfilesForProvider } from "../../config/default-profile-catalog.js";
 import { resolveDefaultProfileKey } from "../../config/llm-resolver.js";
 import { loadConfig } from "../../config/loader.js";
@@ -21,7 +22,17 @@ const callSiteEntrySchema = z.object({
   displayName: z.string(),
   description: z.string(),
   domain: z.string(),
+  /** The effective winning profile key: includes per-call-site pins. */
   defaultProfile: z.string().optional(),
+  /**
+   * The code-owned `CALL_SITE_DEFAULTS` tier key, independent of pins and
+   * tier remaps. Clients group call sites by tier with this; grouping by
+   * `defaultProfile` would scatter pinned or remapped sites across their
+   * winners. Profileless call sites report `balanced`: the resolver's
+   * fallback anchor consults the balanced remap for them, so they follow
+   * the Balanced tier like any balanced-keyed site.
+   */
+  shippedDefaultProfile: z.string().optional(),
 });
 
 const callSiteCatalogResponseSchema = z.object({
@@ -36,6 +47,8 @@ async function handleGetCallSites() {
     callSites: CALL_SITE_CATALOG.map((entry) => ({
       ...entry,
       defaultProfile: resolveDefaultProfileKey(entry.id as LLMCallSite, llm),
+      shippedDefaultProfile:
+        CALL_SITE_DEFAULTS[entry.id]?.profile ?? "balanced",
     })),
   };
 }

package/src/runtime/routes/log-export-routes.ts

@@ -465,7 +465,7 @@ async function handleExport({
     );
 
     // --- Create tar.gz archive ---
-    const archiveBuffer = createTarGz(staging);
+    const archiveBuffer = await createTarGz(staging);
     if (!archiveBuffer) {
       throw new InternalError("Failed to create archive");
     }

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

@@ -6,7 +6,6 @@ import { eq } from "drizzle-orm";
 import { z } from "zod";
 
 import { FeedItemSchema } from "../../api/responses/home.js";
-import { bufferIfDeferred } from "../../notifications/deferred-emit.js";
 import { editNotification } from "../../notifications/edit-notification.js";
 import { emitNotificationSignal } from "../../notifications/emit-signal.js";
 import { listEvents } from "../../notifications/events-store.js";
@@ -72,7 +71,6 @@ const EmitSignalParams = z.object({
   conversationAffinityHint: z.record(z.string(), z.string()).optional(),
   dedupeKey: z.string().optional(),
   throwOnError: z.boolean().optional(),
-  originatingConversationId: z.string().optional(),
 });
 
 const EmitSignalResponse = z.object({
@@ -90,18 +88,6 @@ async function handleEmitSignal({ body = {} }: RouteHandlerArgs) {
     );
   }
   const validated = parsed.data;
-  const buffered = bufferIfDeferred(
-    validated.originatingConversationId,
-    validated,
-  );
-  if (buffered) {
-    return {
-      signalId: buffered.signalId,
-      dispatched: buffered.dispatched,
-      deduplicated: buffered.deduplicated,
-      reason: buffered.reason,
-    };
-  }
   const result = await emitNotificationSignal(validated);
   return {
     signalId: result.signalId,

package/src/runtime/routes/oauth-providers.ts

@@ -397,6 +397,7 @@ export const oauthProviderSummarySchema = z.object({
   supports_managed_mode: z.boolean(),
   managed_service_is_paid: z.boolean(),
   feature_flag: z.string().nullable(),
+  acts_as: z.enum(["user", "assistant"]),
 });
 
 /**

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

@@ -525,6 +525,27 @@ const pluginSurfacesSchema = z
       .describe(
         "Registered tool names from `tools/<name>.{ts,js}` (filenames derived to tool names, e.g. `create-issue` \u2192 `create_issue`).",
       ),
+    schedules: z
+      .array(
+        z.object({
+          name: z
+            .string()
+            .describe("Schedule name: the declaration directory's name."),
+          cadence: z
+            .string()
+            .describe(
+              "Raw schedule `expression` string from the declaration's config.",
+            ),
+          mode: z
+            .enum(["execute", "script"])
+            .describe(
+              "`execute` for a markdown prompt entrypoint, `script` for `index.sh`.",
+            ),
+        }),
+      )
+      .describe(
+        "Schedules declared under `schedules/`, each a `<name>/` directory with `config.json` plus one entrypoint. Display surface only; files directly under `schedules/` and unsupported declarations are omitted.",
+      ),
   })
   .describe(
     "Surfaces the installed copy contributes, read from its on-disk tree.",
@@ -568,7 +589,7 @@ const pluginInspectResponseSchema = z.object({
   surfaces: pluginSurfacesSchema
     .nullable()
     .describe(
-      "Surfaces the installed copy contributes (skills, hooks, tools); null when the plugin is not installed.",
+      "Surfaces the installed copy contributes (skills, hooks, tools, schedules); null when the plugin is not installed.",
     ),
 });
 
@@ -1206,6 +1227,11 @@ async function handleInstallPlugin({ body = {}, headers }: RouteHandlerArgs) {
   // that introduced it through the plugin's reviewed pin history; an unreviewed
   // SHA is refused. Operators who need an unreviewed revision use the local
   // CLI's `assistant plugins install --pin <sha> --allow-unreviewed`.
+  //
+  // No `confirmStaged` consent gate: the daemon route is unattended by design
+  // (there is no interactive surface to prompt on). Declared schedules the
+  // install arms are surfaced to the user by the schedule reconciler's
+  // `schedule.declared` notification.
   try {
     // Validate the name up front — before any catalog/pin/network work — so a
     // malformed name (`../escape`) is a deterministic 400 rather than a 404/503
@@ -1400,6 +1426,34 @@ async function handleDiffPlugin({ pathParams = {} }: RouteHandlerArgs) {
 // Handler — upgrade
 // ---------------------------------------------------------------------------
 
+/**
+ * Install names with an upgrade past the staging boundary right now.
+ *
+ * An upgrade stages into `<plugins>/../.plugins-staging/<name>.upgrading.<pid>`
+ * and finishes with an `rm -rf` + rename over the live install. Two concurrent
+ * upgrades of the same plugin in this process derive the same staging path, so
+ * the second would delete the first's tree mid-flight and leave the install
+ * half-swapped. The upgrade is per-plugin mutable state with more than one
+ * caller (CLI, the web Upgrade button, and the monitor's auto-update sweep),
+ * so it is serialized per name: the second caller is refused rather than
+ * queued, since by the time it could run, the revision it wanted is already
+ * what the first caller installed.
+ *
+ * Dry runs never stage — they return before the swap boundary — so they
+ * neither take nor respect the guard.
+ */
+const upgradesInFlight = new Set<string>();
+
+/** An upgrade for this plugin is already running in this process. */
+class PluginUpgradeInProgressError extends Error {
+  constructor(pluginName: string) {
+    super(
+      `An upgrade for plugin "${pluginName}" is already in progress. Wait for it to finish before starting another.`,
+    );
+    this.name = "PluginUpgradeInProgressError";
+  }
+}
+
 async function handleUpgradePlugin({
   pathParams = {},
   body = {},
@@ -1427,8 +1481,22 @@ async function handleUpgradePlugin({
   // brings the on-disk version up, so the reconcile below must run even when
   // the swap itself failed (re-initializing the untouched old install).
   let deactivated = false;
+  // Name held by this request in `upgradesInFlight`, so `finally` releases
+  // exactly what it claimed (and nothing when the claim was refused).
+  let claimed: string | null = null;
   try {
     const name = sanitizePluginName(rawName);
+    if (!dryRun) {
+      if (upgradesInFlight.has(name)) {
+        throw new PluginUpgradeInProgressError(name);
+      }
+      upgradesInFlight.add(name);
+      claimed = name;
+    }
+    // No `confirmStaged` consent gate here: the daemon route is unattended by
+    // design (there is no interactive surface to prompt on). A schedule the
+    // upgraded revision adds is surfaced to the user by the schedule
+    // reconciler's `schedule.declared` notification when it arms.
     const result = await upgradePlugin(
       { name, dryRun, strategy },
       {
@@ -1476,6 +1544,11 @@ async function handleUpgradePlugin({
     if (err instanceof InvalidPluginNameError) {
       throw new BadRequestError(err.message);
     }
+    // A concurrent upgrade of the same plugin owns the staging path — a
+    // well-formed request that is not actionable until the first one lands.
+    if (err instanceof PluginUpgradeInProgressError) {
+      throw new ConflictError(err.message);
+    }
     if (err instanceof PluginNotInstalledError) {
       throw new NotFoundError(err.message);
     }
@@ -1515,6 +1588,13 @@ async function handleUpgradePlugin({
     if (deactivated) {
       await reconcilePluginSourcesNow();
     }
+    // Released after the reconcile, not before: until the new version's
+    // `init` has run the plugin is still mid-swap, and a second upgrade
+    // starting there would stage against a tree this request is still
+    // bringing up.
+    if (claimed !== null) {
+      upgradesInFlight.delete(claimed);
+    }
   }
 }
 
@@ -1543,6 +1623,29 @@ function mapTogglePluginError(err: unknown): RouteError {
   );
 }
 
+/**
+ * Converge plugin-declared schedules against the sentinel this route just
+ * wrote, so a toggled plugin's rows disarm or re-arm now rather than at the
+ * reconciler's next backstop sweep.
+ *
+ * Fire-and-forget: the toggle itself already succeeded on disk, so a reconcile
+ * failure must not turn it into a route error. Imported lazily, matching the
+ * plugin source reconcile's own hook, to keep the schedule and notification
+ * modules out of this route module's static graph. The scheduler applies the
+ * sentinel at fire time as well, so a slow or failed pass here delays the row
+ * bookkeeping without letting a disabled plugin run.
+ */
+function reconcilePluginSchedulesInBackground(): void {
+  void import("../../schedule/plugin-schedule-reconciler.js")
+    .then(({ reconcilePluginSchedules }) => reconcilePluginSchedules())
+    .catch((err: unknown) => {
+      log.error(
+        { err },
+        "plugin schedule reconcile after a plugin toggle failed",
+      );
+    });
+}
+
 /**
  * Toggle a plugin's `.disabled` sentinel through the shared toggle-plugin lib,
  * then publish a generic `sync_changed(plugins:list)` so every client refetches
@@ -1554,6 +1657,7 @@ function handleEnablePlugin({ pathParams = {}, headers }: RouteHandlerArgs) {
   try {
     enablePlugin(pathParams.name ?? "");
     publishPluginsChanged(getOriginClientId(headers));
+    reconcilePluginSchedulesInBackground();
     return { ok: true };
   } catch (err) {
     throw mapTogglePluginError(err);
@@ -1564,6 +1668,7 @@ function handleDisablePlugin({ pathParams = {}, headers }: RouteHandlerArgs) {
   try {
     disablePlugin(pathParams.name ?? "");
     publishPluginsChanged(getOriginClientId(headers));
+    reconcilePluginSchedulesInBackground();
     return { ok: true };
   } catch (err) {
     throw mapTogglePluginError(err);

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

@@ -127,7 +127,9 @@ function handleGetRun({ pathParams = {} }: RouteHandlerArgs) {
   };
 }
 
-function handleExportRun({ pathParams = {} }: RouteHandlerArgs): Uint8Array {
+async function handleExportRun({
+  pathParams = {},
+}: RouteHandlerArgs): Promise<Uint8Array> {
   const runId = validateRunId(pathParams.runId);
 
   const runDir = getProfilerRunDir(runId);
@@ -140,7 +142,7 @@ function handleExportRun({ pathParams = {} }: RouteHandlerArgs): Uint8Array {
   try {
     copyDirContents(runDir, staging);
 
-    const archiveBuf = createTarGz(staging);
+    const archiveBuf = await createTarGz(staging);
     if (!archiveBuf) {
       log.error(
         { runId },

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

@@ -18,6 +18,11 @@
  *
  * Cross-talk safety: pending interactions of other kinds (`confirmation`,
  * `secret`, host_*, etc.) return 404 here rather than being mis-resolved.
+ *
+ * Status ordering: a missing interaction is always 404, never a body-validation
+ * 400, whichever shape was submitted. Clients treat 404 as the terminal signal
+ * that retires a stale card, so a gone interaction reported as 400 would strand
+ * the card and surface a validation string the user cannot act on.
  */
 import { z } from "zod";
 
@@ -112,8 +117,25 @@ function handleQuestionResponse({ body }: RouteHandlerArgs) {
   const response: QuestionResponseBody = parsed.data;
   const { requestId } = response;
 
-  // The legacy single-question shim needs the interaction's stashed metadata to
-  // synthesize a one-element batch; peek (don't consume) before resolving.
+  // Establish the interaction exists BEFORE normalizing the body. A missing or
+  // wrong-kind interaction is not-found regardless of which body shape asked,
+  // and the legacy shim below reads its stashed metadata: normalizing first
+  // would surface a gone interaction as a body-validation 400, telling the
+  // client its payload was malformed when the real answer is that there is
+  // nothing left to answer. Clients rely on 404 being the terminal signal that
+  // retires a stale card, so the status has to be right for every shape.
+  // Peek, don't consume; `resolvePendingQuestion` performs the real consume.
+  const interaction = pendingInteractions.get(requestId);
+  if (!interaction || interaction.kind !== "question") {
+    log.warn(
+      { requestId },
+      "Question response for unknown or wrong-kind requestId",
+    );
+    throw new NotFoundError(
+      "No pending question interaction found for this requestId",
+    );
+  }
+
   let input;
   try {
     input =
@@ -121,10 +143,7 @@ function handleQuestionResponse({ body }: RouteHandlerArgs) {
         ? ({ kind: "close" } as const)
         : ({
             kind: "submit",
-            submissions: buildSubmissions(
-              response,
-              pendingInteractions.get(requestId),
-            ),
+            submissions: buildSubmissions(response, interaction),
           } as const);
   } catch (err) {
     if (err instanceof QuestionBatchValidationError) {
@@ -135,11 +154,10 @@ function handleQuestionResponse({ body }: RouteHandlerArgs) {
 
   const outcome = resolvePendingQuestion(requestId, input);
 
+  // Still reachable: the interaction can be consumed between the peek above and
+  // the resolve (a channel answer, a timeout firing).
   if (outcome.status === "not_found") {
-    log.warn(
-      { requestId },
-      "Question response for unknown or wrong-kind requestId",
-    );
+    log.warn({ requestId }, "Question interaction resolved before submission");
     throw new NotFoundError(
       "No pending question interaction found for this requestId",
     );

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

@@ -12,6 +12,10 @@
  *
  * `available` gates on `memory.enabled` alone (matching `isMemoryEnabled` in
  * the enqueue path). Retrospectives do NOT depend on `memory.v2.enabled`.
+ * `enabled` narrows `available` by `memory.retrospective.enabled`, the
+ * per-pass kill switch, so a memory-on assistant with retrospectives turned
+ * off reports `available: true, enabled: false` and the Settings row reads
+ * "Paused" rather than implying memory itself is off.
  */
 
 import { z } from "zod";
@@ -71,7 +75,7 @@ function listRetrospectiveConversations(
 function readRetrospectiveConfigResponse() {
   const config = getConfig();
   const available = isMemoryEnabled();
-  const enabled = available;
+  const enabled = available && config.memory.retrospective.enabled;
   const intervalMs = config.memory.retrospective.timeThresholdMs;
   // Retrospectives have no global schedule — runs are triggered per
   // conversation after activity, so a future run time is never known.
@@ -109,8 +113,10 @@ export const ROUTES: RouteDefinition[] = [
       "endpoint exists. `intervalMs` is the per-conversation time threshold " +
       "(`memory.retrospective.timeThresholdMs`), `lastRunAt` is the " +
       "`createdAt` of the most recent retrospective conversation across " +
-      "both legacy and fork sources, and `available` gates on " +
-      "`memory.enabled` (not `memory.v2.enabled`).",
+      "both legacy and fork sources, `available` gates on `memory.enabled` " +
+      "(not `memory.v2.enabled`), and `enabled` narrows that by " +
+      "`memory.retrospective.enabled`, the per-pass kill switch that stops " +
+      "retrospectives without disabling the rest of memory.",
     tags: ["retrospective"],
     responseBody: z.object({
       available: z.boolean(),