@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

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

@@ -63,6 +63,13 @@ import {
   PluginCatalogUnavailableError,
   type PluginSearchMatch,
 } from "../../cli/lib/search-plugins.js";
+import {
+  disablePlugin,
+  enablePlugin,
+  InvalidPluginNameError as InvalidTogglePluginNameError,
+  PluginAlreadyInStateException,
+  PluginDirectoryNotFoundError,
+} from "../../cli/lib/toggle-plugin.js";
 import {
   PluginNotInstalledError,
   uninstallPlugin,
@@ -73,7 +80,13 @@ import {
   type PluginUpgradeStrategy,
   upgradePlugin,
 } from "../../cli/lib/upgrade-plugin.js";
+import { isPluginDisabled } from "../../plugins/disabled-state.js";
+import { getLocalCategorySlugs } from "../../skills/categories-cache.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
+import {
+  getOriginClientId,
+  publishPluginsChanged,
+} from "../sync/resource-sync-events.js";
 import {
   BadRequestError,
   ConflictError,
@@ -95,6 +108,11 @@ const pluginInfoSchema = z.object({
       "Plugin's directory name (kebab-case). Matches `assistant plugins install <id>`.",
     ),
   name: z.string().describe("Display name. Equal to `id` today."),
+  enabled: z
+    .boolean()
+    .describe(
+      "Whether the plugin is active in this workspace. `false` when a `.disabled` sentinel is present under its directory; `true` otherwise.",
+    ),
   description: z
     .string()
     .nullable()
@@ -113,10 +131,27 @@ const pluginInfoSchema = z.object({
     .describe(
       "Non-fatal issues with this entry (missing `package.json`, malformed JSON, ...). Omitted when clean.",
     ),
+  category: z
+    .string()
+    .nullable()
+    .optional()
+    .describe(
+      "Marketplace category slug (Skills taxonomy); null when origin/category is unknown, e.g. non-marketplace installs.",
+    ),
 });
 
 const pluginsListResponseSchema = z.object({
   plugins: z.array(pluginInfoSchema),
+  categoryCounts: z
+    .record(z.string(), z.number())
+    .optional()
+    .describe(
+      "Installed plugins per category (before the category filter is applied).",
+    ),
+  totalCount: z
+    .number()
+    .optional()
+    .describe("Total installed plugins matching non-category filters."),
 });
 
 const pluginMatchSourceSchema = z
@@ -148,6 +183,12 @@ const pluginSearchMatchSchema = z.object({
     .string()
     .optional()
     .describe("Short description, when known (external entries only today)."),
+  category: z
+    .string()
+    .nullable()
+    .describe(
+      "Marketplace category slug (Skills taxonomy); null when the entry declares none.",
+    ),
   source: pluginMatchSourceSchema,
 });
 
@@ -611,10 +652,12 @@ const pluginDiffResponseSchema = z.object({
 interface PluginView {
   id: string;
   name: string;
+  enabled: boolean;
   description: string | null;
   version: string | null;
   path: string;
   issues?: string[];
+  category?: string | null;
 }
 
 function projectPlugin(entry: InstalledPluginInfo): PluginView {
@@ -624,6 +667,8 @@ function projectPlugin(entry: InstalledPluginInfo): PluginView {
   const view: PluginView = {
     id: entry.name,
     name: entry.name,
+    // `entry.name` is the plugin directory name, which is the sentinel key.
+    enabled: !isPluginDisabled(entry.name),
     description: entry.packageJson?.description ?? null,
     version: entry.packageJson?.version ?? null,
     path: entry.target,
@@ -634,11 +679,56 @@ function projectPlugin(entry: InstalledPluginInfo): PluginView {
   return view;
 }
 
+/**
+ * Marketplace → Skills category slug aliases for known, unambiguous mismatches.
+ * Keep this tiny: only add a mapping when it is obviously correct. Marketplace
+ * slugs with no clean Skills equivalent are intentionally absent so they fall
+ * through to `null` → the "system" bucket.
+ */
+const MARKETPLACE_CATEGORY_ALIASES: Record<string, string> = {
+  developer: "development",
+};
+
+/**
+ * Normalize a raw marketplace category slug to the shared Skills taxonomy so
+ * the rail never carries an invisible bucket. Lowercases + trims, applies the
+ * alias map, then returns the slug only when it is a valid Skills slug —
+ * otherwise `null`, which buckets under "system" so the plugin stays both
+ * counted and reachable. `validSlugs` is resolved once per request by the
+ * caller (never per item).
+ */
+export function normalizeMarketplaceCategory(
+  raw: string | null | undefined,
+  validSlugs: Set<string>,
+): string | null {
+  if (!raw) return null;
+  const slug = raw.trim().toLowerCase();
+  if (!slug) return null;
+  const aliased = MARKETPLACE_CATEGORY_ALIASES[slug] ?? slug;
+  return validSlugs.has(aliased) ? aliased : null;
+}
+
+/**
+ * Valid Skills category slugs the marketplace categories normalize against.
+ * Sync + local (bundled YAML via the Skills categories-cache) so the plugins
+ * list never takes on remote latency; a read failure degrades to an empty set,
+ * normalizing every category to `null` → "system" rather than throwing —
+ * mirroring the bounded posture of the catalog lookup.
+ */
+function getValidCategorySlugs(): Set<string> {
+  try {
+    return getLocalCategorySlugs();
+  } catch {
+    return new Set();
+  }
+}
+
 /** Wire shape for a catalog match. Mirrors {@link pluginSearchMatchSchema}. */
 interface PluginMatchView {
   name: string;
   path: string;
   description?: string;
+  category: string | null;
   source: { kind: "github"; repo: string; path?: string; ref: string };
 }
 
@@ -647,10 +737,14 @@ interface PluginMatchView {
  * serializer's `Record<string, unknown>` contract holds. The wire shape is
  * identical to {@link PluginSearchMatch}.
  */
-function projectMatch(m: PluginSearchMatch): PluginMatchView {
+function projectMatch(
+  m: PluginSearchMatch,
+  validSlugs: Set<string>,
+): PluginMatchView {
   const view: PluginMatchView = {
     name: m.name,
     path: m.path,
+    category: normalizeMarketplaceCategory(m.category, validSlugs),
     source: {
       kind: "github",
       repo: m.source.repo,
@@ -678,14 +772,103 @@ function matchesQuery(plugin: PluginView, needle: string): boolean {
 // Handler — list installed
 // ---------------------------------------------------------------------------
 
-function handleListPlugins({ queryParams = {} }: RouteHandlerArgs): {
+/** Uncategorized fallback bucket — matches the Skills taxonomy default. */
+const UNCATEGORIZED = "system";
+
+/**
+ * Time budget for the marketplace category lookup on the installed list.
+ * The installed list is a fast local read; the catalog is a remote GitHub
+ * fetch that can hang on a cold cache. Bounding the lookup keeps `GET
+ * /v1/plugins` responsive during a marketplace slowdown.
+ */
+const CATEGORY_LOOKUP_TIMEOUT_MS = 1500;
+
+/**
+ * Resolve the marketplace category map, racing the catalog fetch against a
+ * timer so a slow/hanging GitHub fetch can't block the installed list: on a
+ * rejection or a timeout past {@link CATEGORY_LOOKUP_TIMEOUT_MS} it degrades to
+ * an empty map (every `category` resolves to `null`). `timeoutMs` is injectable
+ * so tests can exercise the bound without the full production budget.
+ */
+export async function loadCategoryMapBounded(
+  timeoutMs: number = CATEGORY_LOOKUP_TIMEOUT_MS,
+): Promise<Map<string, string | null>> {
+  // Clear the timer once the race settles so a catalog-wins path doesn't leave
+  // the timer pending per request (matters for shutdown / test handles).
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    const catalog = await Promise.race([
+      getPluginCatalog(DEFAULT_PLUGIN_REF, {
+        fetch: globalThis.fetch.bind(globalThis),
+      }),
+      new Promise<null>((resolve) => {
+        timer = setTimeout(() => resolve(null), timeoutMs);
+      }),
+    ]);
+    if (!catalog) return new Map();
+    return new Map(catalog.matches.map((m) => [m.name, m.category]));
+  } catch {
+    return new Map();
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+async function handleListPlugins({
+  queryParams = {},
+}: RouteHandlerArgs): Promise<{
   plugins: PluginView[];
-} {
+  categoryCounts: Record<string, number>;
+  totalCount: number;
+}> {
   const q = queryParams.q?.trim();
+  const category = queryParams.category?.trim();
+
   const installed = listInstalledPlugins();
   const projected = installed.map(projectPlugin);
-  const filtered = q ? projected.filter((p) => matchesQuery(p, q)) : projected;
-  return { plugins: filtered };
+
+  // Nothing installed → `categoryCounts`/`totalCount` are deterministically
+  // empty and there is nothing to categorize, so skip the network-bound catalog
+  // lookup entirely (no wasted GitHub request or bounded stall wait).
+  if (projected.length === 0) {
+    return { plugins: [], categoryCounts: {}, totalCount: 0 };
+  }
+
+  // Categories live only in the catalog. A marketplace outage OR slowdown must
+  // never block the installed list, so the lookup is bounded: it degrades to an
+  // empty map (every category becomes `null`) on a rejection or a stall.
+  const categoryMap = await loadCategoryMapBounded();
+
+  // Normalize raw marketplace slugs to the shared Skills taxonomy once per
+  // request: a raw slug with no Skills row (e.g. `developer`, `memory`) would
+  // otherwise be counted in "All" yet unreachable by any rail row. Normalizing
+  // maps the unambiguous ones (`developer` → `development`) and folds the rest
+  // to `null` → "system", so counts always match visible rows.
+  const validSlugs = getValidCategorySlugs();
+
+  // An installed plugin's `id` is its directory name, which is the catalog
+  // match's `name` — so it's the lookup key.
+  const withCategory = projected.map((p) => ({
+    ...p,
+    category: normalizeMarketplaceCategory(categoryMap.get(p.id), validSlugs),
+  }));
+
+  let list = q ? withCategory.filter((p) => matchesQuery(p, q)) : withCategory;
+
+  // Counts are taken BEFORE the category filter so the rail badges stay stable
+  // while a single category is selected.
+  const categoryCounts: Record<string, number> = {};
+  for (const p of list) {
+    const bucket = p.category ?? UNCATEGORIZED;
+    categoryCounts[bucket] = (categoryCounts[bucket] ?? 0) + 1;
+  }
+  const totalCount = list.length;
+
+  if (category) {
+    list = list.filter((p) => (p.category ?? UNCATEGORIZED) === category);
+  }
+
+  return { plugins: list, categoryCounts, totalCount };
 }
 
 // ---------------------------------------------------------------------------
@@ -718,13 +901,17 @@ async function handleSearchPlugins({
       fetch: globalThis.fetch.bind(globalThis),
     });
     const matches = filterPluginCatalog(catalog, query);
+    // Resolve the valid Skills slugs once per request, then normalize each
+    // match's marketplace category against them so "Available" filters
+    // consistently against the same taxonomy as the installed rail.
+    const validSlugs = getValidCategorySlugs();
     // Re-pack `readonly` lib types into mutable copies so the route
     // serializer's `Record<string, unknown>` contract holds. The wire
     // shape is identical.
     return {
       query,
       ref: catalog.ref,
-      matches: matches.map(projectMatch),
+      matches: matches.map((m) => projectMatch(m, validSlugs)),
     };
   } catch (err) {
     if (err instanceof InvalidSearchPatternError) {
@@ -754,6 +941,7 @@ interface PluginUninstallResponse {
 
 function handleUninstallPlugin({
   pathParams = {},
+  headers,
 }: RouteHandlerArgs): PluginUninstallResponse {
   // The HTTP router has already URL-decoded `:name` for us; pass it
   // through verbatim — `uninstallPlugin` runs the same
@@ -763,6 +951,7 @@ function handleUninstallPlugin({
 
   try {
     const result = uninstallPlugin({ name: rawName });
+    publishPluginsChanged(getOriginClientId(headers));
     return { name: result.name, target: result.target };
   } catch (err) {
     if (err instanceof InvalidPluginNameError) {
@@ -834,7 +1023,7 @@ async function resolveInstallMarketplaceRef(
   return entry.marketplaceCommit;
 }
 
-async function handleInstallPlugin({ body = {} }: RouteHandlerArgs) {
+async function handleInstallPlugin({ body = {}, headers }: RouteHandlerArgs) {
   const name = typeof body.name === "string" ? body.name : "";
   if (!name) {
     throw new BadRequestError("`name` is required");
@@ -858,6 +1047,7 @@ async function handleInstallPlugin({ body = {} }: RouteHandlerArgs) {
       { name, ref: marketplaceRef, force },
       { fetch: globalThis.fetch.bind(globalThis) },
     );
+    publishPluginsChanged(getOriginClientId(headers));
     return {
       ok: true as const,
       name: result.name,
@@ -1008,6 +1198,7 @@ async function handleDiffPlugin({ pathParams = {} }: RouteHandlerArgs) {
 async function handleUpgradePlugin({
   pathParams = {},
   body = {},
+  headers,
 }: RouteHandlerArgs) {
   const rawName = pathParams.name ?? "";
   const dryRun = typeof body.dryRun === "boolean" ? body.dryRun : undefined;
@@ -1025,6 +1216,7 @@ async function handleUpgradePlugin({
       { name: rawName, dryRun, strategy },
       { fetch: globalThis.fetch.bind(globalThis) },
     );
+    publishPluginsChanged(getOriginClientId(headers));
     return {
       name: result.name,
       outcome: result.outcome,
@@ -1073,6 +1265,58 @@ async function handleUpgradePlugin({
   }
 }
 
+// ---------------------------------------------------------------------------
+// Handler — enable / disable
+// ---------------------------------------------------------------------------
+
+/**
+ * Map a `toggle-plugin` lib error onto the transport-agnostic route error.
+ * `enablePlugin` / `disablePlugin` throw their own taxonomy (distinct from the
+ * install/uninstall libs), which the branches below narrow to 400 / 404 / 409;
+ * anything unrecognized surfaces as an unexpected 500.
+ */
+function mapTogglePluginError(err: unknown): RouteError {
+  if (err instanceof InvalidTogglePluginNameError) {
+    return new BadRequestError(err.message);
+  }
+  if (err instanceof PluginDirectoryNotFoundError) {
+    return new NotFoundError(err.message);
+  }
+  if (err instanceof PluginAlreadyInStateException) {
+    return new ConflictError(err.message);
+  }
+  return new InternalError(
+    err instanceof Error ? err.message : "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
+ * `GET /v1/plugins`. Enable and disable emit the SAME invalidation — the tag
+ * names WHICH resource is stale, not the new value. The origin client id is
+ * threaded through for self-echo suppression.
+ */
+function handleEnablePlugin({ pathParams = {}, headers }: RouteHandlerArgs) {
+  try {
+    enablePlugin(pathParams.name ?? "");
+    publishPluginsChanged(getOriginClientId(headers));
+    return { ok: true };
+  } catch (err) {
+    throw mapTogglePluginError(err);
+  }
+}
+
+function handleDisablePlugin({ pathParams = {}, headers }: RouteHandlerArgs) {
+  try {
+    disablePlugin(pathParams.name ?? "");
+    publishPluginsChanged(getOriginClientId(headers));
+    return { ok: true };
+  } catch (err) {
+    throw mapTogglePluginError(err);
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Route definitions
 // ---------------------------------------------------------------------------
@@ -1088,7 +1332,7 @@ export const ROUTES: RouteDefinition[] = [
     },
     summary: "List installed plugins",
     description:
-      "Return one entry per directory under `<workspaceDir>/plugins/`, sorted alphabetically. Matches the CLI's `assistant plugins list`. Supports `?q=<text>` for case-insensitive substring matching across plugin id, name, and description.",
+      "Return one entry per directory under `<workspaceDir>/plugins/`, sorted alphabetically. Matches the CLI's `assistant plugins list`. Supports `?q=<text>` for case-insensitive substring matching across plugin id, name, and description. Each entry carries a `category` (marketplace slug from the Skills taxonomy, or `null` for non-marketplace installs); the response also reports `categoryCounts` (per-category totals, computed before the category filter) and `totalCount`. `?category=<slug>` filters the returned plugins by category server-side while leaving the counts unfiltered. A marketplace outage degrades `category` to `null` without failing the list.",
     tags: ["plugins"],
     queryParams: [
       {
@@ -1097,6 +1341,12 @@ export const ROUTES: RouteDefinition[] = [
         description:
           "Optional substring filter applied to plugin id, name, and description.",
       },
+      {
+        name: "category",
+        schema: { type: "string" },
+        description:
+          "Filter installed plugins by category slug (Skills taxonomy).",
+      },
     ],
     responseBody: pluginsListResponseSchema,
     handler: handleListPlugins,
@@ -1389,4 +1639,75 @@ export const ROUTES: RouteDefinition[] = [
     },
     handler: handleUpgradePlugin,
   },
+  {
+    operationId: "plugins_enable",
+    endpoint: "plugins/:name/enable",
+    method: "POST",
+    policy: {
+      requiredScopes: ["settings.write"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    summary: "Enable a plugin",
+    description:
+      "Enable a plugin in this workspace by removing its `.disabled` sentinel, mirroring the CLI's `assistant plugins enable <name>`. The change is honored live at read time by every tool / injector / hook gate — no restart required. Broadcasts a `sync_changed` invalidation carrying the `plugins:list` tag so other clients refetch `GET /v1/plugins`. An already-enabled plugin returns 409; a name with no plugin directory returns 404 (prefix a default plugin with `default-`); a malformed name returns 400.",
+    tags: ["plugins"],
+    pathParams: [
+      {
+        name: "name",
+        type: "string",
+        description:
+          "Directory name under `<workspaceDir>/plugins/`. Prefix a default plugin with `default-`. Must be kebab-case alphanumerics.",
+      },
+    ],
+    responseBody: z.object({ ok: z.boolean() }),
+    additionalResponses: {
+      "400": {
+        description:
+          "The plugin name failed validation (not kebab-case alphanumerics).",
+      },
+      "404": {
+        description: "No plugin directory exists with the given name.",
+      },
+      "409": {
+        description: "The plugin is already enabled.",
+      },
+    },
+    handler: handleEnablePlugin,
+  },
+  {
+    operationId: "plugins_disable",
+    endpoint: "plugins/:name/disable",
+    method: "POST",
+    policy: {
+      requiredScopes: ["settings.write"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    summary: "Disable a plugin",
+    description:
+      "Disable a plugin in this workspace by dropping a `.disabled` sentinel, mirroring the CLI's `assistant plugins disable <name>`. The change is honored live at read time by every tool / injector / hook gate — no restart required. Broadcasts a `sync_changed` invalidation carrying the `plugins:list` tag so other clients refetch `GET /v1/plugins`. An already-disabled plugin returns 409; a user plugin with no directory returns 404 (default plugins are stubbed on demand via the `default-` prefix); a malformed name returns 400.",
+    tags: ["plugins"],
+    pathParams: [
+      {
+        name: "name",
+        type: "string",
+        description:
+          "Directory name under `<workspaceDir>/plugins/`. Prefix a default plugin with `default-`. Must be kebab-case alphanumerics.",
+      },
+    ],
+    responseBody: z.object({ ok: z.boolean() }),
+    additionalResponses: {
+      "400": {
+        description:
+          "The plugin name failed validation (not kebab-case alphanumerics).",
+      },
+      "404": {
+        description:
+          "No plugin directory exists with the given name (user plugins must already be installed).",
+      },
+      "409": {
+        description: "The plugin is already disabled.",
+      },
+    },
+    handler: handleDisablePlugin,
+  },
 ];

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

@@ -273,7 +273,7 @@ async function handleCreateSchedule(body: Record<string, unknown>) {
   // entirely (see the workflow branch below), so only require a message for the
   // execute path. Requiring it for workflow mode would force API/UI callers to
   // pass an unused dummy string.
-  if (mode !== "workflow" && !message) {
+  if (mode !== "workflow" && mode !== "script" && !message) {
     throw new BadRequestError("message is required");
   }
   if (description === "") {
@@ -283,9 +283,9 @@ async function handleCreateSchedule(body: Record<string, unknown>) {
   // The settings UI only exposes execute mode; `workflow` mode is reachable
   // here (flag-gated) and via the schedule_create LLM tool. All other modes
   // remain tool-only.
-  if (mode !== "execute" && mode !== "workflow") {
+  if (mode !== "execute" && mode !== "workflow" && mode !== "script") {
     throw new BadRequestError(
-      "Only 'execute' and 'workflow' modes are supported by this endpoint",
+      "Only 'execute', 'script', and 'workflow' modes are supported by this endpoint",
     );
   }
 
@@ -321,11 +321,42 @@ async function handleCreateSchedule(body: Record<string, unknown>) {
         { id: job.id, name: job.name, workflowName },
         "Workflow schedule created",
       );
+      return { schedule: serializeSchedule(job, new Map()) };
+    } catch (err) {
+      if (err instanceof Error) throw new BadRequestError(err.message);
+      throw err;
+    }
+  }
+
+  if (mode === "script") {
+    const script = typeof body.script === "string" ? body.script.trim() : "";
+    if (!script) {
+      throw new BadRequestError("script is required for script-mode schedules");
+    }
+    const timeoutMs = body.timeoutMs == null ? null : Number(body.timeoutMs);
+    if (timeoutMs !== null) {
+      const timeoutError = validateScriptTimeoutMs(timeoutMs);
+      if (timeoutError) throw new BadRequestError(timeoutError);
+    }
+    try {
+      const job = await createSchedule({
+        name,
+        description,
+        message,
+        mode: "script",
+        script,
+        enabled,
+        timezone,
+        expression: normalized.expression,
+        syntax: normalized.syntax,
+        timeoutMs,
+      });
+      log.info({ id: job.id, name: job.name }, "Script schedule created");
+      return { schedule: serializeSchedule(job, new Map()) };
     } catch (err) {
       if (err instanceof Error) throw new BadRequestError(err.message);
       throw err;
     }
-    return handleListSchedules({});
   }
 
   try {
@@ -341,11 +372,11 @@ async function handleCreateSchedule(body: Record<string, unknown>) {
       inferenceProfile,
     });
     log.info({ id: job.id, name: job.name }, "Schedule created");
+    return { schedule: serializeSchedule(job, new Map()) };
   } catch (err) {
     if (err instanceof Error) throw new BadRequestError(err.message);
     throw err;
   }
-  return handleListSchedules({});
 }
 
 async function handleToggleSchedule(id: string, body: Record<string, unknown>) {
@@ -675,7 +706,7 @@ export const ROUTES: RouteDefinition[] = [
     },
     summary: "Create schedule",
     description:
-      "Create a new recurring schedule. Currently restricted to mode='execute'.",
+      "Create a new recurring schedule (execute, script, or workflow mode).",
     tags: ["schedules"],
     requestBody: z.object({
       name: z.string().describe("Display name"),
@@ -703,7 +734,7 @@ export const ROUTES: RouteDefinition[] = [
         .optional(),
       mode: z
         .string()
-        .describe("'execute' (default) or 'workflow' (flag-gated)")
+        .describe("'execute' (default), 'script', or 'workflow' (flag-gated)")
         .optional(),
       workflowName: z
         .string()
@@ -713,6 +744,15 @@ export const ROUTES: RouteDefinition[] = [
         .unknown()
         .describe("Args passed to the workflow run (workflow mode)")
         .optional(),
+      script: z
+        .string()
+        .describe("Shell command run on each fire (required for script mode)")
+        .optional(),
+      timeoutMs: z
+        .number()
+        .nullable()
+        .describe("Script execution timeout override in ms (script mode)")
+        .optional(),
       inferenceProfile: z
         .string()
         .nullable()
@@ -722,7 +762,7 @@ export const ROUTES: RouteDefinition[] = [
         .optional(),
     }),
     responseBody: z.object({
-      schedules: z.array(scheduleSchema).describe("Updated schedule list"),
+      schedule: scheduleSchema.describe("The created schedule"),
     }),
     handler: ({ body }: RouteHandlerArgs) => handleCreateSchedule(body ?? {}),
   },
@@ -903,6 +943,7 @@ async function handleRunScheduleNow(id: string) {
       const result = await runScript(schedule.script, {
         timeoutMs: schedule.timeoutMs ?? undefined,
         scheduleRunId: runId,
+        scheduleId: schedule.id,
       });
       await completeScheduleRun(runId, {
         status: result.exitCode === 0 ? "ok" : "error",